/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const e = require("./Package.internal.2.cjs");

const t = require("events");

const r = require("net");

const n = require("tls");

const s = require("string_decoder");

const o = require("url");

const i = require("util");

const u = require("crypto");

const a = require("./Package.internal.524.cjs");

require("buffer");

const c = e => e && e.__esModule ? e : {
    default: e
};

const f = c(t);

const l = c(r);

const m = c(n);

const d = c(s);

const h = c(o);

const _ = c(i);

const E = c(u);

var p = class {
    _eventListeners;
    _maxListeners;
    _logger;
    _throwOnEmitError=false;
    _throwOnEmptyListeners=false;
    _errorEvent="error";
    constructor(e) {
        this._eventListeners = new Map;
        this._maxListeners = 100;
        this._logger = e?.logger;
        if (e?.throwOnEmitError !== void 0) {
            this._throwOnEmitError = e.throwOnEmitError;
        }
        if (e?.throwOnEmptyListeners !== void 0) {
            this._throwOnEmptyListeners = e.throwOnEmptyListeners;
        }
    }
    get logger() {
        return this._logger;
    }
    set logger(e) {
        this._logger = e;
    }
    get throwOnEmitError() {
        return this._throwOnEmitError;
    }
    set throwOnEmitError(e) {
        this._throwOnEmitError = e;
    }
    get throwOnEmptyListeners() {
        return this._throwOnEmptyListeners;
    }
    set throwOnEmptyListeners(e) {
        this._throwOnEmptyListeners = e;
    }
    once(e, t) {
        const r = (...n) => {
            this.off(e, r);
            t(...n);
        };
        this.on(e, r);
        return this;
    }
    listenerCount(e) {
        if (e === void 0) {
            return this.getAllListeners().length;
        }
        const t = this._eventListeners.get(e);
        return t ? t.length : 0;
    }
    eventNames() {
        return [ ...this._eventListeners.keys() ];
    }
    rawListeners(e) {
        if (e === void 0) {
            return this.getAllListeners();
        }
        return this._eventListeners.get(e) ?? [];
    }
    prependListener(e, t) {
        const r = this._eventListeners.get(e) ?? [];
        r.unshift(t);
        this._eventListeners.set(e, r);
        return this;
    }
    prependOnceListener(e, t) {
        const r = (...n) => {
            this.off(e, r);
            t(...n);
        };
        this.prependListener(e, r);
        return this;
    }
    maxListeners() {
        return this._maxListeners;
    }
    addListener(e, t) {
        this.on(e, t);
        return this;
    }
    on(e, t) {
        if (!this._eventListeners.has(e)) {
            this._eventListeners.set(e, []);
        }
        const r = this._eventListeners.get(e);
        if (r) {
            if (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);
        }
        return this;
    }
    removeListener(e, t) {
        this.off(e, t);
        return this;
    }
    off(e, t) {
        const r = this._eventListeners.get(e) ?? [];
        const n = r.indexOf(t);
        if (n !== -1) {
            r.splice(n, 1);
        }
        if (r.length === 0) {
            this._eventListeners.delete(e);
        }
        return this;
    }
    emit(e, ...t) {
        let r = false;
        const n = this._eventListeners.get(e);
        if (n && n.length > 0) {
            for (const e of n) {
                e(...t);
                r = true;
            }
        }
        if (e === this._errorEvent) {
            const e = t[0] instanceof Error ? t[0] : new Error(`${t[0]}`);
            if (this._throwOnEmitError && !r) {
                throw e;
            } else {
                if (this.listeners(this._errorEvent).length === 0 && this._throwOnEmptyListeners === true) {
                    throw e;
                }
            }
        }
        return r;
    }
    listeners(e) {
        return this._eventListeners.get(e) ?? [];
    }
    removeAllListeners(e) {
        if (e !== void 0) {
            this._eventListeners.delete(e);
        } else {
            this._eventListeners.clear();
        }
        return this;
    }
    setMaxListeners(e) {
        this._maxListeners = e;
        for (const t of this._eventListeners.values()) {
            if (t.length > e) {
                t.splice(e);
            }
        }
    }
    getAllListeners() {
        let e = [];
        for (const t of this._eventListeners.values()) {
            e = [ ...e, ...t ];
        }
        return e;
    }
};

var S = class extends p {
    _hooks;
    _throwOnHookError=false;
    _enforceBeforeAfter=false;
    _deprecatedHooks;
    _allowDeprecated=true;
    constructor(e) {
        super({
            logger: e?.logger,
            throwOnEmitError: e?.throwOnEmitError,
            throwOnEmptyListeners: e?.throwOnEmptyListeners
        });
        this._hooks = new Map;
        this._deprecatedHooks = e?.deprecatedHooks ? new Map(e.deprecatedHooks) : new Map;
        if (e?.throwOnHookError !== void 0) {
            this._throwOnHookError = e.throwOnHookError;
        } else if (e?.throwHookErrors !== void 0) {
            this._throwOnHookError = e.throwHookErrors;
        }
        if (e?.enforceBeforeAfter !== void 0) {
            this._enforceBeforeAfter = e.enforceBeforeAfter;
        }
        if (e?.allowDeprecated !== void 0) {
            this._allowDeprecated = e.allowDeprecated;
        }
    }
    get hooks() {
        return this._hooks;
    }
    get throwHookErrors() {
        return this._throwOnHookError;
    }
    set throwHookErrors(e) {
        this._throwOnHookError = e;
    }
    get throwOnHookError() {
        return this._throwOnHookError;
    }
    set throwOnHookError(e) {
        this._throwOnHookError = e;
    }
    get enforceBeforeAfter() {
        return this._enforceBeforeAfter;
    }
    set enforceBeforeAfter(e) {
        this._enforceBeforeAfter = e;
    }
    get deprecatedHooks() {
        return this._deprecatedHooks;
    }
    set deprecatedHooks(e) {
        this._deprecatedHooks = e;
    }
    get allowDeprecated() {
        return this._allowDeprecated;
    }
    set allowDeprecated(e) {
        this._allowDeprecated = e;
    }
    validateHookName(e) {
        if (this._enforceBeforeAfter) {
            const t = e.trim().toLocaleLowerCase();
            if (!t.startsWith("before") && !t.startsWith("after")) {
                throw new Error(`Hook event "${e}" must start with "before" or "after" when enforceBeforeAfter is enabled`);
            }
        }
    }
    checkDeprecatedHook(e) {
        if (this._deprecatedHooks.has(e)) {
            const t = this._deprecatedHooks.get(e);
            const r = `Hook "${e}" is deprecated${t ? `: ${t}` : ""}`;
            this.emit("warn", {
                hook: e,
                message: r
            });
            if (this.logger?.warn) {
                this.logger.warn(r);
            }
            return this._allowDeprecated;
        }
        return true;
    }
    onHook(e, t) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return;
        }
        const r = this._hooks.get(e);
        if (r) {
            r.push(t);
        } else {
            this._hooks.set(e, [ t ]);
        }
    }
    onHookEntry(e) {
        this.onHook(e.event, e.handler);
    }
    addHook(e, t) {
        this.onHook(e, t);
    }
    onHooks(e) {
        for (const t of e) {
            this.onHook(t.event, t.handler);
        }
    }
    prependHook(e, t) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return;
        }
        const r = this._hooks.get(e);
        if (r) {
            r.unshift(t);
        } else {
            this._hooks.set(e, [ t ]);
        }
    }
    prependOnceHook(e, t) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return;
        }
        const r = async (...n) => {
            this.removeHook(e, r);
            return t(...n);
        };
        this.prependHook(e, r);
    }
    onceHook(e, t) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return;
        }
        const r = async (...n) => {
            this.removeHook(e, r);
            return t(...n);
        };
        this.onHook(e, r);
    }
    removeHook(e, t) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return;
        }
        const r = this._hooks.get(e);
        if (r) {
            const e = r.indexOf(t);
            if (e !== -1) {
                r.splice(e, 1);
            }
        }
    }
    removeHooks(e) {
        for (const t of e) {
            this.removeHook(t.event, t.handler);
        }
    }
    async hook(e, ...t) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return;
        }
        const r = this._hooks.get(e);
        if (r) {
            for (const n of r) {
                try {
                    await n(...t);
                } catch (t) {
                    const r = `${e}: ${t.message}`;
                    this.emit("error", new Error(r));
                    if (this.logger) {
                        this.logger.error(r);
                    }
                    if (this._throwOnHookError) {
                        throw new Error(r);
                    }
                }
            }
        }
    }
    async beforeHook(e, ...t) {
        await this.hook(`before:${e}`, ...t);
    }
    async afterHook(e, ...t) {
        await this.hook(`after:${e}`, ...t);
    }
    async callHook(e, ...t) {
        await this.hook(e, ...t);
    }
    getHooks(e) {
        this.validateHookName(e);
        if (!this.checkDeprecatedHook(e)) {
            return void 0;
        }
        return this._hooks.get(e);
    }
    clearHooks() {
        this._hooks.clear();
    }
};

var R = {};

var I = {};

var g = {};

var A = {};

var v = {};

Object.defineProperty(v, "__esModule", {
    value: true
});

v.transformArguments = v.FIRST_KEY_INDEX = void 0;

v.FIRST_KEY_INDEX = 1;

function y(e, t) {
    return [ "APPEND", e, t ];
}

v.transformArguments = y;

var b = {};

Object.defineProperty(b, "__esModule", {
    value: true
});

b.transformArguments = b.IS_READ_ONLY = b.FIRST_KEY_INDEX = void 0;

b.FIRST_KEY_INDEX = 1;

b.IS_READ_ONLY = true;

function N(e, t) {
    const r = [ "BITCOUNT", e ];
    if (t) {
        r.push(t.start.toString(), t.end.toString());
        if (t.mode) {
            r.push(t.mode);
        }
    }
    return r;
}

b.transformArguments = N;

var O = {};

Object.defineProperty(O, "__esModule", {
    value: true
});

O.transformArguments = O.IS_READ_ONLY = O.FIRST_KEY_INDEX = void 0;

O.FIRST_KEY_INDEX = 1;

O.IS_READ_ONLY = true;

function T(e, t) {
    const r = [ "BITFIELD_RO", e ];
    for (const e of t) {
        r.push("GET", e.encoding, e.offset.toString());
    }
    return r;
}

O.transformArguments = T;

var D = {};

Object.defineProperty(D, "__esModule", {
    value: true
});

D.transformArguments = D.FIRST_KEY_INDEX = void 0;

D.FIRST_KEY_INDEX = 1;

function P(e, t) {
    const r = [ "BITFIELD", e ];
    for (const e of t) {
        switch (e.operation) {
          case "GET":
            r.push("GET", e.encoding, e.offset.toString());
            break;

          case "SET":
            r.push("SET", e.encoding, e.offset.toString(), e.value.toString());
            break;

          case "INCRBY":
            r.push("INCRBY", e.encoding, e.offset.toString(), e.increment.toString());
            break;

          case "OVERFLOW":
            r.push("OVERFLOW", e.behavior);
            break;
        }
    }
    return r;
}

D.transformArguments = P;

var L = {};

var C = {};

Object.defineProperty(C, "__esModule", {
    value: true
});

C.transformRangeReply = C.pushSlotRangesArguments = C.pushSortArguments = C.transformFunctionListItemReply = C.RedisFunctionFlags = C.transformCommandReply = C.CommandCategories = C.CommandFlags = C.pushOptionalVerdictArgument = C.pushVerdictArgument = C.pushVerdictNumberArguments = C.pushVerdictArguments = C.pushEvalArguments = C.evalFirstKeyIndex = C.transformPXAT = C.transformEXAT = C.transformGeoMembersWithReply = C.GeoReplyWith = C.pushGeoRadiusStoreArguments = C.pushGeoRadiusArguments = C.pushGeoSearchArguments = C.pushGeoCountArgument = C.transformLMPopArguments = C.transformZMPopArguments = C.transformSortedSetWithScoresReply = C.transformSortedSetMemberReply = C.transformSortedSetMemberNullReply = C.transformStreamsMessagesReply = C.transformStreamMessagesNullReply = C.transformStreamMessagesReply = C.transformStreamMessageNullReply = C.transformStreamMessageReply = C.transformTuplesReply = C.transformStringNumberInfinityArgument = C.transformNumberInfinityArgument = C.transformNumberInfinityNullArrayReply = C.transformNumberInfinityNullReply = C.transformNumberInfinityReply = C.pushScanArguments = C.transformBooleanArrayReply = C.transformBooleanReply = void 0;

function M(e) {
    return e === 1;
}

C.transformBooleanReply = M;

function Y(e) {
    return e.map(M);
}

C.transformBooleanArrayReply = Y;

function w(e, t, r) {
    e.push(t.toString());
    if (r?.MATCH) {
        e.push("MATCH", r.MATCH);
    }
    if (r?.COUNT) {
        e.push("COUNT", r.COUNT.toString());
    }
    return e;
}

C.pushScanArguments = w;

function F(e) {
    switch (e.toString()) {
      case "+inf":
        return Infinity;

      case "-inf":
        return -Infinity;

      default:
        return Number(e);
    }
}

C.transformNumberInfinityReply = F;

function X(e) {
    if (e === null) return null;
    return F(e);
}

C.transformNumberInfinityNullReply = X;

function j(e) {
    return e.map(X);
}

C.transformNumberInfinityNullArrayReply = j;

function K(e) {
    switch (e) {
      case Infinity:
        return "+inf";

      case -Infinity:
        return "-inf";

      default:
        return e.toString();
    }
}

C.transformNumberInfinityArgument = K;

function U(e) {
    if (typeof e !== "number") return e;
    return K(e);
}

C.transformStringNumberInfinityArgument = U;

function B(e) {
    const t = Object.create(null);
    for (let r = 0; r < e.length; r += 2) {
        t[e[r].toString()] = e[r + 1];
    }
    return t;
}

C.transformTuplesReply = B;

function x([e, t]) {
    return {
        id: e,
        message: B(t)
    };
}

C.transformStreamMessageReply = x;

function G(e) {
    if (e === null) return null;
    return x(e);
}

C.transformStreamMessageNullReply = G;

function k(e) {
    return e.map(x);
}

C.transformStreamMessagesReply = k;

function H(e) {
    return e.map(G);
}

C.transformStreamMessagesNullReply = H;

function W(e) {
    if (e === null) return null;
    return e.map(([e, t]) => ({
        name: e,
        messages: k(t)
    }));
}

C.transformStreamsMessagesReply = W;

function V(e) {
    if (!e.length) return null;
    return z(e);
}

C.transformSortedSetMemberNullReply = V;

function z(e) {
    return {
        value: e[0],
        score: F(e[1])
    };
}

C.transformSortedSetMemberReply = z;

function Z(e) {
    const t = [];
    for (let r = 0; r < e.length; r += 2) {
        t.push({
            value: e[r],
            score: F(e[r + 1])
        });
    }
    return t;
}

C.transformSortedSetWithScoresReply = Z;

function q(e, t, r, n) {
    fe(e, t);
    e.push(r);
    if (n?.COUNT) {
        e.push("COUNT", n.COUNT.toString());
    }
    return e;
}

C.transformZMPopArguments = q;

function $(e, t, r, n) {
    fe(e, t);
    e.push(r);
    if (n?.COUNT) {
        e.push("COUNT", n.COUNT.toString());
    }
    return e;
}

C.transformLMPopArguments = $;

function Q(e, t) {
    if (typeof t === "number") {
        e.push("COUNT", t.toString());
    } else if (t) {
        e.push("COUNT", t.value.toString());
        if (t.ANY) {
            e.push("ANY");
        }
    }
    return e;
}

C.pushGeoCountArgument = Q;

function J(e, t, r, n, s) {
    e.push(t);
    if (typeof r === "string") {
        e.push("FROMMEMBER", r);
    } else {
        e.push("FROMLONLAT", r.longitude.toString(), r.latitude.toString());
    }
    if ("radius" in n) {
        e.push("BYRADIUS", n.radius.toString());
    } else {
        e.push("BYBOX", n.width.toString(), n.height.toString());
    }
    e.push(n.unit);
    if (s?.SORT) {
        e.push(s.SORT);
    }
    Q(e, s?.COUNT);
    return e;
}

C.pushGeoSearchArguments = J;

function ee(e, t, r, n, s, o) {
    e.push(t);
    if (typeof r === "string") {
        e.push(r);
    } else {
        e.push(r.longitude.toString(), r.latitude.toString());
    }
    e.push(n.toString(), s);
    if (o?.SORT) {
        e.push(o.SORT);
    }
    Q(e, o?.COUNT);
    return e;
}

C.pushGeoRadiusArguments = ee;

function te(e, t, r, n, s, o, i) {
    ee(e, t, r, n, s, i);
    if (i?.STOREDIST) {
        e.push("STOREDIST", o);
    } else {
        e.push("STORE", o);
    }
    return e;
}

C.pushGeoRadiusStoreArguments = te;

var re;

(function(e) {
    e["DISTANCE"] = "WITHDIST";
    e["HASH"] = "WITHHASH";
    e["COORDINATES"] = "WITHCOORD";
})(re || (C.GeoReplyWith = re = {}));

function ne(e, t) {
    const r = new Set(t);
    let n = 0;
    const s = r.has(re.DISTANCE) && ++n, o = r.has(re.HASH) && ++n, i = r.has(re.COORDINATES) && ++n;
    return e.map(e => {
        const t = {
            member: e[0]
        };
        if (s) {
            t.distance = e[s];
        }
        if (o) {
            t.hash = e[o];
        }
        if (i) {
            const [r, n] = e[i];
            t.coordinates = {
                longitude: r,
                latitude: n
            };
        }
        return t;
    });
}

C.transformGeoMembersWithReply = ne;

function se(e) {
    return (typeof e === "number" ? e : Math.floor(e.getTime() / 1e3)).toString();
}

C.transformEXAT = se;

function oe(e) {
    return (typeof e === "number" ? e : e.getTime()).toString();
}

C.transformPXAT = oe;

function ie(e) {
    return e?.keys?.[0];
}

C.evalFirstKeyIndex = ie;

function ue(e, t) {
    if (t?.keys) {
        e.push(t.keys.length.toString(), ...t.keys);
    } else {
        e.push("0");
    }
    if (t?.arguments) {
        e.push(...t.arguments);
    }
    return e;
}

C.pushEvalArguments = ue;

function ae(e, t) {
    if (Array.isArray(t)) {
        e = e.concat(t);
    } else {
        e.push(t);
    }
    return e;
}

C.pushVerdictArguments = ae;

function ce(e, t) {
    if (Array.isArray(t)) {
        for (const r of t) {
            e.push(r.toString());
        }
    } else {
        e.push(t.toString());
    }
    return e;
}

C.pushVerdictNumberArguments = ce;

function fe(e, t) {
    if (Array.isArray(t)) {
        e.push(t.length.toString(), ...t);
    } else {
        e.push("1", t);
    }
    return e;
}

C.pushVerdictArgument = fe;

function le(e, t, r) {
    if (r === undefined) return e;
    e.push(t);
    return fe(e, r);
}

C.pushOptionalVerdictArgument = le;

var me;

(function(e) {
    e["WRITE"] = "write";
    e["READONLY"] = "readonly";
    e["DENYOOM"] = "denyoom";
    e["ADMIN"] = "admin";
    e["PUBSUB"] = "pubsub";
    e["NOSCRIPT"] = "noscript";
    e["RANDOM"] = "random";
    e["SORT_FOR_SCRIPT"] = "sort_for_script";
    e["LOADING"] = "loading";
    e["STALE"] = "stale";
    e["SKIP_MONITOR"] = "skip_monitor";
    e["ASKING"] = "asking";
    e["FAST"] = "fast";
    e["MOVABLEKEYS"] = "movablekeys";
})(me || (C.CommandFlags = me = {}));

var de;

(function(e) {
    e["KEYSPACE"] = "@keyspace";
    e["READ"] = "@read";
    e["WRITE"] = "@write";
    e["SET"] = "@set";
    e["SORTEDSET"] = "@sortedset";
    e["LIST"] = "@list";
    e["HASH"] = "@hash";
    e["STRING"] = "@string";
    e["BITMAP"] = "@bitmap";
    e["HYPERLOGLOG"] = "@hyperloglog";
    e["GEO"] = "@geo";
    e["STREAM"] = "@stream";
    e["PUBSUB"] = "@pubsub";
    e["ADMIN"] = "@admin";
    e["FAST"] = "@fast";
    e["SLOW"] = "@slow";
    e["BLOCKING"] = "@blocking";
    e["DANGEROUS"] = "@dangerous";
    e["CONNECTION"] = "@connection";
    e["TRANSACTION"] = "@transaction";
    e["SCRIPTING"] = "@scripting";
})(de || (C.CommandCategories = de = {}));

function he([e, t, r, n, s, o, i]) {
    return {
        name: e,
        arity: t,
        flags: new Set(r),
        firstKeyIndex: n,
        lastKeyIndex: s,
        step: o,
        categories: new Set(i)
    };
}

C.transformCommandReply = he;

var _e;

(function(e) {
    e["NO_WRITES"] = "no-writes";
    e["ALLOW_OOM"] = "allow-oom";
    e["ALLOW_STALE"] = "allow-stale";
    e["NO_CLUSTER"] = "no-cluster";
})(_e || (C.RedisFunctionFlags = _e = {}));

function Ee(e) {
    return {
        libraryName: e[1],
        engine: e[3],
        functions: e[5].map(e => ({
            name: e[1],
            description: e[3],
            flags: e[5]
        }))
    };
}

C.transformFunctionListItemReply = Ee;

function pe(e, t) {
    if (t?.BY) {
        e.push("BY", t.BY);
    }
    if (t?.LIMIT) {
        e.push("LIMIT", t.LIMIT.offset.toString(), t.LIMIT.count.toString());
    }
    if (t?.GET) {
        for (const r of typeof t.GET === "string" ? [ t.GET ] : t.GET) {
            e.push("GET", r);
        }
    }
    if (t?.DIRECTION) {
        e.push(t.DIRECTION);
    }
    if (t?.ALPHA) {
        e.push("ALPHA");
    }
    return e;
}

C.pushSortArguments = pe;

function Se(e, t) {
    e.push(t.start.toString(), t.end.toString());
}

function Re(e, t) {
    if (Array.isArray(t)) {
        for (const r of t) {
            Se(e, r);
        }
    } else {
        Se(e, t);
    }
    return e;
}

C.pushSlotRangesArguments = Re;

function Ie([e, t]) {
    return {
        start: e,
        end: t
    };
}

C.transformRangeReply = Ie;

Object.defineProperty(L, "__esModule", {
    value: true
});

L.transformArguments = L.FIRST_KEY_INDEX = void 0;

const ge = C;

L.FIRST_KEY_INDEX = 2;

function Ae(e, t, r) {
    return (0, ge.pushVerdictArguments)([ "BITOP", e, t ], r);
}

L.transformArguments = Ae;

var ve = {};

Object.defineProperty(ve, "__esModule", {
    value: true
});

ve.transformArguments = ve.IS_READ_ONLY = ve.FIRST_KEY_INDEX = void 0;

ve.FIRST_KEY_INDEX = 1;

ve.IS_READ_ONLY = true;

function ye(e, t, r, n, s) {
    const o = [ "BITPOS", e, t.toString() ];
    if (typeof r === "number") {
        o.push(r.toString());
    }
    if (typeof n === "number") {
        o.push(n.toString());
    }
    if (s) {
        o.push(s);
    }
    return o;
}

ve.transformArguments = ye;

var be = {};

Object.defineProperty(be, "__esModule", {
    value: true
});

be.transformArguments = be.FIRST_KEY_INDEX = void 0;

be.FIRST_KEY_INDEX = 1;

function Ne(e, t, r, n, s) {
    return [ "BLMOVE", e, t, r, n, s.toString() ];
}

be.transformArguments = Ne;

var Oe = {};

var Te = {};

Object.defineProperty(Te, "__esModule", {
    value: true
});

Te.transformArguments = Te.FIRST_KEY_INDEX = void 0;

const De = C;

Te.FIRST_KEY_INDEX = 2;

function Pe(e, t, r) {
    return (0, De.transformLMPopArguments)([ "LMPOP" ], e, t, r);
}

Te.transformArguments = Pe;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 3;
    function r(e, r, n, s) {
        return (0, t.transformLMPopArguments)([ "BLMPOP", e.toString() ], r, n, s);
    }
    e.transformArguments = r;
    var n = Te;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(Oe);

var Le = {};

Object.defineProperty(Le, "__esModule", {
    value: true
});

Le.transformReply = Le.transformArguments = Le.FIRST_KEY_INDEX = void 0;

const Ce = C;

Le.FIRST_KEY_INDEX = 1;

function Me(e, t) {
    const r = (0, Ce.pushVerdictArguments)([ "BLPOP" ], e);
    r.push(t.toString());
    return r;
}

Le.transformArguments = Me;

function Ye(e) {
    if (e === null) return null;
    return {
        key: e[0],
        element: e[1]
    };
}

Le.transformReply = Ye;

var we = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r) {
        const n = (0, t.pushVerdictArguments)([ "BRPOP" ], e);
        n.push(r.toString());
        return n;
    }
    e.transformArguments = r;
    var n = Le;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(we);

var Fe = {};

Object.defineProperty(Fe, "__esModule", {
    value: true
});

Fe.transformArguments = Fe.FIRST_KEY_INDEX = void 0;

Fe.FIRST_KEY_INDEX = 1;

function Xe(e, t, r) {
    return [ "BRPOPLPUSH", e, t, r.toString() ];
}

Fe.transformArguments = Xe;

var je = {};

var Ke = {};

Object.defineProperty(Ke, "__esModule", {
    value: true
});

Ke.transformReply = Ke.transformArguments = Ke.FIRST_KEY_INDEX = void 0;

const Ue = C;

Ke.FIRST_KEY_INDEX = 2;

function Be(e, t, r) {
    return (0, Ue.transformZMPopArguments)([ "ZMPOP" ], e, t, r);
}

Ke.transformArguments = Be;

function xe(e) {
    return e === null ? null : {
        key: e[0],
        elements: e[1].map(Ue.transformSortedSetMemberReply)
    };
}

Ke.transformReply = xe;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 3;
    function r(e, r, n, s) {
        return (0, t.transformZMPopArguments)([ "BZMPOP", e.toString() ], r, n, s);
    }
    e.transformArguments = r;
    var n = Ke;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(je);

var Ge = {};

Object.defineProperty(Ge, "__esModule", {
    value: true
});

Ge.transformReply = Ge.transformArguments = Ge.FIRST_KEY_INDEX = void 0;

const ke = C;

Ge.FIRST_KEY_INDEX = 1;

function He(e, t) {
    const r = (0, ke.pushVerdictArguments)([ "BZPOPMAX" ], e);
    r.push(t.toString());
    return r;
}

Ge.transformArguments = He;

function We(e) {
    if (!e) return null;
    return {
        key: e[0],
        value: e[1],
        score: (0, ke.transformNumberInfinityReply)(e[2])
    };
}

Ge.transformReply = We;

var Ve = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r) {
        const n = (0, t.pushVerdictArguments)([ "BZPOPMIN" ], e);
        n.push(r.toString());
        return n;
    }
    e.transformArguments = r;
    var n = Ge;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(Ve);

var ze = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t, r) {
        const n = [ "COPY", e, t ];
        if (r?.destinationDb) {
            n.push("DB", r.destinationDb.toString());
        }
        if (r?.replace) {
            n.push("REPLACE");
        }
        return n;
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(ze);

var Ze = {};

Object.defineProperty(Ze, "__esModule", {
    value: true
});

Ze.transformArguments = Ze.FIRST_KEY_INDEX = void 0;

Ze.FIRST_KEY_INDEX = 1;

function qe(e) {
    return [ "DECR", e ];
}

Ze.transformArguments = qe;

var $e = {};

Object.defineProperty($e, "__esModule", {
    value: true
});

$e.transformArguments = $e.FIRST_KEY_INDEX = void 0;

$e.FIRST_KEY_INDEX = 1;

function Qe(e, t) {
    return [ "DECRBY", e, t.toString() ];
}

$e.transformArguments = Qe;

var Je = {};

Object.defineProperty(Je, "__esModule", {
    value: true
});

Je.transformArguments = Je.FIRST_KEY_INDEX = void 0;

const et = C;

Je.FIRST_KEY_INDEX = 1;

function tt(e) {
    return (0, et.pushVerdictArguments)([ "DEL" ], e);
}

Je.transformArguments = tt;

var rt = {};

Object.defineProperty(rt, "__esModule", {
    value: true
});

rt.transformArguments = rt.FIRST_KEY_INDEX = void 0;

rt.FIRST_KEY_INDEX = 1;

function nt(e) {
    return [ "DUMP", e ];
}

rt.transformArguments = nt;

var st = {};

Object.defineProperty(st, "__esModule", {
    value: true
});

st.transformArguments = st.IS_READ_ONLY = st.FIRST_KEY_INDEX = void 0;

const ot = C;

st.FIRST_KEY_INDEX = ot.evalFirstKeyIndex;

st.IS_READ_ONLY = true;

function it(e, t) {
    return (0, ot.pushEvalArguments)([ "EVAL_RO", e ], t);
}

st.transformArguments = it;

var ut = {};

Object.defineProperty(ut, "__esModule", {
    value: true
});

ut.transformArguments = ut.FIRST_KEY_INDEX = void 0;

const at = C;

ut.FIRST_KEY_INDEX = at.evalFirstKeyIndex;

function ct(e, t) {
    return (0, at.pushEvalArguments)([ "EVAL", e ], t);
}

ut.transformArguments = ct;

var ft = {};

Object.defineProperty(ft, "__esModule", {
    value: true
});

ft.transformArguments = ft.IS_READ_ONLY = ft.FIRST_KEY_INDEX = void 0;

const lt = C;

ft.FIRST_KEY_INDEX = lt.evalFirstKeyIndex;

ft.IS_READ_ONLY = true;

function mt(e, t) {
    return (0, lt.pushEvalArguments)([ "EVALSHA_RO", e ], t);
}

ft.transformArguments = mt;

var dt = {};

Object.defineProperty(dt, "__esModule", {
    value: true
});

dt.transformArguments = dt.FIRST_KEY_INDEX = void 0;

const ht = C;

dt.FIRST_KEY_INDEX = ht.evalFirstKeyIndex;

function _t(e, t) {
    return (0, ht.pushEvalArguments)([ "EVALSHA", e ], t);
}

dt.transformArguments = _t;

var Et = {};

Object.defineProperty(Et, "__esModule", {
    value: true
});

Et.transformArguments = Et.IS_READ_ONLY = Et.FIRST_KEY_INDEX = void 0;

const pt = C;

Et.FIRST_KEY_INDEX = 1;

Et.IS_READ_ONLY = true;

function St(e) {
    return (0, pt.pushVerdictArguments)([ "EXISTS" ], e);
}

Et.transformArguments = St;

var Rt = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t, r) {
        const n = [ "EXPIRE", e, t.toString() ];
        if (r) {
            n.push(r);
        }
        return n;
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Rt);

var It = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r, n) {
        const s = [ "EXPIREAT", e, (0, t.transformEXAT)(r) ];
        if (n) {
            s.push(n);
        }
        return s;
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanReply;
        }
    });
})(It);

var gt = {};

Object.defineProperty(gt, "__esModule", {
    value: true
});

gt.transformArguments = gt.FIRST_KEY_INDEX = void 0;

gt.FIRST_KEY_INDEX = 1;

function At(e) {
    return [ "EXPIRETIME", e ];
}

gt.transformArguments = At;

var vt = {};

Object.defineProperty(vt, "__esModule", {
    value: true
});

vt.transformArguments = vt.IS_READ_ONLY = vt.FIRST_KEY_INDEX = void 0;

const yt = C;

vt.FIRST_KEY_INDEX = yt.evalFirstKeyIndex;

vt.IS_READ_ONLY = true;

function bt(e, t) {
    return (0, yt.pushEvalArguments)([ "FCALL_RO", e ], t);
}

vt.transformArguments = bt;

var Nt = {};

Object.defineProperty(Nt, "__esModule", {
    value: true
});

Nt.transformArguments = Nt.FIRST_KEY_INDEX = void 0;

const Ot = C;

Nt.FIRST_KEY_INDEX = Ot.evalFirstKeyIndex;

function Tt(e, t) {
    return (0, Ot.pushEvalArguments)([ "FCALL", e ], t);
}

Nt.transformArguments = Tt;

var Dt = {};

Object.defineProperty(Dt, "__esModule", {
    value: true
});

Dt.transformArguments = Dt.FIRST_KEY_INDEX = void 0;

Dt.FIRST_KEY_INDEX = 1;

function Pt(e, t, r) {
    const n = [ "GEOADD", e ];
    if (r?.NX) {
        n.push("NX");
    } else if (r?.XX) {
        n.push("XX");
    }
    if (r?.CH) {
        n.push("CH");
    }
    for (const {longitude: e, latitude: r, member: s} of Array.isArray(t) ? t : [ t ]) {
        n.push(e.toString(), r.toString(), s);
    }
    return n;
}

Dt.transformArguments = Pt;

var Lt = {};

Object.defineProperty(Lt, "__esModule", {
    value: true
});

Lt.transformReply = Lt.transformArguments = Lt.IS_READ_ONLY = Lt.FIRST_KEY_INDEX = void 0;

Lt.FIRST_KEY_INDEX = 1;

Lt.IS_READ_ONLY = true;

function Ct(e, t, r, n) {
    const s = [ "GEODIST", e, t, r ];
    if (n) {
        s.push(n);
    }
    return s;
}

Lt.transformArguments = Ct;

function Mt(e) {
    return e === null ? null : Number(e);
}

Lt.transformReply = Mt;

var Yt = {};

Object.defineProperty(Yt, "__esModule", {
    value: true
});

Yt.transformArguments = Yt.IS_READ_ONLY = Yt.FIRST_KEY_INDEX = void 0;

const wt = C;

Yt.FIRST_KEY_INDEX = 1;

Yt.IS_READ_ONLY = true;

function Ft(e, t) {
    return (0, wt.pushVerdictArguments)([ "GEOHASH", e ], t);
}

Yt.transformArguments = Ft;

var Xt = {};

Object.defineProperty(Xt, "__esModule", {
    value: true
});

Xt.transformReply = Xt.transformArguments = Xt.IS_READ_ONLY = Xt.FIRST_KEY_INDEX = void 0;

const jt = C;

Xt.FIRST_KEY_INDEX = 1;

Xt.IS_READ_ONLY = true;

function Kt(e, t) {
    return (0, jt.pushVerdictArguments)([ "GEOPOS", e ], t);
}

Xt.transformArguments = Kt;

function Ut(e) {
    return e.map(e => e === null ? null : {
        longitude: e[0],
        latitude: e[1]
    });
}

Xt.transformReply = Ut;

var Bt = {};

var xt = {};

Object.defineProperty(xt, "__esModule", {
    value: true
});

xt.transformArguments = xt.IS_READ_ONLY = xt.FIRST_KEY_INDEX = void 0;

const Gt = C;

xt.FIRST_KEY_INDEX = 1;

xt.IS_READ_ONLY = true;

function kt(e, t, r, n, s) {
    return (0, Gt.pushGeoRadiusArguments)([ "GEORADIUS_RO" ], e, t, r, n, s);
}

xt.transformArguments = kt;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = xt;
    var r = xt;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o, i) {
        const u = (0, t.transformArguments)(e, r, n, s, i);
        u.push(...o);
        u.preserve = o;
        return u;
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Bt);

var Ht = {};

var Wt = {};

Object.defineProperty(Wt, "__esModule", {
    value: true
});

Wt.transformArguments = Wt.IS_READ_ONLY = Wt.FIRST_KEY_INDEX = void 0;

const Vt = C;

Wt.FIRST_KEY_INDEX = 1;

Wt.IS_READ_ONLY = true;

function zt(e, t, r, n, s) {
    return (0, Vt.pushGeoRadiusArguments)([ "GEORADIUS" ], e, t, r, n, s);
}

Wt.transformArguments = zt;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Wt;
    var r = Wt;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o, i) {
        const u = (0, t.transformArguments)(e, r, n, s, i);
        u.push(...o);
        u.preserve = o;
        return u;
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Ht);

var Zt = {};

var qt = {};

Object.defineProperty(qt, "__esModule", {
    value: true
});

qt.transformArguments = qt.IS_READ_ONLY = qt.FIRST_KEY_INDEX = void 0;

const $t = C;

qt.FIRST_KEY_INDEX = 1;

qt.IS_READ_ONLY = true;

function Qt(e, t, r, n, s) {
    return (0, $t.pushGeoRadiusArguments)([ "GEORADIUSBYMEMBER_RO" ], e, t, r, n, s);
}

qt.transformArguments = Qt;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = qt;
    var r = qt;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o, i) {
        const u = (0, t.transformArguments)(e, r, n, s, i);
        u.push(...o);
        u.preserve = o;
        return u;
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Zt);

var Jt = {};

var er = {};

Object.defineProperty(er, "__esModule", {
    value: true
});

er.transformArguments = er.IS_READ_ONLY = er.FIRST_KEY_INDEX = void 0;

const tr = C;

er.FIRST_KEY_INDEX = 1;

er.IS_READ_ONLY = true;

function rr(e, t, r, n, s) {
    return (0, tr.pushGeoRadiusArguments)([ "GEORADIUSBYMEMBER" ], e, t, r, n, s);
}

er.transformArguments = rr;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = er;
    var r = er;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o, i) {
        const u = (0, t.transformArguments)(e, r, n, s, i);
        u.push(...o);
        u.preserve = o;
        return u;
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Jt);

var nr = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    var r = er;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o, i) {
        return (0, t.pushGeoRadiusStoreArguments)([ "GEORADIUSBYMEMBER" ], e, r, n, s, o, i);
    }
    e.transformArguments = n;
})(nr);

var sr = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    var r = Wt;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o, i) {
        return (0, t.pushGeoRadiusStoreArguments)([ "GEORADIUS" ], e, r, n, s, o, i);
    }
    e.transformArguments = n;
})(sr);

var or = {};

var ir = {};

Object.defineProperty(ir, "__esModule", {
    value: true
});

ir.transformArguments = ir.IS_READ_ONLY = ir.FIRST_KEY_INDEX = void 0;

const ur = C;

ir.FIRST_KEY_INDEX = 1;

ir.IS_READ_ONLY = true;

function ar(e, t, r, n) {
    return (0, ur.pushGeoSearchArguments)([ "GEOSEARCH" ], e, t, r, n);
}

ir.transformArguments = ar;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = ir;
    var r = ir;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o) {
        const i = (0, t.transformArguments)(e, r, n, o);
        i.push(...s);
        i.preserve = s;
        return i;
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(or);

var cr = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    var r = ir;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s, o) {
        const i = (0, t.pushGeoSearchArguments)([ "GEOSEARCHSTORE", e ], r, n, s, o);
        if (o?.STOREDIST) {
            i.push("STOREDIST");
        }
        return i;
    }
    e.transformArguments = n;
    function s(e) {
        if (typeof e !== "number") {
            throw new TypeError(`https://github.com/redis/redis/issues/9261`);
        }
        return e;
    }
    e.transformReply = s;
})(cr);

var fr = {};

Object.defineProperty(fr, "__esModule", {
    value: true
});

fr.transformArguments = fr.IS_READ_ONLY = fr.FIRST_KEY_INDEX = void 0;

fr.FIRST_KEY_INDEX = 1;

fr.IS_READ_ONLY = true;

function lr(e) {
    return [ "GET", e ];
}

fr.transformArguments = lr;

var mr = {};

Object.defineProperty(mr, "__esModule", {
    value: true
});

mr.transformArguments = mr.IS_READ_ONLY = mr.FIRST_KEY_INDEX = void 0;

mr.FIRST_KEY_INDEX = 1;

mr.IS_READ_ONLY = true;

function dr(e, t) {
    return [ "GETBIT", e, t.toString() ];
}

mr.transformArguments = dr;

var hr = {};

Object.defineProperty(hr, "__esModule", {
    value: true
});

hr.transformArguments = hr.FIRST_KEY_INDEX = void 0;

hr.FIRST_KEY_INDEX = 1;

function _r(e) {
    return [ "GETDEL", e ];
}

hr.transformArguments = _r;

var Er = {};

Object.defineProperty(Er, "__esModule", {
    value: true
});

Er.transformArguments = Er.FIRST_KEY_INDEX = void 0;

const pr = C;

Er.FIRST_KEY_INDEX = 1;

function Sr(e, t) {
    const r = [ "GETEX", e ];
    if ("EX" in t) {
        r.push("EX", t.EX.toString());
    } else if ("PX" in t) {
        r.push("PX", t.PX.toString());
    } else if ("EXAT" in t) {
        r.push("EXAT", (0, pr.transformEXAT)(t.EXAT));
    } else if ("PXAT" in t) {
        r.push("PXAT", (0, pr.transformPXAT)(t.PXAT));
    } else {
        r.push("PERSIST");
    }
    return r;
}

Er.transformArguments = Sr;

var Rr = {};

Object.defineProperty(Rr, "__esModule", {
    value: true
});

Rr.transformArguments = Rr.IS_READ_ONLY = Rr.FIRST_KEY_INDEX = void 0;

Rr.FIRST_KEY_INDEX = 1;

Rr.IS_READ_ONLY = true;

function Ir(e, t, r) {
    return [ "GETRANGE", e, t.toString(), r.toString() ];
}

Rr.transformArguments = Ir;

var gr = {};

Object.defineProperty(gr, "__esModule", {
    value: true
});

gr.transformArguments = gr.FIRST_KEY_INDEX = void 0;

gr.FIRST_KEY_INDEX = 1;

function Ar(e, t) {
    return [ "GETSET", e, t ];
}

gr.transformArguments = Ar;

var vr = {};

Object.defineProperty(vr, "__esModule", {
    value: true
});

vr.transformArguments = vr.FIRST_KEY_INDEX = void 0;

const yr = C;

vr.FIRST_KEY_INDEX = 1;

function br(e, t) {
    return (0, yr.pushVerdictArguments)([ "HDEL", e ], t);
}

vr.transformArguments = br;

var Nr = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t) {
        return [ "HEXISTS", e, t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Nr);

var Or = {};

Object.defineProperty(Or, "__esModule", {
    value: true
});

Or.transformArguments = Or.FIRST_KEY_INDEX = Or.HASH_EXPIRATION = void 0;

const Tr = C;

Or.HASH_EXPIRATION = {
    FIELD_NOT_EXISTS: -2,
    CONDITION_NOT_MET: 0,
    UPDATED: 1,
    DELETED: 2
};

Or.FIRST_KEY_INDEX = 1;

function Dr(e, t, r, n) {
    const s = [ "HEXPIRE", e, r.toString() ];
    if (n) {
        s.push(n);
    }
    s.push("FIELDS");
    return (0, Tr.pushVerdictArgument)(s, t);
}

Or.transformArguments = Dr;

var Pr = {};

Object.defineProperty(Pr, "__esModule", {
    value: true
});

Pr.transformArguments = Pr.FIRST_KEY_INDEX = void 0;

const Lr = C;

Pr.FIRST_KEY_INDEX = 1;

function Cr(e, t, r, n) {
    const s = [ "HEXPIREAT", e, (0, Lr.transformEXAT)(r) ];
    if (n) {
        s.push(n);
    }
    s.push("FIELDS");
    return (0, Lr.pushVerdictArgument)(s, t);
}

Pr.transformArguments = Cr;

var Mr = {};

Object.defineProperty(Mr, "__esModule", {
    value: true
});

Mr.transformArguments = Mr.IS_READ_ONLY = Mr.FIRST_KEY_INDEX = Mr.HASH_EXPIRATION_TIME = void 0;

const Yr = C;

Mr.HASH_EXPIRATION_TIME = {
    FIELD_NOT_EXISTS: -2,
    NO_EXPIRATION: -1
};

Mr.FIRST_KEY_INDEX = 1;

Mr.IS_READ_ONLY = true;

function wr(e, t) {
    return (0, Yr.pushVerdictArgument)([ "HEXPIRETIME", e, "FIELDS" ], t);
}

Mr.transformArguments = wr;

var Fr = {};

Object.defineProperty(Fr, "__esModule", {
    value: true
});

Fr.transformArguments = Fr.IS_READ_ONLY = Fr.FIRST_KEY_INDEX = void 0;

Fr.FIRST_KEY_INDEX = 1;

Fr.IS_READ_ONLY = true;

function Xr(e, t) {
    return [ "HGET", e, t ];
}

Fr.transformArguments = Xr;

var jr = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.TRANSFORM_LEGACY_REPLY = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    e.IS_READ_ONLY = true;
    e.TRANSFORM_LEGACY_REPLY = true;
    function t(e) {
        return [ "HGETALL", e ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformTuplesReply;
        }
    });
})(jr);

var Kr = {};

Object.defineProperty(Kr, "__esModule", {
    value: true
});

Kr.transformArguments = Kr.FIRST_KEY_INDEX = void 0;

Kr.FIRST_KEY_INDEX = 1;

function Ur(e, t, r) {
    return [ "HINCRBY", e, t, r.toString() ];
}

Kr.transformArguments = Ur;

var Br = {};

Object.defineProperty(Br, "__esModule", {
    value: true
});

Br.transformArguments = Br.FIRST_KEY_INDEX = void 0;

Br.FIRST_KEY_INDEX = 1;

function xr(e, t, r) {
    return [ "HINCRBYFLOAT", e, t, r.toString() ];
}

Br.transformArguments = xr;

var Gr = {};

Object.defineProperty(Gr, "__esModule", {
    value: true
});

Gr.transformArguments = Gr.FIRST_KEY_INDEX = void 0;

Gr.FIRST_KEY_INDEX = 1;

function kr(e) {
    return [ "HKEYS", e ];
}

Gr.transformArguments = kr;

var Hr = {};

Object.defineProperty(Hr, "__esModule", {
    value: true
});

Hr.transformArguments = Hr.FIRST_KEY_INDEX = void 0;

Hr.FIRST_KEY_INDEX = 1;

function Wr(e) {
    return [ "HLEN", e ];
}

Hr.transformArguments = Wr;

var Vr = {};

Object.defineProperty(Vr, "__esModule", {
    value: true
});

Vr.transformArguments = Vr.IS_READ_ONLY = Vr.FIRST_KEY_INDEX = void 0;

const zr = C;

Vr.FIRST_KEY_INDEX = 1;

Vr.IS_READ_ONLY = true;

function Zr(e, t) {
    return (0, zr.pushVerdictArguments)([ "HMGET", e ], t);
}

Vr.transformArguments = Zr;

var qr = {};

Object.defineProperty(qr, "__esModule", {
    value: true
});

qr.transformArguments = qr.FIRST_KEY_INDEX = void 0;

const $r = C;

qr.FIRST_KEY_INDEX = 1;

function Qr(e, t) {
    return (0, $r.pushVerdictArgument)([ "HPERSIST", e, "FIELDS" ], t);
}

qr.transformArguments = Qr;

var Jr = {};

Object.defineProperty(Jr, "__esModule", {
    value: true
});

Jr.transformArguments = Jr.FIRST_KEY_INDEX = void 0;

const en = C;

Jr.FIRST_KEY_INDEX = 1;

function tn(e, t, r, n) {
    const s = [ "HPEXPIRE", e, r.toString() ];
    if (n) {
        s.push(n);
    }
    s.push("FIELDS");
    return (0, en.pushVerdictArgument)(s, t);
}

Jr.transformArguments = tn;

var rn = {};

Object.defineProperty(rn, "__esModule", {
    value: true
});

rn.transformArguments = rn.IS_READ_ONLY = rn.FIRST_KEY_INDEX = void 0;

const nn = C;

rn.FIRST_KEY_INDEX = 1;

rn.IS_READ_ONLY = true;

function sn(e, t, r, n) {
    const s = [ "HPEXPIREAT", e, (0, nn.transformPXAT)(r) ];
    if (n) {
        s.push(n);
    }
    s.push("FIELDS");
    return (0, nn.pushVerdictArgument)(s, t);
}

rn.transformArguments = sn;

var on = {};

Object.defineProperty(on, "__esModule", {
    value: true
});

on.transformArguments = on.IS_READ_ONLY = on.FIRST_KEY_INDEX = void 0;

const un = C;

on.FIRST_KEY_INDEX = 1;

on.IS_READ_ONLY = true;

function an(e, t) {
    return (0, un.pushVerdictArgument)([ "HPEXPIRETIME", e, "FIELDS" ], t);
}

on.transformArguments = an;

var cn = {};

Object.defineProperty(cn, "__esModule", {
    value: true
});

cn.transformArguments = cn.IS_READ_ONLY = cn.FIRST_KEY_INDEX = void 0;

const fn = C;

cn.FIRST_KEY_INDEX = 1;

cn.IS_READ_ONLY = true;

function ln(e, t) {
    return (0, fn.pushVerdictArgument)([ "HPTTL", e, "FIELDS" ], t);
}

cn.transformArguments = ln;

var mn = {};

var dn = {};

var hn = {};

Object.defineProperty(hn, "__esModule", {
    value: true
});

hn.transformArguments = hn.IS_READ_ONLY = hn.FIRST_KEY_INDEX = void 0;

hn.FIRST_KEY_INDEX = 1;

hn.IS_READ_ONLY = true;

function _n(e) {
    return [ "HRANDFIELD", e ];
}

hn.transformArguments = _n;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = hn;
    var r = hn;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r) {
        return [ ...(0, t.transformArguments)(e), r.toString() ];
    }
    e.transformArguments = n;
})(dn);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = dn;
    var r = dn;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r) {
        return [ ...(0, t.transformArguments)(e, r), "WITHVALUES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformTuplesReply;
        }
    });
})(mn);

var En = {};

Object.defineProperty(En, "__esModule", {
    value: true
});

En.transformReply = En.transformArguments = En.IS_READ_ONLY = En.FIRST_KEY_INDEX = void 0;

const pn = C;

En.FIRST_KEY_INDEX = 1;

En.IS_READ_ONLY = true;

function Sn(e, t, r) {
    return (0, pn.pushScanArguments)([ "HSCAN", e ], t, r);
}

En.transformArguments = Sn;

function Rn([e, t]) {
    const r = [];
    for (let e = 0; e < t.length; e += 2) {
        r.push({
            field: t[e],
            value: t[e + 1]
        });
    }
    return {
        cursor: Number(e),
        tuples: r
    };
}

En.transformReply = Rn;

var In = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = En;
    var r = En;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n) {
        const s = (0, t.transformArguments)(e, r, n);
        s.push("NOVALUES");
        return s;
    }
    e.transformArguments = n;
    function s([e, t]) {
        return {
            cursor: Number(e),
            keys: t
        };
    }
    e.transformReply = s;
})(In);

var gn = {};

Object.defineProperty(gn, "__esModule", {
    value: true
});

gn.transformArguments = gn.FIRST_KEY_INDEX = void 0;

gn.FIRST_KEY_INDEX = 1;

function An(...[e, t, r]) {
    const n = [ "HSET", e ];
    if (typeof t === "string" || typeof t === "number" || Buffer.isBuffer(t)) {
        n.push(Nn(t), Nn(r));
    } else if (t instanceof Map) {
        vn(n, t);
    } else if (Array.isArray(t)) {
        yn(n, t);
    } else {
        bn(n, t);
    }
    return n;
}

gn.transformArguments = An;

function vn(e, t) {
    for (const [r, n] of t.entries()) {
        e.push(Nn(r), Nn(n));
    }
}

function yn(e, t) {
    for (const r of t) {
        if (Array.isArray(r)) {
            yn(e, r);
            continue;
        }
        e.push(Nn(r));
    }
}

function bn(e, t) {
    for (const r of Object.keys(t)) {
        e.push(Nn(r), Nn(t[r]));
    }
}

function Nn(e) {
    return typeof e === "number" ? e.toString() : e;
}

var On = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t, r) {
        return [ "HSETNX", e, t, r ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(On);

var Tn = {};

Object.defineProperty(Tn, "__esModule", {
    value: true
});

Tn.transformArguments = Tn.FIRST_KEY_INDEX = void 0;

Tn.FIRST_KEY_INDEX = 1;

function Dn(e, t) {
    return [ "HSTRLEN", e, t ];
}

Tn.transformArguments = Dn;

var Pn = {};

Object.defineProperty(Pn, "__esModule", {
    value: true
});

Pn.transformArguments = Pn.IS_READ_ONLY = Pn.FIRST_KEY_INDEX = void 0;

const Ln = C;

Pn.FIRST_KEY_INDEX = 1;

Pn.IS_READ_ONLY = true;

function Cn(e, t) {
    return (0, Ln.pushVerdictArgument)([ "HTTL", e, "FIELDS" ], t);
}

Pn.transformArguments = Cn;

var Mn = {};

Object.defineProperty(Mn, "__esModule", {
    value: true
});

Mn.transformArguments = Mn.FIRST_KEY_INDEX = void 0;

Mn.FIRST_KEY_INDEX = 1;

function Yn(e) {
    return [ "HVALS", e ];
}

Mn.transformArguments = Yn;

var wn = {};

Object.defineProperty(wn, "__esModule", {
    value: true
});

wn.transformArguments = wn.FIRST_KEY_INDEX = void 0;

wn.FIRST_KEY_INDEX = 1;

function Fn(e) {
    return [ "INCR", e ];
}

wn.transformArguments = Fn;

var Xn = {};

Object.defineProperty(Xn, "__esModule", {
    value: true
});

Xn.transformArguments = Xn.FIRST_KEY_INDEX = void 0;

Xn.FIRST_KEY_INDEX = 1;

function jn(e, t) {
    return [ "INCRBY", e, t.toString() ];
}

Xn.transformArguments = jn;

var Kn = {};

Object.defineProperty(Kn, "__esModule", {
    value: true
});

Kn.transformArguments = Kn.FIRST_KEY_INDEX = void 0;

Kn.FIRST_KEY_INDEX = 1;

function Un(e, t) {
    return [ "INCRBYFLOAT", e, t.toString() ];
}

Kn.transformArguments = Un;

var Bn = {};

var xn = {};

Object.defineProperty(xn, "__esModule", {
    value: true
});

xn.transformArguments = xn.IS_READ_ONLY = xn.FIRST_KEY_INDEX = void 0;

xn.FIRST_KEY_INDEX = 1;

xn.IS_READ_ONLY = true;

function Gn(e, t) {
    return [ "LCS", e, t ];
}

xn.transformArguments = Gn;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    const r = xn;
    var n = xn;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return n.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return n.IS_READ_ONLY;
        }
    });
    function s(e, t) {
        const n = (0, r.transformArguments)(e, t);
        n.push("IDX", "WITHMATCHLEN");
        return n;
    }
    e.transformArguments = s;
    function o(e) {
        return {
            matches: e[1].map(([e, r, n]) => ({
                key1: (0, t.transformRangeReply)(e),
                key2: (0, t.transformRangeReply)(r),
                length: n
            })),
            length: e[3]
        };
    }
    e.transformReply = o;
})(Bn);

var kn = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    const r = xn;
    var n = xn;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return n.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return n.IS_READ_ONLY;
        }
    });
    function s(e, t) {
        const n = (0, r.transformArguments)(e, t);
        n.push("IDX");
        return n;
    }
    e.transformArguments = s;
    function o(e) {
        return {
            matches: e[1].map(([e, r]) => ({
                key1: (0, t.transformRangeReply)(e),
                key2: (0, t.transformRangeReply)(r)
            })),
            length: e[3]
        };
    }
    e.transformReply = o;
})(kn);

var Hn = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = xn;
    var r = xn;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r) {
        const n = (0, t.transformArguments)(e, r);
        n.push("LEN");
        return n;
    }
    e.transformArguments = n;
})(Hn);

var Wn = {};

Object.defineProperty(Wn, "__esModule", {
    value: true
});

Wn.transformArguments = Wn.IS_READ_ONLY = Wn.FIRST_KEY_INDEX = void 0;

Wn.FIRST_KEY_INDEX = 1;

Wn.IS_READ_ONLY = true;

function Vn(e, t) {
    return [ "LINDEX", e, t.toString() ];
}

Wn.transformArguments = Vn;

var zn = {};

Object.defineProperty(zn, "__esModule", {
    value: true
});

zn.transformArguments = zn.FIRST_KEY_INDEX = void 0;

zn.FIRST_KEY_INDEX = 1;

function Zn(e, t, r, n) {
    return [ "LINSERT", e, t, r, n ];
}

zn.transformArguments = Zn;

var qn = {};

Object.defineProperty(qn, "__esModule", {
    value: true
});

qn.transformArguments = qn.IS_READ_ONLY = qn.FIRST_KEY_INDEX = void 0;

qn.FIRST_KEY_INDEX = 1;

qn.IS_READ_ONLY = true;

function $n(e) {
    return [ "LLEN", e ];
}

qn.transformArguments = $n;

var Qn = {};

Object.defineProperty(Qn, "__esModule", {
    value: true
});

Qn.transformArguments = Qn.FIRST_KEY_INDEX = void 0;

Qn.FIRST_KEY_INDEX = 1;

function Jn(e, t, r, n) {
    return [ "LMOVE", e, t, r, n ];
}

Qn.transformArguments = Jn;

var es = {};

Object.defineProperty(es, "__esModule", {
    value: true
});

es.transformArguments = es.FIRST_KEY_INDEX = void 0;

es.FIRST_KEY_INDEX = 1;

function ts(e, t) {
    return [ "LPOP", e, t.toString() ];
}

es.transformArguments = ts;

var rs = {};

Object.defineProperty(rs, "__esModule", {
    value: true
});

rs.transformArguments = rs.FIRST_KEY_INDEX = void 0;

rs.FIRST_KEY_INDEX = 1;

function ns(e) {
    return [ "LPOP", e ];
}

rs.transformArguments = ns;

var ss = {};

var os = {};

Object.defineProperty(os, "__esModule", {
    value: true
});

os.transformArguments = os.IS_READ_ONLY = os.FIRST_KEY_INDEX = void 0;

os.FIRST_KEY_INDEX = 1;

os.IS_READ_ONLY = true;

function is(e, t, r) {
    const n = [ "LPOS", e, t ];
    if (typeof r?.RANK === "number") {
        n.push("RANK", r.RANK.toString());
    }
    if (typeof r?.MAXLEN === "number") {
        n.push("MAXLEN", r.MAXLEN.toString());
    }
    return n;
}

os.transformArguments = is;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    var t = os;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return t.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return t.IS_READ_ONLY;
        }
    });
    function r(e, t, r, n) {
        const s = [ "LPOS", e, t ];
        if (typeof n?.RANK === "number") {
            s.push("RANK", n.RANK.toString());
        }
        s.push("COUNT", r.toString());
        if (typeof n?.MAXLEN === "number") {
            s.push("MAXLEN", n.MAXLEN.toString());
        }
        return s;
    }
    e.transformArguments = r;
})(ss);

var us = {};

Object.defineProperty(us, "__esModule", {
    value: true
});

us.transformArguments = us.FIRST_KEY_INDEX = void 0;

const as = C;

us.FIRST_KEY_INDEX = 1;

function cs(e, t) {
    return (0, as.pushVerdictArguments)([ "LPUSH", e ], t);
}

us.transformArguments = cs;

var fs = {};

Object.defineProperty(fs, "__esModule", {
    value: true
});

fs.transformArguments = fs.FIRST_KEY_INDEX = void 0;

const ls = C;

fs.FIRST_KEY_INDEX = 1;

function ms(e, t) {
    return (0, ls.pushVerdictArguments)([ "LPUSHX", e ], t);
}

fs.transformArguments = ms;

var ds = {};

Object.defineProperty(ds, "__esModule", {
    value: true
});

ds.transformArguments = ds.IS_READ_ONLY = ds.FIRST_KEY_INDEX = void 0;

ds.FIRST_KEY_INDEX = 1;

ds.IS_READ_ONLY = true;

function hs(e, t, r) {
    return [ "LRANGE", e, t.toString(), r.toString() ];
}

ds.transformArguments = hs;

var _s = {};

Object.defineProperty(_s, "__esModule", {
    value: true
});

_s.transformArguments = _s.FIRST_KEY_INDEX = void 0;

_s.FIRST_KEY_INDEX = 1;

function Es(e, t, r) {
    return [ "LREM", e, t.toString(), r ];
}

_s.transformArguments = Es;

var ps = {};

Object.defineProperty(ps, "__esModule", {
    value: true
});

ps.transformArguments = ps.FIRST_KEY_INDEX = void 0;

ps.FIRST_KEY_INDEX = 1;

function Ss(e, t, r) {
    return [ "LSET", e, t.toString(), r ];
}

ps.transformArguments = Ss;

var Rs = {};

Object.defineProperty(Rs, "__esModule", {
    value: true
});

Rs.transformArguments = Rs.FIRST_KEY_INDEX = void 0;

Rs.FIRST_KEY_INDEX = 1;

function Is(e, t, r) {
    return [ "LTRIM", e, t.toString(), r.toString() ];
}

Rs.transformArguments = Is;

var gs = {};

Object.defineProperty(gs, "__esModule", {
    value: true
});

gs.transformArguments = gs.IS_READ_ONLY = gs.FIRST_KEY_INDEX = void 0;

gs.FIRST_KEY_INDEX = 1;

gs.IS_READ_ONLY = true;

function As(e) {
    return [ "MGET", ...e ];
}

gs.transformArguments = As;

var vs = {};

Object.defineProperty(vs, "__esModule", {
    value: true
});

vs.transformArguments = void 0;

function ys(e, t, r, n, s, o) {
    const i = [ "MIGRATE", e, t.toString() ], u = Array.isArray(r);
    if (u) {
        i.push("");
    } else {
        i.push(r);
    }
    i.push(n.toString(), s.toString());
    if (o?.COPY) {
        i.push("COPY");
    }
    if (o?.REPLACE) {
        i.push("REPLACE");
    }
    if (o?.AUTH) {
        if (o.AUTH.username) {
            i.push("AUTH2", o.AUTH.username, o.AUTH.password);
        } else {
            i.push("AUTH", o.AUTH.password);
        }
    }
    if (u) {
        i.push("KEYS", ...r);
    }
    return i;
}

vs.transformArguments = ys;

var bs = {};

Object.defineProperty(bs, "__esModule", {
    value: true
});

bs.transformArguments = bs.FIRST_KEY_INDEX = void 0;

bs.FIRST_KEY_INDEX = 1;

function Ns(e) {
    const t = [ "MSET" ];
    if (Array.isArray(e)) {
        t.push(...e.flat());
    } else {
        for (const r of Object.keys(e)) {
            t.push(r, e[r]);
        }
    }
    return t;
}

bs.transformArguments = Ns;

var Os = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e) {
        const t = [ "MSETNX" ];
        if (Array.isArray(e)) {
            t.push(...e.flat());
        } else {
            for (const r of Object.keys(e)) {
                t.push(r, e[r]);
            }
        }
        return t;
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Os);

var Ts = {};

Object.defineProperty(Ts, "__esModule", {
    value: true
});

Ts.transformArguments = Ts.IS_READ_ONLY = Ts.FIRST_KEY_INDEX = void 0;

Ts.FIRST_KEY_INDEX = 2;

Ts.IS_READ_ONLY = true;

function Ds(e) {
    return [ "OBJECT", "ENCODING", e ];
}

Ts.transformArguments = Ds;

var Ps = {};

Object.defineProperty(Ps, "__esModule", {
    value: true
});

Ps.transformArguments = Ps.IS_READ_ONLY = Ps.FIRST_KEY_INDEX = void 0;

Ps.FIRST_KEY_INDEX = 2;

Ps.IS_READ_ONLY = true;

function Ls(e) {
    return [ "OBJECT", "FREQ", e ];
}

Ps.transformArguments = Ls;

var Cs = {};

Object.defineProperty(Cs, "__esModule", {
    value: true
});

Cs.transformArguments = Cs.IS_READ_ONLY = Cs.FIRST_KEY_INDEX = void 0;

Cs.FIRST_KEY_INDEX = 2;

Cs.IS_READ_ONLY = true;

function Ms(e) {
    return [ "OBJECT", "IDLETIME", e ];
}

Cs.transformArguments = Ms;

var Ys = {};

Object.defineProperty(Ys, "__esModule", {
    value: true
});

Ys.transformArguments = Ys.IS_READ_ONLY = Ys.FIRST_KEY_INDEX = void 0;

Ys.FIRST_KEY_INDEX = 2;

Ys.IS_READ_ONLY = true;

function ws(e) {
    return [ "OBJECT", "REFCOUNT", e ];
}

Ys.transformArguments = ws;

var Fs = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e) {
        return [ "PERSIST", e ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Fs);

var Xs = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t, r) {
        const n = [ "PEXPIRE", e, t.toString() ];
        if (r) {
            n.push(r);
        }
        return n;
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Xs);

var js = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r, n) {
        const s = [ "PEXPIREAT", e, (0, t.transformPXAT)(r) ];
        if (n) {
            s.push(n);
        }
        return s;
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanReply;
        }
    });
})(js);

var Ks = {};

Object.defineProperty(Ks, "__esModule", {
    value: true
});

Ks.transformArguments = Ks.FIRST_KEY_INDEX = void 0;

Ks.FIRST_KEY_INDEX = 1;

function Us(e) {
    return [ "PEXPIRETIME", e ];
}

Ks.transformArguments = Us;

var Bs = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r) {
        return (0, t.pushVerdictArguments)([ "PFADD", e ], r);
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanReply;
        }
    });
})(Bs);

var xs = {};

Object.defineProperty(xs, "__esModule", {
    value: true
});

xs.transformArguments = xs.FIRST_KEY_INDEX = void 0;

const Gs = C;

xs.FIRST_KEY_INDEX = 1;

function ks(e) {
    return (0, Gs.pushVerdictArguments)([ "PFCOUNT" ], e);
}

xs.transformArguments = ks;

var Hs = {};

Object.defineProperty(Hs, "__esModule", {
    value: true
});

Hs.transformArguments = Hs.FIRST_KEY_INDEX = void 0;

const Ws = C;

Hs.FIRST_KEY_INDEX = 1;

function Vs(e, t) {
    return (0, Ws.pushVerdictArguments)([ "PFMERGE", e ], t);
}

Hs.transformArguments = Vs;

var zs = {};

Object.defineProperty(zs, "__esModule", {
    value: true
});

zs.transformArguments = zs.FIRST_KEY_INDEX = void 0;

zs.FIRST_KEY_INDEX = 1;

function Zs(e, t, r) {
    return [ "PSETEX", e, t.toString(), r ];
}

zs.transformArguments = Zs;

var qs = {};

Object.defineProperty(qs, "__esModule", {
    value: true
});

qs.transformArguments = qs.IS_READ_ONLY = qs.FIRST_KEY_INDEX = void 0;

qs.FIRST_KEY_INDEX = 1;

qs.IS_READ_ONLY = true;

function $s(e) {
    return [ "PTTL", e ];
}

qs.transformArguments = $s;

var Qs = {};

Object.defineProperty(Qs, "__esModule", {
    value: true
});

Qs.transformArguments = Qs.IS_READ_ONLY = void 0;

Qs.IS_READ_ONLY = true;

function Js(e, t) {
    return [ "PUBLISH", e, t ];
}

Qs.transformArguments = Js;

var eo = {};

Object.defineProperty(eo, "__esModule", {
    value: true
});

eo.transformArguments = eo.FIRST_KEY_INDEX = void 0;

eo.FIRST_KEY_INDEX = 1;

function to(e, t) {
    return [ "RENAME", e, t ];
}

eo.transformArguments = to;

var ro = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t) {
        return [ "RENAMENX", e, t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(ro);

var no = {};

Object.defineProperty(no, "__esModule", {
    value: true
});

no.transformArguments = no.FIRST_KEY_INDEX = void 0;

no.FIRST_KEY_INDEX = 1;

function so(e, t, r, n) {
    const s = [ "RESTORE", e, t.toString(), r ];
    if (n?.REPLACE) {
        s.push("REPLACE");
    }
    if (n?.ABSTTL) {
        s.push("ABSTTL");
    }
    if (n?.IDLETIME) {
        s.push("IDLETIME", n.IDLETIME.toString());
    }
    if (n?.FREQ) {
        s.push("FREQ", n.FREQ.toString());
    }
    return s;
}

no.transformArguments = so;

var oo = {};

Object.defineProperty(oo, "__esModule", {
    value: true
});

oo.transformArguments = oo.FIRST_KEY_INDEX = void 0;

oo.FIRST_KEY_INDEX = 1;

function io(e, t) {
    return [ "RPOP", e, t.toString() ];
}

oo.transformArguments = io;

var uo = {};

Object.defineProperty(uo, "__esModule", {
    value: true
});

uo.transformArguments = uo.FIRST_KEY_INDEX = void 0;

uo.FIRST_KEY_INDEX = 1;

function ao(e) {
    return [ "RPOP", e ];
}

uo.transformArguments = ao;

var co = {};

Object.defineProperty(co, "__esModule", {
    value: true
});

co.transformArguments = co.FIRST_KEY_INDEX = void 0;

co.FIRST_KEY_INDEX = 1;

function fo(e, t) {
    return [ "RPOPLPUSH", e, t ];
}

co.transformArguments = fo;

var lo = {};

Object.defineProperty(lo, "__esModule", {
    value: true
});

lo.transformArguments = lo.FIRST_KEY_INDEX = void 0;

const mo = C;

lo.FIRST_KEY_INDEX = 1;

function ho(e, t) {
    return (0, mo.pushVerdictArguments)([ "RPUSH", e ], t);
}

lo.transformArguments = ho;

var _o = {};

Object.defineProperty(_o, "__esModule", {
    value: true
});

_o.transformArguments = _o.FIRST_KEY_INDEX = void 0;

const Eo = C;

_o.FIRST_KEY_INDEX = 1;

function po(e, t) {
    return (0, Eo.pushVerdictArguments)([ "RPUSHX", e ], t);
}

_o.transformArguments = po;

var So = {};

Object.defineProperty(So, "__esModule", {
    value: true
});

So.transformArguments = So.FIRST_KEY_INDEX = void 0;

const Ro = C;

So.FIRST_KEY_INDEX = 1;

function Io(e, t) {
    return (0, Ro.pushVerdictArguments)([ "SADD", e ], t);
}

So.transformArguments = Io;

var go = {};

Object.defineProperty(go, "__esModule", {
    value: true
});

go.transformArguments = go.FIRST_KEY_INDEX = void 0;

go.FIRST_KEY_INDEX = 1;

function Ao(e) {
    return [ "SCARD", e ];
}

go.transformArguments = Ao;

var vo = {};

Object.defineProperty(vo, "__esModule", {
    value: true
});

vo.transformArguments = vo.IS_READ_ONLY = vo.FIRST_KEY_INDEX = void 0;

const yo = C;

vo.FIRST_KEY_INDEX = 1;

vo.IS_READ_ONLY = true;

function bo(e) {
    return (0, yo.pushVerdictArguments)([ "SDIFF" ], e);
}

vo.transformArguments = bo;

var No = {};

Object.defineProperty(No, "__esModule", {
    value: true
});

No.transformArguments = No.FIRST_KEY_INDEX = void 0;

const Oo = C;

No.FIRST_KEY_INDEX = 1;

function To(e, t) {
    return (0, Oo.pushVerdictArguments)([ "SDIFFSTORE", e ], t);
}

No.transformArguments = To;

var Do = {};

Object.defineProperty(Do, "__esModule", {
    value: true
});

Do.transformArguments = Do.FIRST_KEY_INDEX = void 0;

Do.FIRST_KEY_INDEX = 1;

function Po(e, t, r) {
    const n = [ "SET", e, typeof t === "number" ? t.toString() : t ];
    if (r?.EX !== undefined) {
        n.push("EX", r.EX.toString());
    } else if (r?.PX !== undefined) {
        n.push("PX", r.PX.toString());
    } else if (r?.EXAT !== undefined) {
        n.push("EXAT", r.EXAT.toString());
    } else if (r?.PXAT !== undefined) {
        n.push("PXAT", r.PXAT.toString());
    } else if (r?.KEEPTTL) {
        n.push("KEEPTTL");
    }
    if (r?.NX) {
        n.push("NX");
    } else if (r?.XX) {
        n.push("XX");
    }
    if (r?.GET) {
        n.push("GET");
    }
    return n;
}

Do.transformArguments = Po;

var Lo = {};

Object.defineProperty(Lo, "__esModule", {
    value: true
});

Lo.transformArguments = Lo.FIRST_KEY_INDEX = void 0;

Lo.FIRST_KEY_INDEX = 1;

function Co(e, t, r) {
    return [ "SETBIT", e, t.toString(), r.toString() ];
}

Lo.transformArguments = Co;

var Mo = {};

Object.defineProperty(Mo, "__esModule", {
    value: true
});

Mo.transformArguments = Mo.FIRST_KEY_INDEX = void 0;

Mo.FIRST_KEY_INDEX = 1;

function Yo(e, t, r) {
    return [ "SETEX", e, t.toString(), r ];
}

Mo.transformArguments = Yo;

var wo = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t) {
        return [ "SETNX", e, t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(wo);

var Fo = {};

Object.defineProperty(Fo, "__esModule", {
    value: true
});

Fo.transformArguments = Fo.FIRST_KEY_INDEX = void 0;

Fo.FIRST_KEY_INDEX = 1;

function Xo(e, t, r) {
    return [ "SETRANGE", e, t.toString(), r ];
}

Fo.transformArguments = Xo;

var jo = {};

Object.defineProperty(jo, "__esModule", {
    value: true
});

jo.transformArguments = jo.IS_READ_ONLY = jo.FIRST_KEY_INDEX = void 0;

const Ko = C;

jo.FIRST_KEY_INDEX = 1;

jo.IS_READ_ONLY = true;

function Uo(e) {
    return (0, Ko.pushVerdictArguments)([ "SINTER" ], e);
}

jo.transformArguments = Uo;

var Bo = {};

Object.defineProperty(Bo, "__esModule", {
    value: true
});

Bo.transformArguments = Bo.IS_READ_ONLY = Bo.FIRST_KEY_INDEX = void 0;

const xo = C;

Bo.FIRST_KEY_INDEX = 2;

Bo.IS_READ_ONLY = true;

function Go(e, t) {
    const r = (0, xo.pushVerdictArgument)([ "SINTERCARD" ], e);
    if (t) {
        r.push("LIMIT", t.toString());
    }
    return r;
}

Bo.transformArguments = Go;

var ko = {};

Object.defineProperty(ko, "__esModule", {
    value: true
});

ko.transformArguments = ko.FIRST_KEY_INDEX = void 0;

const Ho = C;

ko.FIRST_KEY_INDEX = 1;

function Wo(e, t) {
    return (0, Ho.pushVerdictArguments)([ "SINTERSTORE", e ], t);
}

ko.transformArguments = Wo;

var Vo = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t) {
        return [ "SISMEMBER", e, t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Vo);

var zo = {};

Object.defineProperty(zo, "__esModule", {
    value: true
});

zo.transformArguments = zo.FIRST_KEY_INDEX = void 0;

zo.FIRST_KEY_INDEX = 1;

function Zo(e) {
    return [ "SMEMBERS", e ];
}

zo.transformArguments = Zo;

var qo = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t) {
        return [ "SMISMEMBER", e, ...t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanArrayReply;
        }
    });
})(qo);

var $o = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t, r) {
        return [ "SMOVE", e, t, r ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})($o);

var Qo = {};

Object.defineProperty(Qo, "__esModule", {
    value: true
});

Qo.transformArguments = Qo.IS_READ_ONLY = Qo.FIRST_KEY_INDEX = void 0;

const Jo = C;

Qo.FIRST_KEY_INDEX = 1;

Qo.IS_READ_ONLY = true;

function ei(e, t) {
    return (0, Jo.pushSortArguments)([ "SORT_RO", e ], t);
}

Qo.transformArguments = ei;

var ti = {};

var ri = {};

Object.defineProperty(ri, "__esModule", {
    value: true
});

ri.transformArguments = ri.FIRST_KEY_INDEX = void 0;

const ni = C;

ri.FIRST_KEY_INDEX = 1;

function si(e, t) {
    return (0, ni.pushSortArguments)([ "SORT", e ], t);
}

ri.transformArguments = si;

Object.defineProperty(ti, "__esModule", {
    value: true
});

ti.transformArguments = ti.FIRST_KEY_INDEX = void 0;

const oi = ri;

ti.FIRST_KEY_INDEX = 1;

function ii(e, t, r) {
    const n = (0, oi.transformArguments)(e, r);
    n.push("STORE", t);
    return n;
}

ti.transformArguments = ii;

var ui = {};

Object.defineProperty(ui, "__esModule", {
    value: true
});

ui.transformArguments = ui.FIRST_KEY_INDEX = void 0;

ui.FIRST_KEY_INDEX = 1;

function ai(e, t) {
    const r = [ "SPOP", e ];
    if (typeof t === "number") {
        r.push(t.toString());
    }
    return r;
}

ui.transformArguments = ai;

var ci = {};

Object.defineProperty(ci, "__esModule", {
    value: true
});

ci.transformArguments = ci.FIRST_KEY_INDEX = ci.IS_READ_ONLY = void 0;

ci.IS_READ_ONLY = true;

ci.FIRST_KEY_INDEX = 1;

function fi(e, t) {
    return [ "SPUBLISH", e, t ];
}

ci.transformArguments = fi;

var li = {};

var mi = {};

Object.defineProperty(mi, "__esModule", {
    value: true
});

mi.transformArguments = mi.FIRST_KEY_INDEX = void 0;

mi.FIRST_KEY_INDEX = 1;

function di(e) {
    return [ "SRANDMEMBER", e ];
}

mi.transformArguments = di;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = mi;
    var r = mi;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    function n(e, r) {
        return [ ...(0, t.transformArguments)(e), r.toString() ];
    }
    e.transformArguments = n;
})(li);

var hi = {};

Object.defineProperty(hi, "__esModule", {
    value: true
});

hi.transformArguments = hi.FIRST_KEY_INDEX = void 0;

const _i = C;

hi.FIRST_KEY_INDEX = 1;

function Ei(e, t) {
    return (0, _i.pushVerdictArguments)([ "SREM", e ], t);
}

hi.transformArguments = Ei;

var pi = {};

Object.defineProperty(pi, "__esModule", {
    value: true
});

pi.transformReply = pi.transformArguments = pi.IS_READ_ONLY = pi.FIRST_KEY_INDEX = void 0;

const Si = C;

pi.FIRST_KEY_INDEX = 1;

pi.IS_READ_ONLY = true;

function Ri(e, t, r) {
    return (0, Si.pushScanArguments)([ "SSCAN", e ], t, r);
}

pi.transformArguments = Ri;

function Ii([e, t]) {
    return {
        cursor: Number(e),
        members: t
    };
}

pi.transformReply = Ii;

var gi = {};

Object.defineProperty(gi, "__esModule", {
    value: true
});

gi.transformArguments = gi.IS_READ_ONLY = gi.FIRST_KEY_INDEX = void 0;

gi.FIRST_KEY_INDEX = 1;

gi.IS_READ_ONLY = true;

function Ai(e) {
    return [ "STRLEN", e ];
}

gi.transformArguments = Ai;

var vi = {};

Object.defineProperty(vi, "__esModule", {
    value: true
});

vi.transformArguments = vi.IS_READ_ONLY = vi.FIRST_KEY_INDEX = void 0;

const yi = C;

vi.FIRST_KEY_INDEX = 1;

vi.IS_READ_ONLY = true;

function bi(e) {
    return (0, yi.pushVerdictArguments)([ "SUNION" ], e);
}

vi.transformArguments = bi;

var Ni = {};

Object.defineProperty(Ni, "__esModule", {
    value: true
});

Ni.transformArguments = Ni.FIRST_KEY_INDEX = void 0;

const Oi = C;

Ni.FIRST_KEY_INDEX = 1;

function Ti(e, t) {
    return (0, Oi.pushVerdictArguments)([ "SUNIONSTORE", e ], t);
}

Ni.transformArguments = Ti;

var Di = {};

Object.defineProperty(Di, "__esModule", {
    value: true
});

Di.transformArguments = Di.FIRST_KEY_INDEX = void 0;

const Pi = C;

Di.FIRST_KEY_INDEX = 1;

function Li(e) {
    return (0, Pi.pushVerdictArguments)([ "TOUCH" ], e);
}

Di.transformArguments = Li;

var Ci = {};

Object.defineProperty(Ci, "__esModule", {
    value: true
});

Ci.transformArguments = Ci.IS_READ_ONLY = Ci.FIRST_KEY_INDEX = void 0;

Ci.FIRST_KEY_INDEX = 1;

Ci.IS_READ_ONLY = true;

function Mi(e) {
    return [ "TTL", e ];
}

Ci.transformArguments = Mi;

var Yi = {};

Object.defineProperty(Yi, "__esModule", {
    value: true
});

Yi.transformArguments = Yi.IS_READ_ONLY = Yi.FIRST_KEY_INDEX = void 0;

Yi.FIRST_KEY_INDEX = 1;

Yi.IS_READ_ONLY = true;

function wi(e) {
    return [ "TYPE", e ];
}

Yi.transformArguments = wi;

var Fi = {};

Object.defineProperty(Fi, "__esModule", {
    value: true
});

Fi.transformArguments = Fi.FIRST_KEY_INDEX = void 0;

const Xi = C;

Fi.FIRST_KEY_INDEX = 1;

function ji(e) {
    return (0, Xi.pushVerdictArguments)([ "UNLINK" ], e);
}

Fi.transformArguments = ji;

var Ki = {};

Object.defineProperty(Ki, "__esModule", {
    value: true
});

Ki.transformArguments = Ki.FIRST_KEY_INDEX = void 0;

const Ui = C;

Ki.FIRST_KEY_INDEX = 1;

function Bi(e) {
    return (0, Ui.pushVerdictArguments)([ "WATCH" ], e);
}

Ki.transformArguments = Bi;

var xi = {};

Object.defineProperty(xi, "__esModule", {
    value: true
});

xi.transformArguments = xi.FIRST_KEY_INDEX = void 0;

const Gi = C;

xi.FIRST_KEY_INDEX = 1;

function ki(e, t, r) {
    return (0, Gi.pushVerdictArguments)([ "XACK", e, t ], r);
}

xi.transformArguments = ki;

var Hi = {};

Object.defineProperty(Hi, "__esModule", {
    value: true
});

Hi.transformArguments = Hi.FIRST_KEY_INDEX = void 0;

Hi.FIRST_KEY_INDEX = 1;

function Wi(e, t, r, n) {
    const s = [ "XADD", e ];
    if (n?.NOMKSTREAM) {
        s.push("NOMKSTREAM");
    }
    if (n?.TRIM) {
        if (n.TRIM.strategy) {
            s.push(n.TRIM.strategy);
        }
        if (n.TRIM.strategyModifier) {
            s.push(n.TRIM.strategyModifier);
        }
        s.push(n.TRIM.threshold.toString());
        if (n.TRIM.limit) {
            s.push("LIMIT", n.TRIM.limit.toString());
        }
    }
    s.push(t);
    for (const [e, t] of Object.entries(r)) {
        s.push(e, t);
    }
    return s;
}

Hi.transformArguments = Wi;

var Vi = {};

var zi = {};

Object.defineProperty(zi, "__esModule", {
    value: true
});

zi.transformReply = zi.transformArguments = zi.FIRST_KEY_INDEX = void 0;

const Zi = C;

zi.FIRST_KEY_INDEX = 1;

function qi(e, t, r, n, s, o) {
    const i = [ "XAUTOCLAIM", e, t, r, n.toString(), s ];
    if (o?.COUNT) {
        i.push("COUNT", o.COUNT.toString());
    }
    return i;
}

zi.transformArguments = qi;

function $i(e) {
    return {
        nextId: e[0],
        messages: (0, Zi.transformStreamMessagesNullReply)(e[1])
    };
}

zi.transformReply = $i;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = zi;
    var r = zi;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "JUSTID" ];
    }
    e.transformArguments = n;
    function s(e) {
        return {
            nextId: e[0],
            messages: e[1]
        };
    }
    e.transformReply = s;
})(Vi);

var Qi = {};

var Ji = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r, n, s, o, i) {
        const u = (0, t.pushVerdictArguments)([ "XCLAIM", e, r, n, s.toString() ], o);
        if (i?.IDLE) {
            u.push("IDLE", i.IDLE.toString());
        }
        if (i?.TIME) {
            u.push("TIME", (typeof i.TIME === "number" ? i.TIME : i.TIME.getTime()).toString());
        }
        if (i?.RETRYCOUNT) {
            u.push("RETRYCOUNT", i.RETRYCOUNT.toString());
        }
        if (i?.FORCE) {
            u.push("FORCE");
        }
        return u;
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformStreamMessagesNullReply;
        }
    });
})(Ji);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = Ji;
    var r = Ji;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "JUSTID" ];
    }
    e.transformArguments = n;
})(Qi);

var eu = {};

Object.defineProperty(eu, "__esModule", {
    value: true
});

eu.transformArguments = eu.FIRST_KEY_INDEX = void 0;

const tu = C;

eu.FIRST_KEY_INDEX = 1;

function ru(e, t) {
    return (0, tu.pushVerdictArguments)([ "XDEL", e ], t);
}

eu.transformArguments = ru;

var nu = {};

Object.defineProperty(nu, "__esModule", {
    value: true
});

nu.transformArguments = nu.FIRST_KEY_INDEX = void 0;

nu.FIRST_KEY_INDEX = 2;

function su(e, t, r, n) {
    const s = [ "XGROUP", "CREATE", e, t, r ];
    if (n?.MKSTREAM) {
        s.push("MKSTREAM");
    }
    return s;
}

nu.transformArguments = su;

var ou = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 2;
    function t(e, t, r) {
        return [ "XGROUP", "CREATECONSUMER", e, t, r ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(ou);

var iu = {};

Object.defineProperty(iu, "__esModule", {
    value: true
});

iu.transformArguments = iu.FIRST_KEY_INDEX = void 0;

iu.FIRST_KEY_INDEX = 2;

function uu(e, t, r) {
    return [ "XGROUP", "DELCONSUMER", e, t, r ];
}

iu.transformArguments = uu;

var au = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 2;
    function t(e, t) {
        return [ "XGROUP", "DESTROY", e, t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(au);

var cu = {};

Object.defineProperty(cu, "__esModule", {
    value: true
});

cu.transformArguments = cu.FIRST_KEY_INDEX = void 0;

cu.FIRST_KEY_INDEX = 2;

function fu(e, t, r) {
    return [ "XGROUP", "SETID", e, t, r ];
}

cu.transformArguments = fu;

var lu = {};

Object.defineProperty(lu, "__esModule", {
    value: true
});

lu.transformReply = lu.transformArguments = lu.IS_READ_ONLY = lu.FIRST_KEY_INDEX = void 0;

lu.FIRST_KEY_INDEX = 2;

lu.IS_READ_ONLY = true;

function mu(e, t) {
    return [ "XINFO", "CONSUMERS", e, t ];
}

lu.transformArguments = mu;

function du(e) {
    return e.map(e => ({
        name: e[1],
        pending: e[3],
        idle: e[5],
        inactive: e[7]
    }));
}

lu.transformReply = du;

var hu = {};

Object.defineProperty(hu, "__esModule", {
    value: true
});

hu.transformReply = hu.transformArguments = hu.IS_READ_ONLY = hu.FIRST_KEY_INDEX = void 0;

hu.FIRST_KEY_INDEX = 2;

hu.IS_READ_ONLY = true;

function _u(e) {
    return [ "XINFO", "GROUPS", e ];
}

hu.transformArguments = _u;

function Eu(e) {
    return e.map(e => ({
        name: e[1],
        consumers: e[3],
        pending: e[5],
        lastDeliveredId: e[7]
    }));
}

hu.transformReply = Eu;

var pu = {};

Object.defineProperty(pu, "__esModule", {
    value: true
});

pu.transformReply = pu.transformArguments = pu.IS_READ_ONLY = pu.FIRST_KEY_INDEX = void 0;

const Su = C;

pu.FIRST_KEY_INDEX = 2;

pu.IS_READ_ONLY = true;

function Ru(e) {
    return [ "XINFO", "STREAM", e ];
}

pu.transformArguments = Ru;

function Iu(e) {
    const t = {};
    for (let r = 0; r < e.length; r += 2) {
        switch (e[r]) {
          case "length":
            t.length = e[r + 1];
            break;

          case "radix-tree-keys":
            t.radixTreeKeys = e[r + 1];
            break;

          case "radix-tree-nodes":
            t.radixTreeNodes = e[r + 1];
            break;

          case "groups":
            t.groups = e[r + 1];
            break;

          case "last-generated-id":
            t.lastGeneratedId = e[r + 1];
            break;

          case "first-entry":
            t.firstEntry = e[r + 1] ? {
                id: e[r + 1][0],
                message: (0, Su.transformTuplesReply)(e[r + 1][1])
            } : null;
            break;

          case "last-entry":
            t.lastEntry = e[r + 1] ? {
                id: e[r + 1][0],
                message: (0, Su.transformTuplesReply)(e[r + 1][1])
            } : null;
            break;
        }
    }
    return t;
}

pu.transformReply = Iu;

var gu = {};

Object.defineProperty(gu, "__esModule", {
    value: true
});

gu.transformArguments = gu.IS_READ_ONLY = gu.FIRST_KEY_INDEX = void 0;

gu.FIRST_KEY_INDEX = 1;

gu.IS_READ_ONLY = true;

function Au(e) {
    return [ "XLEN", e ];
}

gu.transformArguments = Au;

var vu = {};

Object.defineProperty(vu, "__esModule", {
    value: true
});

vu.transformReply = vu.transformArguments = vu.IS_READ_ONLY = vu.FIRST_KEY_INDEX = void 0;

vu.FIRST_KEY_INDEX = 1;

vu.IS_READ_ONLY = true;

function yu(e, t, r, n, s, o) {
    const i = [ "XPENDING", e, t ];
    if (o?.IDLE) {
        i.push("IDLE", o.IDLE.toString());
    }
    i.push(r, n, s.toString());
    if (o?.consumer) {
        i.push(o.consumer);
    }
    return i;
}

vu.transformArguments = yu;

function bu(e) {
    return e.map(([e, t, r, n]) => ({
        id: e,
        owner: t,
        millisecondsSinceLastDelivery: r,
        deliveriesCounter: n
    }));
}

vu.transformReply = bu;

var Nu = {};

Object.defineProperty(Nu, "__esModule", {
    value: true
});

Nu.transformReply = Nu.transformArguments = Nu.IS_READ_ONLY = Nu.FIRST_KEY_INDEX = void 0;

Nu.FIRST_KEY_INDEX = 1;

Nu.IS_READ_ONLY = true;

function Ou(e, t) {
    return [ "XPENDING", e, t ];
}

Nu.transformArguments = Ou;

function Tu(e) {
    return {
        pending: e[0],
        firstId: e[1],
        lastId: e[2],
        consumers: e[3] === null ? null : e[3].map(([e, t]) => ({
            name: e,
            deliveriesCounter: Number(t)
        }))
    };
}

Nu.transformReply = Tu;

var Du = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    e.IS_READ_ONLY = true;
    function t(e, t, r, n) {
        const s = [ "XRANGE", e, t, r ];
        if (n?.COUNT) {
            s.push("COUNT", n.COUNT.toString());
        }
        return s;
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformStreamMessagesReply;
        }
    });
})(Du);

var Pu = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = e => Array.isArray(e) ? e[0].key : e.key;
    e.FIRST_KEY_INDEX = t;
    e.IS_READ_ONLY = true;
    function r(e, t) {
        const r = [ "XREAD" ];
        if (t?.COUNT) {
            r.push("COUNT", t.COUNT.toString());
        }
        if (typeof t?.BLOCK === "number") {
            r.push("BLOCK", t.BLOCK.toString());
        }
        r.push("STREAMS");
        const n = Array.isArray(e) ? e : [ e ], s = r.length;
        for (let e = 0; e < n.length; e++) {
            const t = n[e];
            r[s + e] = t.key;
            r[s + n.length + e] = t.id;
        }
        return r;
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformStreamsMessagesReply;
        }
    });
})(Pu);

var Lu = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = (e, t, r) => Array.isArray(r) ? r[0].key : r.key;
    e.FIRST_KEY_INDEX = t;
    e.IS_READ_ONLY = true;
    function r(e, t, r, n) {
        const s = [ "XREADGROUP", "GROUP", e, t ];
        if (n?.COUNT) {
            s.push("COUNT", n.COUNT.toString());
        }
        if (typeof n?.BLOCK === "number") {
            s.push("BLOCK", n.BLOCK.toString());
        }
        if (n?.NOACK) {
            s.push("NOACK");
        }
        s.push("STREAMS");
        const o = Array.isArray(r) ? r : [ r ], i = s.length;
        for (let e = 0; e < o.length; e++) {
            const t = o[e];
            s[i + e] = t.key;
            s[i + o.length + e] = t.id;
        }
        return s;
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformStreamsMessagesReply;
        }
    });
})(Lu);

var Cu = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    e.IS_READ_ONLY = true;
    function t(e, t, r, n) {
        const s = [ "XREVRANGE", e, t, r ];
        if (n?.COUNT) {
            s.push("COUNT", n.COUNT.toString());
        }
        return s;
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformStreamMessagesReply;
        }
    });
})(Cu);

var Mu = {};

Object.defineProperty(Mu, "__esModule", {
    value: true
});

Mu.transformArguments = Mu.FIRST_KEY_INDEX = void 0;

Mu.FIRST_KEY_INDEX = 1;

function Yu(e, t, r) {
    const n = [ "XSETID", e, t ];
    if (r?.ENTRIESADDED) {
        n.push("ENTRIESADDED", r.ENTRIESADDED.toString());
    }
    if (r?.MAXDELETEDID) {
        n.push("MAXDELETEDID", r.MAXDELETEDID);
    }
    return n;
}

Mu.transformArguments = Yu;

var wu = {};

Object.defineProperty(wu, "__esModule", {
    value: true
});

wu.transformArguments = wu.FIRST_KEY_INDEX = void 0;

wu.FIRST_KEY_INDEX = 1;

function Fu(e, t, r, n) {
    const s = [ "XTRIM", e, t ];
    if (n?.strategyModifier) {
        s.push(n.strategyModifier);
    }
    s.push(r.toString());
    if (n?.LIMIT) {
        s.push("LIMIT", n.LIMIT.toString());
    }
    return s;
}

wu.transformArguments = Fu;

var Xu = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r, n) {
        const s = [ "ZADD", e ];
        if (n?.NX) {
            s.push("NX");
        } else {
            if (n?.XX) {
                s.push("XX");
            }
            if (n?.GT) {
                s.push("GT");
            } else if (n?.LT) {
                s.push("LT");
            }
        }
        if (n?.CH) {
            s.push("CH");
        }
        if (n?.INCR) {
            s.push("INCR");
        }
        for (const {score: e, value: n} of Array.isArray(r) ? r : [ r ]) {
            s.push((0, t.transformNumberInfinityArgument)(e), n);
        }
        return s;
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformNumberInfinityReply;
        }
    });
})(Xu);

var ju = {};

Object.defineProperty(ju, "__esModule", {
    value: true
});

ju.transformArguments = ju.IS_READ_ONLY = ju.FIRST_KEY_INDEX = void 0;

ju.FIRST_KEY_INDEX = 1;

ju.IS_READ_ONLY = true;

function Ku(e) {
    return [ "ZCARD", e ];
}

ju.transformArguments = Ku;

var Uu = {};

Object.defineProperty(Uu, "__esModule", {
    value: true
});

Uu.transformArguments = Uu.IS_READ_ONLY = Uu.FIRST_KEY_INDEX = void 0;

const Bu = C;

Uu.FIRST_KEY_INDEX = 1;

Uu.IS_READ_ONLY = true;

function xu(e, t, r) {
    return [ "ZCOUNT", e, (0, Bu.transformStringNumberInfinityArgument)(t), (0, Bu.transformStringNumberInfinityArgument)(r) ];
}

Uu.transformArguments = xu;

var Gu = {};

var ku = {};

Object.defineProperty(ku, "__esModule", {
    value: true
});

ku.transformArguments = ku.IS_READ_ONLY = ku.FIRST_KEY_INDEX = void 0;

const Hu = C;

ku.FIRST_KEY_INDEX = 2;

ku.IS_READ_ONLY = true;

function Wu(e) {
    return (0, Hu.pushVerdictArgument)([ "ZDIFF" ], e);
}

ku.transformArguments = Wu;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = ku;
    var r = ku;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Gu);

var Vu = {};

Object.defineProperty(Vu, "__esModule", {
    value: true
});

Vu.transformArguments = Vu.FIRST_KEY_INDEX = void 0;

const zu = C;

Vu.FIRST_KEY_INDEX = 1;

function Zu(e, t) {
    return (0, zu.pushVerdictArgument)([ "ZDIFFSTORE", e ], t);
}

Vu.transformArguments = Zu;

var qu = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    function r(e, r, n) {
        return [ "ZINCRBY", e, (0, t.transformNumberInfinityArgument)(r), n ];
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformNumberInfinityReply;
        }
    });
})(qu);

var $u = {};

var Qu = {};

Object.defineProperty(Qu, "__esModule", {
    value: true
});

Qu.transformArguments = Qu.IS_READ_ONLY = Qu.FIRST_KEY_INDEX = void 0;

const Ju = C;

Qu.FIRST_KEY_INDEX = 2;

Qu.IS_READ_ONLY = true;

function ea(e, t) {
    const r = (0, Ju.pushVerdictArgument)([ "ZINTER" ], e);
    if (t?.WEIGHTS) {
        r.push("WEIGHTS", ...t.WEIGHTS.map(e => e.toString()));
    }
    if (t?.AGGREGATE) {
        r.push("AGGREGATE", t.AGGREGATE);
    }
    return r;
}

Qu.transformArguments = ea;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Qu;
    var r = Qu;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})($u);

var ta = {};

Object.defineProperty(ta, "__esModule", {
    value: true
});

ta.transformArguments = ta.IS_READ_ONLY = ta.FIRST_KEY_INDEX = void 0;

const ra = C;

ta.FIRST_KEY_INDEX = 2;

ta.IS_READ_ONLY = true;

function na(e, t) {
    const r = (0, ra.pushVerdictArgument)([ "ZINTERCARD" ], e);
    if (t) {
        r.push("LIMIT", t.toString());
    }
    return r;
}

ta.transformArguments = na;

var sa = {};

Object.defineProperty(sa, "__esModule", {
    value: true
});

sa.transformArguments = sa.FIRST_KEY_INDEX = void 0;

const oa = C;

sa.FIRST_KEY_INDEX = 1;

function ia(e, t, r) {
    const n = (0, oa.pushVerdictArgument)([ "ZINTERSTORE", e ], t);
    if (r?.WEIGHTS) {
        n.push("WEIGHTS", ...r.WEIGHTS.map(e => e.toString()));
    }
    if (r?.AGGREGATE) {
        n.push("AGGREGATE", r.AGGREGATE);
    }
    return n;
}

sa.transformArguments = ia;

var ua = {};

Object.defineProperty(ua, "__esModule", {
    value: true
});

ua.transformArguments = ua.IS_READ_ONLY = ua.FIRST_KEY_INDEX = void 0;

ua.FIRST_KEY_INDEX = 1;

ua.IS_READ_ONLY = true;

function aa(e, t, r) {
    return [ "ZLEXCOUNT", e, t, r ];
}

ua.transformArguments = aa;

var ca = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = C;
    e.FIRST_KEY_INDEX = 1;
    e.IS_READ_ONLY = true;
    function r(e, r) {
        return (0, t.pushVerdictArguments)([ "ZMSCORE", e ], r);
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformNumberInfinityNullArrayReply;
        }
    });
})(ca);

var fa = {};

var la = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e) {
        return [ "ZPOPMAX", e ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformSortedSetMemberNullReply;
        }
    });
})(la);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = la;
    var r = la;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    function n(e, r) {
        return [ ...(0, t.transformArguments)(e), r.toString() ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(fa);

var ma = {};

var da = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e) {
        return [ "ZPOPMIN", e ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformSortedSetMemberNullReply;
        }
    });
})(da);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = da;
    var r = da;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    function n(e, r) {
        return [ ...(0, t.transformArguments)(e), r.toString() ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(ma);

var ha = {};

var _a = {};

var Ea = {};

Object.defineProperty(Ea, "__esModule", {
    value: true
});

Ea.transformArguments = Ea.IS_READ_ONLY = Ea.FIRST_KEY_INDEX = void 0;

Ea.FIRST_KEY_INDEX = 1;

Ea.IS_READ_ONLY = true;

function pa(e) {
    return [ "ZRANDMEMBER", e ];
}

Ea.transformArguments = pa;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Ea;
    var r = Ea;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r) {
        return [ ...(0, t.transformArguments)(e), r.toString() ];
    }
    e.transformArguments = n;
})(_a);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = _a;
    var r = _a;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(ha);

var Sa = {};

var Ra = {};

Object.defineProperty(Ra, "__esModule", {
    value: true
});

Ra.transformArguments = Ra.IS_READ_ONLY = Ra.FIRST_KEY_INDEX = void 0;

const Ia = C;

Ra.FIRST_KEY_INDEX = 1;

Ra.IS_READ_ONLY = true;

function ga(e, t, r, n) {
    const s = [ "ZRANGE", e, (0, Ia.transformStringNumberInfinityArgument)(t), (0, Ia.transformStringNumberInfinityArgument)(r) ];
    switch (n?.BY) {
      case "SCORE":
        s.push("BYSCORE");
        break;

      case "LEX":
        s.push("BYLEX");
        break;
    }
    if (n?.REV) {
        s.push("REV");
    }
    if (n?.LIMIT) {
        s.push("LIMIT", n.LIMIT.offset.toString(), n.LIMIT.count.toString());
    }
    return s;
}

Ra.transformArguments = ga;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Ra;
    var r = Ra;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Sa);

var Aa = {};

Object.defineProperty(Aa, "__esModule", {
    value: true
});

Aa.transformArguments = Aa.IS_READ_ONLY = Aa.FIRST_KEY_INDEX = void 0;

const va = C;

Aa.FIRST_KEY_INDEX = 1;

Aa.IS_READ_ONLY = true;

function ya(e, t, r, n) {
    const s = [ "ZRANGEBYLEX", e, (0, va.transformStringNumberInfinityArgument)(t), (0, 
    va.transformStringNumberInfinityArgument)(r) ];
    if (n?.LIMIT) {
        s.push("LIMIT", n.LIMIT.offset.toString(), n.LIMIT.count.toString());
    }
    return s;
}

Aa.transformArguments = ya;

var ba = {};

var Na = {};

Object.defineProperty(Na, "__esModule", {
    value: true
});

Na.transformArguments = Na.IS_READ_ONLY = Na.FIRST_KEY_INDEX = void 0;

const Oa = C;

Na.FIRST_KEY_INDEX = 1;

Na.IS_READ_ONLY = true;

function Ta(e, t, r, n) {
    const s = [ "ZRANGEBYSCORE", e, (0, Oa.transformStringNumberInfinityArgument)(t), (0, 
    Oa.transformStringNumberInfinityArgument)(r) ];
    if (n?.LIMIT) {
        s.push("LIMIT", n.LIMIT.offset.toString(), n.LIMIT.count.toString());
    }
    return s;
}

Na.transformArguments = Ta;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Na;
    var r = Na;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(e, r, n, s) {
        return [ ...(0, t.transformArguments)(e, r, n, s), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(ba);

var Da = {};

Object.defineProperty(Da, "__esModule", {
    value: true
});

Da.transformReply = Da.transformArguments = Da.FIRST_KEY_INDEX = void 0;

const Pa = C;

Da.FIRST_KEY_INDEX = 1;

function La(e, t, r, n, s) {
    const o = [ "ZRANGESTORE", e, t, (0, Pa.transformStringNumberInfinityArgument)(r), (0, 
    Pa.transformStringNumberInfinityArgument)(n) ];
    switch (s?.BY) {
      case "SCORE":
        o.push("BYSCORE");
        break;

      case "LEX":
        o.push("BYLEX");
        break;
    }
    if (s?.REV) {
        o.push("REV");
    }
    if (s?.LIMIT) {
        o.push("LIMIT", s.LIMIT.offset.toString(), s.LIMIT.count.toString());
    }
    if (s?.WITHSCORES) {
        o.push("WITHSCORES");
    }
    return o;
}

Da.transformArguments = La;

function Ca(e) {
    if (typeof e !== "number") {
        throw new TypeError(`Upgrade to Redis 6.2.5 and up (https://github.com/redis/redis/pull/9089)`);
    }
    return e;
}

Da.transformReply = Ca;

var Ma = {};

Object.defineProperty(Ma, "__esModule", {
    value: true
});

Ma.transformArguments = Ma.IS_READ_ONLY = Ma.FIRST_KEY_INDEX = void 0;

Ma.FIRST_KEY_INDEX = 1;

Ma.IS_READ_ONLY = true;

function Ya(e, t) {
    return [ "ZRANK", e, t ];
}

Ma.transformArguments = Ya;

var wa = {};

Object.defineProperty(wa, "__esModule", {
    value: true
});

wa.transformArguments = wa.FIRST_KEY_INDEX = void 0;

const Fa = C;

wa.FIRST_KEY_INDEX = 1;

function Xa(e, t) {
    return (0, Fa.pushVerdictArguments)([ "ZREM", e ], t);
}

wa.transformArguments = Xa;

var ja = {};

Object.defineProperty(ja, "__esModule", {
    value: true
});

ja.transformArguments = ja.FIRST_KEY_INDEX = void 0;

const Ka = C;

ja.FIRST_KEY_INDEX = 1;

function Ua(e, t, r) {
    return [ "ZREMRANGEBYLEX", e, (0, Ka.transformStringNumberInfinityArgument)(t), (0, 
    Ka.transformStringNumberInfinityArgument)(r) ];
}

ja.transformArguments = Ua;

var Ba = {};

Object.defineProperty(Ba, "__esModule", {
    value: true
});

Ba.transformArguments = Ba.FIRST_KEY_INDEX = void 0;

Ba.FIRST_KEY_INDEX = 1;

function xa(e, t, r) {
    return [ "ZREMRANGEBYRANK", e, t.toString(), r.toString() ];
}

Ba.transformArguments = xa;

var Ga = {};

Object.defineProperty(Ga, "__esModule", {
    value: true
});

Ga.transformArguments = Ga.FIRST_KEY_INDEX = void 0;

const ka = C;

Ga.FIRST_KEY_INDEX = 1;

function Ha(e, t, r) {
    return [ "ZREMRANGEBYSCORE", e, (0, ka.transformStringNumberInfinityArgument)(t), (0, 
    ka.transformStringNumberInfinityArgument)(r) ];
}

Ga.transformArguments = Ha;

var Wa = {};

Object.defineProperty(Wa, "__esModule", {
    value: true
});

Wa.transformArguments = Wa.IS_READ_ONLY = Wa.FIRST_KEY_INDEX = void 0;

Wa.FIRST_KEY_INDEX = 1;

Wa.IS_READ_ONLY = true;

function Va(e, t) {
    return [ "ZREVRANK", e, t ];
}

Wa.transformArguments = Va;

var za = {};

Object.defineProperty(za, "__esModule", {
    value: true
});

za.transformReply = za.transformArguments = za.IS_READ_ONLY = za.FIRST_KEY_INDEX = void 0;

const Za = C;

za.FIRST_KEY_INDEX = 1;

za.IS_READ_ONLY = true;

function qa(e, t, r) {
    return (0, Za.pushScanArguments)([ "ZSCAN", e ], t, r);
}

za.transformArguments = qa;

function $a([e, t]) {
    const r = [];
    for (let e = 0; e < t.length; e += 2) {
        r.push({
            value: t[e],
            score: (0, Za.transformNumberInfinityReply)(t[e + 1])
        });
    }
    return {
        cursor: Number(e),
        members: r
    };
}

za.transformReply = $a;

var Qa = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    e.IS_READ_ONLY = true;
    function t(e, t) {
        return [ "ZSCORE", e, t ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformNumberInfinityNullReply;
        }
    });
})(Qa);

var Ja = {};

var ec = {};

Object.defineProperty(ec, "__esModule", {
    value: true
});

ec.transformArguments = ec.IS_READ_ONLY = ec.FIRST_KEY_INDEX = void 0;

const tc = C;

ec.FIRST_KEY_INDEX = 2;

ec.IS_READ_ONLY = true;

function rc(e, t) {
    const r = (0, tc.pushVerdictArgument)([ "ZUNION" ], e);
    if (t?.WEIGHTS) {
        r.push("WEIGHTS", ...t.WEIGHTS.map(e => e.toString()));
    }
    if (t?.AGGREGATE) {
        r.push("AGGREGATE", t.AGGREGATE);
    }
    return r;
}

ec.transformArguments = rc;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = ec;
    var r = ec;
    Object.defineProperty(e, "FIRST_KEY_INDEX", {
        enumerable: true,
        get: function() {
            return r.FIRST_KEY_INDEX;
        }
    });
    Object.defineProperty(e, "IS_READ_ONLY", {
        enumerable: true,
        get: function() {
            return r.IS_READ_ONLY;
        }
    });
    function n(...e) {
        return [ ...(0, t.transformArguments)(...e), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Ja);

var nc = {};

Object.defineProperty(nc, "__esModule", {
    value: true
});

nc.transformArguments = nc.FIRST_KEY_INDEX = void 0;

const sc = C;

nc.FIRST_KEY_INDEX = 1;

function oc(e, t, r) {
    const n = (0, sc.pushVerdictArgument)([ "ZUNIONSTORE", e ], t);
    if (r?.WEIGHTS) {
        n.push("WEIGHTS", ...r.WEIGHTS.map(e => e.toString()));
    }
    if (r?.AGGREGATE) {
        n.push("AGGREGATE", r.AGGREGATE);
    }
    return n;
}

nc.transformArguments = oc;

Object.defineProperty(A, "__esModule", {
    value: true
});

const ic = v;

const uc = b;

const ac = O;

const cc = D;

const fc = L;

const lc = ve;

const mc = be;

const dc = Oe;

const hc = Le;

const _c = we;

const Ec = Fe;

const pc = je;

const Sc = Ge;

const Rc = Ve;

const Ic = ze;

const gc = Ze;

const Ac = $e;

const vc = Je;

const yc = rt;

const bc = st;

const Nc = ut;

const Oc = ft;

const Tc = dt;

const Dc = Et;

const Pc = Rt;

const Lc = It;

const Cc = gt;

const Mc = vt;

const Yc = Nt;

const wc = Dt;

const Fc = Lt;

const Xc = Yt;

const jc = Xt;

const Kc = Bt;

const Uc = xt;

const Bc = Ht;

const xc = Wt;

const Gc = Zt;

const kc = qt;

const Hc = Jt;

const Wc = er;

const Vc = nr;

const zc = sr;

const Zc = or;

const qc = ir;

const $c = cr;

const Qc = fr;

const Jc = mr;

const ef = hr;

const tf = Er;

const rf = Rr;

const nf = gr;

const sf = vr;

const of = Nr;

const uf = Or;

const af = Pr;

const cf = Mr;

const ff = Fr;

const lf = jr;

const mf = Kr;

const df = Br;

const hf = Gr;

const _f = Hr;

const Ef = Vr;

const pf = qr;

const Sf = Jr;

const Rf = rn;

const If = on;

const gf = cn;

const Af = mn;

const vf = dn;

const yf = hn;

const bf = En;

const Nf = In;

const Of = gn;

const Tf = On;

const Df = Tn;

const Pf = Pn;

const Lf = Mn;

const Cf = wn;

const Mf = Xn;

const Yf = Kn;

const wf = Bn;

const Ff = kn;

const Xf = Hn;

const jf = xn;

const Kf = Wn;

const Uf = zn;

const Bf = qn;

const xf = Qn;

const Gf = Te;

const kf = es;

const Hf = rs;

const Wf = ss;

const Vf = os;

const zf = us;

const Zf = fs;

const qf = ds;

const $f = _s;

const Qf = ps;

const Jf = Rs;

const el = gs;

const tl = vs;

const rl = bs;

const nl = Os;

const sl = Ts;

const ol = Ps;

const il = Cs;

const ul = Ys;

const al = Fs;

const cl = Xs;

const fl = js;

const ll = Ks;

const ml = Bs;

const dl = xs;

const hl = Hs;

const _l = zs;

const El = qs;

const pl = Qs;

const Sl = eo;

const Rl = ro;

const Il = no;

const gl = oo;

const Al = uo;

const vl = co;

const yl = lo;

const bl = _o;

const Nl = So;

const Ol = go;

const Tl = vo;

const Dl = No;

const Pl = Do;

const Ll = Lo;

const Cl = Mo;

const Ml = wo;

const Yl = Fo;

const wl = jo;

const Fl = Bo;

const Xl = ko;

const jl = Vo;

const Kl = zo;

const Ul = qo;

const Bl = $o;

const xl = Qo;

const Gl = ti;

const kl = ri;

const Hl = ui;

const Wl = ci;

const Vl = li;

const zl = mi;

const Zl = hi;

const ql = pi;

const $l = gi;

const Ql = vi;

const Jl = Ni;

const em = Di;

const tm = Ci;

const rm = Yi;

const nm = Fi;

const sm = Ki;

const om = xi;

const im = Hi;

const um = Vi;

const am = zi;

const cm = Qi;

const fm = Ji;

const lm = eu;

const mm = nu;

const dm = ou;

const hm = iu;

const _m = au;

const Em = cu;

const pm = lu;

const Sm = hu;

const Rm = pu;

const Im = gu;

const gm = vu;

const Am = Nu;

const vm = Du;

const ym = Pu;

const bm = Lu;

const Nm = Cu;

const Om = Mu;

const Tm = wu;

const Dm = Xu;

const Pm = ju;

const Lm = Uu;

const Cm = Gu;

const Mm = ku;

const Ym = Vu;

const wm = qu;

const Fm = $u;

const Xm = Qu;

const jm = ta;

const Km = sa;

const Um = ua;

const Bm = Ke;

const xm = ca;

const Gm = fa;

const km = la;

const Hm = ma;

const Wm = da;

const Vm = ha;

const zm = _a;

const Zm = Ea;

const qm = Sa;

const $m = Ra;

const Qm = Aa;

const Jm = ba;

const ed = Na;

const td = Da;

const rd = Ma;

const nd = wa;

const sd = ja;

const od = Ba;

const id = Ga;

const ud = Wa;

const ad = za;

const cd = Qa;

const fd = Ja;

const ld = ec;

const md = nc;

A.default = {
    APPEND: ic,
    append: ic,
    BITCOUNT: uc,
    bitCount: uc,
    BITFIELD_RO: ac,
    bitFieldRo: ac,
    BITFIELD: cc,
    bitField: cc,
    BITOP: fc,
    bitOp: fc,
    BITPOS: lc,
    bitPos: lc,
    BLMOVE: mc,
    blMove: mc,
    BLMPOP: dc,
    blmPop: dc,
    BLPOP: hc,
    blPop: hc,
    BRPOP: _c,
    brPop: _c,
    BRPOPLPUSH: Ec,
    brPopLPush: Ec,
    BZMPOP: pc,
    bzmPop: pc,
    BZPOPMAX: Sc,
    bzPopMax: Sc,
    BZPOPMIN: Rc,
    bzPopMin: Rc,
    COPY: Ic,
    copy: Ic,
    DECR: gc,
    decr: gc,
    DECRBY: Ac,
    decrBy: Ac,
    DEL: vc,
    del: vc,
    DUMP: yc,
    dump: yc,
    EVAL_RO: bc,
    evalRo: bc,
    EVAL: Nc,
    eval: Nc,
    EVALSHA: Tc,
    evalSha: Tc,
    EVALSHA_RO: Oc,
    evalShaRo: Oc,
    EXISTS: Dc,
    exists: Dc,
    EXPIRE: Pc,
    expire: Pc,
    EXPIREAT: Lc,
    expireAt: Lc,
    EXPIRETIME: Cc,
    expireTime: Cc,
    FCALL_RO: Mc,
    fCallRo: Mc,
    FCALL: Yc,
    fCall: Yc,
    GEOADD: wc,
    geoAdd: wc,
    GEODIST: Fc,
    geoDist: Fc,
    GEOHASH: Xc,
    geoHash: Xc,
    GEOPOS: jc,
    geoPos: jc,
    GEORADIUS_RO_WITH: Kc,
    geoRadiusRoWith: Kc,
    GEORADIUS_RO: Uc,
    geoRadiusRo: Uc,
    GEORADIUS_WITH: Bc,
    geoRadiusWith: Bc,
    GEORADIUS: xc,
    geoRadius: xc,
    GEORADIUSBYMEMBER_RO_WITH: Gc,
    geoRadiusByMemberRoWith: Gc,
    GEORADIUSBYMEMBER_RO: kc,
    geoRadiusByMemberRo: kc,
    GEORADIUSBYMEMBER_WITH: Hc,
    geoRadiusByMemberWith: Hc,
    GEORADIUSBYMEMBER: Wc,
    geoRadiusByMember: Wc,
    GEORADIUSBYMEMBERSTORE: Vc,
    geoRadiusByMemberStore: Vc,
    GEORADIUSSTORE: zc,
    geoRadiusStore: zc,
    GEOSEARCH_WITH: Zc,
    geoSearchWith: Zc,
    GEOSEARCH: qc,
    geoSearch: qc,
    GEOSEARCHSTORE: $c,
    geoSearchStore: $c,
    GET: Qc,
    get: Qc,
    GETBIT: Jc,
    getBit: Jc,
    GETDEL: ef,
    getDel: ef,
    GETEX: tf,
    getEx: tf,
    GETRANGE: rf,
    getRange: rf,
    GETSET: nf,
    getSet: nf,
    HDEL: sf,
    hDel: sf,
    HEXISTS: of,
    hExists: of,
    HEXPIRE: uf,
    hExpire: uf,
    HEXPIREAT: af,
    hExpireAt: af,
    HEXPIRETIME: cf,
    hExpireTime: cf,
    HGET: ff,
    hGet: ff,
    HGETALL: lf,
    hGetAll: lf,
    HINCRBY: mf,
    hIncrBy: mf,
    HINCRBYFLOAT: df,
    hIncrByFloat: df,
    HKEYS: hf,
    hKeys: hf,
    HLEN: _f,
    hLen: _f,
    HMGET: Ef,
    hmGet: Ef,
    HPERSIST: pf,
    hPersist: pf,
    HPEXPIRE: Sf,
    hpExpire: Sf,
    HPEXPIREAT: Rf,
    hpExpireAt: Rf,
    HPEXPIRETIME: If,
    hpExpireTime: If,
    HPTTL: gf,
    hpTTL: gf,
    HRANDFIELD_COUNT_WITHVALUES: Af,
    hRandFieldCountWithValues: Af,
    HRANDFIELD_COUNT: vf,
    hRandFieldCount: vf,
    HRANDFIELD: yf,
    hRandField: yf,
    HSCAN: bf,
    hScan: bf,
    HSCAN_NOVALUES: Nf,
    hScanNoValues: Nf,
    HSET: Of,
    hSet: Of,
    HSETNX: Tf,
    hSetNX: Tf,
    HSTRLEN: Df,
    hStrLen: Df,
    HTTL: Pf,
    hTTL: Pf,
    HVALS: Lf,
    hVals: Lf,
    INCR: Cf,
    incr: Cf,
    INCRBY: Mf,
    incrBy: Mf,
    INCRBYFLOAT: Yf,
    incrByFloat: Yf,
    LCS_IDX_WITHMATCHLEN: wf,
    lcsIdxWithMatchLen: wf,
    LCS_IDX: Ff,
    lcsIdx: Ff,
    LCS_LEN: Xf,
    lcsLen: Xf,
    LCS: jf,
    lcs: jf,
    LINDEX: Kf,
    lIndex: Kf,
    LINSERT: Uf,
    lInsert: Uf,
    LLEN: Bf,
    lLen: Bf,
    LMOVE: xf,
    lMove: xf,
    LMPOP: Gf,
    lmPop: Gf,
    LPOP_COUNT: kf,
    lPopCount: kf,
    LPOP: Hf,
    lPop: Hf,
    LPOS_COUNT: Wf,
    lPosCount: Wf,
    LPOS: Vf,
    lPos: Vf,
    LPUSH: zf,
    lPush: zf,
    LPUSHX: Zf,
    lPushX: Zf,
    LRANGE: qf,
    lRange: qf,
    LREM: $f,
    lRem: $f,
    LSET: Qf,
    lSet: Qf,
    LTRIM: Jf,
    lTrim: Jf,
    MGET: el,
    mGet: el,
    MIGRATE: tl,
    migrate: tl,
    MSET: rl,
    mSet: rl,
    MSETNX: nl,
    mSetNX: nl,
    OBJECT_ENCODING: sl,
    objectEncoding: sl,
    OBJECT_FREQ: ol,
    objectFreq: ol,
    OBJECT_IDLETIME: il,
    objectIdleTime: il,
    OBJECT_REFCOUNT: ul,
    objectRefCount: ul,
    PERSIST: al,
    persist: al,
    PEXPIRE: cl,
    pExpire: cl,
    PEXPIREAT: fl,
    pExpireAt: fl,
    PEXPIRETIME: ll,
    pExpireTime: ll,
    PFADD: ml,
    pfAdd: ml,
    PFCOUNT: dl,
    pfCount: dl,
    PFMERGE: hl,
    pfMerge: hl,
    PSETEX: _l,
    pSetEx: _l,
    PTTL: El,
    pTTL: El,
    PUBLISH: pl,
    publish: pl,
    RENAME: Sl,
    rename: Sl,
    RENAMENX: Rl,
    renameNX: Rl,
    RESTORE: Il,
    restore: Il,
    RPOP_COUNT: gl,
    rPopCount: gl,
    RPOP: Al,
    rPop: Al,
    RPOPLPUSH: vl,
    rPopLPush: vl,
    RPUSH: yl,
    rPush: yl,
    RPUSHX: bl,
    rPushX: bl,
    SADD: Nl,
    sAdd: Nl,
    SCARD: Ol,
    sCard: Ol,
    SDIFF: Tl,
    sDiff: Tl,
    SDIFFSTORE: Dl,
    sDiffStore: Dl,
    SINTER: wl,
    sInter: wl,
    SINTERCARD: Fl,
    sInterCard: Fl,
    SINTERSTORE: Xl,
    sInterStore: Xl,
    SET: Pl,
    set: Pl,
    SETBIT: Ll,
    setBit: Ll,
    SETEX: Cl,
    setEx: Cl,
    SETNX: Ml,
    setNX: Ml,
    SETRANGE: Yl,
    setRange: Yl,
    SISMEMBER: jl,
    sIsMember: jl,
    SMEMBERS: Kl,
    sMembers: Kl,
    SMISMEMBER: Ul,
    smIsMember: Ul,
    SMOVE: Bl,
    sMove: Bl,
    SORT_RO: xl,
    sortRo: xl,
    SORT_STORE: Gl,
    sortStore: Gl,
    SORT: kl,
    sort: kl,
    SPOP: Hl,
    sPop: Hl,
    SPUBLISH: Wl,
    sPublish: Wl,
    SRANDMEMBER_COUNT: Vl,
    sRandMemberCount: Vl,
    SRANDMEMBER: zl,
    sRandMember: zl,
    SREM: Zl,
    sRem: Zl,
    SSCAN: ql,
    sScan: ql,
    STRLEN: $l,
    strLen: $l,
    SUNION: Ql,
    sUnion: Ql,
    SUNIONSTORE: Jl,
    sUnionStore: Jl,
    TOUCH: em,
    touch: em,
    TTL: tm,
    ttl: tm,
    TYPE: rm,
    type: rm,
    UNLINK: nm,
    unlink: nm,
    WATCH: sm,
    watch: sm,
    XACK: om,
    xAck: om,
    XADD: im,
    xAdd: im,
    XAUTOCLAIM_JUSTID: um,
    xAutoClaimJustId: um,
    XAUTOCLAIM: am,
    xAutoClaim: am,
    XCLAIM: fm,
    xClaim: fm,
    XCLAIM_JUSTID: cm,
    xClaimJustId: cm,
    XDEL: lm,
    xDel: lm,
    XGROUP_CREATE: mm,
    xGroupCreate: mm,
    XGROUP_CREATECONSUMER: dm,
    xGroupCreateConsumer: dm,
    XGROUP_DELCONSUMER: hm,
    xGroupDelConsumer: hm,
    XGROUP_DESTROY: _m,
    xGroupDestroy: _m,
    XGROUP_SETID: Em,
    xGroupSetId: Em,
    XINFO_CONSUMERS: pm,
    xInfoConsumers: pm,
    XINFO_GROUPS: Sm,
    xInfoGroups: Sm,
    XINFO_STREAM: Rm,
    xInfoStream: Rm,
    XLEN: Im,
    xLen: Im,
    XPENDING_RANGE: gm,
    xPendingRange: gm,
    XPENDING: Am,
    xPending: Am,
    XRANGE: vm,
    xRange: vm,
    XREAD: ym,
    xRead: ym,
    XREADGROUP: bm,
    xReadGroup: bm,
    XREVRANGE: Nm,
    xRevRange: Nm,
    XSETID: Om,
    xSetId: Om,
    XTRIM: Tm,
    xTrim: Tm,
    ZADD: Dm,
    zAdd: Dm,
    ZCARD: Pm,
    zCard: Pm,
    ZCOUNT: Lm,
    zCount: Lm,
    ZDIFF_WITHSCORES: Cm,
    zDiffWithScores: Cm,
    ZDIFF: Mm,
    zDiff: Mm,
    ZDIFFSTORE: Ym,
    zDiffStore: Ym,
    ZINCRBY: wm,
    zIncrBy: wm,
    ZINTER_WITHSCORES: Fm,
    zInterWithScores: Fm,
    ZINTER: Xm,
    zInter: Xm,
    ZINTERCARD: jm,
    zInterCard: jm,
    ZINTERSTORE: Km,
    zInterStore: Km,
    ZLEXCOUNT: Um,
    zLexCount: Um,
    ZMPOP: Bm,
    zmPop: Bm,
    ZMSCORE: xm,
    zmScore: xm,
    ZPOPMAX_COUNT: Gm,
    zPopMaxCount: Gm,
    ZPOPMAX: km,
    zPopMax: km,
    ZPOPMIN_COUNT: Hm,
    zPopMinCount: Hm,
    ZPOPMIN: Wm,
    zPopMin: Wm,
    ZRANDMEMBER_COUNT_WITHSCORES: Vm,
    zRandMemberCountWithScores: Vm,
    ZRANDMEMBER_COUNT: zm,
    zRandMemberCount: zm,
    ZRANDMEMBER: Zm,
    zRandMember: Zm,
    ZRANGE_WITHSCORES: qm,
    zRangeWithScores: qm,
    ZRANGE: $m,
    zRange: $m,
    ZRANGEBYLEX: Qm,
    zRangeByLex: Qm,
    ZRANGEBYSCORE_WITHSCORES: Jm,
    zRangeByScoreWithScores: Jm,
    ZRANGEBYSCORE: ed,
    zRangeByScore: ed,
    ZRANGESTORE: td,
    zRangeStore: td,
    ZRANK: rd,
    zRank: rd,
    ZREM: nd,
    zRem: nd,
    ZREMRANGEBYLEX: sd,
    zRemRangeByLex: sd,
    ZREMRANGEBYRANK: od,
    zRemRangeByRank: od,
    ZREMRANGEBYSCORE: id,
    zRemRangeByScore: id,
    ZREVRANK: ud,
    zRevRank: ud,
    ZSCAN: ad,
    zScan: ad,
    ZSCORE: cd,
    zScore: cd,
    ZUNION_WITHSCORES: fd,
    zUnionWithScores: fd,
    ZUNION: ld,
    zUnion: ld,
    ZUNIONSTORE: md,
    zUnionStore: md
};

var dd = {};

Object.defineProperty(dd, "__esModule", {
    value: true
});

dd.transformArguments = void 0;

function hd(e) {
    const t = [ "ACL", "CAT" ];
    if (e) {
        t.push(e);
    }
    return t;
}

dd.transformArguments = hd;

var _d = {};

Object.defineProperty(_d, "__esModule", {
    value: true
});

_d.transformArguments = void 0;

const Ed = C;

function pd(e) {
    return (0, Ed.pushVerdictArguments)([ "ACL", "DELUSER" ], e);
}

_d.transformArguments = pd;

var Sd = {};

Object.defineProperty(Sd, "__esModule", {
    value: true
});

Sd.transformArguments = Sd.IS_READ_ONLY = void 0;

Sd.IS_READ_ONLY = true;

function Rd(e, t) {
    return [ "ACL", "DRYRUN", e, ...t ];
}

Sd.transformArguments = Rd;

var Id = {};

Object.defineProperty(Id, "__esModule", {
    value: true
});

Id.transformArguments = void 0;

function gd(e) {
    const t = [ "ACL", "GENPASS" ];
    if (e) {
        t.push(e.toString());
    }
    return t;
}

Id.transformArguments = gd;

var Ad = {};

Object.defineProperty(Ad, "__esModule", {
    value: true
});

Ad.transformReply = Ad.transformArguments = void 0;

function vd(e) {
    return [ "ACL", "GETUSER", e ];
}

Ad.transformArguments = vd;

function yd(e) {
    return {
        flags: e[1],
        passwords: e[3],
        commands: e[5],
        keys: e[7],
        channels: e[9],
        selectors: e[11]
    };
}

Ad.transformReply = yd;

var bd = {};

Object.defineProperty(bd, "__esModule", {
    value: true
});

bd.transformArguments = void 0;

function Nd() {
    return [ "ACL", "LIST" ];
}

bd.transformArguments = Nd;

var Od = {};

Object.defineProperty(Od, "__esModule", {
    value: true
});

Od.transformArguments = void 0;

function Td() {
    return [ "ACL", "LOAD" ];
}

Od.transformArguments = Td;

var Dd = {};

Object.defineProperty(Dd, "__esModule", {
    value: true
});

Dd.transformArguments = void 0;

function Pd() {
    return [ "ACL", "LOG", "RESET" ];
}

Dd.transformArguments = Pd;

var Ld = {};

Object.defineProperty(Ld, "__esModule", {
    value: true
});

Ld.transformReply = Ld.transformArguments = void 0;

function Cd(e) {
    const t = [ "ACL", "LOG" ];
    if (e) {
        t.push(e.toString());
    }
    return t;
}

Ld.transformArguments = Cd;

function Md(e) {
    return e.map(e => ({
        count: e[1],
        reason: e[3],
        context: e[5],
        object: e[7],
        username: e[9],
        ageSeconds: Number(e[11]),
        clientInfo: e[13]
    }));
}

Ld.transformReply = Md;

var Yd = {};

Object.defineProperty(Yd, "__esModule", {
    value: true
});

Yd.transformArguments = void 0;

function wd() {
    return [ "ACL", "SAVE" ];
}

Yd.transformArguments = wd;

var Fd = {};

Object.defineProperty(Fd, "__esModule", {
    value: true
});

Fd.transformArguments = void 0;

const Xd = C;

function jd(e, t) {
    return (0, Xd.pushVerdictArguments)([ "ACL", "SETUSER", e ], t);
}

Fd.transformArguments = jd;

var Kd = {};

Object.defineProperty(Kd, "__esModule", {
    value: true
});

Kd.transformArguments = void 0;

function Ud() {
    return [ "ACL", "USERS" ];
}

Kd.transformArguments = Ud;

var Bd = {};

Object.defineProperty(Bd, "__esModule", {
    value: true
});

Bd.transformArguments = void 0;

function xd() {
    return [ "ACL", "WHOAMI" ];
}

Bd.transformArguments = xd;

var Gd = {};

Object.defineProperty(Gd, "__esModule", {
    value: true
});

Gd.transformArguments = void 0;

function kd() {
    return [ "ASKING" ];
}

Gd.transformArguments = kd;

var Hd = {};

Object.defineProperty(Hd, "__esModule", {
    value: true
});

Hd.transformArguments = void 0;

function Wd({username: e, password: t}) {
    if (!e) {
        return [ "AUTH", t ];
    }
    return [ "AUTH", e, t ];
}

Hd.transformArguments = Wd;

var Vd = {};

Object.defineProperty(Vd, "__esModule", {
    value: true
});

Vd.transformArguments = void 0;

function zd() {
    return [ "BGREWRITEAOF" ];
}

Vd.transformArguments = zd;

var Zd = {};

Object.defineProperty(Zd, "__esModule", {
    value: true
});

Zd.transformArguments = void 0;

function qd(e) {
    const t = [ "BGSAVE" ];
    if (e?.SCHEDULE) {
        t.push("SCHEDULE");
    }
    return t;
}

Zd.transformArguments = qd;

var $d = {};

Object.defineProperty($d, "__esModule", {
    value: true
});

$d.transformArguments = void 0;

function Qd(e) {
    return [ "CLIENT", "CACHING", e ? "YES" : "NO" ];
}

$d.transformArguments = Qd;

var Jd = {};

Object.defineProperty(Jd, "__esModule", {
    value: true
});

Jd.transformArguments = void 0;

function eh() {
    return [ "CLIENT", "GETNAME" ];
}

Jd.transformArguments = eh;

var th = {};

Object.defineProperty(th, "__esModule", {
    value: true
});

th.transformArguments = void 0;

function rh() {
    return [ "CLIENT", "GETREDIR" ];
}

th.transformArguments = rh;

var nh = {};

Object.defineProperty(nh, "__esModule", {
    value: true
});

nh.transformArguments = nh.IS_READ_ONLY = void 0;

nh.IS_READ_ONLY = true;

function sh() {
    return [ "CLIENT", "ID" ];
}

nh.transformArguments = sh;

var oh = {};

Object.defineProperty(oh, "__esModule", {
    value: true
});

oh.transformArguments = oh.ClientKillFilters = void 0;

var ih;

(function(e) {
    e["ADDRESS"] = "ADDR";
    e["LOCAL_ADDRESS"] = "LADDR";
    e["ID"] = "ID";
    e["TYPE"] = "TYPE";
    e["USER"] = "USER";
    e["SKIP_ME"] = "SKIPME";
    e["MAXAGE"] = "MAXAGE";
})(ih || (oh.ClientKillFilters = ih = {}));

function uh(e) {
    const t = [ "CLIENT", "KILL" ];
    if (Array.isArray(e)) {
        for (const r of e) {
            ah(t, r);
        }
    } else {
        ah(t, e);
    }
    return t;
}

oh.transformArguments = uh;

function ah(e, t) {
    if (t === ih.SKIP_ME) {
        e.push("SKIPME");
        return;
    }
    e.push(t.filter);
    switch (t.filter) {
      case ih.ADDRESS:
        e.push(t.address);
        break;

      case ih.LOCAL_ADDRESS:
        e.push(t.localAddress);
        break;

      case ih.ID:
        e.push(typeof t.id === "number" ? t.id.toString() : t.id);
        break;

      case ih.TYPE:
        e.push(t.type);
        break;

      case ih.USER:
        e.push(t.username);
        break;

      case ih.SKIP_ME:
        e.push(t.skipMe ? "yes" : "no");
        break;

      case ih.MAXAGE:
        e.push(t.maxAge.toString());
        break;
    }
}

var ch = {};

var fh = {};

Object.defineProperty(fh, "__esModule", {
    value: true
});

fh.transformReply = fh.transformArguments = fh.IS_READ_ONLY = void 0;

fh.IS_READ_ONLY = true;

function lh() {
    return [ "CLIENT", "INFO" ];
}

fh.transformArguments = lh;

const mh = /([^\s=]+)=([^\s]*)/g;

function dh(e) {
    const t = {};
    for (const r of e.matchAll(mh)) {
        t[r[1]] = r[2];
    }
    const r = {
        id: Number(t.id),
        addr: t.addr,
        fd: Number(t.fd),
        name: t.name,
        age: Number(t.age),
        idle: Number(t.idle),
        flags: t.flags,
        db: Number(t.db),
        sub: Number(t.sub),
        psub: Number(t.psub),
        multi: Number(t.multi),
        qbuf: Number(t.qbuf),
        qbufFree: Number(t["qbuf-free"]),
        argvMem: Number(t["argv-mem"]),
        obl: Number(t.obl),
        oll: Number(t.oll),
        omem: Number(t.omem),
        totMem: Number(t["tot-mem"]),
        events: t.events,
        cmd: t.cmd,
        user: t.user,
        libName: t["lib-name"],
        libVer: t["lib-ver"]
    };
    if (t.laddr !== undefined) {
        r.laddr = t.laddr;
    }
    if (t.redir !== undefined) {
        r.redir = Number(t.redir);
    }
    if (t.ssub !== undefined) {
        r.ssub = Number(t.ssub);
    }
    if (t["multi-mem"] !== undefined) {
        r.multiMem = Number(t["multi-mem"]);
    }
    if (t.resp !== undefined) {
        r.resp = Number(t.resp);
    }
    return r;
}

fh.transformReply = dh;

Object.defineProperty(ch, "__esModule", {
    value: true
});

ch.transformReply = ch.transformArguments = ch.IS_READ_ONLY = void 0;

const hh = C;

const _h = fh;

ch.IS_READ_ONLY = true;

function Eh(e) {
    let t = [ "CLIENT", "LIST" ];
    if (e) {
        if (e.TYPE !== undefined) {
            t.push("TYPE", e.TYPE);
        } else {
            t.push("ID");
            t = (0, hh.pushVerdictArguments)(t, e.ID);
        }
    }
    return t;
}

ch.transformArguments = Eh;

function ph(e) {
    const t = e.split("\n"), r = t.length - 1, n = [];
    for (let e = 0; e < r; e++) {
        n.push((0, _h.transformReply)(t[e]));
    }
    return n;
}

ch.transformReply = ph;

var Sh = {};

Object.defineProperty(Sh, "__esModule", {
    value: true
});

Sh.transformArguments = void 0;

function Rh(e) {
    return [ "CLIENT", "NO-EVICT", e ? "ON" : "OFF" ];
}

Sh.transformArguments = Rh;

var Ih = {};

Object.defineProperty(Ih, "__esModule", {
    value: true
});

Ih.transformArguments = void 0;

function gh(e) {
    return [ "CLIENT", "NO-TOUCH", e ? "ON" : "OFF" ];
}

Ih.transformArguments = gh;

var Ah = {};

Object.defineProperty(Ah, "__esModule", {
    value: true
});

Ah.transformArguments = void 0;

function vh(e, t) {
    const r = [ "CLIENT", "PAUSE", e.toString() ];
    if (t) {
        r.push(t);
    }
    return r;
}

Ah.transformArguments = vh;

var yh = {};

Object.defineProperty(yh, "__esModule", {
    value: true
});

yh.transformArguments = void 0;

function bh(e) {
    return [ "CLIENT", "SETNAME", e ];
}

yh.transformArguments = bh;

var Nh = {};

Object.defineProperty(Nh, "__esModule", {
    value: true
});

Nh.transformArguments = void 0;

function Oh(e, t) {
    const r = [ "CLIENT", "TRACKING", e ? "ON" : "OFF" ];
    if (e) {
        if (t?.REDIRECT) {
            r.push("REDIRECT", t.REDIRECT.toString());
        }
        if (Th(t)) {
            r.push("BCAST");
            if (t?.PREFIX) {
                if (Array.isArray(t.PREFIX)) {
                    for (const e of t.PREFIX) {
                        r.push("PREFIX", e);
                    }
                } else {
                    r.push("PREFIX", t.PREFIX);
                }
            }
        } else if (Dh(t)) {
            r.push("OPTIN");
        } else if (Ph(t)) {
            r.push("OPTOUT");
        }
        if (t?.NOLOOP) {
            r.push("NOLOOP");
        }
    }
    return r;
}

Nh.transformArguments = Oh;

function Th(e) {
    return e?.BCAST === true;
}

function Dh(e) {
    return e?.OPTIN === true;
}

function Ph(e) {
    return e?.OPTOUT === true;
}

var Lh = {};

Object.defineProperty(Lh, "__esModule", {
    value: true
});

Lh.transformReply = Lh.transformArguments = void 0;

function Ch() {
    return [ "CLIENT", "TRACKINGINFO" ];
}

Lh.transformArguments = Ch;

function Mh(e) {
    return {
        flags: new Set(e[1]),
        redirect: e[3],
        prefixes: e[5]
    };
}

Lh.transformReply = Mh;

var Yh = {};

Object.defineProperty(Yh, "__esModule", {
    value: true
});

Yh.transformArguments = void 0;

function wh() {
    return [ "CLIENT", "UNPAUSE" ];
}

Yh.transformArguments = wh;

var Fh = {};

Object.defineProperty(Fh, "__esModule", {
    value: true
});

Fh.transformArguments = void 0;

const Xh = C;

function jh(e) {
    return (0, Xh.pushVerdictNumberArguments)([ "CLUSTER", "ADDSLOTS" ], e);
}

Fh.transformArguments = jh;

var Kh = {};

Object.defineProperty(Kh, "__esModule", {
    value: true
});

Kh.transformArguments = void 0;

const Uh = C;

function Bh(e) {
    return (0, Uh.pushSlotRangesArguments)([ "CLUSTER", "ADDSLOTSRANGE" ], e);
}

Kh.transformArguments = Bh;

var xh = {};

Object.defineProperty(xh, "__esModule", {
    value: true
});

xh.transformArguments = void 0;

function Gh() {
    return [ "CLUSTER", "BUMPEPOCH" ];
}

xh.transformArguments = Gh;

var kh = {};

Object.defineProperty(kh, "__esModule", {
    value: true
});

kh.transformArguments = void 0;

function Hh(e) {
    return [ "CLUSTER", "COUNT-FAILURE-REPORTS", e ];
}

kh.transformArguments = Hh;

var Wh = {};

Object.defineProperty(Wh, "__esModule", {
    value: true
});

Wh.transformArguments = void 0;

function Vh(e) {
    return [ "CLUSTER", "COUNTKEYSINSLOT", e.toString() ];
}

Wh.transformArguments = Vh;

var zh = {};

Object.defineProperty(zh, "__esModule", {
    value: true
});

zh.transformArguments = void 0;

const Zh = C;

function qh(e) {
    return (0, Zh.pushVerdictNumberArguments)([ "CLUSTER", "DELSLOTS" ], e);
}

zh.transformArguments = qh;

var $h = {};

Object.defineProperty($h, "__esModule", {
    value: true
});

$h.transformArguments = void 0;

const Qh = C;

function Jh(e) {
    return (0, Qh.pushSlotRangesArguments)([ "CLUSTER", "DELSLOTSRANGE" ], e);
}

$h.transformArguments = Jh;

var e_ = {};

Object.defineProperty(e_, "__esModule", {
    value: true
});

e_.transformArguments = e_.FailoverModes = void 0;

var t_;

(function(e) {
    e["FORCE"] = "FORCE";
    e["TAKEOVER"] = "TAKEOVER";
})(t_ || (e_.FailoverModes = t_ = {}));

function r_(e) {
    const t = [ "CLUSTER", "FAILOVER" ];
    if (e) {
        t.push(e);
    }
    return t;
}

e_.transformArguments = r_;

var n_ = {};

Object.defineProperty(n_, "__esModule", {
    value: true
});

n_.transformArguments = void 0;

function s_() {
    return [ "CLUSTER", "FLUSHSLOTS" ];
}

n_.transformArguments = s_;

var o_ = {};

Object.defineProperty(o_, "__esModule", {
    value: true
});

o_.transformArguments = void 0;

function i_(e) {
    return [ "CLUSTER", "FORGET", e ];
}

o_.transformArguments = i_;

var u_ = {};

Object.defineProperty(u_, "__esModule", {
    value: true
});

u_.transformArguments = void 0;

function a_(e, t) {
    return [ "CLUSTER", "GETKEYSINSLOT", e.toString(), t.toString() ];
}

u_.transformArguments = a_;

var c_ = {};

Object.defineProperty(c_, "__esModule", {
    value: true
});

c_.extractLineValue = c_.transformReply = c_.transformArguments = void 0;

function f_() {
    return [ "CLUSTER", "INFO" ];
}

c_.transformArguments = f_;

function l_(e) {
    const t = e.split("\r\n");
    return {
        state: m_(t[0]),
        slots: {
            assigned: Number(m_(t[1])),
            ok: Number(m_(t[2])),
            pfail: Number(m_(t[3])),
            fail: Number(m_(t[4]))
        },
        knownNodes: Number(m_(t[5])),
        size: Number(m_(t[6])),
        currentEpoch: Number(m_(t[7])),
        myEpoch: Number(m_(t[8])),
        stats: {
            messagesSent: Number(m_(t[9])),
            messagesReceived: Number(m_(t[10]))
        }
    };
}

c_.transformReply = l_;

function m_(e) {
    return e.substring(e.indexOf(":") + 1);
}

c_.extractLineValue = m_;

var d_ = {};

Object.defineProperty(d_, "__esModule", {
    value: true
});

d_.transformArguments = void 0;

function h_(e) {
    return [ "CLUSTER", "KEYSLOT", e ];
}

d_.transformArguments = h_;

var __ = {};

Object.defineProperty(__, "__esModule", {
    value: true
});

__.transformReply = __.transformArguments = void 0;

function E_() {
    return [ "CLUSTER", "LINKS" ];
}

__.transformArguments = E_;

function p_(e) {
    return e.map(e => ({
        direction: e[1],
        node: e[3],
        createTime: Number(e[5]),
        events: e[7],
        sendBufferAllocated: Number(e[9]),
        sendBufferUsed: Number(e[11])
    }));
}

__.transformReply = p_;

var S_ = {};

Object.defineProperty(S_, "__esModule", {
    value: true
});

S_.transformArguments = void 0;

function R_(e, t) {
    return [ "CLUSTER", "MEET", e, t.toString() ];
}

S_.transformArguments = R_;

var I_ = {};

Object.defineProperty(I_, "__esModule", {
    value: true
});

I_.transformArguments = void 0;

function g_() {
    return [ "CLUSTER", "MYID" ];
}

I_.transformArguments = g_;

var A_ = {};

Object.defineProperty(A_, "__esModule", {
    value: true
});

A_.transformArguments = A_.IS_READ_ONLY = void 0;

A_.IS_READ_ONLY = true;

function v_() {
    return [ "CLUSTER", "MYSHARDID" ];
}

A_.transformArguments = v_;

var y_ = {};

Object.defineProperty(y_, "__esModule", {
    value: true
});

y_.transformReply = y_.RedisClusterNodeLinkStates = y_.transformArguments = void 0;

function b_() {
    return [ "CLUSTER", "NODES" ];
}

y_.transformArguments = b_;

var N_;

(function(e) {
    e["CONNECTED"] = "connected";
    e["DISCONNECTED"] = "disconnected";
})(N_ || (y_.RedisClusterNodeLinkStates = N_ = {}));

function O_(e) {
    const t = e.split("\n");
    t.pop();
    const r = new Map, n = new Map;
    for (const e of t) {
        const [t, s, o, i, u, a, c, f, ...l] = e.split(" "), m = {
            id: t,
            address: s,
            ...T_(s),
            flags: o.split(","),
            pingSent: Number(u),
            pongRecv: Number(a),
            configEpoch: Number(c),
            linkState: f
        };
        if (i === "-") {
            let e = n.get(t);
            if (!e) {
                e = [];
                n.set(t, e);
            }
            r.set(t, {
                ...m,
                slots: l.map(e => {
                    const [t, r] = e.split("-", 2), n = Number(t);
                    return {
                        from: n,
                        to: r ? Number(r) : n
                    };
                }),
                replicas: e
            });
        } else {
            const e = n.get(i);
            if (!e) {
                n.set(i, [ m ]);
            } else {
                e.push(m);
            }
        }
    }
    return [ ...r.values() ];
}

y_.transformReply = O_;

function T_(e) {
    const t = e.lastIndexOf(":"), r = e.indexOf("@", t), n = e.substring(0, t);
    if (r === -1) {
        return {
            host: n,
            port: Number(e.substring(t + 1)),
            cport: null
        };
    }
    return {
        host: e.substring(0, t),
        port: Number(e.substring(t + 1, r)),
        cport: Number(e.substring(r + 1))
    };
}

var D_ = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = void 0;
    function t(e) {
        return [ "CLUSTER", "REPLICAS", e ];
    }
    e.transformArguments = t;
    var r = y_;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformReply;
        }
    });
})(D_);

var P_ = {};

Object.defineProperty(P_, "__esModule", {
    value: true
});

P_.transformArguments = void 0;

function L_(e) {
    return [ "CLUSTER", "REPLICATE", e ];
}

P_.transformArguments = L_;

var C_ = {};

Object.defineProperty(C_, "__esModule", {
    value: true
});

C_.transformArguments = void 0;

function M_(e) {
    const t = [ "CLUSTER", "RESET" ];
    if (e) {
        t.push(e);
    }
    return t;
}

C_.transformArguments = M_;

var Y_ = {};

Object.defineProperty(Y_, "__esModule", {
    value: true
});

Y_.transformArguments = void 0;

function w_() {
    return [ "CLUSTER", "SAVECONFIG" ];
}

Y_.transformArguments = w_;

var F_ = {};

Object.defineProperty(F_, "__esModule", {
    value: true
});

F_.transformArguments = void 0;

function X_(e) {
    return [ "CLUSTER", "SET-CONFIG-EPOCH", e.toString() ];
}

F_.transformArguments = X_;

var j_ = {};

Object.defineProperty(j_, "__esModule", {
    value: true
});

j_.transformArguments = j_.ClusterSlotStates = void 0;

var K_;

(function(e) {
    e["IMPORTING"] = "IMPORTING";
    e["MIGRATING"] = "MIGRATING";
    e["STABLE"] = "STABLE";
    e["NODE"] = "NODE";
})(K_ || (j_.ClusterSlotStates = K_ = {}));

function U_(e, t, r) {
    const n = [ "CLUSTER", "SETSLOT", e.toString(), t ];
    if (r) {
        n.push(r);
    }
    return n;
}

j_.transformArguments = U_;

var B_ = {};

Object.defineProperty(B_, "__esModule", {
    value: true
});

B_.transformReply = B_.transformArguments = void 0;

function x_() {
    return [ "CLUSTER", "SLOTS" ];
}

B_.transformArguments = x_;

function G_(e) {
    return e.map(([e, t, r, ...n]) => ({
        from: e,
        to: t,
        master: k_(r),
        replicas: n.map(k_)
    }));
}

B_.transformReply = G_;

function k_([e, t, r]) {
    return {
        ip: e,
        port: t,
        id: r
    };
}

var H_ = {};

Object.defineProperty(H_, "__esModule", {
    value: true
});

H_.transformArguments = H_.IS_READ_ONLY = void 0;

H_.IS_READ_ONLY = true;

function W_() {
    return [ "COMMAND", "COUNT" ];
}

H_.transformArguments = W_;

var V_ = {};

Object.defineProperty(V_, "__esModule", {
    value: true
});

V_.transformArguments = V_.IS_READ_ONLY = void 0;

V_.IS_READ_ONLY = true;

function z_(e) {
    return [ "COMMAND", "GETKEYS", ...e ];
}

V_.transformArguments = z_;

var Z_ = {};

Object.defineProperty(Z_, "__esModule", {
    value: true
});

Z_.transformReply = Z_.transformArguments = Z_.IS_READ_ONLY = void 0;

Z_.IS_READ_ONLY = true;

function q_(e) {
    return [ "COMMAND", "GETKEYSANDFLAGS", ...e ];
}

Z_.transformArguments = q_;

function $_(e) {
    return e.map(([e, t]) => ({
        key: e,
        flags: t
    }));
}

Z_.transformReply = $_;

var Q_ = {};

Object.defineProperty(Q_, "__esModule", {
    value: true
});

Q_.transformReply = Q_.transformArguments = Q_.IS_READ_ONLY = void 0;

const J_ = C;

Q_.IS_READ_ONLY = true;

function eE(e) {
    return [ "COMMAND", "INFO", ...e ];
}

Q_.transformArguments = eE;

function tE(e) {
    return e.map(e => e ? (0, J_.transformCommandReply)(e) : null);
}

Q_.transformReply = tE;

var rE = {};

Object.defineProperty(rE, "__esModule", {
    value: true
});

rE.transformArguments = rE.FilterBy = rE.IS_READ_ONLY = void 0;

rE.IS_READ_ONLY = true;

var nE;

(function(e) {
    e["MODULE"] = "MODULE";
    e["ACLCAT"] = "ACLCAT";
    e["PATTERN"] = "PATTERN";
})(nE || (rE.FilterBy = nE = {}));

function sE(e) {
    const t = [ "COMMAND", "LIST" ];
    if (e) {
        t.push("FILTERBY", e.filterBy, e.value);
    }
    return t;
}

rE.transformArguments = sE;

var oE = {};

Object.defineProperty(oE, "__esModule", {
    value: true
});

oE.transformReply = oE.transformArguments = oE.IS_READ_ONLY = void 0;

const iE = C;

oE.IS_READ_ONLY = true;

function uE() {
    return [ "COMMAND" ];
}

oE.transformArguments = uE;

function aE(e) {
    return e.map(iE.transformCommandReply);
}

oE.transformReply = aE;

var cE = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = void 0;
    function t(e) {
        return [ "CONFIG", "GET", e ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformTuplesReply;
        }
    });
})(cE);

var fE = {};

Object.defineProperty(fE, "__esModule", {
    value: true
});

fE.transformArguments = void 0;

function lE() {
    return [ "CONFIG", "RESETSTAT" ];
}

fE.transformArguments = lE;

var mE = {};

Object.defineProperty(mE, "__esModule", {
    value: true
});

mE.transformArguments = void 0;

function dE() {
    return [ "CONFIG", "REWRITE" ];
}

mE.transformArguments = dE;

var hE = {};

Object.defineProperty(hE, "__esModule", {
    value: true
});

hE.transformArguments = void 0;

function _E(...[e, t]) {
    const r = [ "CONFIG", "SET" ];
    if (typeof e === "string") {
        r.push(e, t);
    } else {
        for (const [t, n] of Object.entries(e)) {
            r.push(t, n);
        }
    }
    return r;
}

hE.transformArguments = _E;

var EE = {};

Object.defineProperty(EE, "__esModule", {
    value: true
});

EE.transformArguments = EE.IS_READ_ONLY = void 0;

EE.IS_READ_ONLY = true;

function pE() {
    return [ "DBSIZE" ];
}

EE.transformArguments = pE;

var SE = {};

Object.defineProperty(SE, "__esModule", {
    value: true
});

SE.transformArguments = void 0;

function RE() {
    return [ "DISCARD" ];
}

SE.transformArguments = RE;

var IE = {};

Object.defineProperty(IE, "__esModule", {
    value: true
});

IE.transformArguments = IE.IS_READ_ONLY = void 0;

IE.IS_READ_ONLY = true;

function gE(e) {
    return [ "ECHO", e ];
}

IE.transformArguments = gE;

var AE = {};

Object.defineProperty(AE, "__esModule", {
    value: true
});

AE.transformArguments = void 0;

function vE(e) {
    const t = [ "FAILOVER" ];
    if (e?.TO) {
        t.push("TO", e.TO.host, e.TO.port.toString());
        if (e.TO.FORCE) {
            t.push("FORCE");
        }
    }
    if (e?.ABORT) {
        t.push("ABORT");
    }
    if (e?.TIMEOUT) {
        t.push("TIMEOUT", e.TIMEOUT.toString());
    }
    return t;
}

AE.transformArguments = vE;

var yE = {};

Object.defineProperty(yE, "__esModule", {
    value: true
});

yE.transformArguments = yE.RedisFlushModes = void 0;

var bE;

(function(e) {
    e["ASYNC"] = "ASYNC";
    e["SYNC"] = "SYNC";
})(bE || (yE.RedisFlushModes = bE = {}));

function NE(e) {
    const t = [ "FLUSHALL" ];
    if (e) {
        t.push(e);
    }
    return t;
}

yE.transformArguments = NE;

var OE = {};

Object.defineProperty(OE, "__esModule", {
    value: true
});

OE.transformArguments = void 0;

function TE(e) {
    const t = [ "FLUSHDB" ];
    if (e) {
        t.push(e);
    }
    return t;
}

OE.transformArguments = TE;

var DE = {};

Object.defineProperty(DE, "__esModule", {
    value: true
});

DE.transformArguments = void 0;

function PE(e) {
    return [ "FUNCTION", "DELETE", e ];
}

DE.transformArguments = PE;

var LE = {};

Object.defineProperty(LE, "__esModule", {
    value: true
});

LE.transformArguments = void 0;

function CE() {
    return [ "FUNCTION", "DUMP" ];
}

LE.transformArguments = CE;

var ME = {};

Object.defineProperty(ME, "__esModule", {
    value: true
});

ME.transformArguments = void 0;

function YE(e) {
    const t = [ "FUNCTION", "FLUSH" ];
    if (e) {
        t.push(e);
    }
    return t;
}

ME.transformArguments = YE;

var wE = {};

Object.defineProperty(wE, "__esModule", {
    value: true
});

wE.transformArguments = void 0;

function FE() {
    return [ "FUNCTION", "KILL" ];
}

wE.transformArguments = FE;

var XE = {};

var jE = {};

Object.defineProperty(jE, "__esModule", {
    value: true
});

jE.transformReply = jE.transformArguments = void 0;

const KE = C;

function UE(e) {
    const t = [ "FUNCTION", "LIST" ];
    if (e) {
        t.push(e);
    }
    return t;
}

jE.transformArguments = UE;

function BE(e) {
    return e.map(KE.transformFunctionListItemReply);
}

jE.transformReply = BE;

Object.defineProperty(XE, "__esModule", {
    value: true
});

XE.transformReply = XE.transformArguments = void 0;

const xE = jE;

const GE = C;

function kE(e) {
    const t = (0, xE.transformArguments)(e);
    t.push("WITHCODE");
    return t;
}

XE.transformArguments = kE;

function HE(e) {
    return e.map(e => ({
        ...(0, GE.transformFunctionListItemReply)(e),
        libraryCode: e[7]
    }));
}

XE.transformReply = HE;

var WE = {};

Object.defineProperty(WE, "__esModule", {
    value: true
});

WE.transformArguments = void 0;

function VE(e, t) {
    const r = [ "FUNCTION", "LOAD" ];
    if (t?.REPLACE) {
        r.push("REPLACE");
    }
    r.push(e);
    return r;
}

WE.transformArguments = VE;

var zE = {};

Object.defineProperty(zE, "__esModule", {
    value: true
});

zE.transformArguments = void 0;

function ZE(e, t) {
    const r = [ "FUNCTION", "RESTORE", e ];
    if (t) {
        r.push(t);
    }
    return r;
}

zE.transformArguments = ZE;

var qE = {};

Object.defineProperty(qE, "__esModule", {
    value: true
});

qE.transformReply = qE.transformArguments = void 0;

function $E() {
    return [ "FUNCTION", "STATS" ];
}

qE.transformArguments = $E;

function QE(e) {
    const t = Object.create(null);
    for (let r = 0; r < e[3].length; r++) {
        t[e[3][r]] = {
            librariesCount: e[3][++r][1],
            functionsCount: e[3][r][3]
        };
    }
    return {
        runningScript: e[1] === null ? null : {
            name: e[1][1],
            command: e[1][3],
            durationMs: e[1][5]
        },
        engines: t
    };
}

qE.transformReply = QE;

var JE = {};

Object.defineProperty(JE, "__esModule", {
    value: true
});

JE.transformReply = JE.transformArguments = void 0;

function ep(e) {
    const t = [ "HELLO" ];
    if (e) {
        t.push(e.protover.toString());
        if (e.auth) {
            t.push("AUTH", e.auth.username, e.auth.password);
        }
        if (e.clientName) {
            t.push("SETNAME", e.clientName);
        }
    }
    return t;
}

JE.transformArguments = ep;

function tp(e) {
    return {
        server: e[1],
        version: e[3],
        proto: e[5],
        id: e[7],
        mode: e[9],
        role: e[11],
        modules: e[13]
    };
}

JE.transformReply = tp;

var rp = {};

Object.defineProperty(rp, "__esModule", {
    value: true
});

rp.transformArguments = rp.IS_READ_ONLY = void 0;

rp.IS_READ_ONLY = true;

function np(e) {
    const t = [ "INFO" ];
    if (e) {
        t.push(e);
    }
    return t;
}

rp.transformArguments = np;

var sp = {};

Object.defineProperty(sp, "__esModule", {
    value: true
});

sp.transformArguments = void 0;

function op(e) {
    return [ "KEYS", e ];
}

sp.transformArguments = op;

var ip = {};

Object.defineProperty(ip, "__esModule", {
    value: true
});

ip.transformReply = ip.transformArguments = ip.IS_READ_ONLY = void 0;

ip.IS_READ_ONLY = true;

function up() {
    return [ "LASTSAVE" ];
}

ip.transformArguments = up;

function ap(e) {
    return new Date(e);
}

ip.transformReply = ap;

var cp = {};

Object.defineProperty(cp, "__esModule", {
    value: true
});

cp.transformArguments = void 0;

function fp() {
    return [ "LATENCY", "DOCTOR" ];
}

cp.transformArguments = fp;

var lp = {};

Object.defineProperty(lp, "__esModule", {
    value: true
});

lp.transformArguments = void 0;

function mp(e) {
    return [ "LATENCY", "GRAPH", e ];
}

lp.transformArguments = mp;

var dp = {};

Object.defineProperty(dp, "__esModule", {
    value: true
});

dp.transformArguments = void 0;

function hp(e) {
    return [ "LATENCY", "HISTORY", e ];
}

dp.transformArguments = hp;

var _p = {};

Object.defineProperty(_p, "__esModule", {
    value: true
});

_p.transformArguments = void 0;

function Ep() {
    return [ "LATENCY", "LATEST" ];
}

_p.transformArguments = Ep;

var pp = {};

Object.defineProperty(pp, "__esModule", {
    value: true
});

pp.transformArguments = pp.IS_READ_ONLY = void 0;

pp.IS_READ_ONLY = true;

function Sp(e, ...t) {
    const r = [ "LOLWUT" ];
    if (e) {
        r.push("VERSION", e.toString(), ...t.map(String));
    }
    return r;
}

pp.transformArguments = Sp;

var Rp = {};

Object.defineProperty(Rp, "__esModule", {
    value: true
});

Rp.transformArguments = void 0;

function Ip() {
    return [ "MEMORY", "DOCTOR" ];
}

Rp.transformArguments = Ip;

var gp = {};

Object.defineProperty(gp, "__esModule", {
    value: true
});

gp.transformArguments = void 0;

function Ap() {
    return [ "MEMORY", "MALLOC-STATS" ];
}

gp.transformArguments = Ap;

var vp = {};

Object.defineProperty(vp, "__esModule", {
    value: true
});

vp.transformArguments = void 0;

function yp() {
    return [ "MEMORY", "PURGE" ];
}

vp.transformArguments = yp;

var bp = {};

Object.defineProperty(bp, "__esModule", {
    value: true
});

bp.transformReply = bp.transformArguments = void 0;

function Np() {
    return [ "MEMORY", "STATS" ];
}

bp.transformArguments = Np;

const Op = {
    "peak.allocated": "peakAllocated",
    "total.allocated": "totalAllocated",
    "startup.allocated": "startupAllocated",
    "replication.backlog": "replicationBacklog",
    "clients.slaves": "clientsReplicas",
    "clients.normal": "clientsNormal",
    "aof.buffer": "aofBuffer",
    "lua.caches": "luaCaches",
    "overhead.total": "overheadTotal",
    "keys.count": "keysCount",
    "keys.bytes-per-key": "keysBytesPerKey",
    "dataset.bytes": "datasetBytes",
    "dataset.percentage": "datasetPercentage",
    "peak.percentage": "peakPercentage",
    "allocator.allocated": "allocatorAllocated",
    "allocator.active": "allocatorActive",
    "allocator.resident": "allocatorResident",
    "allocator-fragmentation.ratio": "allocatorFragmentationRatio",
    "allocator-fragmentation.bytes": "allocatorFragmentationBytes",
    "allocator-rss.ratio": "allocatorRssRatio",
    "allocator-rss.bytes": "allocatorRssBytes",
    "rss-overhead.ratio": "rssOverheadRatio",
    "rss-overhead.bytes": "rssOverheadBytes",
    fragmentation: "fragmentation",
    "fragmentation.bytes": "fragmentationBytes"
}, Tp = {
    "overhead.hashtable.main": "overheadHashtableMain",
    "overhead.hashtable.expires": "overheadHashtableExpires"
};

function Dp(e) {
    const t = {
        db: {}
    };
    for (let r = 0; r < e.length; r += 2) {
        const n = e[r];
        if (n.startsWith("db.")) {
            const s = e[r + 1], o = {};
            for (let e = 0; e < s.length; e += 2) {
                o[Tp[s[e]]] = s[e + 1];
            }
            t.db[n.substring(3)] = o;
            continue;
        }
        t[Op[n]] = Number(e[r + 1]);
    }
    return t;
}

bp.transformReply = Dp;

var Pp = {};

Object.defineProperty(Pp, "__esModule", {
    value: true
});

Pp.transformArguments = Pp.IS_READ_ONLY = Pp.FIRST_KEY_INDEX = void 0;

Pp.FIRST_KEY_INDEX = 1;

Pp.IS_READ_ONLY = true;

function Lp(e, t) {
    const r = [ "MEMORY", "USAGE", e ];
    if (t?.SAMPLES) {
        r.push("SAMPLES", t.SAMPLES.toString());
    }
    return r;
}

Pp.transformArguments = Lp;

var Cp = {};

Object.defineProperty(Cp, "__esModule", {
    value: true
});

Cp.transformArguments = void 0;

function Mp() {
    return [ "MODULE", "LIST" ];
}

Cp.transformArguments = Mp;

var Yp = {};

Object.defineProperty(Yp, "__esModule", {
    value: true
});

Yp.transformArguments = void 0;

function wp(e, t) {
    const r = [ "MODULE", "LOAD", e ];
    if (t) {
        r.push(...t);
    }
    return r;
}

Yp.transformArguments = wp;

var Fp = {};

Object.defineProperty(Fp, "__esModule", {
    value: true
});

Fp.transformArguments = void 0;

function Xp(e) {
    return [ "MODULE", "UNLOAD", e ];
}

Fp.transformArguments = Xp;

var jp = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    e.FIRST_KEY_INDEX = 1;
    function t(e, t) {
        return [ "MOVE", e, t.toString() ];
    }
    e.transformArguments = t;
    var r = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(jp);

var Kp = {};

Object.defineProperty(Kp, "__esModule", {
    value: true
});

Kp.transformArguments = void 0;

function Up(e) {
    const t = [ "PING" ];
    if (e) {
        t.push(e);
    }
    return t;
}

Kp.transformArguments = Up;

var Bp = {};

Object.defineProperty(Bp, "__esModule", {
    value: true
});

Bp.transformArguments = Bp.IS_READ_ONLY = void 0;

Bp.IS_READ_ONLY = true;

function xp(e) {
    const t = [ "PUBSUB", "CHANNELS" ];
    if (e) {
        t.push(e);
    }
    return t;
}

Bp.transformArguments = xp;

var Gp = {};

Object.defineProperty(Gp, "__esModule", {
    value: true
});

Gp.transformArguments = Gp.IS_READ_ONLY = void 0;

Gp.IS_READ_ONLY = true;

function kp() {
    return [ "PUBSUB", "NUMPAT" ];
}

Gp.transformArguments = kp;

var Hp = {};

Object.defineProperty(Hp, "__esModule", {
    value: true
});

Hp.transformReply = Hp.transformArguments = Hp.IS_READ_ONLY = void 0;

const Wp = C;

Hp.IS_READ_ONLY = true;

function Vp(e) {
    const t = [ "PUBSUB", "NUMSUB" ];
    if (e) return (0, Wp.pushVerdictArguments)(t, e);
    return t;
}

Hp.transformArguments = Vp;

function zp(e) {
    const t = Object.create(null);
    for (let r = 0; r < e.length; r += 2) {
        t[e[r]] = e[r + 1];
    }
    return t;
}

Hp.transformReply = zp;

var Zp = {};

Object.defineProperty(Zp, "__esModule", {
    value: true
});

Zp.transformArguments = Zp.IS_READ_ONLY = void 0;

Zp.IS_READ_ONLY = true;

function qp(e) {
    const t = [ "PUBSUB", "SHARDCHANNELS" ];
    if (e) t.push(e);
    return t;
}

Zp.transformArguments = qp;

var $p = {};

Object.defineProperty($p, "__esModule", {
    value: true
});

$p.transformReply = $p.transformArguments = $p.IS_READ_ONLY = void 0;

const Qp = C;

$p.IS_READ_ONLY = true;

function Jp(e) {
    const t = [ "PUBSUB", "SHARDNUMSUB" ];
    if (e) return (0, Qp.pushVerdictArguments)(t, e);
    return t;
}

$p.transformArguments = Jp;

function eS(e) {
    const t = Object.create(null);
    for (let r = 0; r < e.length; r += 2) {
        t[e[r]] = e[r + 1];
    }
    return t;
}

$p.transformReply = eS;

var tS = {};

Object.defineProperty(tS, "__esModule", {
    value: true
});

tS.transformArguments = tS.IS_READ_ONLY = void 0;

tS.IS_READ_ONLY = true;

function rS() {
    return [ "RANDOMKEY" ];
}

tS.transformArguments = rS;

var nS = {};

Object.defineProperty(nS, "__esModule", {
    value: true
});

nS.transformArguments = void 0;

function sS() {
    return [ "READONLY" ];
}

nS.transformArguments = sS;

var oS = {};

Object.defineProperty(oS, "__esModule", {
    value: true
});

oS.transformArguments = void 0;

function iS() {
    return [ "READWRITE" ];
}

oS.transformArguments = iS;

var uS = {};

Object.defineProperty(uS, "__esModule", {
    value: true
});

uS.transformArguments = void 0;

function aS(e, t) {
    return [ "REPLICAOF", e, t.toString() ];
}

uS.transformArguments = aS;

var cS = {};

Object.defineProperty(cS, "__esModule", {
    value: true
});

cS.transformArguments = void 0;

function fS() {
    return [ "RESTORE-ASKING" ];
}

cS.transformArguments = fS;

var lS = {};

Object.defineProperty(lS, "__esModule", {
    value: true
});

lS.transformReply = lS.transformArguments = lS.IS_READ_ONLY = void 0;

lS.IS_READ_ONLY = true;

function mS() {
    return [ "ROLE" ];
}

lS.transformArguments = mS;

function dS(e) {
    switch (e[0]) {
      case "master":
        return {
            role: "master",
            replicationOffest: e[1],
            replicas: e[2].map(([e, t, r]) => ({
                ip: e,
                port: Number(t),
                replicationOffest: Number(r)
            }))
        };

      case "slave":
        return {
            role: "slave",
            master: {
                ip: e[1],
                port: e[2]
            },
            state: e[3],
            dataReceived: e[4]
        };

      case "sentinel":
        return {
            role: "sentinel",
            masterNames: e[1]
        };
    }
}

lS.transformReply = dS;

var hS = {};

Object.defineProperty(hS, "__esModule", {
    value: true
});

hS.transformArguments = void 0;

function _S() {
    return [ "SAVE" ];
}

hS.transformArguments = _S;

var ES = {};

Object.defineProperty(ES, "__esModule", {
    value: true
});

ES.transformReply = ES.transformArguments = ES.IS_READ_ONLY = void 0;

const pS = C;

ES.IS_READ_ONLY = true;

function SS(e, t) {
    const r = (0, pS.pushScanArguments)([ "SCAN" ], e, t);
    if (t?.TYPE) {
        r.push("TYPE", t.TYPE);
    }
    return r;
}

ES.transformArguments = SS;

function RS([e, t]) {
    return {
        cursor: Number(e),
        keys: t
    };
}

ES.transformReply = RS;

var IS = {};

Object.defineProperty(IS, "__esModule", {
    value: true
});

IS.transformArguments = void 0;

function gS(e) {
    return [ "SCRIPT", "DEBUG", e ];
}

IS.transformArguments = gS;

var AS = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = void 0;
    const t = C;
    function r(e) {
        return (0, t.pushVerdictArguments)([ "SCRIPT", "EXISTS" ], e);
    }
    e.transformArguments = r;
    var n = C;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanArrayReply;
        }
    });
})(AS);

var vS = {};

Object.defineProperty(vS, "__esModule", {
    value: true
});

vS.transformArguments = void 0;

function yS(e) {
    const t = [ "SCRIPT", "FLUSH" ];
    if (e) {
        t.push(e);
    }
    return t;
}

vS.transformArguments = yS;

var bS = {};

Object.defineProperty(bS, "__esModule", {
    value: true
});

bS.transformArguments = void 0;

function NS() {
    return [ "SCRIPT", "KILL" ];
}

bS.transformArguments = NS;

var OS = {};

Object.defineProperty(OS, "__esModule", {
    value: true
});

OS.transformArguments = void 0;

function TS(e) {
    return [ "SCRIPT", "LOAD", e ];
}

OS.transformArguments = TS;

var DS = {};

Object.defineProperty(DS, "__esModule", {
    value: true
});

DS.transformArguments = void 0;

function PS(e) {
    const t = [ "SHUTDOWN" ];
    if (e) {
        t.push(e);
    }
    return t;
}

DS.transformArguments = PS;

var LS = {};

Object.defineProperty(LS, "__esModule", {
    value: true
});

LS.transformArguments = void 0;

function CS(e, t) {
    return [ "SWAPDB", e.toString(), t.toString() ];
}

LS.transformArguments = CS;

var MS = {};

Object.defineProperty(MS, "__esModule", {
    value: true
});

MS.transformReply = MS.transformArguments = void 0;

function YS() {
    return [ "TIME" ];
}

MS.transformArguments = YS;

function wS(e) {
    const t = Number(e[0]), r = Number(e[1]), n = new Date(t * 1e3 + r / 1e3);
    n.microseconds = r;
    return n;
}

MS.transformReply = wS;

var FS = {};

Object.defineProperty(FS, "__esModule", {
    value: true
});

FS.transformArguments = void 0;

function XS() {
    return [ "UNWATCH" ];
}

FS.transformArguments = XS;

var jS = {};

Object.defineProperty(jS, "__esModule", {
    value: true
});

jS.transformArguments = jS.FIRST_KEY_INDEX = void 0;

jS.FIRST_KEY_INDEX = 1;

function KS(e, t) {
    return [ "WAIT", e.toString(), t.toString() ];
}

jS.transformArguments = KS;

Object.defineProperty(g, "__esModule", {
    value: true
});

const US = A;

const BS = dd;

const xS = _d;

const GS = Sd;

const kS = Id;

const HS = Ad;

const WS = bd;

const VS = Od;

const zS = Dd;

const ZS = Ld;

const qS = Yd;

const $S = Fd;

const QS = Kd;

const JS = Bd;

const eR = Gd;

const tR = Hd;

const rR = Vd;

const nR = Zd;

const sR = $d;

const oR = Jd;

const iR = th;

const uR = nh;

const aR = oh;

const cR = ch;

const fR = Sh;

const lR = Ih;

const mR = Ah;

const dR = yh;

const hR = Nh;

const _R = Lh;

const ER = Yh;

const pR = fh;

const SR = Fh;

const RR = Kh;

const IR = xh;

const gR = kh;

const AR = Wh;

const vR = zh;

const yR = $h;

const bR = e_;

const NR = n_;

const OR = o_;

const TR = u_;

const DR = c_;

const PR = d_;

const LR = __;

const CR = S_;

const MR = I_;

const YR = A_;

const wR = y_;

const FR = D_;

const XR = P_;

const jR = C_;

const KR = Y_;

const UR = F_;

const BR = j_;

const xR = B_;

const GR = H_;

const kR = V_;

const HR = Z_;

const WR = Q_;

const VR = rE;

const zR = oE;

const ZR = cE;

const qR = fE;

const $R = mE;

const QR = hE;

const JR = EE;

const eI = SE;

const tI = IE;

const rI = AE;

const nI = yE;

const sI = OE;

const oI = DE;

const iI = LE;

const uI = ME;

const aI = wE;

const cI = XE;

const fI = jE;

const lI = WE;

const mI = zE;

const dI = qE;

const hI = JE;

const _I = rp;

const EI = sp;

const pI = ip;

const SI = cp;

const RI = lp;

const II = dp;

const gI = _p;

const AI = pp;

const vI = Rp;

const yI = gp;

const bI = vp;

const NI = bp;

const OI = Pp;

const TI = Cp;

const DI = Yp;

const PI = Fp;

const LI = jp;

const CI = Kp;

const MI = Bp;

const YI = Gp;

const wI = Hp;

const FI = Zp;

const XI = $p;

const jI = tS;

const KI = nS;

const UI = oS;

const BI = uS;

const xI = cS;

const GI = lS;

const kI = hS;

const HI = ES;

const WI = IS;

const VI = AS;

const zI = vS;

const ZI = bS;

const qI = OS;

const $I = DS;

const QI = LS;

const JI = MS;

const eg = FS;

const tg = jS;

g.default = {
    ...US.default,
    ACL_CAT: BS,
    aclCat: BS,
    ACL_DELUSER: xS,
    aclDelUser: xS,
    ACL_DRYRUN: GS,
    aclDryRun: GS,
    ACL_GENPASS: kS,
    aclGenPass: kS,
    ACL_GETUSER: HS,
    aclGetUser: HS,
    ACL_LIST: WS,
    aclList: WS,
    ACL_LOAD: VS,
    aclLoad: VS,
    ACL_LOG_RESET: zS,
    aclLogReset: zS,
    ACL_LOG: ZS,
    aclLog: ZS,
    ACL_SAVE: qS,
    aclSave: qS,
    ACL_SETUSER: $S,
    aclSetUser: $S,
    ACL_USERS: QS,
    aclUsers: QS,
    ACL_WHOAMI: JS,
    aclWhoAmI: JS,
    ASKING: eR,
    asking: eR,
    AUTH: tR,
    auth: tR,
    BGREWRITEAOF: rR,
    bgRewriteAof: rR,
    BGSAVE: nR,
    bgSave: nR,
    CLIENT_CACHING: sR,
    clientCaching: sR,
    CLIENT_GETNAME: oR,
    clientGetName: oR,
    CLIENT_GETREDIR: iR,
    clientGetRedir: iR,
    CLIENT_ID: uR,
    clientId: uR,
    CLIENT_KILL: aR,
    clientKill: aR,
    "CLIENT_NO-EVICT": fR,
    clientNoEvict: fR,
    "CLIENT_NO-TOUCH": lR,
    clientNoTouch: lR,
    CLIENT_LIST: cR,
    clientList: cR,
    CLIENT_PAUSE: mR,
    clientPause: mR,
    CLIENT_SETNAME: dR,
    clientSetName: dR,
    CLIENT_TRACKING: hR,
    clientTracking: hR,
    CLIENT_TRACKINGINFO: _R,
    clientTrackingInfo: _R,
    CLIENT_UNPAUSE: ER,
    clientUnpause: ER,
    CLIENT_INFO: pR,
    clientInfo: pR,
    CLUSTER_ADDSLOTS: SR,
    clusterAddSlots: SR,
    CLUSTER_ADDSLOTSRANGE: RR,
    clusterAddSlotsRange: RR,
    CLUSTER_BUMPEPOCH: IR,
    clusterBumpEpoch: IR,
    CLUSTER_COUNT_FAILURE_REPORTS: gR,
    clusterCountFailureReports: gR,
    CLUSTER_COUNTKEYSINSLOT: AR,
    clusterCountKeysInSlot: AR,
    CLUSTER_DELSLOTS: vR,
    clusterDelSlots: vR,
    CLUSTER_DELSLOTSRANGE: yR,
    clusterDelSlotsRange: yR,
    CLUSTER_FAILOVER: bR,
    clusterFailover: bR,
    CLUSTER_FLUSHSLOTS: NR,
    clusterFlushSlots: NR,
    CLUSTER_FORGET: OR,
    clusterForget: OR,
    CLUSTER_GETKEYSINSLOT: TR,
    clusterGetKeysInSlot: TR,
    CLUSTER_INFO: DR,
    clusterInfo: DR,
    CLUSTER_KEYSLOT: PR,
    clusterKeySlot: PR,
    CLUSTER_LINKS: LR,
    clusterLinks: LR,
    CLUSTER_MEET: CR,
    clusterMeet: CR,
    CLUSTER_MYID: MR,
    clusterMyId: MR,
    CLUSTER_MYSHARDID: YR,
    clusterMyShardId: YR,
    CLUSTER_NODES: wR,
    clusterNodes: wR,
    CLUSTER_REPLICAS: FR,
    clusterReplicas: FR,
    CLUSTER_REPLICATE: XR,
    clusterReplicate: XR,
    CLUSTER_RESET: jR,
    clusterReset: jR,
    CLUSTER_SAVECONFIG: KR,
    clusterSaveConfig: KR,
    CLUSTER_SET_CONFIG_EPOCH: UR,
    clusterSetConfigEpoch: UR,
    CLUSTER_SETSLOT: BR,
    clusterSetSlot: BR,
    CLUSTER_SLOTS: xR,
    clusterSlots: xR,
    COMMAND_COUNT: GR,
    commandCount: GR,
    COMMAND_GETKEYS: kR,
    commandGetKeys: kR,
    COMMAND_GETKEYSANDFLAGS: HR,
    commandGetKeysAndFlags: HR,
    COMMAND_INFO: WR,
    commandInfo: WR,
    COMMAND_LIST: VR,
    commandList: VR,
    COMMAND: zR,
    command: zR,
    CONFIG_GET: ZR,
    configGet: ZR,
    CONFIG_RESETASTAT: qR,
    configResetStat: qR,
    CONFIG_REWRITE: $R,
    configRewrite: $R,
    CONFIG_SET: QR,
    configSet: QR,
    DBSIZE: JR,
    dbSize: JR,
    DISCARD: eI,
    discard: eI,
    ECHO: tI,
    echo: tI,
    FAILOVER: rI,
    failover: rI,
    FLUSHALL: nI,
    flushAll: nI,
    FLUSHDB: sI,
    flushDb: sI,
    FUNCTION_DELETE: oI,
    functionDelete: oI,
    FUNCTION_DUMP: iI,
    functionDump: iI,
    FUNCTION_FLUSH: uI,
    functionFlush: uI,
    FUNCTION_KILL: aI,
    functionKill: aI,
    FUNCTION_LIST_WITHCODE: cI,
    functionListWithCode: cI,
    FUNCTION_LIST: fI,
    functionList: fI,
    FUNCTION_LOAD: lI,
    functionLoad: lI,
    FUNCTION_RESTORE: mI,
    functionRestore: mI,
    FUNCTION_STATS: dI,
    functionStats: dI,
    HELLO: hI,
    hello: hI,
    INFO: _I,
    info: _I,
    KEYS: EI,
    keys: EI,
    LASTSAVE: pI,
    lastSave: pI,
    LATENCY_DOCTOR: SI,
    latencyDoctor: SI,
    LATENCY_GRAPH: RI,
    latencyGraph: RI,
    LATENCY_HISTORY: II,
    latencyHistory: II,
    LATENCY_LATEST: gI,
    latencyLatest: gI,
    LOLWUT: AI,
    lolwut: AI,
    MEMORY_DOCTOR: vI,
    memoryDoctor: vI,
    "MEMORY_MALLOC-STATS": yI,
    memoryMallocStats: yI,
    MEMORY_PURGE: bI,
    memoryPurge: bI,
    MEMORY_STATS: NI,
    memoryStats: NI,
    MEMORY_USAGE: OI,
    memoryUsage: OI,
    MODULE_LIST: TI,
    moduleList: TI,
    MODULE_LOAD: DI,
    moduleLoad: DI,
    MODULE_UNLOAD: PI,
    moduleUnload: PI,
    MOVE: LI,
    move: LI,
    PING: CI,
    ping: CI,
    PUBSUB_CHANNELS: MI,
    pubSubChannels: MI,
    PUBSUB_NUMPAT: YI,
    pubSubNumPat: YI,
    PUBSUB_NUMSUB: wI,
    pubSubNumSub: wI,
    PUBSUB_SHARDCHANNELS: FI,
    pubSubShardChannels: FI,
    PUBSUB_SHARDNUMSUB: XI,
    pubSubShardNumSub: XI,
    RANDOMKEY: jI,
    randomKey: jI,
    READONLY: KI,
    readonly: KI,
    READWRITE: UI,
    readwrite: UI,
    REPLICAOF: BI,
    replicaOf: BI,
    "RESTORE-ASKING": xI,
    restoreAsking: xI,
    ROLE: GI,
    role: GI,
    SAVE: kI,
    save: kI,
    SCAN: HI,
    scan: HI,
    SCRIPT_DEBUG: WI,
    scriptDebug: WI,
    SCRIPT_EXISTS: VI,
    scriptExists: VI,
    SCRIPT_FLUSH: zI,
    scriptFlush: zI,
    SCRIPT_KILL: ZI,
    scriptKill: ZI,
    SCRIPT_LOAD: qI,
    scriptLoad: qI,
    SHUTDOWN: $I,
    shutdown: $I,
    SWAPDB: QI,
    swapDb: QI,
    TIME: JI,
    time: JI,
    UNWATCH: eg,
    unwatch: eg,
    WAIT: tg,
    wait: tg
};

var rg = {};

var ng = {};

Object.defineProperty(ng, "__esModule", {
    value: true
});

ng.MultiErrorReply = ng.ErrorReply = ng.ReconnectStrategyError = ng.RootNodesUnavailableError = ng.SocketClosedUnexpectedlyError = ng.DisconnectsClientError = ng.ClientOfflineError = ng.ClientClosedError = ng.ConnectionTimeoutError = ng.WatchError = ng.AbortError = void 0;

class AbortError extends Error {
    constructor() {
        super("The command was aborted");
    }
}

ng.AbortError = AbortError;

class WatchError extends Error {
    constructor() {
        super("One (or more) of the watched keys has been changed");
    }
}

ng.WatchError = WatchError;

class ConnectionTimeoutError extends Error {
    constructor() {
        super("Connection timeout");
    }
}

ng.ConnectionTimeoutError = ConnectionTimeoutError;

class ClientClosedError extends Error {
    constructor() {
        super("The client is closed");
    }
}

ng.ClientClosedError = ClientClosedError;

class ClientOfflineError extends Error {
    constructor() {
        super("The client is offline");
    }
}

ng.ClientOfflineError = ClientOfflineError;

class DisconnectsClientError extends Error {
    constructor() {
        super("Disconnects client");
    }
}

ng.DisconnectsClientError = DisconnectsClientError;

class SocketClosedUnexpectedlyError extends Error {
    constructor() {
        super("Socket closed unexpectedly");
    }
}

ng.SocketClosedUnexpectedlyError = SocketClosedUnexpectedlyError;

class RootNodesUnavailableError extends Error {
    constructor() {
        super("All the root nodes are unavailable");
    }
}

ng.RootNodesUnavailableError = RootNodesUnavailableError;

class ReconnectStrategyError extends Error {
    constructor(e, t) {
        super(e.message);
        Object.defineProperty(this, "originalError", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "socketError", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.originalError = e;
        this.socketError = t;
    }
}

ng.ReconnectStrategyError = ReconnectStrategyError;

class ErrorReply extends Error {
    constructor(e) {
        super(e);
        this.stack = undefined;
    }
}

ng.ErrorReply = ErrorReply;

class MultiErrorReply extends ErrorReply {
    constructor(e, t) {
        super(`${t.length} commands failed, see .replies and .errorIndexes for more information`);
        Object.defineProperty(this, "replies", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "errorIndexes", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.replies = e;
        this.errorIndexes = t;
    }
    * errors() {
        for (const e of this.errorIndexes) {
            yield this.replies[e];
        }
    }
}

ng.MultiErrorReply = MultiErrorReply;

var sg = {};

Object.defineProperty(sg, "__esModule", {
    value: true
});

sg.promiseTimeout = void 0;

function og(e) {
    return new Promise(t => setTimeout(t, e));
}

sg.promiseTimeout = og;

var ig = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
    if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
    if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
};

var ug = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
    if (n === "m") throw new TypeError("Private method is not writable");
    if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
    if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
};

var ag, cg, fg, lg, mg, dg, hg, _g, Eg, pg, Sg, Rg, Ig, gg, Ag, vg, yg, bg, Ng, Og;

Object.defineProperty(rg, "__esModule", {
    value: true
});

const Tg = f.default;

const Dg = l.default;

const Pg = m.default;

const Lg = ng;

const Cg = sg;

class RedisSocket extends Tg.EventEmitter {
    get isOpen() {
        return ig(this, _g, "f");
    }
    get isReady() {
        return ig(this, Eg, "f");
    }
    get writableNeedDrain() {
        return ig(this, pg, "f");
    }
    constructor(e, t) {
        super();
        ag.add(this);
        mg.set(this, void 0);
        dg.set(this, void 0);
        hg.set(this, void 0);
        _g.set(this, false);
        Eg.set(this, false);
        pg.set(this, false);
        Sg.set(this, false);
        Og.set(this, false);
        ug(this, mg, e, "f");
        ug(this, dg, ig(cg, cg, "m", fg).call(cg, t), "f");
    }
    async connect() {
        if (ig(this, _g, "f")) {
            throw new Error("Socket already opened");
        }
        ug(this, _g, true, "f");
        return ig(this, ag, "m", gg).call(this);
    }
    writeCommand(e) {
        if (!ig(this, hg, "f")) {
            throw new Lg.ClientClosedError;
        }
        for (const t of e) {
            ug(this, pg, !ig(this, hg, "f").write(t), "f");
        }
    }
    disconnect() {
        if (!ig(this, _g, "f")) {
            throw new Lg.ClientClosedError;
        }
        ug(this, _g, false, "f");
        ig(this, ag, "m", Ng).call(this);
    }
    async quit(e) {
        if (!ig(this, _g, "f")) {
            throw new Lg.ClientClosedError;
        }
        ug(this, _g, false, "f");
        const t = await e();
        ig(this, ag, "m", Ng).call(this);
        return t;
    }
    cork() {
        if (!ig(this, hg, "f") || ig(this, Og, "f")) {
            return;
        }
        ig(this, hg, "f").cork();
        ug(this, Og, true, "f");
        setImmediate(() => {
            ig(this, hg, "f")?.uncork();
            ug(this, Og, false, "f");
        });
    }
    ref() {
        ug(this, Sg, false, "f");
        ig(this, hg, "f")?.ref();
    }
    unref() {
        ug(this, Sg, true, "f");
        ig(this, hg, "f")?.unref();
    }
}

cg = RedisSocket, mg = new WeakMap, dg = new WeakMap, hg = new WeakMap, _g = new WeakMap, 
Eg = new WeakMap, pg = new WeakMap, Sg = new WeakMap, Og = new WeakMap, ag = new WeakSet, 
fg = function e(t) {
    var r, n;
    t ?? (t = {});
    if (!t.path) {
        (r = t).port ?? (r.port = 6379);
        (n = t).host ?? (n.host = "localhost");
    }
    t.connectTimeout ?? (t.connectTimeout = 5e3);
    t.keepAlive ?? (t.keepAlive = 5e3);
    t.noDelay ?? (t.noDelay = true);
    return t;
}, lg = function e(t) {
    return t.tls === true;
}, Rg = function e(t, r) {
    if (ig(this, dg, "f").reconnectStrategy === false) {
        return false;
    } else if (typeof ig(this, dg, "f").reconnectStrategy === "number") {
        return ig(this, dg, "f").reconnectStrategy;
    } else if (ig(this, dg, "f").reconnectStrategy) {
        try {
            const e = ig(this, dg, "f").reconnectStrategy(t, r);
            if (e !== false && !(e instanceof Error) && typeof e !== "number") {
                throw new TypeError(`Reconnect strategy should return \`false | Error | number\`, got ${e} instead`);
            }
            return e;
        } catch (e) {
            this.emit("error", e);
        }
    }
    return Math.min(t * 50, 500);
}, Ig = function e(t, r) {
    const n = ig(this, ag, "m", Rg).call(this, t, r);
    if (n === false) {
        ug(this, _g, false, "f");
        this.emit("error", r);
        return r;
    } else if (n instanceof Error) {
        ug(this, _g, false, "f");
        this.emit("error", r);
        return new Lg.ReconnectStrategyError(n, r);
    }
    return n;
}, gg = async function e() {
    let t = 0;
    do {
        try {
            ug(this, hg, await ig(this, ag, "m", Ag).call(this), "f");
            ug(this, pg, false, "f");
            this.emit("connect");
            try {
                await ig(this, mg, "f").call(this);
            } catch (e) {
                ig(this, hg, "f").destroy();
                ug(this, hg, undefined, "f");
                throw e;
            }
            ug(this, Eg, true, "f");
            this.emit("ready");
        } catch (e) {
            const r = ig(this, ag, "m", Ig).call(this, t++, e);
            if (typeof r !== "number") {
                throw r;
            }
            this.emit("error", e);
            await (0, Cg.promiseTimeout)(r);
            this.emit("reconnecting");
        }
    } while (ig(this, _g, "f") && !ig(this, Eg, "f"));
}, Ag = function e() {
    return new Promise((e, t) => {
        const {connectEvent: r, socket: n} = ig(cg, cg, "m", lg).call(cg, ig(this, dg, "f")) ? ig(this, ag, "m", yg).call(this) : ig(this, ag, "m", vg).call(this);
        if (ig(this, dg, "f").connectTimeout) {
            n.setTimeout(ig(this, dg, "f").connectTimeout, () => n.destroy(new Lg.ConnectionTimeoutError));
        }
        if (ig(this, Sg, "f")) {
            n.unref();
        }
        n.setNoDelay(ig(this, dg, "f").noDelay).once("error", t).once(r, () => {
            n.setTimeout(0).setKeepAlive(ig(this, dg, "f").keepAlive !== false, ig(this, dg, "f").keepAlive || 0).off("error", t).once("error", e => ig(this, ag, "m", bg).call(this, e)).once("close", e => {
                if (!e && ig(this, _g, "f") && ig(this, hg, "f") === n) {
                    ig(this, ag, "m", bg).call(this, new Lg.SocketClosedUnexpectedlyError);
                }
            }).on("drain", () => {
                ug(this, pg, false, "f");
                this.emit("drain");
            }).on("data", e => this.emit("data", e));
            e(n);
        });
    });
}, vg = function e() {
    return {
        connectEvent: "connect",
        socket: Dg.connect(ig(this, dg, "f"))
    };
}, yg = function e() {
    return {
        connectEvent: "secureConnect",
        socket: Pg.connect(ig(this, dg, "f"))
    };
}, bg = function e(t) {
    const r = ig(this, Eg, "f");
    ug(this, Eg, false, "f");
    this.emit("error", t);
    if (!r || !ig(this, _g, "f") || typeof ig(this, ag, "m", Ig).call(this, 0, t) !== "number") return;
    this.emit("reconnecting");
    ig(this, ag, "m", gg).call(this).catch(() => {});
}, Ng = function e() {
    ug(this, Eg, false, "f");
    if (ig(this, hg, "f")) {
        ig(this, hg, "f").destroy();
        ug(this, hg, undefined, "f");
    }
    this.emit("end");
};

rg.default = RedisSocket;

var Mg = {};

var Yg;

var wg;

function Fg() {
    if (wg) return Yg;
    wg = 1;
    Yg = function(e) {
        e.prototype[Symbol.iterator] = function*() {
            for (let e = this.head; e; e = e.next) {
                yield e.value;
            }
        };
    };
    return Yg;
}

var Xg = jg;

jg.Node = xg;

jg.create = jg;

function jg(e) {
    var t = this;
    if (!(t instanceof jg)) {
        t = new jg;
    }
    t.tail = null;
    t.head = null;
    t.length = 0;
    if (e && typeof e.forEach === "function") {
        e.forEach(function(e) {
            t.push(e);
        });
    } else if (arguments.length > 0) {
        for (var r = 0, n = arguments.length; r < n; r++) {
            t.push(arguments[r]);
        }
    }
    return t;
}

jg.prototype.removeNode = function(e) {
    if (e.list !== this) {
        throw new Error("removing node which does not belong to this list");
    }
    var t = e.next;
    var r = e.prev;
    if (t) {
        t.prev = r;
    }
    if (r) {
        r.next = t;
    }
    if (e === this.head) {
        this.head = t;
    }
    if (e === this.tail) {
        this.tail = r;
    }
    e.list.length--;
    e.next = null;
    e.prev = null;
    e.list = null;
    return t;
};

jg.prototype.unshiftNode = function(e) {
    if (e === this.head) {
        return;
    }
    if (e.list) {
        e.list.removeNode(e);
    }
    var t = this.head;
    e.list = this;
    e.next = t;
    if (t) {
        t.prev = e;
    }
    this.head = e;
    if (!this.tail) {
        this.tail = e;
    }
    this.length++;
};

jg.prototype.pushNode = function(e) {
    if (e === this.tail) {
        return;
    }
    if (e.list) {
        e.list.removeNode(e);
    }
    var t = this.tail;
    e.list = this;
    e.prev = t;
    if (t) {
        t.next = e;
    }
    this.tail = e;
    if (!this.head) {
        this.head = e;
    }
    this.length++;
};

jg.prototype.push = function() {
    for (var e = 0, t = arguments.length; e < t; e++) {
        Ug(this, arguments[e]);
    }
    return this.length;
};

jg.prototype.unshift = function() {
    for (var e = 0, t = arguments.length; e < t; e++) {
        Bg(this, arguments[e]);
    }
    return this.length;
};

jg.prototype.pop = function() {
    if (!this.tail) {
        return undefined;
    }
    var e = this.tail.value;
    this.tail = this.tail.prev;
    if (this.tail) {
        this.tail.next = null;
    } else {
        this.head = null;
    }
    this.length--;
    return e;
};

jg.prototype.shift = function() {
    if (!this.head) {
        return undefined;
    }
    var e = this.head.value;
    this.head = this.head.next;
    if (this.head) {
        this.head.prev = null;
    } else {
        this.tail = null;
    }
    this.length--;
    return e;
};

jg.prototype.forEach = function(e, t) {
    t = t || this;
    for (var r = this.head, n = 0; r !== null; n++) {
        e.call(t, r.value, n, this);
        r = r.next;
    }
};

jg.prototype.forEachReverse = function(e, t) {
    t = t || this;
    for (var r = this.tail, n = this.length - 1; r !== null; n--) {
        e.call(t, r.value, n, this);
        r = r.prev;
    }
};

jg.prototype.get = function(e) {
    for (var t = 0, r = this.head; r !== null && t < e; t++) {
        r = r.next;
    }
    if (t === e && r !== null) {
        return r.value;
    }
};

jg.prototype.getReverse = function(e) {
    for (var t = 0, r = this.tail; r !== null && t < e; t++) {
        r = r.prev;
    }
    if (t === e && r !== null) {
        return r.value;
    }
};

jg.prototype.map = function(e, t) {
    t = t || this;
    var r = new jg;
    for (var n = this.head; n !== null; ) {
        r.push(e.call(t, n.value, this));
        n = n.next;
    }
    return r;
};

jg.prototype.mapReverse = function(e, t) {
    t = t || this;
    var r = new jg;
    for (var n = this.tail; n !== null; ) {
        r.push(e.call(t, n.value, this));
        n = n.prev;
    }
    return r;
};

jg.prototype.reduce = function(e, t) {
    var r;
    var n = this.head;
    if (arguments.length > 1) {
        r = t;
    } else if (this.head) {
        n = this.head.next;
        r = this.head.value;
    } else {
        throw new TypeError("Reduce of empty list with no initial value");
    }
    for (var s = 0; n !== null; s++) {
        r = e(r, n.value, s);
        n = n.next;
    }
    return r;
};

jg.prototype.reduceReverse = function(e, t) {
    var r;
    var n = this.tail;
    if (arguments.length > 1) {
        r = t;
    } else if (this.tail) {
        n = this.tail.prev;
        r = this.tail.value;
    } else {
        throw new TypeError("Reduce of empty list with no initial value");
    }
    for (var s = this.length - 1; n !== null; s--) {
        r = e(r, n.value, s);
        n = n.prev;
    }
    return r;
};

jg.prototype.toArray = function() {
    var e = new Array(this.length);
    for (var t = 0, r = this.head; r !== null; t++) {
        e[t] = r.value;
        r = r.next;
    }
    return e;
};

jg.prototype.toArrayReverse = function() {
    var e = new Array(this.length);
    for (var t = 0, r = this.tail; r !== null; t++) {
        e[t] = r.value;
        r = r.prev;
    }
    return e;
};

jg.prototype.slice = function(e, t) {
    t = t || this.length;
    if (t < 0) {
        t += this.length;
    }
    e = e || 0;
    if (e < 0) {
        e += this.length;
    }
    var r = new jg;
    if (t < e || t < 0) {
        return r;
    }
    if (e < 0) {
        e = 0;
    }
    if (t > this.length) {
        t = this.length;
    }
    for (var n = 0, s = this.head; s !== null && n < e; n++) {
        s = s.next;
    }
    for (;s !== null && n < t; n++, s = s.next) {
        r.push(s.value);
    }
    return r;
};

jg.prototype.sliceReverse = function(e, t) {
    t = t || this.length;
    if (t < 0) {
        t += this.length;
    }
    e = e || 0;
    if (e < 0) {
        e += this.length;
    }
    var r = new jg;
    if (t < e || t < 0) {
        return r;
    }
    if (e < 0) {
        e = 0;
    }
    if (t > this.length) {
        t = this.length;
    }
    for (var n = this.length, s = this.tail; s !== null && n > t; n--) {
        s = s.prev;
    }
    for (;s !== null && n > e; n--, s = s.prev) {
        r.push(s.value);
    }
    return r;
};

jg.prototype.splice = function(e, t, ...r) {
    if (e > this.length) {
        e = this.length - 1;
    }
    if (e < 0) {
        e = this.length + e;
    }
    for (var n = 0, s = this.head; s !== null && n < e; n++) {
        s = s.next;
    }
    var o = [];
    for (var n = 0; s && n < t; n++) {
        o.push(s.value);
        s = this.removeNode(s);
    }
    if (s === null) {
        s = this.tail;
    }
    if (s !== this.head && s !== this.tail) {
        s = s.prev;
    }
    for (var n = 0; n < r.length; n++) {
        s = Kg(this, s, r[n]);
    }
    return o;
};

jg.prototype.reverse = function() {
    var e = this.head;
    var t = this.tail;
    for (var r = e; r !== null; r = r.prev) {
        var n = r.prev;
        r.prev = r.next;
        r.next = n;
    }
    this.head = t;
    this.tail = e;
    return this;
};

function Kg(e, t, r) {
    var n = t === e.head ? new xg(r, null, t, e) : new xg(r, t, t.next, e);
    if (n.next === null) {
        e.tail = n;
    }
    if (n.prev === null) {
        e.head = n;
    }
    e.length++;
    return n;
}

function Ug(e, t) {
    e.tail = new xg(t, e.tail, null, e);
    if (!e.head) {
        e.head = e.tail;
    }
    e.length++;
}

function Bg(e, t) {
    e.head = new xg(t, null, e.head, e);
    if (!e.tail) {
        e.tail = e.head;
    }
    e.length++;
}

function xg(e, t, r, n) {
    if (!(this instanceof xg)) {
        return new xg(e, t, r, n);
    }
    this.list = n;
    this.value = e;
    if (t) {
        t.next = this;
        this.prev = t;
    } else {
        this.prev = null;
    }
    if (r) {
        r.prev = this;
        this.next = r;
    } else {
        this.next = null;
    }
}

try {
    Fg()(jg);
} catch (e) {}

var Gg = {};

var kg = {};

Object.defineProperty(kg, "__esModule", {
    value: true
});

class BufferComposer {
    constructor() {
        Object.defineProperty(this, "chunks", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: []
        });
    }
    write(e) {
        this.chunks.push(e);
    }
    end(e) {
        this.write(e);
        return Buffer.concat(this.chunks.splice(0));
    }
    reset() {
        this.chunks = [];
    }
}

kg.default = BufferComposer;

var Hg = {};

Object.defineProperty(Hg, "__esModule", {
    value: true
});

const Wg = d.default;

class StringComposer {
    constructor() {
        Object.defineProperty(this, "decoder", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Wg.StringDecoder
        });
        Object.defineProperty(this, "string", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: ""
        });
    }
    write(e) {
        this.string += this.decoder.write(e);
    }
    end(e) {
        const t = this.string + this.decoder.end(e);
        this.string = "";
        return t;
    }
    reset() {
        this.string = "";
    }
}

Hg.default = StringComposer;

Object.defineProperty(Gg, "__esModule", {
    value: true
});

const Vg = ng;

const zg = kg;

const Zg = Hg;

var qg;

(function(e) {
    e[e["SIMPLE_STRING"] = 43] = "SIMPLE_STRING";
    e[e["ERROR"] = 45] = "ERROR";
    e[e["INTEGER"] = 58] = "INTEGER";
    e[e["BULK_STRING"] = 36] = "BULK_STRING";
    e[e["ARRAY"] = 42] = "ARRAY";
})(qg || (qg = {}));

var $g;

(function(e) {
    e[e["CR"] = 13] = "CR";
    e[e["ZERO"] = 48] = "ZERO";
    e[e["MINUS"] = 45] = "MINUS";
})($g || ($g = {}));

class RESP2Decoder {
    constructor(e) {
        Object.defineProperty(this, "options", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: e
        });
        Object.defineProperty(this, "cursor", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 0
        });
        Object.defineProperty(this, "type", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "bufferComposer", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new zg.default
        });
        Object.defineProperty(this, "stringComposer", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Zg.default
        });
        Object.defineProperty(this, "currentStringComposer", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.stringComposer
        });
        Object.defineProperty(this, "integer", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 0
        });
        Object.defineProperty(this, "isNegativeInteger", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "bulkStringRemainingLength", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "arraysInProcess", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: []
        });
        Object.defineProperty(this, "initializeArray", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: false
        });
        Object.defineProperty(this, "arrayItemType", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
    }
    reset() {
        this.cursor = 0;
        this.type = undefined;
        this.bufferComposer.reset();
        this.stringComposer.reset();
        this.currentStringComposer = this.stringComposer;
    }
    write(e) {
        while (this.cursor < e.length) {
            if (!this.type) {
                this.currentStringComposer = this.options.returnStringsAsBuffers() ? this.bufferComposer : this.stringComposer;
                this.type = e[this.cursor];
                if (++this.cursor >= e.length) break;
            }
            const t = this.parseType(e, this.type);
            if (t === undefined) break;
            this.type = undefined;
            this.options.onReply(t);
        }
        this.cursor -= e.length;
    }
    parseType(e, t, r) {
        switch (t) {
          case qg.SIMPLE_STRING:
            return this.parseSimpleString(e);

          case qg.ERROR:
            return this.parseError(e);

          case qg.INTEGER:
            return this.parseInteger(e);

          case qg.BULK_STRING:
            return this.parseBulkString(e);

          case qg.ARRAY:
            return this.parseArray(e, r);
        }
    }
    compose(e, t) {
        for (let r = this.cursor; r < e.length; r++) {
            if (e[r] === $g.CR) {
                const n = t.end(e.subarray(this.cursor, r));
                this.cursor = r + 2;
                return n;
            }
        }
        const r = e.subarray(this.cursor);
        t.write(r);
        this.cursor = e.length;
    }
    parseSimpleString(e) {
        return this.compose(e, this.currentStringComposer);
    }
    parseError(e) {
        const t = this.compose(e, this.stringComposer);
        if (t !== undefined) {
            return new Vg.ErrorReply(t);
        }
    }
    parseInteger(e) {
        if (this.isNegativeInteger === undefined) {
            this.isNegativeInteger = e[this.cursor] === $g.MINUS;
            if (this.isNegativeInteger && ++this.cursor === e.length) return;
        }
        do {
            const t = e[this.cursor];
            if (t === $g.CR) {
                const e = this.isNegativeInteger ? -this.integer : this.integer;
                this.integer = 0;
                this.isNegativeInteger = undefined;
                this.cursor += 2;
                return e;
            }
            this.integer = this.integer * 10 + t - $g.ZERO;
        } while (++this.cursor < e.length);
    }
    parseBulkString(e) {
        if (this.bulkStringRemainingLength === undefined) {
            const t = this.parseInteger(e);
            if (t === undefined) return;
            if (t === -1) return null;
            this.bulkStringRemainingLength = t;
            if (this.cursor >= e.length) return;
        }
        const t = this.cursor + this.bulkStringRemainingLength;
        if (e.length >= t) {
            const r = this.currentStringComposer.end(e.subarray(this.cursor, t));
            this.bulkStringRemainingLength = undefined;
            this.cursor = t + 2;
            return r;
        }
        const r = e.subarray(this.cursor);
        this.currentStringComposer.write(r);
        this.bulkStringRemainingLength -= r.length;
        this.cursor = e.length;
    }
    parseArray(e, t = 0) {
        if (this.initializeArray || this.arraysInProcess.length === t) {
            const r = this.parseInteger(e);
            if (r === undefined) {
                this.initializeArray = true;
                return undefined;
            }
            this.initializeArray = false;
            this.arrayItemType = undefined;
            if (r === -1) {
                return this.returnArrayReply(null, t, e);
            } else if (r === 0) {
                return this.returnArrayReply([], t, e);
            }
            this.arraysInProcess.push({
                array: new Array(r),
                pushCounter: 0
            });
        }
        while (this.cursor < e.length) {
            if (!this.arrayItemType) {
                this.arrayItemType = e[this.cursor];
                if (++this.cursor >= e.length) break;
            }
            const r = this.parseType(e, this.arrayItemType, t + 1);
            if (r === undefined) break;
            this.arrayItemType = undefined;
            const n = this.pushArrayItem(r, t);
            if (n !== undefined) return n;
        }
    }
    returnArrayReply(e, t, r) {
        if (this.arraysInProcess.length <= t) return e;
        return this.pushArrayItem(e, t, r);
    }
    pushArrayItem(e, t, r) {
        const n = this.arraysInProcess[this.arraysInProcess.length - 1];
        n.array[n.pushCounter] = e;
        if (++n.pushCounter === n.array.length) {
            return this.returnArrayReply(this.arraysInProcess.pop().array, t, r);
        } else if (r && r.length > this.cursor) {
            return this.parseArray(r, t);
        }
    }
}

Gg.default = RESP2Decoder;

var Qg = {};

Object.defineProperty(Qg, "__esModule", {
    value: true
});

const Jg = "\r\n";

function eA(e) {
    const t = [];
    let r = "*" + e.length + Jg;
    for (let n = 0; n < e.length; n++) {
        const s = e[n];
        if (typeof s === "string") {
            r += "$" + Buffer.byteLength(s) + Jg + s + Jg;
        } else if (s instanceof Buffer) {
            t.push(r + "$" + s.length.toString() + Jg, s);
            r = Jg;
        } else {
            throw new TypeError("Invalid argument type");
        }
    }
    t.push(r);
    return t;
}

Qg.default = eA;

var tA = {};

var rA = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
    if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
    if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
};

var nA = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
    if (n === "m") throw new TypeError("Private method is not writable");
    if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
    if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
};

var sA, oA, iA, uA, aA, cA, fA, lA, mA, dA, hA;

Object.defineProperty(tA, "__esModule", {
    value: true
});

tA.PubSub = tA.PubSubType = void 0;

var _A;

(function(e) {
    e["CHANNELS"] = "CHANNELS";
    e["PATTERNS"] = "PATTERNS";
    e["SHARDED"] = "SHARDED";
})(_A || (tA.PubSubType = _A = {}));

const EA = {
    [_A.CHANNELS]: {
        subscribe: Buffer.from("subscribe"),
        unsubscribe: Buffer.from("unsubscribe"),
        message: Buffer.from("message")
    },
    [_A.PATTERNS]: {
        subscribe: Buffer.from("psubscribe"),
        unsubscribe: Buffer.from("punsubscribe"),
        message: Buffer.from("pmessage")
    },
    [_A.SHARDED]: {
        subscribe: Buffer.from("ssubscribe"),
        unsubscribe: Buffer.from("sunsubscribe"),
        message: Buffer.from("smessage")
    }
};

class PubSub {
    constructor() {
        sA.add(this);
        aA.set(this, 0);
        cA.set(this, false);
        fA.set(this, {
            [_A.CHANNELS]: new Map,
            [_A.PATTERNS]: new Map,
            [_A.SHARDED]: new Map
        });
    }
    static isStatusReply(e) {
        return EA[_A.CHANNELS].subscribe.equals(e[0]) || EA[_A.CHANNELS].unsubscribe.equals(e[0]) || EA[_A.PATTERNS].subscribe.equals(e[0]) || EA[_A.PATTERNS].unsubscribe.equals(e[0]) || EA[_A.SHARDED].subscribe.equals(e[0]);
    }
    static isShardedUnsubscribe(e) {
        return EA[_A.SHARDED].unsubscribe.equals(e[0]);
    }
    get isActive() {
        return rA(this, cA, "f");
    }
    subscribe(e, t, r, n) {
        var s;
        const o = [ EA[e].subscribe ], i = rA(oA, oA, "m", iA).call(oA, t);
        for (const t of i) {
            let r = rA(this, fA, "f")[e].get(t);
            if (!r || r.unsubscribing) {
                o.push(t);
            }
        }
        if (o.length === 1) {
            for (const t of i) {
                rA(oA, oA, "m", uA).call(oA, rA(this, fA, "f")[e].get(t), n).add(r);
            }
            return;
        }
        nA(this, cA, true, "f");
        nA(this, aA, (s = rA(this, aA, "f"), s++, s), "f");
        return {
            args: o,
            channelsCounter: o.length - 1,
            resolve: () => {
                var t;
                nA(this, aA, (t = rA(this, aA, "f"), t--, t), "f");
                for (const t of i) {
                    let s = rA(this, fA, "f")[e].get(t);
                    if (!s) {
                        s = {
                            unsubscribing: false,
                            buffers: new Set,
                            strings: new Set
                        };
                        rA(this, fA, "f")[e].set(t, s);
                    }
                    rA(oA, oA, "m", uA).call(oA, s, n).add(r);
                }
            },
            reject: () => {
                var e;
                nA(this, aA, (e = rA(this, aA, "f"), e--, e), "f");
                rA(this, sA, "m", dA).call(this);
            }
        };
    }
    extendChannelListeners(e, t, r) {
        var n;
        if (!rA(this, sA, "m", lA).call(this, e, t, r)) return;
        nA(this, cA, true, "f");
        nA(this, aA, (n = rA(this, aA, "f"), n++, n), "f");
        return {
            args: [ EA[e].subscribe, t ],
            channelsCounter: 1,
            resolve: () => {
                var e, t;
                return nA(this, aA, (t = rA(this, aA, "f"), e = t--, t), "f"), e;
            },
            reject: () => {
                var e;
                nA(this, aA, (e = rA(this, aA, "f"), e--, e), "f");
                rA(this, sA, "m", dA).call(this);
            }
        };
    }
    extendTypeListeners(e, t) {
        var r;
        const n = [ EA[e].subscribe ];
        for (const [r, s] of t) {
            if (rA(this, sA, "m", lA).call(this, e, r, s)) {
                n.push(r);
            }
        }
        if (n.length === 1) return;
        nA(this, cA, true, "f");
        nA(this, aA, (r = rA(this, aA, "f"), r++, r), "f");
        return {
            args: n,
            channelsCounter: n.length - 1,
            resolve: () => {
                var e, t;
                return nA(this, aA, (t = rA(this, aA, "f"), e = t--, t), "f"), e;
            },
            reject: () => {
                var e;
                nA(this, aA, (e = rA(this, aA, "f"), e--, e), "f");
                rA(this, sA, "m", dA).call(this);
            }
        };
    }
    unsubscribe(e, t, r, n) {
        const s = rA(this, fA, "f")[e];
        if (!t) {
            return rA(this, sA, "m", mA).call(this, [ EA[e].unsubscribe ], NaN, () => s.clear());
        }
        const o = rA(oA, oA, "m", iA).call(oA, t);
        if (!r) {
            return rA(this, sA, "m", mA).call(this, [ EA[e].unsubscribe, ...o ], o.length, () => {
                for (const e of o) {
                    s.delete(e);
                }
            });
        }
        const i = [ EA[e].unsubscribe ];
        for (const e of o) {
            const t = s.get(e);
            if (t) {
                let e, s;
                if (n) {
                    e = t.buffers;
                    s = t.strings;
                } else {
                    e = t.strings;
                    s = t.buffers;
                }
                const o = e.has(r) ? e.size - 1 : e.size;
                if (o !== 0 || s.size !== 0) continue;
                t.unsubscribing = true;
            }
            i.push(e);
        }
        if (i.length === 1) {
            for (const e of o) {
                rA(oA, oA, "m", uA).call(oA, s.get(e), n).delete(r);
            }
            return;
        }
        return rA(this, sA, "m", mA).call(this, i, i.length - 1, () => {
            for (const e of o) {
                const t = s.get(e);
                if (!t) continue;
                (n ? t.buffers : t.strings).delete(r);
                if (t.buffers.size === 0 && t.strings.size === 0) {
                    s.delete(e);
                }
            }
        });
    }
    reset() {
        nA(this, cA, false, "f");
        nA(this, aA, 0, "f");
    }
    resubscribe() {
        var e;
        const t = [];
        for (const [r, n] of Object.entries(rA(this, fA, "f"))) {
            if (!n.size) continue;
            nA(this, cA, true, "f");
            nA(this, aA, (e = rA(this, aA, "f"), e++, e), "f");
            const s = () => {
                var e, t;
                return nA(this, aA, (t = rA(this, aA, "f"), e = t--, t), "f"), e;
            };
            t.push({
                args: [ EA[r].subscribe, ...n.keys() ],
                channelsCounter: n.size,
                resolve: s,
                reject: s
            });
        }
        return t;
    }
    handleMessageReply(e) {
        if (EA[_A.CHANNELS].message.equals(e[0])) {
            rA(this, sA, "m", hA).call(this, _A.CHANNELS, e[2], e[1]);
            return true;
        } else if (EA[_A.PATTERNS].message.equals(e[0])) {
            rA(this, sA, "m", hA).call(this, _A.PATTERNS, e[3], e[2], e[1]);
            return true;
        } else if (EA[_A.SHARDED].message.equals(e[0])) {
            rA(this, sA, "m", hA).call(this, _A.SHARDED, e[2], e[1]);
            return true;
        }
        return false;
    }
    removeShardedListeners(e) {
        const t = rA(this, fA, "f")[_A.SHARDED].get(e);
        rA(this, fA, "f")[_A.SHARDED].delete(e);
        rA(this, sA, "m", dA).call(this);
        return t;
    }
    getTypeListeners(e) {
        return rA(this, fA, "f")[e];
    }
}

tA.PubSub = PubSub;

oA = PubSub, aA = new WeakMap, cA = new WeakMap, fA = new WeakMap, sA = new WeakSet, 
iA = function e(t) {
    return Array.isArray(t) ? t : [ t ];
}, uA = function e(t, r) {
    return r ? t.buffers : t.strings;
}, lA = function e(t, r, n) {
    const s = rA(this, fA, "f")[t].get(r);
    if (!s) {
        rA(this, fA, "f")[t].set(r, n);
        return true;
    }
    for (const e of n.buffers) {
        s.buffers.add(e);
    }
    for (const e of n.strings) {
        s.strings.add(e);
    }
    return false;
}, mA = function e(t, r, n) {
    return {
        args: t,
        channelsCounter: r,
        resolve: () => {
            n();
            rA(this, sA, "m", dA).call(this);
        },
        reject: undefined
    };
}, dA = function e() {
    nA(this, cA, rA(this, fA, "f")[_A.CHANNELS].size !== 0 || rA(this, fA, "f")[_A.PATTERNS].size !== 0 || rA(this, fA, "f")[_A.SHARDED].size !== 0 || rA(this, aA, "f") !== 0, "f");
}, hA = function e(t, r, n, s) {
    const o = (s ?? n).toString(), i = rA(this, fA, "f")[t].get(o);
    if (!i) return;
    for (const e of i.buffers) {
        e(r, n);
    }
    if (!i.strings.size) return;
    const u = s ? n.toString() : o, a = u === "__redis__:invalidate" ? r === null ? null : r.map(e => e.toString()) : r.toString();
    for (const e of i.strings) {
        e(a, u);
    }
};

var pA = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
    if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
    if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
};

var SA = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
    if (n === "m") throw new TypeError("Private method is not writable");
    if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
    if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
};

var RA, IA, gA, AA, vA, yA, bA, NA, OA, TA, DA;

Object.defineProperty(Mg, "__esModule", {
    value: true
});

const PA = Xg;

const LA = ng;

const CA = Gg;

const MA = Qg;

const YA = tA;

const wA = Buffer.from("pong");

class RedisCommandsQueue {
    get isPubSubActive() {
        return pA(this, NA, "f").isActive;
    }
    constructor(e, t) {
        RA.add(this);
        AA.set(this, void 0);
        vA.set(this, new PA);
        yA.set(this, new PA);
        bA.set(this, void 0);
        NA.set(this, new YA.PubSub);
        OA.set(this, void 0);
        TA.set(this, new CA.default({
            returnStringsAsBuffers: () => !!pA(this, yA, "f").head?.value.returnBuffers || pA(this, NA, "f").isActive,
            onReply: e => {
                if (pA(this, NA, "f").isActive && Array.isArray(e)) {
                    if (pA(this, NA, "f").handleMessageReply(e)) return;
                    const t = YA.PubSub.isShardedUnsubscribe(e);
                    if (t && !pA(this, yA, "f").length) {
                        const t = e[1].toString();
                        pA(this, bA, "f").call(this, t, pA(this, NA, "f").removeShardedListeners(t));
                        return;
                    } else if (t || YA.PubSub.isStatusReply(e)) {
                        const t = pA(this, yA, "f").head.value;
                        if (Number.isNaN(t.channelsCounter) && e[2] === 0 || --t.channelsCounter === 0) {
                            pA(this, yA, "f").shift().resolve();
                        }
                        return;
                    }
                    if (wA.equals(e[0])) {
                        const {resolve: t, returnBuffers: r} = pA(this, yA, "f").shift(), n = e[1].length === 0 ? e[0] : e[1];
                        t(r ? n : n.toString());
                        return;
                    }
                }
                const {resolve: t, reject: r} = pA(this, yA, "f").shift();
                if (e instanceof LA.ErrorReply) {
                    r(e);
                } else {
                    t(e);
                }
            }
        }));
        SA(this, AA, e, "f");
        SA(this, bA, t, "f");
    }
    addCommand(e, t) {
        if (pA(this, AA, "f") && pA(this, vA, "f").length + pA(this, yA, "f").length >= pA(this, AA, "f")) {
            return Promise.reject(new Error("The queue is full"));
        } else if (t?.signal?.aborted) {
            return Promise.reject(new LA.AbortError);
        }
        return new Promise((r, n) => {
            const s = new PA.Node({
                args: e,
                chainId: t?.chainId,
                returnBuffers: t?.returnBuffers,
                resolve: r,
                reject: n
            });
            if (t?.signal) {
                const e = () => {
                    pA(this, vA, "f").removeNode(s);
                    s.value.reject(new LA.AbortError);
                };
                s.value.abort = {
                    signal: t.signal,
                    listener: e
                };
                t.signal.addEventListener("abort", e, {
                    once: true
                });
            }
            if (t?.asap) {
                pA(this, vA, "f").unshiftNode(s);
            } else {
                pA(this, vA, "f").pushNode(s);
            }
        });
    }
    subscribe(e, t, r, n) {
        return pA(this, RA, "m", DA).call(this, pA(this, NA, "f").subscribe(e, t, r, n));
    }
    unsubscribe(e, t, r, n) {
        return pA(this, RA, "m", DA).call(this, pA(this, NA, "f").unsubscribe(e, t, r, n));
    }
    resubscribe() {
        const e = pA(this, NA, "f").resubscribe();
        if (!e.length) return;
        return Promise.all(e.map(e => pA(this, RA, "m", DA).call(this, e)));
    }
    extendPubSubChannelListeners(e, t, r) {
        return pA(this, RA, "m", DA).call(this, pA(this, NA, "f").extendChannelListeners(e, t, r));
    }
    extendPubSubListeners(e, t) {
        return pA(this, RA, "m", DA).call(this, pA(this, NA, "f").extendTypeListeners(e, t));
    }
    getPubSubListeners(e) {
        return pA(this, NA, "f").getTypeListeners(e);
    }
    getCommandToSend() {
        const e = pA(this, vA, "f").shift();
        if (!e) return;
        let t;
        try {
            t = (0, MA.default)(e.args);
        } catch (t) {
            e.reject(t);
            return;
        }
        pA(this, yA, "f").push({
            resolve: e.resolve,
            reject: e.reject,
            channelsCounter: e.channelsCounter,
            returnBuffers: e.returnBuffers
        });
        SA(this, OA, e.chainId, "f");
        return t;
    }
    onReplyChunk(e) {
        pA(this, TA, "f").write(e);
    }
    flushWaitingForReply(e) {
        pA(this, TA, "f").reset();
        pA(this, NA, "f").reset();
        pA(IA, IA, "m", gA).call(IA, pA(this, yA, "f"), e);
        if (!pA(this, OA, "f")) return;
        while (pA(this, vA, "f").head?.value.chainId === pA(this, OA, "f")) {
            pA(this, vA, "f").shift();
        }
        SA(this, OA, undefined, "f");
    }
    flushAll(e) {
        pA(this, TA, "f").reset();
        pA(this, NA, "f").reset();
        pA(IA, IA, "m", gA).call(IA, pA(this, yA, "f"), e);
        pA(IA, IA, "m", gA).call(IA, pA(this, vA, "f"), e);
    }
}

IA = RedisCommandsQueue, AA = new WeakMap, vA = new WeakMap, yA = new WeakMap, bA = new WeakMap, 
NA = new WeakMap, OA = new WeakMap, TA = new WeakMap, RA = new WeakSet, gA = function e(t, r) {
    while (t.length) {
        t.shift().reject(r);
    }
}, DA = function e(t) {
    if (t === undefined) return;
    return new Promise((e, r) => {
        pA(this, vA, "f").push({
            args: t.args,
            channelsCounter: t.channelsCounter,
            returnBuffers: true,
            resolve: () => {
                t.resolve();
                e();
            },
            reject: e => {
                t.reject?.();
                r(e);
            }
        });
    });
};

Mg.default = RedisCommandsQueue;

var FA = {};

var XA = {};

var jA = {};

var KA = {};

Object.defineProperty(KA, "__esModule", {
    value: true
});

KA.isCommandOptions = KA.commandOptions = void 0;

const UA = Symbol("Command Options");

function BA(e) {
    e[UA] = true;
    return e;
}

KA.commandOptions = BA;

function xA(e) {
    return e?.[UA] === true;
}

KA.isCommandOptions = xA;

Object.defineProperty(jA, "__esModule", {
    value: true
});

jA.fCallArguments = jA.transformCommandReply = jA.transformLegacyCommandArguments = jA.transformCommandArguments = jA.attachExtensions = jA.attachCommands = void 0;

const GA = KA;

function kA({BaseClass: e, commands: t, executor: r}) {
    for (const [n, s] of Object.entries(t)) {
        e.prototype[n] = function(...e) {
            return r.call(this, s, e, n);
        };
    }
}

jA.attachCommands = kA;

function HA(e) {
    let t;
    if (e.modules) {
        t = WA({
            BaseClass: e.BaseClass,
            namespaces: e.modules,
            executor: e.modulesExecutor
        });
    }
    if (e.functions) {
        t = WA({
            BaseClass: t ?? e.BaseClass,
            namespaces: e.functions,
            executor: e.functionsExecutor
        });
    }
    if (e.scripts) {
        t ?? (t = class extends e.BaseClass {});
        kA({
            BaseClass: t,
            commands: e.scripts,
            executor: e.scriptsExecutor
        });
    }
    return t ?? e.BaseClass;
}

jA.attachExtensions = HA;

function WA({BaseClass: e, namespaces: t, executor: r}) {
    const n = class extends e {
        constructor(...e) {
            super(...e);
            for (const e of Object.keys(t)) {
                this[e] = Object.create(this[e], {
                    self: {
                        value: this
                    }
                });
            }
        }
    };
    for (const [e, s] of Object.entries(t)) {
        n.prototype[e] = {};
        for (const [t, o] of Object.entries(s)) {
            n.prototype[e][t] = function(...e) {
                return r.call(this.self, o, e, t);
            };
        }
    }
    return n;
}

function VA(e, t) {
    let r;
    if ((0, GA.isCommandOptions)(t[0])) {
        r = t[0];
        t = t.slice(1);
    }
    return {
        jsArgs: t,
        args: e.transformArguments(...t),
        options: r
    };
}

jA.transformCommandArguments = VA;

function zA(e) {
    return e.flat().map(e => typeof e === "number" || e instanceof Date ? e.toString() : e);
}

jA.transformLegacyCommandArguments = zA;

function ZA(e, t, r) {
    if (!e.transformReply) {
        return t;
    }
    return e.transformReply(t, r);
}

jA.transformCommandReply = ZA;

function qA(e, t, r) {
    const n = [ t.IS_READ_ONLY ? "FCALL_RO" : "FCALL", e ];
    if (t.NUMBER_OF_KEYS !== undefined) {
        n.push(t.NUMBER_OF_KEYS.toString());
    }
    n.push(...r);
    return n;
}

jA.fCallArguments = qA;

Object.defineProperty(XA, "__esModule", {
    value: true
});

const $A = jA;

const QA = ng;

class RedisMultiCommand {
    constructor() {
        Object.defineProperty(this, "queue", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: []
        });
        Object.defineProperty(this, "scriptsInUse", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Set
        });
    }
    static generateChainId() {
        return Symbol("RedisMultiCommand Chain Id");
    }
    addCommand(e, t) {
        this.queue.push({
            args: e,
            transformReply: t
        });
    }
    addFunction(e, t, r) {
        const n = (0, $A.fCallArguments)(e, t, t.transformArguments(...r));
        this.queue.push({
            args: n,
            transformReply: t.transformReply
        });
        return n;
    }
    addScript(e, t) {
        const r = [];
        if (this.scriptsInUse.has(e.SHA1)) {
            r.push("EVALSHA", e.SHA1);
        } else {
            this.scriptsInUse.add(e.SHA1);
            r.push("EVAL", e.SCRIPT);
        }
        if (e.NUMBER_OF_KEYS !== undefined) {
            r.push(e.NUMBER_OF_KEYS.toString());
        }
        const n = e.transformArguments(...t);
        r.push(...n);
        if (n.preserve) {
            r.preserve = n.preserve;
        }
        this.addCommand(r, e.transformReply);
        return r;
    }
    handleExecReplies(e) {
        const t = e[e.length - 1];
        if (t === null) {
            throw new QA.WatchError;
        }
        return this.transformReplies(t);
    }
    transformReplies(e) {
        const t = [], r = e.map((e, r) => {
            if (e instanceof QA.ErrorReply) {
                t.push(r);
                return e;
            }
            const {transformReply: n, args: s} = this.queue[r];
            return n ? n(e, s.preserve) : e;
        });
        if (t.length) throw new QA.MultiErrorReply(r, t);
        return r;
    }
}

XA.default = RedisMultiCommand;

var JA = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
    if (n === "m") throw new TypeError("Private method is not writable");
    if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
    if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
};

var ev = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
    if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
    if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
};

var tv, rv, nv, sv, ov, iv;

Object.defineProperty(FA, "__esModule", {
    value: true
});

const uv = g;

const av = XA;

const cv = jA;

class RedisClientMultiCommand {
    static extend(e) {
        return (0, cv.attachExtensions)({
            BaseClass: RedisClientMultiCommand,
            modulesExecutor: RedisClientMultiCommand.prototype.commandsExecutor,
            modules: e?.modules,
            functionsExecutor: RedisClientMultiCommand.prototype.functionsExecutor,
            functions: e?.functions,
            scriptsExecutor: RedisClientMultiCommand.prototype.scriptsExecutor,
            scripts: e?.scripts
        });
    }
    constructor(e, t = false) {
        tv.add(this);
        rv.set(this, new av.default);
        nv.set(this, void 0);
        Object.defineProperty(this, "v4", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: {}
        });
        sv.set(this, void 0);
        Object.defineProperty(this, "select", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.SELECT
        });
        Object.defineProperty(this, "EXEC", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.exec
        });
        JA(this, nv, e, "f");
        if (t) {
            ev(this, tv, "m", ov).call(this);
        }
    }
    commandsExecutor(e, t) {
        return this.addCommand(e.transformArguments(...t), e.transformReply);
    }
    SELECT(e, t) {
        JA(this, sv, e, "f");
        return this.addCommand([ "SELECT", e.toString() ], t);
    }
    addCommand(e, t) {
        ev(this, rv, "f").addCommand(e, t);
        return this;
    }
    functionsExecutor(e, t, r) {
        ev(this, rv, "f").addFunction(r, e, t);
        return this;
    }
    scriptsExecutor(e, t) {
        ev(this, rv, "f").addScript(e, t);
        return this;
    }
    async exec(e = false) {
        if (e) {
            return this.execAsPipeline();
        }
        return ev(this, rv, "f").handleExecReplies(await ev(this, nv, "f").call(this, ev(this, rv, "f").queue, ev(this, sv, "f"), av.default.generateChainId()));
    }
    async execAsPipeline() {
        if (ev(this, rv, "f").queue.length === 0) return [];
        return ev(this, rv, "f").transformReplies(await ev(this, nv, "f").call(this, ev(this, rv, "f").queue, ev(this, sv, "f")));
    }
}

rv = new WeakMap, nv = new WeakMap, sv = new WeakMap, tv = new WeakSet, ov = function e() {
    var t, r;
    this.v4.addCommand = this.addCommand.bind(this);
    this.addCommand = (...e) => {
        ev(this, rv, "f").addCommand((0, cv.transformLegacyCommandArguments)(e));
        return this;
    };
    this.v4.exec = this.exec.bind(this);
    this.exec = e => {
        this.v4.exec().then(t => {
            if (!e) return;
            e(null, t);
        }).catch(t => {
            if (!e) {
                return;
            }
            e(t);
        });
    };
    for (const [e, n] of Object.entries(uv.default)) {
        ev(this, tv, "m", iv).call(this, e, n);
        (t = this)[r = e.toLowerCase()] ?? (t[r] = this[e]);
    }
}, iv = function e(t, r) {
    this.v4[t] = this[t].bind(this.v4);
    this[t] = r && r.TRANSFORM_LEGACY_REPLY && r.transformReply ? (...e) => {
        ev(this, rv, "f").addCommand([ t, ...(0, cv.transformLegacyCommandArguments)(e) ], r.transformReply);
        return this;
    } : (...e) => this.addCommand(t, ...e);
};

FA.default = RedisClientMultiCommand;

(0, cv.attachCommands)({
    BaseClass: RedisClientMultiCommand,
    commands: uv.default,
    executor: RedisClientMultiCommand.prototype.commandsExecutor
});

var fv = function(e) {
    if (typeof e.create !== "function") {
        throw new TypeError("factory.create must be a function");
    }
    if (typeof e.destroy !== "function") {
        throw new TypeError("factory.destroy must be a function");
    }
    if (typeof e.validate !== "undefined" && typeof e.validate !== "function") {
        throw new TypeError("factory.validate must be a function");
    }
};

let lv = class PoolDefaults {
    constructor() {
        this.fifo = true;
        this.priorityRange = 1;
        this.testOnBorrow = false;
        this.testOnReturn = false;
        this.autostart = true;
        this.evictionRunIntervalMillis = 0;
        this.numTestsPerEvictionRun = 3;
        this.softIdleTimeoutMillis = -1;
        this.idleTimeoutMillis = 3e4;
        this.acquireTimeoutMillis = null;
        this.destroyTimeoutMillis = null;
        this.maxWaitingClients = null;
        this.min = null;
        this.max = null;
        this.Promise = Promise;
    }
};

var mv = lv;

const dv = mv;

let hv = class PoolOptions {
    constructor(e) {
        const t = new dv;
        e = e || {};
        this.fifo = typeof e.fifo === "boolean" ? e.fifo : t.fifo;
        this.priorityRange = e.priorityRange || t.priorityRange;
        this.testOnBorrow = typeof e.testOnBorrow === "boolean" ? e.testOnBorrow : t.testOnBorrow;
        this.testOnReturn = typeof e.testOnReturn === "boolean" ? e.testOnReturn : t.testOnReturn;
        this.autostart = typeof e.autostart === "boolean" ? e.autostart : t.autostart;
        if (e.acquireTimeoutMillis) {
            this.acquireTimeoutMillis = parseInt(e.acquireTimeoutMillis, 10);
        }
        if (e.destroyTimeoutMillis) {
            this.destroyTimeoutMillis = parseInt(e.destroyTimeoutMillis, 10);
        }
        if (e.maxWaitingClients !== undefined) {
            this.maxWaitingClients = parseInt(e.maxWaitingClients, 10);
        }
        this.max = parseInt(e.max, 10);
        this.min = parseInt(e.min, 10);
        this.max = Math.max(isNaN(this.max) ? 1 : this.max, 1);
        this.min = Math.min(isNaN(this.min) ? 0 : this.min, this.max);
        this.evictionRunIntervalMillis = e.evictionRunIntervalMillis || t.evictionRunIntervalMillis;
        this.numTestsPerEvictionRun = e.numTestsPerEvictionRun || t.numTestsPerEvictionRun;
        this.softIdleTimeoutMillis = e.softIdleTimeoutMillis || t.softIdleTimeoutMillis;
        this.idleTimeoutMillis = e.idleTimeoutMillis || t.idleTimeoutMillis;
        this.Promise = e.Promise != null ? e.Promise : t.Promise;
    }
};

var _v = hv;

let Ev = class Deferred {
    constructor(e) {
        this._state = Deferred.PENDING;
        this._resolve = undefined;
        this._reject = undefined;
        this._promise = new e((e, t) => {
            this._resolve = e;
            this._reject = t;
        });
    }
    get state() {
        return this._state;
    }
    get promise() {
        return this._promise;
    }
    reject(e) {
        if (this._state !== Deferred.PENDING) {
            return;
        }
        this._state = Deferred.REJECTED;
        this._reject(e);
    }
    resolve(e) {
        if (this._state !== Deferred.PENDING) {
            return;
        }
        this._state = Deferred.FULFILLED;
        this._resolve(e);
    }
};

Ev.PENDING = "PENDING";

Ev.FULFILLED = "FULFILLED";

Ev.REJECTED = "REJECTED";

var pv = Ev;

class ExtendableError extends Error {
    constructor(e) {
        super(e);
        this.name = this.constructor.name;
        this.message = e;
        if (typeof Error.captureStackTrace === "function") {
            Error.captureStackTrace(this, this.constructor);
        } else {
            this.stack = new Error(e).stack;
        }
    }
}

class TimeoutError extends ExtendableError {
    constructor(e) {
        super(e);
    }
}

var Sv = {
    TimeoutError: TimeoutError
};

const Rv = pv;

const Iv = Sv;

function gv(e, t) {
    return function r() {
        return e.apply(t, arguments);
    };
}

let Av = class ResourceRequest extends Rv {
    constructor(e, t) {
        super(t);
        this._creationTimestamp = Date.now();
        this._timeout = null;
        if (e !== undefined) {
            this.setTimeout(e);
        }
    }
    setTimeout(e) {
        if (this._state !== ResourceRequest.PENDING) {
            return;
        }
        const t = parseInt(e, 10);
        if (isNaN(t) || t <= 0) {
            throw new Error("delay must be a positive int");
        }
        const r = Date.now() - this._creationTimestamp;
        if (this._timeout) {
            this.removeTimeout();
        }
        this._timeout = setTimeout(gv(this._fireTimeout, this), Math.max(t - r, 0));
    }
    removeTimeout() {
        if (this._timeout) {
            clearTimeout(this._timeout);
        }
        this._timeout = null;
    }
    _fireTimeout() {
        this.reject(new Iv.TimeoutError("ResourceRequest timed out"));
    }
    reject(e) {
        this.removeTimeout();
        super.reject(e);
    }
    resolve(e) {
        this.removeTimeout();
        super.resolve(e);
    }
};

var vv = Av;

const yv = pv;

let bv = class ResourceLoan extends yv {
    constructor(e, t) {
        super(t);
        this._creationTimestamp = Date.now();
        this.pooledResource = e;
    }
    reject() {}
};

var Nv = bv;

const Ov = {
    ALLOCATED: "ALLOCATED",
    IDLE: "IDLE",
    INVALID: "INVALID",
    RETURNING: "RETURNING",
    VALIDATION: "VALIDATION"
};

var Tv = Ov;

const Dv = Tv;

let Pv = class PooledResource {
    constructor(e) {
        this.creationTime = Date.now();
        this.lastReturnTime = null;
        this.lastBorrowTime = null;
        this.lastIdleTime = null;
        this.obj = e;
        this.state = Dv.IDLE;
    }
    allocate() {
        this.lastBorrowTime = Date.now();
        this.state = Dv.ALLOCATED;
    }
    deallocate() {
        this.lastReturnTime = Date.now();
        this.state = Dv.IDLE;
    }
    invalidate() {
        this.state = Dv.INVALID;
    }
    test() {
        this.state = Dv.VALIDATION;
    }
    idle() {
        this.lastIdleTime = Date.now();
        this.state = Dv.IDLE;
    }
    returning() {
        this.state = Dv.RETURNING;
    }
};

var Lv = Pv;

let Cv = class DefaultEvictor {
    evict(e, t, r) {
        const n = Date.now() - t.lastIdleTime;
        if (e.softIdleTimeoutMillis > 0 && e.softIdleTimeoutMillis < n && e.min < r) {
            return true;
        }
        if (e.idleTimeoutMillis < n) {
            return true;
        }
        return false;
    }
};

var Mv = Cv;

let Yv = class DoublyLinkedList {
    constructor() {
        this.head = null;
        this.tail = null;
        this.length = 0;
    }
    insertBeginning(e) {
        if (this.head === null) {
            this.head = e;
            this.tail = e;
            e.prev = null;
            e.next = null;
            this.length++;
        } else {
            this.insertBefore(this.head, e);
        }
    }
    insertEnd(e) {
        if (this.tail === null) {
            this.insertBeginning(e);
        } else {
            this.insertAfter(this.tail, e);
        }
    }
    insertAfter(e, t) {
        t.prev = e;
        t.next = e.next;
        if (e.next === null) {
            this.tail = t;
        } else {
            e.next.prev = t;
        }
        e.next = t;
        this.length++;
    }
    insertBefore(e, t) {
        t.prev = e.prev;
        t.next = e;
        if (e.prev === null) {
            this.head = t;
        } else {
            e.prev.next = t;
        }
        e.prev = t;
        this.length++;
    }
    remove(e) {
        if (e.prev === null) {
            this.head = e.next;
        } else {
            e.prev.next = e.next;
        }
        if (e.next === null) {
            this.tail = e.prev;
        } else {
            e.next.prev = e.prev;
        }
        e.prev = null;
        e.next = null;
        this.length--;
    }
    static createNode(e) {
        return {
            prev: null,
            next: null,
            data: e
        };
    }
};

var wv = Yv;

let Fv = class DoublyLinkedListIterator {
    constructor(e, t) {
        this._list = e;
        this._direction = t === true ? "prev" : "next";
        this._startPosition = t === true ? "tail" : "head";
        this._started = false;
        this._cursor = null;
        this._done = false;
    }
    _start() {
        this._cursor = this._list[this._startPosition];
        this._started = true;
    }
    _advanceCursor() {
        if (this._started === false) {
            this._started = true;
            this._cursor = this._list[this._startPosition];
            return;
        }
        this._cursor = this._cursor[this._direction];
    }
    reset() {
        this._done = false;
        this._started = false;
        this._cursor = null;
    }
    remove() {
        if (this._started === false || this._done === true || this._isCursorDetached()) {
            return false;
        }
        this._list.remove(this._cursor);
    }
    next() {
        if (this._done === true) {
            return {
                done: true
            };
        }
        this._advanceCursor();
        if (this._cursor === null || this._isCursorDetached()) {
            this._done = true;
            return {
                done: true
            };
        }
        return {
            value: this._cursor,
            done: false
        };
    }
    _isCursorDetached() {
        return this._cursor.prev === null && this._cursor.next === null && this._list.tail !== this._cursor && this._list.head !== this._cursor;
    }
};

var Xv = Fv;

const jv = Xv;

let Kv = class DequeIterator extends jv {
    next() {
        const e = super.next();
        if (e.value) {
            e.value = e.value.data;
        }
        return e;
    }
};

var Uv = Kv;

const Bv = wv;

const xv = Uv;

let Gv = class Deque {
    constructor() {
        this._list = new Bv;
    }
    shift() {
        if (this.length === 0) {
            return undefined;
        }
        const e = this._list.head;
        this._list.remove(e);
        return e.data;
    }
    unshift(e) {
        const t = Bv.createNode(e);
        this._list.insertBeginning(t);
    }
    push(e) {
        const t = Bv.createNode(e);
        this._list.insertEnd(t);
    }
    pop() {
        if (this.length === 0) {
            return undefined;
        }
        const e = this._list.tail;
        this._list.remove(e);
        return e.data;
    }
    [Symbol.iterator]() {
        return new xv(this._list);
    }
    iterator() {
        return new xv(this._list);
    }
    reverseIterator() {
        return new xv(this._list, true);
    }
    get head() {
        if (this.length === 0) {
            return undefined;
        }
        const e = this._list.head;
        return e.data;
    }
    get tail() {
        if (this.length === 0) {
            return undefined;
        }
        const e = this._list.tail;
        return e.data;
    }
    get length() {
        return this._list.length;
    }
};

var kv = Gv;

const Hv = wv;

const Wv = kv;

let Vv = class Queue extends Wv {
    push(e) {
        const t = Hv.createNode(e);
        e.promise.catch(this._createTimeoutRejectionHandler(t));
        this._list.insertEnd(t);
    }
    _createTimeoutRejectionHandler(e) {
        return t => {
            if (t.name === "TimeoutError") {
                this._list.remove(e);
            }
        };
    }
};

var zv = Vv;

const Zv = zv;

let qv = class PriorityQueue {
    constructor(e) {
        this._size = Math.max(+e | 0, 1);
        this._slots = [];
        for (let e = 0; e < this._size; e++) {
            this._slots.push(new Zv);
        }
    }
    get length() {
        let e = 0;
        for (let t = 0, r = this._slots.length; t < r; t++) {
            e += this._slots[t].length;
        }
        return e;
    }
    enqueue(e, t) {
        t = t && +t | 0 || 0;
        if (t) {
            if (t < 0 || t >= this._size) {
                t = this._size - 1;
            }
        }
        this._slots[t].push(e);
    }
    dequeue() {
        for (let e = 0, t = this._slots.length; e < t; e += 1) {
            if (this._slots[e].length) {
                return this._slots[e].shift();
            }
        }
        return;
    }
    get head() {
        for (let e = 0, t = this._slots.length; e < t; e += 1) {
            if (this._slots[e].length > 0) {
                return this._slots[e].head;
            }
        }
        return;
    }
    get tail() {
        for (let e = this._slots.length - 1; e >= 0; e--) {
            if (this._slots[e].length > 0) {
                return this._slots[e].tail;
            }
        }
        return;
    }
};

var $v = qv;

var Qv = {};

function Jv() {}

Qv.reflector = function(e) {
    return e.then(Jv, Jv);
};

const ey = f.default.EventEmitter;

const ty = fv;

const ry = _v;

const ny = vv;

const sy = Nv;

const oy = Lv;

const iy = pv;

const uy = Qv.reflector;

const ay = "factoryCreateError";

const cy = "factoryDestroyError";

let fy = class Pool extends ey {
    constructor(e, t, r, n, s) {
        super();
        ty(n);
        this._config = new ry(s);
        this._Promise = this._config.Promise;
        this._factory = n;
        this._draining = false;
        this._started = false;
        this._waitingClientsQueue = new r(this._config.priorityRange);
        this._factoryCreateOperations = new Set;
        this._factoryDestroyOperations = new Set;
        this._availableObjects = new t;
        this._testOnBorrowResources = new Set;
        this._testOnReturnResources = new Set;
        this._validationOperations = new Set;
        this._allObjects = new Set;
        this._resourceLoans = new Map;
        this._evictionIterator = this._availableObjects.iterator();
        this._evictor = new e;
        this._scheduledEviction = null;
        if (this._config.autostart === true) {
            this.start();
        }
    }
    _destroy(e) {
        e.invalidate();
        this._allObjects.delete(e);
        const t = this._factory.destroy(e.obj);
        const r = this._config.destroyTimeoutMillis ? this._Promise.resolve(this._applyDestroyTimeout(t)) : this._Promise.resolve(t);
        this._trackOperation(r, this._factoryDestroyOperations).catch(e => {
            this.emit(cy, e);
        });
        this._ensureMinimum();
    }
    _applyDestroyTimeout(e) {
        const t = new this._Promise((e, t) => {
            setTimeout(() => {
                t(new Error("destroy timed out"));
            }, this._config.destroyTimeoutMillis).unref();
        });
        return this._Promise.race([ t, e ]);
    }
    _testOnBorrow() {
        if (this._availableObjects.length < 1) {
            return false;
        }
        const e = this._availableObjects.shift();
        e.test();
        this._testOnBorrowResources.add(e);
        const t = this._factory.validate(e.obj);
        const r = this._Promise.resolve(t);
        this._trackOperation(r, this._validationOperations).then(t => {
            this._testOnBorrowResources.delete(e);
            if (t === false) {
                e.invalidate();
                this._destroy(e);
                this._dispense();
                return;
            }
            this._dispatchPooledResourceToNextWaitingClient(e);
        });
        return true;
    }
    _dispatchResource() {
        if (this._availableObjects.length < 1) {
            return false;
        }
        const e = this._availableObjects.shift();
        this._dispatchPooledResourceToNextWaitingClient(e);
        return false;
    }
    _dispense() {
        const e = this._waitingClientsQueue.length;
        if (e < 1) {
            return;
        }
        const t = e - this._potentiallyAllocableResourceCount;
        const r = Math.min(this.spareResourceCapacity, t);
        for (let e = 0; r > e; e++) {
            this._createResource();
        }
        if (this._config.testOnBorrow === true) {
            const t = e - this._testOnBorrowResources.size;
            const r = Math.min(this._availableObjects.length, t);
            for (let e = 0; r > e; e++) {
                this._testOnBorrow();
            }
        }
        if (this._config.testOnBorrow === false) {
            const t = Math.min(this._availableObjects.length, e);
            for (let e = 0; t > e; e++) {
                this._dispatchResource();
            }
        }
    }
    _dispatchPooledResourceToNextWaitingClient(e) {
        const t = this._waitingClientsQueue.dequeue();
        if (t === undefined || t.state !== iy.PENDING) {
            this._addPooledResourceToAvailableObjects(e);
            return false;
        }
        const r = new sy(e, this._Promise);
        this._resourceLoans.set(e.obj, r);
        e.allocate();
        t.resolve(e.obj);
        return true;
    }
    _trackOperation(e, t) {
        t.add(e);
        return e.then(r => {
            t.delete(e);
            return this._Promise.resolve(r);
        }, r => {
            t.delete(e);
            return this._Promise.reject(r);
        });
    }
    _createResource() {
        const e = this._factory.create();
        const t = this._Promise.resolve(e).then(e => {
            const t = new oy(e);
            this._allObjects.add(t);
            this._addPooledResourceToAvailableObjects(t);
        });
        this._trackOperation(t, this._factoryCreateOperations).then(() => {
            this._dispense();
            return null;
        }).catch(e => {
            this.emit(ay, e);
            this._dispense();
        });
    }
    _ensureMinimum() {
        if (this._draining === true) {
            return;
        }
        const e = this._config.min - this._count;
        for (let t = 0; t < e; t++) {
            this._createResource();
        }
    }
    _evict() {
        const e = Math.min(this._config.numTestsPerEvictionRun, this._availableObjects.length);
        const t = {
            softIdleTimeoutMillis: this._config.softIdleTimeoutMillis,
            idleTimeoutMillis: this._config.idleTimeoutMillis,
            min: this._config.min
        };
        for (let r = 0; r < e; ) {
            const e = this._evictionIterator.next();
            if (e.done === true && this._availableObjects.length < 1) {
                this._evictionIterator.reset();
                return;
            }
            if (e.done === true && this._availableObjects.length > 0) {
                this._evictionIterator.reset();
                continue;
            }
            const n = e.value;
            const s = this._evictor.evict(t, n, this._availableObjects.length);
            r++;
            if (s === true) {
                this._evictionIterator.remove();
                this._destroy(n);
            }
        }
    }
    _scheduleEvictorRun() {
        if (this._config.evictionRunIntervalMillis > 0) {
            this._scheduledEviction = setTimeout(() => {
                this._evict();
                this._scheduleEvictorRun();
            }, this._config.evictionRunIntervalMillis).unref();
        }
    }
    _descheduleEvictorRun() {
        if (this._scheduledEviction) {
            clearTimeout(this._scheduledEviction);
        }
        this._scheduledEviction = null;
    }
    start() {
        if (this._draining === true) {
            return;
        }
        if (this._started === true) {
            return;
        }
        this._started = true;
        this._scheduleEvictorRun();
        this._ensureMinimum();
    }
    acquire(e) {
        if (this._started === false && this._config.autostart === false) {
            this.start();
        }
        if (this._draining) {
            return this._Promise.reject(new Error("pool is draining and cannot accept work"));
        }
        if (this.spareResourceCapacity < 1 && this._availableObjects.length < 1 && this._config.maxWaitingClients !== undefined && this._waitingClientsQueue.length >= this._config.maxWaitingClients) {
            return this._Promise.reject(new Error("max waitingClients count exceeded"));
        }
        const t = new ny(this._config.acquireTimeoutMillis, this._Promise);
        this._waitingClientsQueue.enqueue(t, e);
        this._dispense();
        return t.promise;
    }
    use(e, t) {
        return this.acquire(t).then(t => e(t).then(e => {
            this.release(t);
            return e;
        }, e => {
            this.destroy(t);
            throw e;
        }));
    }
    isBorrowedResource(e) {
        return this._resourceLoans.has(e);
    }
    release(e) {
        const t = this._resourceLoans.get(e);
        if (t === undefined) {
            return this._Promise.reject(new Error("Resource not currently part of this pool"));
        }
        this._resourceLoans.delete(e);
        t.resolve();
        const r = t.pooledResource;
        r.deallocate();
        this._addPooledResourceToAvailableObjects(r);
        this._dispense();
        return this._Promise.resolve();
    }
    destroy(e) {
        const t = this._resourceLoans.get(e);
        if (t === undefined) {
            return this._Promise.reject(new Error("Resource not currently part of this pool"));
        }
        this._resourceLoans.delete(e);
        t.resolve();
        const r = t.pooledResource;
        r.deallocate();
        this._destroy(r);
        this._dispense();
        return this._Promise.resolve();
    }
    _addPooledResourceToAvailableObjects(e) {
        e.idle();
        if (this._config.fifo === true) {
            this._availableObjects.push(e);
        } else {
            this._availableObjects.unshift(e);
        }
    }
    drain() {
        this._draining = true;
        return this.__allResourceRequestsSettled().then(() => this.__allResourcesReturned()).then(() => {
            this._descheduleEvictorRun();
        });
    }
    __allResourceRequestsSettled() {
        if (this._waitingClientsQueue.length > 0) {
            return uy(this._waitingClientsQueue.tail.promise);
        }
        return this._Promise.resolve();
    }
    __allResourcesReturned() {
        const e = Array.from(this._resourceLoans.values()).map(e => e.promise).map(uy);
        return this._Promise.all(e);
    }
    clear() {
        const e = Array.from(this._factoryCreateOperations).map(uy);
        return this._Promise.all(e).then(() => {
            for (const e of this._availableObjects) {
                this._destroy(e);
            }
            const e = Array.from(this._factoryDestroyOperations).map(uy);
            return uy(this._Promise.all(e));
        });
    }
    ready() {
        return new this._Promise(e => {
            const t = () => {
                if (this.available >= this.min) {
                    e();
                } else {
                    setTimeout(t, 100);
                }
            };
            t();
        });
    }
    get _potentiallyAllocableResourceCount() {
        return this._availableObjects.length + this._testOnBorrowResources.size + this._testOnReturnResources.size + this._factoryCreateOperations.size;
    }
    get _count() {
        return this._allObjects.size + this._factoryCreateOperations.size;
    }
    get spareResourceCapacity() {
        return this._config.max - (this._allObjects.size + this._factoryCreateOperations.size);
    }
    get size() {
        return this._count;
    }
    get available() {
        return this._availableObjects.length;
    }
    get borrowed() {
        return this._resourceLoans.size;
    }
    get pending() {
        return this._waitingClientsQueue.length;
    }
    get max() {
        return this._config.max;
    }
    get min() {
        return this._config.min;
    }
};

var ly = fy;

const my = ly;

const dy = kv;

const hy = $v;

const _y = Mv;

var Ey = {
    Pool: my,
    Deque: dy,
    PriorityQueue: hy,
    DefaultEvictor: _y,
    createPool: function(e, t) {
        return new my(_y, dy, hy, e, t);
    }
};

var py = "1.6.0";

const Sy = {
    version: py
};

var Ry = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
    if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
    if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
};

var Iy = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
    if (n === "m") throw new TypeError("Private method is not writable");
    if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
    if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
};

var gy, Ay, vy, yy, by, Ny, Oy, Ty, Dy, Py, Ly, Cy, My, Yy, wy, Fy, Xy, jy, Ky, Uy, By, xy;

Object.defineProperty(I, "__esModule", {
    value: true
});

const Gy = g;

const ky = rg;

const Hy = Mg;

const Wy = FA;

const Vy = f.default;

const zy = KA;

const Zy = jA;

const qy = Ey;

const $y = ng;

const Qy = h.default;

const Jy = tA;

const eb = Sy;

class RedisClient extends Vy.EventEmitter {
    static commandOptions(e) {
        return (0, zy.commandOptions)(e);
    }
    static extend(e) {
        const t = (0, Zy.attachExtensions)({
            BaseClass: Ay,
            modulesExecutor: Ay.prototype.commandsExecutor,
            modules: e?.modules,
            functionsExecutor: Ay.prototype.functionsExecuter,
            functions: e?.functions,
            scriptsExecutor: Ay.prototype.scriptsExecuter,
            scripts: e?.scripts
        });
        if (t !== Ay) {
            t.prototype.Multi = Wy.default.extend(e);
        }
        return t;
    }
    static create(e) {
        return new (Ay.extend(e))(e);
    }
    static parseURL(e) {
        const {hostname: t, port: r, protocol: n, username: s, password: o, pathname: i} = new Qy.URL(e), u = {
            socket: {
                host: t
            }
        };
        if (n === "rediss:") {
            u.socket.tls = true;
        } else if (n !== "redis:") {
            throw new TypeError("Invalid protocol");
        }
        if (r) {
            u.socket.port = Number(r);
        }
        if (s) {
            u.username = decodeURIComponent(s);
        }
        if (o) {
            u.password = decodeURIComponent(o);
        }
        if (i.length > 1) {
            const e = Number(i.substring(1));
            if (isNaN(e)) {
                throw new TypeError("Invalid pathname");
            }
            u.database = e;
        }
        return u;
    }
    get options() {
        return Ry(this, vy, "f");
    }
    get isOpen() {
        return Ry(this, yy, "f").isOpen;
    }
    get isReady() {
        return Ry(this, yy, "f").isReady;
    }
    get isPubSubActive() {
        return Ry(this, by, "f").isPubSubActive;
    }
    get v4() {
        if (!Ry(this, vy, "f")?.legacyMode) {
            throw new Error('the client is not in "legacy mode"');
        }
        return Ry(this, Oy, "f");
    }
    constructor(e) {
        super();
        gy.add(this);
        Object.defineProperty(this, "commandOptions", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: Ay.commandOptions
        });
        vy.set(this, void 0);
        yy.set(this, void 0);
        by.set(this, void 0);
        Ny.set(this, void 0);
        Oy.set(this, {});
        Ty.set(this, 0);
        Fy.set(this, void 0);
        Object.defineProperty(this, "select", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.SELECT
        });
        Object.defineProperty(this, "subscribe", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.SUBSCRIBE
        });
        Object.defineProperty(this, "unsubscribe", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.UNSUBSCRIBE
        });
        Object.defineProperty(this, "pSubscribe", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.PSUBSCRIBE
        });
        Object.defineProperty(this, "pUnsubscribe", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.PUNSUBSCRIBE
        });
        Object.defineProperty(this, "sSubscribe", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.SSUBSCRIBE
        });
        Object.defineProperty(this, "sUnsubscribe", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.SUNSUBSCRIBE
        });
        Object.defineProperty(this, "quit", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.QUIT
        });
        Object.defineProperty(this, "multi", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: this.MULTI
        });
        Iy(this, vy, Ry(this, gy, "m", Dy).call(this, e), "f");
        Iy(this, by, Ry(this, gy, "m", Py).call(this), "f");
        Iy(this, yy, Ry(this, gy, "m", Ly).call(this), "f");
        Iy(this, Ny, Ry(this, gy, "m", Cy).call(this), "f");
        Ry(this, gy, "m", My).call(this);
    }
    duplicate(e) {
        return new (Object.getPrototypeOf(this).constructor)({
            ...Ry(this, vy, "f"),
            ...e
        });
    }
    async connect() {
        Iy(this, Ny, Ry(this, Ny, "f") ?? Ry(this, gy, "m", Cy).call(this), "f");
        await Ry(this, yy, "f").connect();
        return this;
    }
    async commandsExecutor(e, t) {
        const {args: r, options: n} = (0, Zy.transformCommandArguments)(e, t);
        return (0, Zy.transformCommandReply)(e, await Ry(this, gy, "m", jy).call(this, r, n), r.preserve);
    }
    sendCommand(e, t) {
        return Ry(this, gy, "m", jy).call(this, e, t);
    }
    async functionsExecuter(e, t, r) {
        const {args: n, options: s} = (0, Zy.transformCommandArguments)(e, t);
        return (0, Zy.transformCommandReply)(e, await this.executeFunction(r, e, n, s), n.preserve);
    }
    executeFunction(e, t, r, n) {
        return Ry(this, gy, "m", jy).call(this, (0, Zy.fCallArguments)(e, t, r), n);
    }
    async scriptsExecuter(e, t) {
        const {args: r, options: n} = (0, Zy.transformCommandArguments)(e, t);
        return (0, Zy.transformCommandReply)(e, await this.executeScript(e, r, n), r.preserve);
    }
    async executeScript(e, t, r) {
        const n = [ "EVALSHA", e.SHA1 ];
        if (e.NUMBER_OF_KEYS !== undefined) {
            n.push(e.NUMBER_OF_KEYS.toString());
        }
        n.push(...t);
        try {
            return await Ry(this, gy, "m", jy).call(this, n, r);
        } catch (t) {
            if (!t?.message?.startsWith?.("NOSCRIPT")) {
                throw t;
            }
            n[0] = "EVAL";
            n[1] = e.SCRIPT;
            return Ry(this, gy, "m", jy).call(this, n, r);
        }
    }
    async SELECT(e, t) {
        if (!(0, zy.isCommandOptions)(e)) {
            t = e;
            e = null;
        }
        await Ry(this, gy, "m", jy).call(this, [ "SELECT", t.toString() ], e);
        Iy(this, Ty, t, "f");
    }
    SUBSCRIBE(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").subscribe(Jy.PubSubType.CHANNELS, e, t, r));
    }
    UNSUBSCRIBE(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").unsubscribe(Jy.PubSubType.CHANNELS, e, t, r));
    }
    PSUBSCRIBE(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").subscribe(Jy.PubSubType.PATTERNS, e, t, r));
    }
    PUNSUBSCRIBE(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").unsubscribe(Jy.PubSubType.PATTERNS, e, t, r));
    }
    SSUBSCRIBE(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").subscribe(Jy.PubSubType.SHARDED, e, t, r));
    }
    SUNSUBSCRIBE(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").unsubscribe(Jy.PubSubType.SHARDED, e, t, r));
    }
    getPubSubListeners(e) {
        return Ry(this, by, "f").getPubSubListeners(e);
    }
    extendPubSubChannelListeners(e, t, r) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").extendPubSubChannelListeners(e, t, r));
    }
    extendPubSubListeners(e, t) {
        return Ry(this, gy, "m", Ky).call(this, Ry(this, by, "f").extendPubSubListeners(e, t));
    }
    QUIT() {
        return Ry(this, yy, "f").quit(async () => {
            if (Ry(this, Fy, "f")) clearTimeout(Ry(this, Fy, "f"));
            const e = Ry(this, by, "f").addCommand([ "QUIT" ]);
            Ry(this, gy, "m", Uy).call(this);
            const [t] = await Promise.all([ e, Ry(this, gy, "m", xy).call(this) ]);
            return t;
        });
    }
    executeIsolated(e) {
        if (!Ry(this, Ny, "f")) return Promise.reject(new $y.ClientClosedError);
        return Ry(this, Ny, "f").use(e);
    }
    MULTI() {
        return new this.Multi(this.multiExecutor.bind(this), Ry(this, vy, "f")?.legacyMode);
    }
    async multiExecutor(e, t, r) {
        if (!Ry(this, yy, "f").isOpen) {
            return Promise.reject(new $y.ClientClosedError);
        }
        const n = r ? Promise.all([ Ry(this, by, "f").addCommand([ "MULTI" ], {
            chainId: r
        }), Ry(this, gy, "m", By).call(this, e, r), Ry(this, by, "f").addCommand([ "EXEC" ], {
            chainId: r
        }) ]) : Ry(this, gy, "m", By).call(this, e);
        Ry(this, gy, "m", Uy).call(this);
        const s = await n;
        if (t !== undefined) {
            Iy(this, Ty, t, "f");
        }
        return s;
    }
    async* scanIterator(e) {
        let t = 0;
        do {
            const r = await this.scan(t, e);
            t = r.cursor;
            for (const e of r.keys) {
                yield e;
            }
        } while (t !== 0);
    }
    async* hScanIterator(e, t) {
        let r = 0;
        do {
            const n = await this.hScan(e, r, t);
            r = n.cursor;
            for (const e of n.tuples) {
                yield e;
            }
        } while (r !== 0);
    }
    async* hScanNoValuesIterator(e, t) {
        let r = 0;
        do {
            const n = await this.hScanNoValues(e, r, t);
            r = n.cursor;
            for (const e of n.keys) {
                yield e;
            }
        } while (r !== 0);
    }
    async* sScanIterator(e, t) {
        let r = 0;
        do {
            const n = await this.sScan(e, r, t);
            r = n.cursor;
            for (const e of n.members) {
                yield e;
            }
        } while (r !== 0);
    }
    async* zScanIterator(e, t) {
        let r = 0;
        do {
            const n = await this.zScan(e, r, t);
            r = n.cursor;
            for (const e of n.members) {
                yield e;
            }
        } while (r !== 0);
    }
    async disconnect() {
        if (Ry(this, Fy, "f")) clearTimeout(Ry(this, Fy, "f"));
        Ry(this, by, "f").flushAll(new $y.DisconnectsClientError);
        Ry(this, yy, "f").disconnect();
        await Ry(this, gy, "m", xy).call(this);
    }
    ref() {
        Ry(this, yy, "f").ref();
    }
    unref() {
        Ry(this, yy, "f").unref();
    }
}

Ay = RedisClient, vy = new WeakMap, yy = new WeakMap, by = new WeakMap, Ny = new WeakMap, 
Oy = new WeakMap, Ty = new WeakMap, Fy = new WeakMap, gy = new WeakSet, Dy = function e(t) {
    if (t?.url) {
        const e = Ay.parseURL(t.url);
        if (t.socket) {
            e.socket = Object.assign(t.socket, e.socket);
        }
        Object.assign(t, e);
    }
    if (t?.database) {
        Iy(this, Ty, t.database, "f");
    }
    return t;
}, Py = function e() {
    return new Hy.default(Ry(this, vy, "f")?.commandsQueueMaxLength, (e, t) => this.emit("sharded-channel-moved", e, t));
}, Ly = function e() {
    const t = async () => {
        const e = [];
        if (Ry(this, Ty, "f") !== 0) {
            e.push(Ry(this, by, "f").addCommand([ "SELECT", Ry(this, Ty, "f").toString() ], {
                asap: true
            }));
        }
        if (Ry(this, vy, "f")?.readonly) {
            e.push(Ry(this, by, "f").addCommand(Gy.default.READONLY.transformArguments(), {
                asap: true
            }));
        }
        if (!Ry(this, vy, "f")?.disableClientInfo) {
            e.push(Ry(this, by, "f").addCommand([ "CLIENT", "SETINFO", "LIB-VER", eb.version ], {
                asap: true
            }).catch(e => {
                if (!(e instanceof $y.ErrorReply)) {
                    throw e;
                }
            }));
            e.push(Ry(this, by, "f").addCommand([ "CLIENT", "SETINFO", "LIB-NAME", Ry(this, vy, "f")?.clientInfoTag ? `node-redis(${Ry(this, vy, "f").clientInfoTag})` : "node-redis" ], {
                asap: true
            }).catch(e => {
                if (!(e instanceof $y.ErrorReply)) {
                    throw e;
                }
            }));
        }
        if (Ry(this, vy, "f")?.name) {
            e.push(Ry(this, by, "f").addCommand(Gy.default.CLIENT_SETNAME.transformArguments(Ry(this, vy, "f").name), {
                asap: true
            }));
        }
        if (Ry(this, vy, "f")?.username || Ry(this, vy, "f")?.password) {
            e.push(Ry(this, by, "f").addCommand(Gy.default.AUTH.transformArguments({
                username: Ry(this, vy, "f").username,
                password: Ry(this, vy, "f").password ?? ""
            }), {
                asap: true
            }));
        }
        const t = Ry(this, by, "f").resubscribe();
        if (t) {
            e.push(t);
        }
        if (e.length) {
            Ry(this, gy, "m", Uy).call(this, true);
            await Promise.all(e);
        }
    };
    return new ky.default(t, Ry(this, vy, "f")?.socket).on("data", e => Ry(this, by, "f").onReplyChunk(e)).on("error", e => {
        this.emit("error", e);
        if (Ry(this, yy, "f").isOpen && !Ry(this, vy, "f")?.disableOfflineQueue) {
            Ry(this, by, "f").flushWaitingForReply(e);
        } else {
            Ry(this, by, "f").flushAll(e);
        }
    }).on("connect", () => {
        this.emit("connect");
    }).on("ready", () => {
        this.emit("ready");
        Ry(this, gy, "m", Xy).call(this);
        Ry(this, gy, "m", Uy).call(this);
    }).on("reconnecting", () => this.emit("reconnecting")).on("drain", () => Ry(this, gy, "m", Uy).call(this)).on("end", () => this.emit("end"));
}, Cy = function e() {
    return (0, qy.createPool)({
        create: async () => {
            const e = this.duplicate({
                isolationPoolOptions: undefined
            }).on("error", e => this.emit("error", e));
            await e.connect();
            return e;
        },
        destroy: e => e.disconnect()
    }, Ry(this, vy, "f")?.isolationPoolOptions);
}, My = function e() {
    var t, r;
    if (!Ry(this, vy, "f")?.legacyMode) return;
    Ry(this, Oy, "f").sendCommand = Ry(this, gy, "m", jy).bind(this);
    this.sendCommand = (...e) => {
        const t = Ry(this, gy, "m", Yy).call(this, ...e);
        if (t) {
            t.promise.then(e => t.callback(null, e)).catch(e => t.callback(e));
        }
    };
    for (const [e, n] of Object.entries(Gy.default)) {
        Ry(this, gy, "m", wy).call(this, e, n);
        (t = this)[r = e.toLowerCase()] ?? (t[r] = this[e]);
    }
    Ry(this, gy, "m", wy).call(this, "SELECT");
    Ry(this, gy, "m", wy).call(this, "select");
    Ry(this, gy, "m", wy).call(this, "SUBSCRIBE");
    Ry(this, gy, "m", wy).call(this, "subscribe");
    Ry(this, gy, "m", wy).call(this, "PSUBSCRIBE");
    Ry(this, gy, "m", wy).call(this, "pSubscribe");
    Ry(this, gy, "m", wy).call(this, "UNSUBSCRIBE");
    Ry(this, gy, "m", wy).call(this, "unsubscribe");
    Ry(this, gy, "m", wy).call(this, "PUNSUBSCRIBE");
    Ry(this, gy, "m", wy).call(this, "pUnsubscribe");
    Ry(this, gy, "m", wy).call(this, "QUIT");
    Ry(this, gy, "m", wy).call(this, "quit");
}, Yy = function e(...t) {
    const r = typeof t[t.length - 1] === "function" ? t.pop() : undefined;
    const n = Ry(this, gy, "m", jy).call(this, (0, Zy.transformLegacyCommandArguments)(t));
    if (r) return {
        promise: n,
        callback: r
    };
    n.catch(e => this.emit("error", e));
}, wy = function e(t, r) {
    Ry(this, Oy, "f")[t] = this[t].bind(this);
    this[t] = r && r.TRANSFORM_LEGACY_REPLY && r.transformReply ? (...e) => {
        const n = Ry(this, gy, "m", Yy).call(this, t, ...e);
        if (n) {
            n.promise.then(e => n.callback(null, r.transformReply(e))).catch(e => n.callback(e));
        }
    } : (...e) => this.sendCommand(t, ...e);
}, Xy = function e() {
    if (!Ry(this, vy, "f")?.pingInterval || !Ry(this, yy, "f").isReady) return;
    clearTimeout(Ry(this, Fy, "f"));
    Iy(this, Fy, setTimeout(() => {
        if (!Ry(this, yy, "f").isReady) return;
        Ry(this, gy, "m", jy).call(this, [ "PING" ]).then(e => this.emit("ping-interval", e)).catch(e => this.emit("error", e)).finally(() => Ry(this, gy, "m", e).call(this));
    }, Ry(this, vy, "f").pingInterval), "f");
}, jy = function e(t, r) {
    if (!Ry(this, yy, "f").isOpen) {
        return Promise.reject(new $y.ClientClosedError);
    } else if (r?.isolated) {
        return this.executeIsolated(e => e.sendCommand(t, {
            ...r,
            isolated: false
        }));
    } else if (!Ry(this, yy, "f").isReady && Ry(this, vy, "f")?.disableOfflineQueue) {
        return Promise.reject(new $y.ClientOfflineError);
    }
    const n = Ry(this, by, "f").addCommand(t, r);
    Ry(this, gy, "m", Uy).call(this);
    return n;
}, Ky = function e(t) {
    if (t === undefined) return Promise.resolve();
    Ry(this, gy, "m", Uy).call(this);
    return t;
}, Uy = function e(t = false) {
    if (Ry(this, yy, "f").writableNeedDrain || !t && !Ry(this, yy, "f").isReady) {
        return;
    }
    Ry(this, yy, "f").cork();
    while (!Ry(this, yy, "f").writableNeedDrain) {
        const e = Ry(this, by, "f").getCommandToSend();
        if (e === undefined) break;
        Ry(this, yy, "f").writeCommand(e);
    }
}, By = function e(t, r) {
    return Promise.all(t.map(({args: e}) => Ry(this, by, "f").addCommand(e, {
        chainId: r
    })));
}, xy = async function e() {
    await Ry(this, Ny, "f").drain();
    await Ry(this, Ny, "f").clear();
    Iy(this, Ny, undefined, "f");
};

I.default = RedisClient;

(0, Zy.attachCommands)({
    BaseClass: RedisClient,
    commands: Gy.default,
    executor: RedisClient.prototype.commandsExecutor
});

RedisClient.prototype.Multi = Wy.default;

var tb = {};

var rb = {};

var nb = {
    exports: {}
};

nb.exports;

var sb = [ 0, 4129, 8258, 12387, 16516, 20645, 24774, 28903, 33032, 37161, 41290, 45419, 49548, 53677, 57806, 61935, 4657, 528, 12915, 8786, 21173, 17044, 29431, 25302, 37689, 33560, 45947, 41818, 54205, 50076, 62463, 58334, 9314, 13379, 1056, 5121, 25830, 29895, 17572, 21637, 42346, 46411, 34088, 38153, 58862, 62927, 50604, 54669, 13907, 9842, 5649, 1584, 30423, 26358, 22165, 18100, 46939, 42874, 38681, 34616, 63455, 59390, 55197, 51132, 18628, 22757, 26758, 30887, 2112, 6241, 10242, 14371, 51660, 55789, 59790, 63919, 35144, 39273, 43274, 47403, 23285, 19156, 31415, 27286, 6769, 2640, 14899, 10770, 56317, 52188, 64447, 60318, 39801, 35672, 47931, 43802, 27814, 31879, 19684, 23749, 11298, 15363, 3168, 7233, 60846, 64911, 52716, 56781, 44330, 48395, 36200, 40265, 32407, 28342, 24277, 20212, 15891, 11826, 7761, 3696, 65439, 61374, 57309, 53244, 48923, 44858, 40793, 36728, 37256, 33193, 45514, 41451, 53516, 49453, 61774, 57711, 4224, 161, 12482, 8419, 20484, 16421, 28742, 24679, 33721, 37784, 41979, 46042, 49981, 54044, 58239, 62302, 689, 4752, 8947, 13010, 16949, 21012, 25207, 29270, 46570, 42443, 38312, 34185, 62830, 58703, 54572, 50445, 13538, 9411, 5280, 1153, 29798, 25671, 21540, 17413, 42971, 47098, 34713, 38840, 59231, 63358, 50973, 55100, 9939, 14066, 1681, 5808, 26199, 30326, 17941, 22068, 55628, 51565, 63758, 59695, 39368, 35305, 47498, 43435, 22596, 18533, 30726, 26663, 6336, 2273, 14466, 10403, 52093, 56156, 60223, 64286, 35833, 39896, 43963, 48026, 19061, 23124, 27191, 31254, 2801, 6864, 10931, 14994, 64814, 60687, 56684, 52557, 48554, 44427, 40424, 36297, 31782, 27655, 23652, 19525, 15522, 11395, 7392, 3265, 61215, 65342, 53085, 57212, 44955, 49082, 36825, 40952, 28183, 32310, 20053, 24180, 11923, 16050, 3793, 7920 ];

var ob = function e(t) {
    var r;
    var n = 0;
    var s = 0;
    var o = [];
    var i = t.length;
    for (;n < i; n++) {
        r = t.charCodeAt(n);
        if (r < 128) {
            o[s++] = r;
        } else if (r < 2048) {
            o[s++] = r >> 6 | 192;
            o[s++] = r & 63 | 128;
        } else if ((r & 64512) === 55296 && n + 1 < t.length && (t.charCodeAt(n + 1) & 64512) === 56320) {
            r = 65536 + ((r & 1023) << 10) + (t.charCodeAt(++n) & 1023);
            o[s++] = r >> 18 | 240;
            o[s++] = r >> 12 & 63 | 128;
            o[s++] = r >> 6 & 63 | 128;
            o[s++] = r & 63 | 128;
        } else {
            o[s++] = r >> 12 | 224;
            o[s++] = r >> 6 & 63 | 128;
            o[s++] = r & 63 | 128;
        }
    }
    return o;
};

var ib = nb.exports = function e(t) {
    var r;
    var n = 0;
    var s = -1;
    var o = 0;
    var i = 0;
    var u = typeof t === "string" ? ob(t) : t;
    var a = u.length;
    while (n < a) {
        r = u[n++];
        if (s === -1) {
            if (r === 123) {
                s = n;
            }
        } else if (r !== 125) {
            i = sb[(r ^ i >> 8) & 255] ^ i << 8;
        } else if (n - 1 !== s) {
            return i & 16383;
        }
        o = sb[(r ^ o >> 8) & 255] ^ o << 8;
    }
    return o & 16383;
};

nb.exports.generateMulti = function e(t) {
    var r = 1;
    var n = t.length;
    var s = ib(t[0]);
    while (r < n) {
        if (ib(t[r++]) !== s) return -1;
    }
    return s;
};

var ub = nb.exports;

const ab = e.getDefaultExportFromCjs(ub);

var cb = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
    if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
    if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
};

var fb = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
    if (n === "m") throw new TypeError("Private method is not writable");
    if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
    if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
};

var lb, mb, db, hb, _b, Eb, pb, Sb, Rb, Ib, gb, Ab, vb, yb, bb, Nb, Ob, Tb, Db, Pb, Lb, Cb, Mb, Yb, wb;

Object.defineProperty(rb, "__esModule", {
    value: true
});

const Fb = I;

const Xb = ng;

const jb = _.default;

const Kb = tA;

const Ub = ub;

class RedisClusterSlots {
    get isOpen() {
        return cb(this, pb, "f");
    }
    constructor(e, t) {
        lb.add(this);
        hb.set(this, void 0);
        _b.set(this, void 0);
        Eb.set(this, void 0);
        Object.defineProperty(this, "slots", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Array(cb(mb, mb, "f", db))
        });
        Object.defineProperty(this, "shards", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Array
        });
        Object.defineProperty(this, "masters", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Array
        });
        Object.defineProperty(this, "replicas", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Array
        });
        Object.defineProperty(this, "nodeByAddress", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Map
        });
        Object.defineProperty(this, "pubSubNode", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        pb.set(this, false);
        Ob.set(this, void 0);
        Cb.set(this, void 0);
        fb(this, hb, e, "f");
        fb(this, _b, Fb.default.extend(e), "f");
        fb(this, Eb, t, "f");
    }
    async connect() {
        if (cb(this, pb, "f")) {
            throw new Error("Cluster already open");
        }
        fb(this, pb, true, "f");
        try {
            await cb(this, lb, "m", Sb).call(this);
        } catch (e) {
            fb(this, pb, false, "f");
            throw e;
        }
    }
    nodeClient(e) {
        return e.client ?? cb(this, lb, "m", Nb).call(this, e);
    }
    async rediscover(e) {
        fb(this, Ob, cb(this, Ob, "f") ?? cb(this, lb, "m", Tb).call(this, e).finally(() => fb(this, Ob, undefined, "f")), "f");
        return cb(this, Ob, "f");
    }
    quit() {
        return cb(this, lb, "m", Db).call(this, e => e.quit());
    }
    disconnect() {
        return cb(this, lb, "m", Db).call(this, e => e.disconnect());
    }
    getClient(e, t) {
        if (!e) {
            return this.nodeClient(this.getRandomNode());
        }
        const r = Ub(e);
        if (!t) {
            return this.nodeClient(this.slots[r].master);
        }
        return this.nodeClient(this.getSlotRandomNode(r));
    }
    getRandomNode() {
        fb(this, Cb, cb(this, Cb, "f") ?? cb(this, lb, "m", Lb).call(this), "f");
        return cb(this, Cb, "f").next().value;
    }
    getSlotRandomNode(e) {
        const t = this.slots[e];
        if (!t.replicas?.length) {
            return t.master;
        }
        t.nodesIterator ?? (t.nodesIterator = cb(this, lb, "m", Mb).call(this, t));
        return t.nodesIterator.next().value;
    }
    getMasterByAddress(e) {
        const t = this.nodeByAddress.get(e);
        if (!t) return;
        return this.nodeClient(t);
    }
    getPubSubClient() {
        return this.pubSubNode ? this.pubSubNode.client : cb(this, lb, "m", Yb).call(this);
    }
    async executeUnsubscribeCommand(e) {
        const t = await this.getPubSubClient();
        await e(t);
        if (!t.isPubSubActive && t.isOpen) {
            await t.disconnect();
            this.pubSubNode = undefined;
        }
    }
    getShardedPubSubClient(e) {
        const {master: t} = this.slots[Ub(e)];
        return t.pubSubClient ?? cb(this, lb, "m", wb).call(this, t);
    }
    async executeShardedUnsubscribeCommand(e, t) {
        const {master: r} = this.slots[Ub(e)];
        if (!r.pubSubClient) return Promise.resolve();
        const n = await r.pubSubClient;
        await t(n);
        if (!n.isPubSubActive && n.isOpen) {
            await n.disconnect();
            r.pubSubClient = undefined;
        }
    }
}

mb = RedisClusterSlots, hb = new WeakMap, _b = new WeakMap, Eb = new WeakMap, pb = new WeakMap, 
Ob = new WeakMap, Cb = new WeakMap, lb = new WeakSet, Sb = async function e() {
    let t = Math.floor(Math.random() * cb(this, hb, "f").rootNodes.length);
    for (let e = t; e < cb(this, hb, "f").rootNodes.length; e++) {
        if (await cb(this, lb, "m", Ib).call(this, cb(this, hb, "f").rootNodes[e])) return;
    }
    for (let e = 0; e < t; e++) {
        if (await cb(this, lb, "m", Ib).call(this, cb(this, hb, "f").rootNodes[e])) return;
    }
    throw new Xb.RootNodesUnavailableError;
}, Rb = function e() {
    this.slots = new Array(cb(mb, mb, "f", db));
    this.shards = [];
    this.masters = [];
    this.replicas = [];
    fb(this, Cb, undefined, "f");
}, Ib = async function e(t) {
    const r = new Set;
    try {
        const e = await cb(this, lb, "m", gb).call(this, t), n = [], s = cb(this, hb, "f").minimizeConnections !== true;
        cb(this, lb, "m", Rb).call(this);
        for (const {from: t, to: o, master: i, replicas: u} of e) {
            const e = {
                master: cb(this, lb, "m", yb).call(this, i, false, s, r, n)
            };
            if (cb(this, hb, "f").useReplicas) {
                e.replicas = u.map(e => cb(this, lb, "m", yb).call(this, e, true, s, r, n));
            }
            this.shards.push(e);
            for (let r = t; r <= o; r++) {
                this.slots[r] = e;
            }
        }
        if (this.pubSubNode && !r.has(this.pubSubNode.address)) {
            if (jb.types.isPromise(this.pubSubNode.client)) {
                n.push(this.pubSubNode.client.then(e => e.disconnect()));
                this.pubSubNode = undefined;
            } else {
                n.push(this.pubSubNode.client.disconnect());
                const e = this.pubSubNode.client.getPubSubListeners(Kb.PubSubType.CHANNELS), t = this.pubSubNode.client.getPubSubListeners(Kb.PubSubType.PATTERNS);
                if (e.size || t.size) {
                    n.push(cb(this, lb, "m", Yb).call(this, {
                        [Kb.PubSubType.CHANNELS]: e,
                        [Kb.PubSubType.PATTERNS]: t
                    }));
                }
            }
        }
        for (const [e, t] of this.nodeByAddress.entries()) {
            if (r.has(e)) continue;
            if (t.client) {
                n.push(cb(this, lb, "m", Pb).call(this, t.client, e => e.disconnect()));
            }
            const {pubSubClient: s} = t;
            if (s) {
                n.push(cb(this, lb, "m", Pb).call(this, s, e => e.disconnect()));
            }
            this.nodeByAddress.delete(e);
        }
        await Promise.all(n);
        return true;
    } catch (e) {
        cb(this, Eb, "f").call(this, "error", e);
        return false;
    }
}, gb = async function e(t) {
    const r = new (cb(this, _b, "f"))(cb(this, lb, "m", vb).call(this, t, true));
    r.on("error", e => cb(this, Eb, "f").call(this, "error", e));
    await r.connect();
    try {
        return await r.clusterSlots();
    } finally {
        await r.disconnect();
    }
}, Ab = function e(t) {
    switch (typeof cb(this, hb, "f").nodeAddressMap) {
      case "object":
        return cb(this, hb, "f").nodeAddressMap[t];

      case "function":
        return cb(this, hb, "f").nodeAddressMap(t);
    }
}, vb = function e(t, r) {
    let n;
    if (cb(this, hb, "f").defaults) {
        let e;
        if (cb(this, hb, "f").defaults.socket) {
            e = {
                ...cb(this, hb, "f").defaults.socket,
                ...t?.socket
            };
        } else {
            e = t?.socket;
        }
        n = {
            ...cb(this, hb, "f").defaults,
            ...t,
            socket: e
        };
    } else {
        n = t;
    }
    if (r) {
        n ?? (n = {});
        n.socket ?? (n.socket = {});
        n.socket.reconnectStrategy = false;
    }
    return n;
}, yb = function e({id: t, ip: r, port: n}, s, o, i, u) {
    const a = `${r}:${n}`;
    i.add(a);
    let c = this.nodeByAddress.get(a);
    if (!c) {
        c = {
            id: t,
            host: r,
            port: n,
            address: a,
            readonly: s,
            client: undefined
        };
        if (o) {
            u.push(cb(this, lb, "m", Nb).call(this, c));
        }
        this.nodeByAddress.set(a, c);
    }
    (s ? this.replicas : this.masters).push(c);
    return c;
}, bb = async function e(t, r = t.readonly) {
    const n = new (cb(this, _b, "f"))(cb(this, lb, "m", vb).call(this, {
        socket: cb(this, lb, "m", Ab).call(this, t.address) ?? {
            host: t.host,
            port: t.port
        },
        readonly: r
    }));
    n.on("error", e => cb(this, Eb, "f").call(this, "error", e));
    await n.connect();
    return n;
}, Nb = function e(t) {
    const r = cb(this, lb, "m", bb).call(this, t).then(e => {
        t.client = e;
        return e;
    }).catch(e => {
        t.client = undefined;
        throw e;
    });
    t.client = r;
    return r;
}, Tb = async function e(t) {
    if (await cb(this, lb, "m", Ib).call(this, t.options)) return;
    return cb(this, lb, "m", Sb).call(this);
}, Db = async function e(t) {
    fb(this, pb, false, "f");
    const r = [];
    for (const {master: e, replicas: n} of this.shards) {
        if (e.client) {
            r.push(cb(this, lb, "m", Pb).call(this, e.client, t));
        }
        if (e.pubSubClient) {
            r.push(cb(this, lb, "m", Pb).call(this, e.pubSubClient, t));
        }
        if (n) {
            for (const {client: e} of n) {
                if (e) {
                    r.push(cb(this, lb, "m", Pb).call(this, e, t));
                }
            }
        }
    }
    if (this.pubSubNode) {
        r.push(cb(this, lb, "m", Pb).call(this, this.pubSubNode.client, t));
        this.pubSubNode = undefined;
    }
    cb(this, lb, "m", Rb).call(this);
    this.nodeByAddress.clear();
    await Promise.allSettled(r);
}, Pb = function e(t, r) {
    return jb.types.isPromise(t) ? t.then(r) : r(t);
}, Lb = function* e() {
    let t = Math.floor(Math.random() * (this.masters.length + this.replicas.length));
    if (t < this.masters.length) {
        do {
            yield this.masters[t];
        } while (++t < this.masters.length);
        for (const e of this.replicas) {
            yield e;
        }
    } else {
        t -= this.masters.length;
        do {
            yield this.replicas[t];
        } while (++t < this.replicas.length);
    }
    while (true) {
        for (const e of this.masters) {
            yield e;
        }
        for (const e of this.replicas) {
            yield e;
        }
    }
}, Mb = function* e(t) {
    let r = Math.floor(Math.random() * (1 + t.replicas.length));
    if (r < t.replicas.length) {
        do {
            yield t.replicas[r];
        } while (++r < t.replicas.length);
    }
    while (true) {
        yield t.master;
        for (const e of t.replicas) {
            yield e;
        }
    }
}, Yb = async function e(t) {
    const r = Math.floor(Math.random() * (this.masters.length + this.replicas.length)), n = r < this.masters.length ? this.masters[r] : this.replicas[r - this.masters.length];
    this.pubSubNode = {
        address: n.address,
        client: cb(this, lb, "m", bb).call(this, n, false).then(async e => {
            if (t) {
                await Promise.all([ e.extendPubSubListeners(Kb.PubSubType.CHANNELS, t[Kb.PubSubType.CHANNELS]), e.extendPubSubListeners(Kb.PubSubType.PATTERNS, t[Kb.PubSubType.PATTERNS]) ]);
            }
            this.pubSubNode.client = e;
            return e;
        }).catch(e => {
            this.pubSubNode = undefined;
            throw e;
        })
    };
    return this.pubSubNode.client;
}, wb = function e(t) {
    const r = cb(this, lb, "m", bb).call(this, t, false).then(e => {
        e.on("server-sunsubscribe", async (t, r) => {
            try {
                await this.rediscover(e);
                const n = await this.getShardedPubSubClient(t);
                n.extendPubSubChannelListeners(Kb.PubSubType.SHARDED, t, r);
            } catch (e) {
                cb(this, Eb, "f").call(this, "sharded-shannel-moved-error", e, t, r);
            }
        });
        t.pubSubClient = e;
        return e;
    }).catch(e => {
        t.pubSubClient = undefined;
        throw e;
    });
    t.pubSubClient = r;
    return r;
};

db = {
    value: 16384
};

rb.default = RedisClusterSlots;

var Bb = {};

var xb;

function Gb() {
    if (xb) return Bb;
    xb = 1;
    var t = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
        if (n === "m") throw new TypeError("Private method is not writable");
        if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
        if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
        return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
    };
    var r = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
        if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
        if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
        return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
    };
    var n, s, o;
    Object.defineProperty(Bb, "__esModule", {
        value: true
    });
    const i = A;
    const u = XA;
    const a = jA;
    const c = Hb();
    class RedisClusterMultiCommand {
        static extend(e) {
            return (0, a.attachExtensions)({
                BaseClass: RedisClusterMultiCommand,
                modulesExecutor: RedisClusterMultiCommand.prototype.commandsExecutor,
                modules: e?.modules,
                functionsExecutor: RedisClusterMultiCommand.prototype.functionsExecutor,
                functions: e?.functions,
                scriptsExecutor: RedisClusterMultiCommand.prototype.scriptsExecutor,
                scripts: e?.scripts
            });
        }
        constructor(e, r) {
            n.set(this, new u.default);
            s.set(this, void 0);
            o.set(this, void 0);
            Object.defineProperty(this, "EXEC", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.exec
            });
            t(this, s, e, "f");
            t(this, o, r, "f");
        }
        commandsExecutor(e, n) {
            const s = e.transformArguments(...n);
            t(this, o, r(this, o, "f") ?? c.default.extractFirstKey(e, n, s), "f");
            return this.addCommand(undefined, s, e.transformReply);
        }
        addCommand(e, s, i) {
            t(this, o, r(this, o, "f") ?? e, "f");
            r(this, n, "f").addCommand(s, i);
            return this;
        }
        functionsExecutor(e, s, i) {
            const u = r(this, n, "f").addFunction(i, e, s);
            t(this, o, r(this, o, "f") ?? c.default.extractFirstKey(e, s, u), "f");
            return this;
        }
        scriptsExecutor(e, s) {
            const i = r(this, n, "f").addScript(e, s);
            t(this, o, r(this, o, "f") ?? c.default.extractFirstKey(e, s, i), "f");
            return this;
        }
        async exec(e = false) {
            if (e) {
                return this.execAsPipeline();
            }
            return r(this, n, "f").handleExecReplies(await r(this, s, "f").call(this, r(this, n, "f").queue, r(this, o, "f"), u.default.generateChainId()));
        }
        async execAsPipeline() {
            return r(this, n, "f").transformReplies(await r(this, s, "f").call(this, r(this, n, "f").queue, r(this, o, "f")));
        }
    }
    n = new WeakMap, s = new WeakMap, o = new WeakMap;
    Bb.default = RedisClusterMultiCommand;
    (0, a.attachCommands)({
        BaseClass: RedisClusterMultiCommand,
        commands: i.default,
        executor: RedisClusterMultiCommand.prototype.commandsExecutor
    });
    return Bb;
}

var kb;

function Hb() {
    if (kb) return tb;
    kb = 1;
    var t = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldGet || function(e, t, r, n) {
        if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
        if (typeof t === "function" ? e !== t || !n : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
        return r === "m" ? n : r === "a" ? n.call(e) : n ? n.value : t.get(e);
    };
    var r = e.commonjsGlobal && e.commonjsGlobal.__classPrivateFieldSet || function(e, t, r, n, s) {
        if (n === "m") throw new TypeError("Private method is not writable");
        if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
        if (typeof t === "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
        return n === "a" ? s.call(e, r) : s ? s.value = r : t.set(e, r), r;
    };
    var n, s, o, i, u;
    Object.defineProperty(tb, "__esModule", {
        value: true
    });
    const a = A;
    const c = rb;
    const l = jA;
    const m = f.default;
    const d = Gb();
    const h = ng;
    class RedisCluster extends m.EventEmitter {
        static extractFirstKey(e, t, r) {
            if (e.FIRST_KEY_INDEX === undefined) {
                return undefined;
            } else if (typeof e.FIRST_KEY_INDEX === "number") {
                return r[e.FIRST_KEY_INDEX];
            }
            return e.FIRST_KEY_INDEX(...t);
        }
        static create(e) {
            return new ((0, l.attachExtensions)({
                BaseClass: RedisCluster,
                modulesExecutor: RedisCluster.prototype.commandsExecutor,
                modules: e?.modules,
                functionsExecutor: RedisCluster.prototype.functionsExecutor,
                functions: e?.functions,
                scriptsExecutor: RedisCluster.prototype.scriptsExecutor,
                scripts: e?.scripts
            }))(e);
        }
        get slots() {
            return t(this, o, "f").slots;
        }
        get shards() {
            return t(this, o, "f").shards;
        }
        get masters() {
            return t(this, o, "f").masters;
        }
        get replicas() {
            return t(this, o, "f").replicas;
        }
        get nodeByAddress() {
            return t(this, o, "f").nodeByAddress;
        }
        get pubSubNode() {
            return t(this, o, "f").pubSubNode;
        }
        get isOpen() {
            return t(this, o, "f").isOpen;
        }
        constructor(e) {
            super();
            n.add(this);
            s.set(this, void 0);
            o.set(this, void 0);
            i.set(this, void 0);
            Object.defineProperty(this, "multi", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.MULTI
            });
            Object.defineProperty(this, "subscribe", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.SUBSCRIBE
            });
            Object.defineProperty(this, "unsubscribe", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.UNSUBSCRIBE
            });
            Object.defineProperty(this, "pSubscribe", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.PSUBSCRIBE
            });
            Object.defineProperty(this, "pUnsubscribe", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.PUNSUBSCRIBE
            });
            Object.defineProperty(this, "sSubscribe", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.SSUBSCRIBE
            });
            Object.defineProperty(this, "sUnsubscribe", {
                enumerable: true,
                configurable: true,
                writable: true,
                value: this.SUNSUBSCRIBE
            });
            r(this, s, e, "f");
            r(this, o, new c.default(e, this.emit.bind(this)), "f");
            r(this, i, d.default.extend(e), "f");
        }
        duplicate(e) {
            return new (Object.getPrototypeOf(this).constructor)({
                ...t(this, s, "f"),
                ...e
            });
        }
        connect() {
            return t(this, o, "f").connect();
        }
        async commandsExecutor(e, t) {
            const {jsArgs: r, args: n, options: s} = (0, l.transformCommandArguments)(e, t);
            return (0, l.transformCommandReply)(e, await this.sendCommand(RedisCluster.extractFirstKey(e, r, n), e.IS_READ_ONLY, n, s), n.preserve);
        }
        async sendCommand(e, r, s, o) {
            return t(this, n, "m", u).call(this, e, r, e => e.sendCommand(s, o));
        }
        async functionsExecutor(e, t, r) {
            const {args: n, options: s} = (0, l.transformCommandArguments)(e, t);
            return (0, l.transformCommandReply)(e, await this.executeFunction(r, e, t, n, s), n.preserve);
        }
        async executeFunction(e, r, s, o, i) {
            return t(this, n, "m", u).call(this, RedisCluster.extractFirstKey(r, s, o), r.IS_READ_ONLY, t => t.executeFunction(e, r, o, i));
        }
        async scriptsExecutor(e, t) {
            const {args: r, options: n} = (0, l.transformCommandArguments)(e, t);
            return (0, l.transformCommandReply)(e, await this.executeScript(e, t, r, n), r.preserve);
        }
        async executeScript(e, r, s, o) {
            return t(this, n, "m", u).call(this, RedisCluster.extractFirstKey(e, r, s), e.IS_READ_ONLY, t => t.executeScript(e, s, o));
        }
        MULTI(e) {
            return new (t(this, i, "f"))((e, r, s) => t(this, n, "m", u).call(this, r, false, t => t.multiExecutor(e, undefined, s)), e);
        }
        async SUBSCRIBE(e, r, n) {
            return (await t(this, o, "f").getPubSubClient()).SUBSCRIBE(e, r, n);
        }
        async UNSUBSCRIBE(e, r, n) {
            return t(this, o, "f").executeUnsubscribeCommand(t => t.UNSUBSCRIBE(e, r, n));
        }
        async PSUBSCRIBE(e, r, n) {
            return (await t(this, o, "f").getPubSubClient()).PSUBSCRIBE(e, r, n);
        }
        async PUNSUBSCRIBE(e, r, n) {
            return t(this, o, "f").executeUnsubscribeCommand(t => t.PUNSUBSCRIBE(e, r, n));
        }
        async SSUBSCRIBE(e, r, n) {
            const i = t(this, s, "f").maxCommandRedirections ?? 16, u = Array.isArray(e) ? e[0] : e;
            let a = await t(this, o, "f").getShardedPubSubClient(u);
            for (let s = 0; ;s++) {
                try {
                    return await a.SSUBSCRIBE(e, r, n);
                } catch (e) {
                    if (++s > i || !(e instanceof h.ErrorReply)) {
                        throw e;
                    }
                    if (e.message.startsWith("MOVED")) {
                        await t(this, o, "f").rediscover(a);
                        a = await t(this, o, "f").getShardedPubSubClient(u);
                        continue;
                    }
                    throw e;
                }
            }
        }
        SUNSUBSCRIBE(e, r, n) {
            return t(this, o, "f").executeShardedUnsubscribeCommand(Array.isArray(e) ? e[0] : e, t => t.SUNSUBSCRIBE(e, r, n));
        }
        quit() {
            return t(this, o, "f").quit();
        }
        disconnect() {
            return t(this, o, "f").disconnect();
        }
        nodeClient(e) {
            return t(this, o, "f").nodeClient(e);
        }
        getRandomNode() {
            return t(this, o, "f").getRandomNode();
        }
        getSlotRandomNode(e) {
            return t(this, o, "f").getSlotRandomNode(e);
        }
        getMasters() {
            return this.masters;
        }
        getSlotMaster(e) {
            return this.slots[e].master;
        }
    }
    s = new WeakMap, o = new WeakMap, i = new WeakMap, n = new WeakSet, u = async function e(r, n, i) {
        const u = t(this, s, "f").maxCommandRedirections ?? 16;
        let a = await t(this, o, "f").getClient(r, n);
        for (let e = 0; ;e++) {
            try {
                return await i(a);
            } catch (s) {
                if (++e > u || !(s instanceof h.ErrorReply)) {
                    throw s;
                }
                if (s.message.startsWith("ASK")) {
                    const e = s.message.substring(s.message.lastIndexOf(" ") + 1);
                    let r = await t(this, o, "f").getMasterByAddress(e);
                    if (!r) {
                        await t(this, o, "f").rediscover(a);
                        r = await t(this, o, "f").getMasterByAddress(e);
                    }
                    if (!r) {
                        throw new Error(`Cannot find node ${e}`);
                    }
                    await r.asking();
                    a = r;
                    continue;
                } else if (s.message.startsWith("MOVED")) {
                    await t(this, o, "f").rediscover(a);
                    a = await t(this, o, "f").getClient(r, n);
                    continue;
                }
                throw s;
            }
        }
    };
    tb.default = RedisCluster;
    (0, l.attachCommands)({
        BaseClass: RedisCluster,
        commands: a.default,
        executor: RedisCluster.prototype.commandsExecutor
    });
    return tb;
}

var Wb = {};

Object.defineProperty(Wb, "__esModule", {
    value: true
});

Wb.scriptSha1 = Wb.defineScript = void 0;

const Vb = E.default;

function zb(e) {
    return {
        ...e,
        SHA1: Zb(e.SCRIPT)
    };
}

Wb.defineScript = zb;

function Zb(e) {
    return (0, Vb.createHash)("sha1").update(e).digest("hex");
}

Wb.scriptSha1 = Zb;

(function(t) {
    var r = e.commonjsGlobal && e.commonjsGlobal.__createBinding || (Object.create ? function(e, t, r, n) {
        if (n === undefined) n = r;
        var s = Object.getOwnPropertyDescriptor(t, r);
        if (!s || ("get" in s ? !t.__esModule : s.writable || s.configurable)) {
            s = {
                enumerable: true,
                get: function() {
                    return t[r];
                }
            };
        }
        Object.defineProperty(e, n, s);
    } : function(e, t, r, n) {
        if (n === undefined) n = r;
        e[n] = t[r];
    });
    var n = e.commonjsGlobal && e.commonjsGlobal.__exportStar || function(e, t) {
        for (var n in e) if (n !== "default" && !Object.prototype.hasOwnProperty.call(t, n)) r(t, e, n);
    };
    Object.defineProperty(t, "__esModule", {
        value: true
    });
    t.RedisFlushModes = t.GeoReplyWith = t.defineScript = t.createCluster = t.commandOptions = t.createClient = void 0;
    const s = I;
    const o = Hb();
    t.createClient = s.default.create;
    t.commandOptions = s.default.commandOptions;
    t.createCluster = o.default.create;
    var i = Wb;
    Object.defineProperty(t, "defineScript", {
        enumerable: true,
        get: function() {
            return i.defineScript;
        }
    });
    n(ng, t);
    var u = C;
    Object.defineProperty(t, "GeoReplyWith", {
        enumerable: true,
        get: function() {
            return u.GeoReplyWith;
        }
    });
    var a = yE;
    Object.defineProperty(t, "RedisFlushModes", {
        enumerable: true,
        get: function() {
            return a.RedisFlushModes;
        }
    });
})(R);

exports.defaultReconnectStrategy = e => {
    const t = Math.min(2 ** e * 100, 2e3);
    const r = (Math.random() - .5) * 100;
    return t + r;
};

exports.default = class KeyvRedis extends S {
    _client=R.createClient();
    _namespace;
    _keyPrefixSeparator="::";
    _clearBatchSize=1e3;
    _useUnlink=true;
    _noNamespaceAffectsAll=false;
    _throwOnConnectError=true;
    _throwErrors=false;
    _connectionTimeout;
    constructor(e, t) {
        super();
        const r = {
            reconnectStrategy: exports.defaultReconnectStrategy
        };
        if (e) {
            if (typeof e === "string") {
                this._client = R.createClient({
                    url: e,
                    socket: r
                });
            } else if (e.connect !== void 0) {
                this._client = this.isClientCluster(e) ? e : e;
            } else if (e instanceof Object) {
                this._client = e.rootNodes === void 0 ? R.createClient(e) : R.createCluster(e);
            }
        }
        this.setOptions(t);
        this.initClient();
    }
    get client() {
        return this._client;
    }
    set client(e) {
        this._client = e;
        this.initClient();
    }
    get opts() {
        let e = "redis://localhost:6379";
        if (this._client.options) {
            const t = this._client.options?.url;
            if (t) {
                e = t;
            }
        }
        const t = {
            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: e
        };
        return t;
    }
    set opts(e) {
        this.setOptions(e);
    }
    get namespace() {
        return this._namespace;
    }
    set namespace(e) {
        this._namespace = e;
    }
    get keyPrefixSeparator() {
        return this._keyPrefixSeparator;
    }
    set keyPrefixSeparator(e) {
        this._keyPrefixSeparator = e;
    }
    get clearBatchSize() {
        return this._clearBatchSize;
    }
    set clearBatchSize(e) {
        if (e > 0) {
            this._clearBatchSize = e;
        } else {
            this.emit("error", "clearBatchSize must be greater than 0");
        }
    }
    get useUnlink() {
        return this._useUnlink;
    }
    set useUnlink(e) {
        this._useUnlink = e;
    }
    get noNamespaceAffectsAll() {
        return this._noNamespaceAffectsAll;
    }
    set noNamespaceAffectsAll(e) {
        this._noNamespaceAffectsAll = e;
    }
    get throwOnConnectError() {
        return this._throwOnConnectError;
    }
    set throwOnConnectError(e) {
        this._throwOnConnectError = e;
    }
    get throwErrors() {
        return this._throwErrors;
    }
    set throwErrors(e) {
        this._throwErrors = e;
    }
    get connectionTimeout() {
        return this._connectionTimeout;
    }
    set connectionTimeout(e) {
        this._connectionTimeout = e;
    }
    async getClient() {
        if (this._client.isOpen) {
            return this._client;
        }
        try {
            if (this._connectionTimeout === void 0) {
                await this._client.connect();
            } else {
                await Promise.race([ this._client.connect(), this.createTimeoutPromise(this._connectionTimeout) ]);
            }
        } catch (e) {
            this.emit("error", e);
            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) {
        const n = await this.getClient();
        try {
            e = this.createKeyPrefix(e, this._namespace);
            if (r) {
                await n.set(e, t, {
                    PX: r
                });
            } else {
                await n.set(e, t);
            }
        } catch (e) {
            this.emit("error", e);
            if (this._throwErrors) {
                throw e;
            }
        }
    }
    async setMany(e) {
        const t = await this.getClient();
        try {
            const r = t.multi();
            for (const {key: t, value: n, ttl: s} of e) {
                const e = this.createKeyPrefix(t, this._namespace);
                if (s) {
                    r.set(e, n, {
                        PX: s
                    });
                } else {
                    r.set(e, n);
                }
            }
            await r.exec();
        } catch (e) {
            this.emit("error", e);
            if (this._throwErrors) {
                throw e;
            }
        }
    }
    async has(e) {
        const t = await this.getClient();
        try {
            e = this.createKeyPrefix(e, this._namespace);
            const r = await t.exists(e);
            return r === 1;
        } catch (e) {
            this.emit("error", e);
            if (this._throwErrors) {
                throw e;
            }
            return false;
        }
    }
    async hasMany(e) {
        const t = await this.getClient();
        try {
            const r = t.multi();
            for (const t of e) {
                const e = this.createKeyPrefix(t, this._namespace);
                r.exists(e);
            }
            const n = await r.exec();
            return n.map(e => e === 1);
        } catch (t) {
            this.emit("error", t);
            if (this._throwErrors) {
                throw t;
            }
            return Array.from({
                length: e.length
            }).fill(false);
        }
    }
    async get(e) {
        const t = await this.getClient();
        try {
            e = this.createKeyPrefix(e, this._namespace);
            const r = await t.get(e);
            if (r === null) {
                return void 0;
            }
            return r;
        } catch (e) {
            this.emit("error", e);
            if (this._throwErrors) {
                throw e;
            }
            return void 0;
        }
    }
    async getMany(e) {
        if (e.length === 0) {
            return [];
        }
        e = e.map(e => this.createKeyPrefix(e, this._namespace));
        try {
            const t = await this.mget(e);
            return t;
        } catch (t) {
            this.emit("error", t);
            if (this._throwErrors) {
                throw t;
            }
            return Array.from({
                length: e.length
            }).fill(void 0);
        }
    }
    async delete(e) {
        const t = await this.getClient();
        try {
            e = this.createKeyPrefix(e, this._namespace);
            let r = 0;
            r = await (this._useUnlink ? t.unlink(e) : t.del(e));
            return r > 0;
        } catch (e) {
            this.emit("error", e);
            if (this._throwErrors) {
                throw e;
            }
            return false;
        }
    }
    async deleteMany(e) {
        let t = false;
        const r = await this.getClient();
        try {
            const n = r.multi();
            for (const t of e) {
                const e = this.createKeyPrefix(t, this._namespace);
                if (this._useUnlink) {
                    n.unlink(e);
                } else {
                    n.del(e);
                }
            }
            const s = await n.exec();
            for (const e of s) {
                if (typeof e === "number" && e > 0) {
                    t = true;
                }
            }
        } catch (e) {
            this.emit("error", e);
            if (this._throwErrors) {
                throw e;
            }
        }
        return t;
    }
    async disconnect(e) {
        if (this._client.isOpen) {
            await (e ? this._client.disconnect() : this._client.quit());
        }
    }
    createKeyPrefix(e, t) {
        if (t) {
            return `${t}${this._keyPrefixSeparator}${e}`;
        }
        return e;
    }
    getKeyWithoutPrefix(e, t) {
        if (t) {
            return e.replace(`${t}${this._keyPrefixSeparator}`, "");
        }
        return e;
    }
    isCluster() {
        return this.isClientCluster(this._client);
    }
    async getMasterNodes() {
        if (this.isCluster()) {
            const e = await this.getClient();
            return Promise.all(e.masters.map(async t => e.nodeClient(t)));
        }
        return [ await this.getClient() ];
    }
    async* iterator(e) {
        const t = await this.getMasterNodes();
        for (const r of t) {
            const t = e ? `${e}${this._keyPrefixSeparator}*` : "*";
            let n = "0";
            do {
                const s = await r.scan(Number.parseInt(n, 10), {
                    MATCH: t,
                    TYPE: "string"
                });
                n = s.cursor.toString();
                let {keys: o} = s;
                if (!e && !this._noNamespaceAffectsAll) {
                    o = o.filter(e => !e.includes(this._keyPrefixSeparator));
                }
                if (o.length > 0) {
                    const t = await this.mget(o);
                    for (const r of o.keys()) {
                        const n = this.getKeyWithoutPrefix(o[r], e);
                        const s = t[r];
                        yield [ n, s ];
                    }
                }
            } while (n !== "0");
        }
    }
    async clear() {
        try {
            const e = await this.getMasterNodes();
            await Promise.all(e.map(async e => {
                if (!this._namespace && this._noNamespaceAffectsAll) {
                    await e.flushDb();
                    return;
                }
                let t = "0";
                const r = this._clearBatchSize;
                const n = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
                const s = [];
                do {
                    const o = await e.scan(Number.parseInt(t, 10), {
                        MATCH: n,
                        COUNT: r,
                        TYPE: "string"
                    });
                    t = o.cursor.toString();
                    let {keys: i} = o;
                    if (i.length === 0) {
                        continue;
                    }
                    if (!this._namespace) {
                        i = i.filter(e => !e.includes(this._keyPrefixSeparator));
                    }
                    s.push(this.clearWithClusterSupport(i));
                } while (t !== "0");
                await Promise.all(s);
            }));
        } catch (e) {
            this.emit("error", e);
        }
    }
    async mget(e) {
        const t = this.getSlotMap(e);
        const r = new Map;
        await Promise.all(Array.from(t.entries(), async ([e, t]) => {
            const n = await this.getSlotMaster(e);
            const s = await n.mGet(t);
            for (const [e, n] of s.entries()) {
                r.set(t[e], n ?? 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);
            }));
        }
    }
    async getSlotMaster(e) {
        const t = await this.getClient();
        if (this.isCluster()) {
            const r = t;
            const n = r.slots[e].master;
            return r.nodeClient(n);
        }
        return t;
    }
    getSlotMap(e) {
        const t = new Map;
        if (this.isCluster()) {
            for (const r of e) {
                const e = ab(r);
                const n = t.get(e) ?? [];
                n.push(r);
                t.set(e, n);
            }
        } else {
            t.set(0, e);
        }
        return t;
    }
    isClientCluster(e) {
        if (e.options === void 0 && e.scan === void 0) {
            return true;
        }
        return false;
    }
    setOptions(e) {
        if (!e) {
            return;
        }
        if (e.namespace) {
            this._namespace = e.namespace;
        }
        if (e.keyPrefixSeparator !== void 0) {
            this._keyPrefixSeparator = e.keyPrefixSeparator;
        }
        if (e.clearBatchSize !== void 0 && e.clearBatchSize > 0) {
            this._clearBatchSize = e.clearBatchSize;
        }
        if (e.useUnlink !== void 0) {
            this._useUnlink = e.useUnlink;
        }
        if (e.noNamespaceAffectsAll !== void 0) {
            this._noNamespaceAffectsAll = e.noNamespaceAffectsAll;
        }
        if (e.throwOnConnectError !== void 0) {
            this._throwOnConnectError = e.throwOnConnectError;
        }
        if (e.throwErrors !== void 0) {
            this._throwErrors = e.throwErrors;
        }
        if (e.connectionTimeout !== void 0) {
            this._connectionTimeout = e.connectionTimeout;
        }
    }
    initClient() {
        this._client.on("connect", () => {
            this.emit("connect", this._client);
        });
        this._client.on("disconnect", () => {
            this.emit("disconnect", this._client);
        });
        this._client.on("reconnecting", e => {
            this.emit("reconnecting", e);
        });
    }
    async createTimeoutPromise(e) {
        return new Promise((t, r) => setTimeout(() => {
            r(new Error(`Redis timed out after ${e}ms`));
        }, e));
    }
};

Object.defineProperty(exports, "Keyv", {
    enumerable: true,
    get: () => a.Keyv
});

exports.createClient = R.createClient;

exports.createCluster = R.createCluster;