/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
import { c as e, a as t } from "./Package.internal.2.mjs";

import r from "events";

import n from "net";

import s from "tls";

import o from "string_decoder";

import i from "url";

import u from "util";

import a from "crypto";

export { K as Keyv } from "./Package.internal.524.mjs";

import "buffer";

var c = 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 f = class extends c {
    _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 l = {};

var m = {};

var d = {};

var h = {};

var _ = {};

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

_.transformArguments = _.FIRST_KEY_INDEX = void 0;

_.FIRST_KEY_INDEX = 1;

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

_.transformArguments = E;

var p = {};

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

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

p.FIRST_KEY_INDEX = 1;

p.IS_READ_ONLY = true;

function S(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;
}

p.transformArguments = S;

var R = {};

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

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

R.FIRST_KEY_INDEX = 1;

R.IS_READ_ONLY = true;

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

R.transformArguments = I;

var g = {};

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

g.transformArguments = g.FIRST_KEY_INDEX = void 0;

g.FIRST_KEY_INDEX = 1;

function A(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;
}

g.transformArguments = A;

var v = {};

var y = {};

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

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

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

y.transformBooleanReply = N;

function T(e) {
    return e.map(N);
}

y.transformBooleanArrayReply = T;

function O(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;
}

y.pushScanArguments = O;

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

      case "-inf":
        return -Infinity;

      default:
        return Number(e);
    }
}

y.transformNumberInfinityReply = b;

function D(e) {
    if (e === null) return null;
    return b(e);
}

y.transformNumberInfinityNullReply = D;

function P(e) {
    return e.map(D);
}

y.transformNumberInfinityNullArrayReply = P;

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

      case -Infinity:
        return "-inf";

      default:
        return e.toString();
    }
}

y.transformNumberInfinityArgument = L;

function C(e) {
    if (typeof e !== "number") return e;
    return L(e);
}

y.transformStringNumberInfinityArgument = C;

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

y.transformTuplesReply = M;

function Y([e, t]) {
    return {
        id: e,
        message: M(t)
    };
}

y.transformStreamMessageReply = Y;

function w(e) {
    if (e === null) return null;
    return Y(e);
}

y.transformStreamMessageNullReply = w;

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

y.transformStreamMessagesReply = F;

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

y.transformStreamMessagesNullReply = X;

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

y.transformStreamsMessagesReply = j;

function U(e) {
    if (!e.length) return null;
    return B(e);
}

y.transformSortedSetMemberNullReply = U;

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

y.transformSortedSetMemberReply = B;

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

y.transformSortedSetWithScoresReply = x;

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

y.transformZMPopArguments = k;

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

y.transformLMPopArguments = G;

function H(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;
}

y.pushGeoCountArgument = H;

function W(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);
    }
    H(e, s?.COUNT);
    return e;
}

y.pushGeoSearchArguments = W;

function V(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);
    }
    H(e, o?.COUNT);
    return e;
}

y.pushGeoRadiusArguments = V;

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

y.pushGeoRadiusStoreArguments = z;

var Z;

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

function q(e, t) {
    const r = new Set(t);
    let n = 0;
    const s = r.has(Z.DISTANCE) && ++n, o = r.has(Z.HASH) && ++n, i = r.has(Z.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;
    });
}

y.transformGeoMembersWithReply = q;

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

y.transformEXAT = $;

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

y.transformPXAT = Q;

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

y.evalFirstKeyIndex = J;

function ee(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;
}

y.pushEvalArguments = ee;

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

y.pushVerdictArguments = te;

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

y.pushVerdictNumberArguments = re;

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

y.pushVerdictArgument = ne;

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

y.pushOptionalVerdictArgument = se;

var oe;

(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";
})(oe || (y.CommandFlags = oe = {}));

var ie;

(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";
})(ie || (y.CommandCategories = ie = {}));

function ue([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)
    };
}

y.transformCommandReply = ue;

var ae;

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

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

y.transformFunctionListItemReply = ce;

function fe(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;
}

y.pushSortArguments = fe;

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

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

y.pushSlotRangesArguments = me;

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

y.transformRangeReply = de;

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

v.transformArguments = v.FIRST_KEY_INDEX = void 0;

const he = y;

v.FIRST_KEY_INDEX = 2;

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

v.transformArguments = _e;

var Ee = {};

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

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

Ee.FIRST_KEY_INDEX = 1;

Ee.IS_READ_ONLY = true;

function pe(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;
}

Ee.transformArguments = pe;

var Se = {};

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

Se.transformArguments = Se.FIRST_KEY_INDEX = void 0;

Se.FIRST_KEY_INDEX = 1;

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

Se.transformArguments = Re;

var Ie = {};

var ge = {};

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

ge.transformArguments = ge.FIRST_KEY_INDEX = void 0;

const Ae = y;

ge.FIRST_KEY_INDEX = 2;

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

ge.transformArguments = ve;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = ge;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(Ie);

var ye = {};

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

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

const Ne = y;

ye.FIRST_KEY_INDEX = 1;

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

ye.transformArguments = Te;

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

ye.transformReply = Oe;

var be = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = ye;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(be);

var De = {};

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

De.transformArguments = De.FIRST_KEY_INDEX = void 0;

De.FIRST_KEY_INDEX = 1;

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

De.transformArguments = Pe;

var Le = {};

var Ce = {};

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

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

const Me = y;

Ce.FIRST_KEY_INDEX = 2;

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

Ce.transformArguments = Ye;

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

Ce.transformReply = we;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = Ce;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(Le);

var Fe = {};

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

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

const Xe = y;

Fe.FIRST_KEY_INDEX = 1;

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

Fe.transformArguments = je;

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

Fe.transformReply = Ke;

var Ue = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = Fe;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformReply;
        }
    });
})(Ue);

var Be = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Be);

var xe = {};

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

xe.transformArguments = xe.FIRST_KEY_INDEX = void 0;

xe.FIRST_KEY_INDEX = 1;

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

xe.transformArguments = ke;

var Ge = {};

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

Ge.transformArguments = Ge.FIRST_KEY_INDEX = void 0;

Ge.FIRST_KEY_INDEX = 1;

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

Ge.transformArguments = He;

var We = {};

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

We.transformArguments = We.FIRST_KEY_INDEX = void 0;

const Ve = y;

We.FIRST_KEY_INDEX = 1;

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

We.transformArguments = 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 [ "DUMP", e ];
}

Ze.transformArguments = qe;

var $e = {};

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

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

const Qe = y;

$e.FIRST_KEY_INDEX = Qe.evalFirstKeyIndex;

$e.IS_READ_ONLY = true;

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

$e.transformArguments = Je;

var et = {};

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

et.transformArguments = et.FIRST_KEY_INDEX = void 0;

const tt = y;

et.FIRST_KEY_INDEX = tt.evalFirstKeyIndex;

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

et.transformArguments = rt;

var nt = {};

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

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

const st = y;

nt.FIRST_KEY_INDEX = st.evalFirstKeyIndex;

nt.IS_READ_ONLY = true;

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

nt.transformArguments = ot;

var it = {};

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

it.transformArguments = it.FIRST_KEY_INDEX = void 0;

const ut = y;

it.FIRST_KEY_INDEX = ut.evalFirstKeyIndex;

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

it.transformArguments = at;

var ct = {};

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

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

const ft = y;

ct.FIRST_KEY_INDEX = 1;

ct.IS_READ_ONLY = true;

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

ct.transformArguments = lt;

var mt = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(mt);

var dt = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanReply;
        }
    });
})(dt);

var ht = {};

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

ht.transformArguments = ht.FIRST_KEY_INDEX = void 0;

ht.FIRST_KEY_INDEX = 1;

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

ht.transformArguments = _t;

var Et = {};

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

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

const pt = y;

Et.FIRST_KEY_INDEX = pt.evalFirstKeyIndex;

Et.IS_READ_ONLY = true;

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

Et.transformArguments = St;

var Rt = {};

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

Rt.transformArguments = Rt.FIRST_KEY_INDEX = void 0;

const It = y;

Rt.FIRST_KEY_INDEX = It.evalFirstKeyIndex;

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

Rt.transformArguments = gt;

var At = {};

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

At.transformArguments = At.FIRST_KEY_INDEX = void 0;

At.FIRST_KEY_INDEX = 1;

function vt(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;
}

At.transformArguments = vt;

var yt = {};

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

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

yt.FIRST_KEY_INDEX = 1;

yt.IS_READ_ONLY = true;

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

yt.transformArguments = Nt;

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

yt.transformReply = Tt;

var Ot = {};

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

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

const bt = y;

Ot.FIRST_KEY_INDEX = 1;

Ot.IS_READ_ONLY = true;

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

Ot.transformArguments = Dt;

var Pt = {};

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

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

const Lt = y;

Pt.FIRST_KEY_INDEX = 1;

Pt.IS_READ_ONLY = true;

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

Pt.transformArguments = Ct;

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

Pt.transformReply = Mt;

var Yt = {};

var wt = {};

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

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

const Ft = y;

wt.FIRST_KEY_INDEX = 1;

wt.IS_READ_ONLY = true;

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

wt.transformArguments = Xt;

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Yt);

var jt = {};

var Kt = {};

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

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

const Ut = y;

Kt.FIRST_KEY_INDEX = 1;

Kt.IS_READ_ONLY = true;

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

Kt.transformArguments = Bt;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Kt;
    var r = Kt;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(jt);

var xt = {};

var kt = {};

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

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

const Gt = y;

kt.FIRST_KEY_INDEX = 1;

kt.IS_READ_ONLY = true;

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

kt.transformArguments = Ht;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = kt;
    var r = kt;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(xt);

var Wt = {};

var Vt = {};

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

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

const zt = y;

Vt.FIRST_KEY_INDEX = 1;

Vt.IS_READ_ONLY = true;

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

Vt.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 = Vt;
    var r = Vt;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Wt);

var qt = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    var r = Vt;
    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;
})(qt);

var $t = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    var r = Kt;
    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;
})($t);

var Qt = {};

var Jt = {};

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

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

const er = y;

Jt.FIRST_KEY_INDEX = 1;

Jt.IS_READ_ONLY = true;

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

Jt.transformArguments = tr;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Jt;
    var r = Jt;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformGeoMembersWithReply;
        }
    });
})(Qt);

var 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 = y;
    var r = Jt;
    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;
})(rr);

var nr = {};

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

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

nr.FIRST_KEY_INDEX = 1;

nr.IS_READ_ONLY = true;

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

nr.transformArguments = sr;

var or = {};

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

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

or.FIRST_KEY_INDEX = 1;

or.IS_READ_ONLY = true;

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

or.transformArguments = ir;

var ur = {};

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

ur.transformArguments = ur.FIRST_KEY_INDEX = void 0;

ur.FIRST_KEY_INDEX = 1;

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

ur.transformArguments = ar;

var cr = {};

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

cr.transformArguments = cr.FIRST_KEY_INDEX = void 0;

const fr = y;

cr.FIRST_KEY_INDEX = 1;

function lr(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, fr.transformEXAT)(t.EXAT));
    } else if ("PXAT" in t) {
        r.push("PXAT", (0, fr.transformPXAT)(t.PXAT));
    } else {
        r.push("PERSIST");
    }
    return r;
}

cr.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, r) {
    return [ "GETRANGE", e, t.toString(), r.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, t) {
    return [ "GETSET", e, t ];
}

hr.transformArguments = _r;

var Er = {};

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

Er.transformArguments = Er.FIRST_KEY_INDEX = void 0;

const pr = y;

Er.FIRST_KEY_INDEX = 1;

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

Er.transformArguments = Sr;

var Rr = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Rr);

var Ir = {};

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

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

const gr = y;

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

Ir.FIRST_KEY_INDEX = 1;

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

Ir.transformArguments = Ar;

var vr = {};

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

vr.transformArguments = vr.FIRST_KEY_INDEX = void 0;

const yr = y;

vr.FIRST_KEY_INDEX = 1;

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

vr.transformArguments = Nr;

var Tr = {};

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

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

const Or = y;

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

Tr.FIRST_KEY_INDEX = 1;

Tr.IS_READ_ONLY = true;

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

Tr.transformArguments = br;

var Dr = {};

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

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

Dr.FIRST_KEY_INDEX = 1;

Dr.IS_READ_ONLY = true;

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

Dr.transformArguments = Pr;

var Lr = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformTuplesReply;
        }
    });
})(Lr);

var Cr = {};

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

Cr.transformArguments = Cr.FIRST_KEY_INDEX = void 0;

Cr.FIRST_KEY_INDEX = 1;

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

Cr.transformArguments = Mr;

var Yr = {};

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

Yr.transformArguments = Yr.FIRST_KEY_INDEX = void 0;

Yr.FIRST_KEY_INDEX = 1;

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

Yr.transformArguments = wr;

var Fr = {};

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

Fr.transformArguments = Fr.FIRST_KEY_INDEX = void 0;

Fr.FIRST_KEY_INDEX = 1;

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

Fr.transformArguments = Xr;

var jr = {};

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

jr.transformArguments = jr.FIRST_KEY_INDEX = void 0;

jr.FIRST_KEY_INDEX = 1;

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

jr.transformArguments = Kr;

var Ur = {};

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

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

const Br = y;

Ur.FIRST_KEY_INDEX = 1;

Ur.IS_READ_ONLY = true;

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

Ur.transformArguments = xr;

var kr = {};

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

kr.transformArguments = kr.FIRST_KEY_INDEX = void 0;

const Gr = y;

kr.FIRST_KEY_INDEX = 1;

function Hr(e, t) {
    return (0, Gr.pushVerdictArgument)([ "HPERSIST", e, "FIELDS" ], t);
}

kr.transformArguments = Hr;

var Wr = {};

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

Wr.transformArguments = Wr.FIRST_KEY_INDEX = void 0;

const Vr = y;

Wr.FIRST_KEY_INDEX = 1;

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

Wr.transformArguments = zr;

var Zr = {};

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

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

const qr = y;

Zr.FIRST_KEY_INDEX = 1;

Zr.IS_READ_ONLY = true;

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

Zr.transformArguments = $r;

var Qr = {};

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

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

const Jr = y;

Qr.FIRST_KEY_INDEX = 1;

Qr.IS_READ_ONLY = true;

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

Qr.transformArguments = en;

var tn = {};

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

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

const rn = y;

tn.FIRST_KEY_INDEX = 1;

tn.IS_READ_ONLY = true;

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

tn.transformArguments = nn;

var sn = {};

var on = {};

var un = {};

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

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

un.FIRST_KEY_INDEX = 1;

un.IS_READ_ONLY = true;

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

un.transformArguments = an;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = un;
    var r = un;
    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;
})(on);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = on;
    var r = on;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformTuplesReply;
        }
    });
})(sn);

var cn = {};

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

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

const fn = y;

cn.FIRST_KEY_INDEX = 1;

cn.IS_READ_ONLY = true;

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

cn.transformArguments = ln;

function mn([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
    };
}

cn.transformReply = mn;

var 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 = cn;
    var r = cn;
    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;
})(dn);

var hn = {};

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

hn.transformArguments = hn.FIRST_KEY_INDEX = void 0;

hn.FIRST_KEY_INDEX = 1;

function _n(...[e, t, r]) {
    const n = [ "HSET", e ];
    if (typeof t === "string" || typeof t === "number" || Buffer.isBuffer(t)) {
        n.push(Rn(t), Rn(r));
    } else if (t instanceof Map) {
        En(n, t);
    } else if (Array.isArray(t)) {
        pn(n, t);
    } else {
        Sn(n, t);
    }
    return n;
}

hn.transformArguments = _n;

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

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

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

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

var In = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(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) {
    return [ "HSTRLEN", e, t ];
}

gn.transformArguments = An;

var vn = {};

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

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

const yn = y;

vn.FIRST_KEY_INDEX = 1;

vn.IS_READ_ONLY = true;

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

vn.transformArguments = Nn;

var Tn = {};

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

Tn.transformArguments = Tn.FIRST_KEY_INDEX = void 0;

Tn.FIRST_KEY_INDEX = 1;

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

Tn.transformArguments = On;

var bn = {};

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

bn.transformArguments = bn.FIRST_KEY_INDEX = void 0;

bn.FIRST_KEY_INDEX = 1;

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

bn.transformArguments = Dn;

var Pn = {};

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

Pn.transformArguments = Pn.FIRST_KEY_INDEX = void 0;

Pn.FIRST_KEY_INDEX = 1;

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

Pn.transformArguments = Ln;

var Cn = {};

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

Cn.transformArguments = Cn.FIRST_KEY_INDEX = void 0;

Cn.FIRST_KEY_INDEX = 1;

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

Cn.transformArguments = Mn;

var Yn = {};

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 Fn(e, t) {
    return [ "LCS", e, t ];
}

wn.transformArguments = Fn;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    const r = wn;
    var n = wn;
    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;
})(Yn);

var Xn = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    const r = wn;
    var n = wn;
    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;
})(Xn);

var jn = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = wn;
    var r = wn;
    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;
})(jn);

var Kn = {};

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

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

Kn.FIRST_KEY_INDEX = 1;

Kn.IS_READ_ONLY = true;

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

Kn.transformArguments = Un;

var Bn = {};

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

Bn.transformArguments = Bn.FIRST_KEY_INDEX = void 0;

Bn.FIRST_KEY_INDEX = 1;

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

Bn.transformArguments = xn;

var kn = {};

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

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

kn.FIRST_KEY_INDEX = 1;

kn.IS_READ_ONLY = true;

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

kn.transformArguments = Gn;

var Hn = {};

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

Hn.transformArguments = Hn.FIRST_KEY_INDEX = void 0;

Hn.FIRST_KEY_INDEX = 1;

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

Hn.transformArguments = Wn;

var Vn = {};

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

Vn.transformArguments = Vn.FIRST_KEY_INDEX = void 0;

Vn.FIRST_KEY_INDEX = 1;

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

Vn.transformArguments = zn;

var Zn = {};

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

Zn.transformArguments = Zn.FIRST_KEY_INDEX = void 0;

Zn.FIRST_KEY_INDEX = 1;

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

Zn.transformArguments = qn;

var $n = {};

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 Jn(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;
}

Qn.transformArguments = Jn;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    var t = Qn;
    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;
})($n);

var es = {};

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

es.transformArguments = es.FIRST_KEY_INDEX = void 0;

const ts = y;

es.FIRST_KEY_INDEX = 1;

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

es.transformArguments = rs;

var ns = {};

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

ns.transformArguments = ns.FIRST_KEY_INDEX = void 0;

const ss = y;

ns.FIRST_KEY_INDEX = 1;

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

ns.transformArguments = os;

var is = {};

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

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

is.FIRST_KEY_INDEX = 1;

is.IS_READ_ONLY = true;

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

is.transformArguments = us;

var as = {};

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

as.transformArguments = as.FIRST_KEY_INDEX = void 0;

as.FIRST_KEY_INDEX = 1;

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

as.transformArguments = cs;

var fs = {};

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

fs.transformArguments = fs.FIRST_KEY_INDEX = void 0;

fs.FIRST_KEY_INDEX = 1;

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

fs.transformArguments = ls;

var ms = {};

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

ms.transformArguments = ms.FIRST_KEY_INDEX = void 0;

ms.FIRST_KEY_INDEX = 1;

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

ms.transformArguments = ds;

var hs = {};

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

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

hs.FIRST_KEY_INDEX = 1;

hs.IS_READ_ONLY = true;

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

hs.transformArguments = _s;

var Es = {};

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

Es.transformArguments = void 0;

function ps(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;
}

Es.transformArguments = ps;

var Ss = {};

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

Ss.transformArguments = Ss.FIRST_KEY_INDEX = void 0;

Ss.FIRST_KEY_INDEX = 1;

function Rs(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;
}

Ss.transformArguments = Rs;

var Is = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(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 = 2;

gs.IS_READ_ONLY = true;

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

gs.transformArguments = As;

var vs = {};

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

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

vs.FIRST_KEY_INDEX = 2;

vs.IS_READ_ONLY = true;

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

vs.transformArguments = ys;

var Ns = {};

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

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

Ns.FIRST_KEY_INDEX = 2;

Ns.IS_READ_ONLY = true;

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

Ns.transformArguments = Ts;

var Os = {};

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

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

Os.FIRST_KEY_INDEX = 2;

Os.IS_READ_ONLY = true;

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

Os.transformArguments = bs;

var Ds = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Ds);

var Ps = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Ps);

var Ls = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanReply;
        }
    });
})(Ls);

var Cs = {};

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

Cs.transformArguments = Cs.FIRST_KEY_INDEX = void 0;

Cs.FIRST_KEY_INDEX = 1;

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

Cs.transformArguments = Ms;

var Ys = {};

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

var ws = {};

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

ws.transformArguments = ws.FIRST_KEY_INDEX = void 0;

const Fs = y;

ws.FIRST_KEY_INDEX = 1;

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

ws.transformArguments = Xs;

var js = {};

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

js.transformArguments = js.FIRST_KEY_INDEX = void 0;

const Ks = y;

js.FIRST_KEY_INDEX = 1;

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

js.transformArguments = Us;

var Bs = {};

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

Bs.transformArguments = Bs.FIRST_KEY_INDEX = void 0;

Bs.FIRST_KEY_INDEX = 1;

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

Bs.transformArguments = xs;

var ks = {};

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

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

ks.FIRST_KEY_INDEX = 1;

ks.IS_READ_ONLY = true;

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

ks.transformArguments = Gs;

var Hs = {};

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

Hs.transformArguments = Hs.IS_READ_ONLY = void 0;

Hs.IS_READ_ONLY = true;

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

Hs.transformArguments = Ws;

var Vs = {};

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

Vs.transformArguments = Vs.FIRST_KEY_INDEX = void 0;

Vs.FIRST_KEY_INDEX = 1;

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

Vs.transformArguments = zs;

var Zs = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Zs);

var qs = {};

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

qs.transformArguments = qs.FIRST_KEY_INDEX = void 0;

qs.FIRST_KEY_INDEX = 1;

function $s(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;
}

qs.transformArguments = $s;

var Qs = {};

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

Qs.transformArguments = Qs.FIRST_KEY_INDEX = void 0;

Qs.FIRST_KEY_INDEX = 1;

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

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) {
    return [ "RPOP", e ];
}

eo.transformArguments = to;

var ro = {};

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

ro.transformArguments = ro.FIRST_KEY_INDEX = void 0;

ro.FIRST_KEY_INDEX = 1;

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

ro.transformArguments = no;

var so = {};

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

so.transformArguments = so.FIRST_KEY_INDEX = void 0;

const oo = y;

so.FIRST_KEY_INDEX = 1;

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

so.transformArguments = io;

var uo = {};

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

uo.transformArguments = uo.FIRST_KEY_INDEX = void 0;

const ao = y;

uo.FIRST_KEY_INDEX = 1;

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

uo.transformArguments = co;

var fo = {};

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

fo.transformArguments = fo.FIRST_KEY_INDEX = void 0;

const lo = y;

fo.FIRST_KEY_INDEX = 1;

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

fo.transformArguments = mo;

var ho = {};

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

ho.transformArguments = ho.FIRST_KEY_INDEX = void 0;

ho.FIRST_KEY_INDEX = 1;

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

ho.transformArguments = _o;

var Eo = {};

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

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

const po = y;

Eo.FIRST_KEY_INDEX = 1;

Eo.IS_READ_ONLY = true;

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

Eo.transformArguments = So;

var Ro = {};

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

Ro.transformArguments = Ro.FIRST_KEY_INDEX = void 0;

const Io = y;

Ro.FIRST_KEY_INDEX = 1;

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

Ro.transformArguments = go;

var Ao = {};

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

Ao.transformArguments = Ao.FIRST_KEY_INDEX = void 0;

Ao.FIRST_KEY_INDEX = 1;

function vo(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;
}

Ao.transformArguments = vo;

var yo = {};

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

yo.transformArguments = yo.FIRST_KEY_INDEX = void 0;

yo.FIRST_KEY_INDEX = 1;

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

yo.transformArguments = No;

var To = {};

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

To.transformArguments = To.FIRST_KEY_INDEX = void 0;

To.FIRST_KEY_INDEX = 1;

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

To.transformArguments = Oo;

var bo = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(bo);

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) {
    return [ "SETRANGE", e, t.toString(), r ];
}

Do.transformArguments = Po;

var Lo = {};

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

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

const Co = y;

Lo.FIRST_KEY_INDEX = 1;

Lo.IS_READ_ONLY = true;

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

Lo.transformArguments = Mo;

var Yo = {};

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

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

const wo = y;

Yo.FIRST_KEY_INDEX = 2;

Yo.IS_READ_ONLY = true;

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

Yo.transformArguments = Fo;

var Xo = {};

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

Xo.transformArguments = Xo.FIRST_KEY_INDEX = void 0;

const jo = y;

Xo.FIRST_KEY_INDEX = 1;

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

Xo.transformArguments = Ko;

var Uo = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Uo);

var Bo = {};

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

Bo.transformArguments = Bo.FIRST_KEY_INDEX = void 0;

Bo.FIRST_KEY_INDEX = 1;

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

Bo.transformArguments = xo;

var ko = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanArrayReply;
        }
    });
})(ko);

var Go = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Go);

var Ho = {};

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

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

const Wo = y;

Ho.FIRST_KEY_INDEX = 1;

Ho.IS_READ_ONLY = true;

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

Ho.transformArguments = Vo;

var zo = {};

var Zo = {};

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

Zo.transformArguments = Zo.FIRST_KEY_INDEX = void 0;

const qo = y;

Zo.FIRST_KEY_INDEX = 1;

function $o(e, t) {
    return (0, qo.pushSortArguments)([ "SORT", e ], t);
}

Zo.transformArguments = $o;

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

zo.transformArguments = zo.FIRST_KEY_INDEX = void 0;

const Qo = Zo;

zo.FIRST_KEY_INDEX = 1;

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

zo.transformArguments = Jo;

var ei = {};

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

ei.transformArguments = ei.FIRST_KEY_INDEX = void 0;

ei.FIRST_KEY_INDEX = 1;

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

ei.transformArguments = ti;

var ri = {};

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

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

ri.IS_READ_ONLY = true;

ri.FIRST_KEY_INDEX = 1;

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

ri.transformArguments = ni;

var si = {};

var oi = {};

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

oi.transformArguments = oi.FIRST_KEY_INDEX = void 0;

oi.FIRST_KEY_INDEX = 1;

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

oi.transformArguments = ii;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = oi;
    var r = oi;
    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;
})(si);

var ui = {};

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

ui.transformArguments = ui.FIRST_KEY_INDEX = void 0;

const ai = y;

ui.FIRST_KEY_INDEX = 1;

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

ui.transformArguments = ci;

var fi = {};

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

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

const li = y;

fi.FIRST_KEY_INDEX = 1;

fi.IS_READ_ONLY = true;

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

fi.transformArguments = mi;

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

fi.transformReply = di;

var hi = {};

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

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

hi.FIRST_KEY_INDEX = 1;

hi.IS_READ_ONLY = true;

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

hi.transformArguments = _i;

var Ei = {};

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

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

const pi = y;

Ei.FIRST_KEY_INDEX = 1;

Ei.IS_READ_ONLY = true;

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

Ei.transformArguments = Si;

var Ri = {};

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

Ri.transformArguments = Ri.FIRST_KEY_INDEX = void 0;

const Ii = y;

Ri.FIRST_KEY_INDEX = 1;

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

Ri.transformArguments = gi;

var Ai = {};

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

Ai.transformArguments = Ai.FIRST_KEY_INDEX = void 0;

const vi = y;

Ai.FIRST_KEY_INDEX = 1;

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

Ai.transformArguments = yi;

var Ni = {};

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

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

Ni.FIRST_KEY_INDEX = 1;

Ni.IS_READ_ONLY = true;

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

Ni.transformArguments = Ti;

var Oi = {};

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

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

Oi.FIRST_KEY_INDEX = 1;

Oi.IS_READ_ONLY = true;

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

Oi.transformArguments = bi;

var Di = {};

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

Di.transformArguments = Di.FIRST_KEY_INDEX = void 0;

const Pi = y;

Di.FIRST_KEY_INDEX = 1;

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

Di.transformArguments = Li;

var Ci = {};

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

Ci.transformArguments = Ci.FIRST_KEY_INDEX = void 0;

const Mi = y;

Ci.FIRST_KEY_INDEX = 1;

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

Ci.transformArguments = Yi;

var wi = {};

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

wi.transformArguments = wi.FIRST_KEY_INDEX = void 0;

const Fi = y;

wi.FIRST_KEY_INDEX = 1;

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

wi.transformArguments = Xi;

var ji = {};

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

ji.transformArguments = ji.FIRST_KEY_INDEX = void 0;

ji.FIRST_KEY_INDEX = 1;

function Ki(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;
}

ji.transformArguments = Ki;

var Ui = {};

var Bi = {};

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

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

const xi = y;

Bi.FIRST_KEY_INDEX = 1;

function ki(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;
}

Bi.transformArguments = ki;

function Gi(e) {
    return {
        nextId: e[0],
        messages: (0, xi.transformStreamMessagesNullReply)(e[1])
    };
}

Bi.transformReply = Gi;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = Bi;
    var r = Bi;
    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;
})(Ui);

var Hi = {};

var Wi = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformStreamMessagesNullReply;
        }
    });
})(Wi);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = Wi;
    var r = Wi;
    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;
})(Hi);

var Vi = {};

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

Vi.transformArguments = Vi.FIRST_KEY_INDEX = void 0;

const zi = y;

Vi.FIRST_KEY_INDEX = 1;

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

Vi.transformArguments = Zi;

var qi = {};

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

qi.transformArguments = qi.FIRST_KEY_INDEX = void 0;

qi.FIRST_KEY_INDEX = 2;

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

qi.transformArguments = $i;

var Qi = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Qi);

var Ji = {};

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

Ji.transformArguments = Ji.FIRST_KEY_INDEX = void 0;

Ji.FIRST_KEY_INDEX = 2;

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

Ji.transformArguments = eu;

var tu = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(tu);

var ru = {};

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

ru.transformArguments = ru.FIRST_KEY_INDEX = void 0;

ru.FIRST_KEY_INDEX = 2;

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

ru.transformArguments = nu;

var su = {};

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

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

su.FIRST_KEY_INDEX = 2;

su.IS_READ_ONLY = true;

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

su.transformArguments = ou;

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

su.transformReply = iu;

var uu = {};

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

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

uu.FIRST_KEY_INDEX = 2;

uu.IS_READ_ONLY = true;

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

uu.transformArguments = au;

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

uu.transformReply = cu;

var fu = {};

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

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

const lu = y;

fu.FIRST_KEY_INDEX = 2;

fu.IS_READ_ONLY = true;

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

fu.transformArguments = mu;

function du(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, lu.transformTuplesReply)(e[r + 1][1])
            } : null;
            break;

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

fu.transformReply = du;

var hu = {};

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

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

hu.FIRST_KEY_INDEX = 1;

hu.IS_READ_ONLY = true;

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

hu.transformArguments = _u;

var Eu = {};

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

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

Eu.FIRST_KEY_INDEX = 1;

Eu.IS_READ_ONLY = true;

function pu(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;
}

Eu.transformArguments = pu;

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

Eu.transformReply = Su;

var Ru = {};

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

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

Ru.FIRST_KEY_INDEX = 1;

Ru.IS_READ_ONLY = true;

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

Ru.transformArguments = Iu;

function gu(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)
        }))
    };
}

Ru.transformReply = gu;

var Au = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformStreamMessagesReply;
        }
    });
})(Au);

var vu = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformStreamsMessagesReply;
        }
    });
})(vu);

var yu = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformStreamsMessagesReply;
        }
    });
})(yu);

var Nu = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformStreamMessagesReply;
        }
    });
})(Nu);

var Tu = {};

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

Tu.transformArguments = Tu.FIRST_KEY_INDEX = void 0;

Tu.FIRST_KEY_INDEX = 1;

function Ou(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;
}

Tu.transformArguments = Ou;

var bu = {};

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

bu.transformArguments = bu.FIRST_KEY_INDEX = void 0;

bu.FIRST_KEY_INDEX = 1;

function Du(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;
}

bu.transformArguments = Du;

var Pu = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformNumberInfinityReply;
        }
    });
})(Pu);

var Lu = {};

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

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

Lu.FIRST_KEY_INDEX = 1;

Lu.IS_READ_ONLY = true;

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

Lu.transformArguments = Cu;

var Mu = {};

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

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

const Yu = y;

Mu.FIRST_KEY_INDEX = 1;

Mu.IS_READ_ONLY = true;

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

Mu.transformArguments = wu;

var Fu = {};

var Xu = {};

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

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

const ju = y;

Xu.FIRST_KEY_INDEX = 2;

Xu.IS_READ_ONLY = true;

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

Xu.transformArguments = Ku;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Xu;
    var r = Xu;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Fu);

var Uu = {};

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

Uu.transformArguments = Uu.FIRST_KEY_INDEX = void 0;

const Bu = y;

Uu.FIRST_KEY_INDEX = 1;

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

Uu.transformArguments = xu;

var ku = {};

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

var Gu = {};

var Hu = {};

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

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

const Wu = y;

Hu.FIRST_KEY_INDEX = 2;

Hu.IS_READ_ONLY = true;

function Vu(e, t) {
    const r = (0, Wu.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;
}

Hu.transformArguments = Vu;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Hu;
    var r = Hu;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Gu);

var zu = {};

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

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

const Zu = y;

zu.FIRST_KEY_INDEX = 2;

zu.IS_READ_ONLY = true;

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

zu.transformArguments = qu;

var $u = {};

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

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

const Qu = y;

$u.FIRST_KEY_INDEX = 1;

function Ju(e, t, r) {
    const n = (0, Qu.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;
}

$u.transformArguments = Ju;

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 ta(e, t, r) {
    return [ "ZLEXCOUNT", e, t, r ];
}

ea.transformArguments = ta;

var ra = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = y;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformNumberInfinityNullArrayReply;
        }
    });
})(ra);

var na = {};

var sa = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformSortedSetMemberNullReply;
        }
    });
})(sa);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = sa;
    var r = sa;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(na);

var oa = {};

var ia = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformSortedSetMemberNullReply;
        }
    });
})(ia);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.FIRST_KEY_INDEX = void 0;
    const t = ia;
    var r = ia;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(oa);

var ua = {};

var aa = {};

var ca = {};

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

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

ca.FIRST_KEY_INDEX = 1;

ca.IS_READ_ONLY = true;

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

ca.transformArguments = fa;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = ca;
    var r = ca;
    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;
})(aa);

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = aa;
    var r = aa;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(ua);

var la = {};

var ma = {};

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

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

const da = y;

ma.FIRST_KEY_INDEX = 1;

ma.IS_READ_ONLY = true;

function ha(e, t, r, n) {
    const s = [ "ZRANGE", e, (0, da.transformStringNumberInfinityArgument)(t), (0, da.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;
}

ma.transformArguments = ha;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = ma;
    var r = ma;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(la);

var _a = {};

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

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

const Ea = y;

_a.FIRST_KEY_INDEX = 1;

_a.IS_READ_ONLY = true;

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

_a.transformArguments = pa;

var Sa = {};

var Ra = {};

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

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

const Ia = y;

Ra.FIRST_KEY_INDEX = 1;

Ra.IS_READ_ONLY = true;

function ga(e, t, r, n) {
    const s = [ "ZRANGEBYSCORE", e, (0, Ia.transformStringNumberInfinityArgument)(t), (0, 
    Ia.transformStringNumberInfinityArgument)(r) ];
    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, r, n, s) {
        return [ ...(0, t.transformArguments)(e, r, n, s), "WITHSCORES" ];
    }
    e.transformArguments = n;
    var s = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Sa);

var Aa = {};

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

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

const va = y;

Aa.FIRST_KEY_INDEX = 1;

function ya(e, t, r, n, s) {
    const o = [ "ZRANGESTORE", e, t, (0, va.transformStringNumberInfinityArgument)(r), (0, 
    va.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;
}

Aa.transformArguments = ya;

function Na(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;
}

Aa.transformReply = Na;

var Ta = {};

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

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

Ta.FIRST_KEY_INDEX = 1;

Ta.IS_READ_ONLY = true;

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

Ta.transformArguments = Oa;

var ba = {};

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

ba.transformArguments = ba.FIRST_KEY_INDEX = void 0;

const Da = y;

ba.FIRST_KEY_INDEX = 1;

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

ba.transformArguments = Pa;

var La = {};

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

La.transformArguments = La.FIRST_KEY_INDEX = void 0;

const Ca = y;

La.FIRST_KEY_INDEX = 1;

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

La.transformArguments = Ma;

var Ya = {};

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

Ya.transformArguments = Ya.FIRST_KEY_INDEX = void 0;

Ya.FIRST_KEY_INDEX = 1;

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

Ya.transformArguments = wa;

var Fa = {};

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

Fa.transformArguments = Fa.FIRST_KEY_INDEX = void 0;

const Xa = y;

Fa.FIRST_KEY_INDEX = 1;

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

Fa.transformArguments = ja;

var Ka = {};

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

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

Ka.FIRST_KEY_INDEX = 1;

Ka.IS_READ_ONLY = true;

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

Ka.transformArguments = Ua;

var Ba = {};

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

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

const xa = y;

Ba.FIRST_KEY_INDEX = 1;

Ba.IS_READ_ONLY = true;

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

Ba.transformArguments = ka;

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

Ba.transformReply = Ga;

var Ha = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformNumberInfinityNullReply;
        }
    });
})(Ha);

var Wa = {};

var Va = {};

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

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

const za = y;

Va.FIRST_KEY_INDEX = 2;

Va.IS_READ_ONLY = true;

function Za(e, t) {
    const r = (0, za.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;
}

Va.transformArguments = Za;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = e.IS_READ_ONLY = e.FIRST_KEY_INDEX = void 0;
    const t = Va;
    var r = Va;
    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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return s.transformSortedSetWithScoresReply;
        }
    });
})(Wa);

var qa = {};

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

qa.transformArguments = qa.FIRST_KEY_INDEX = void 0;

const $a = y;

qa.FIRST_KEY_INDEX = 1;

function Qa(e, t, r) {
    const n = (0, $a.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;
}

qa.transformArguments = Qa;

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

const Ja = _;

const ec = p;

const tc = R;

const rc = g;

const nc = v;

const sc = Ee;

const oc = Se;

const ic = Ie;

const uc = ye;

const ac = be;

const cc = De;

const fc = Le;

const lc = Fe;

const mc = Ue;

const dc = Be;

const hc = xe;

const _c = Ge;

const Ec = We;

const pc = Ze;

const Sc = $e;

const Rc = et;

const Ic = nt;

const gc = it;

const Ac = ct;

const vc = mt;

const yc = dt;

const Nc = ht;

const Tc = Et;

const Oc = Rt;

const bc = At;

const Dc = yt;

const Pc = Ot;

const Lc = Pt;

const Cc = Yt;

const Mc = wt;

const Yc = jt;

const wc = Kt;

const Fc = xt;

const Xc = kt;

const jc = Wt;

const Kc = Vt;

const Uc = qt;

const Bc = $t;

const xc = Qt;

const kc = Jt;

const Gc = rr;

const Hc = nr;

const Wc = or;

const Vc = ur;

const zc = cr;

const Zc = mr;

const qc = hr;

const $c = Er;

const Qc = Rr;

const Jc = Ir;

const ef = vr;

const tf = Tr;

const rf = Dr;

const nf = Lr;

const sf = Cr;

const of = Yr;

const uf = Fr;

const af = jr;

const cf = Ur;

const ff = kr;

const lf = Wr;

const mf = Zr;

const df = Qr;

const hf = tn;

const _f = sn;

const Ef = on;

const pf = un;

const Sf = cn;

const Rf = dn;

const If = hn;

const gf = In;

const Af = gn;

const vf = vn;

const yf = Tn;

const Nf = bn;

const Tf = Pn;

const Of = Cn;

const bf = Yn;

const Df = Xn;

const Pf = jn;

const Lf = wn;

const Cf = Kn;

const Mf = Bn;

const Yf = kn;

const wf = Hn;

const Ff = ge;

const Xf = Vn;

const jf = Zn;

const Kf = $n;

const Uf = Qn;

const Bf = es;

const xf = ns;

const kf = is;

const Gf = as;

const Hf = fs;

const Wf = ms;

const Vf = hs;

const zf = Es;

const Zf = Ss;

const qf = Is;

const $f = gs;

const Qf = vs;

const Jf = Ns;

const el = Os;

const tl = Ds;

const rl = Ps;

const nl = Ls;

const sl = Cs;

const ol = Ys;

const il = ws;

const ul = js;

const al = Bs;

const cl = ks;

const fl = Hs;

const ll = Vs;

const ml = Zs;

const dl = qs;

const hl = Qs;

const _l = eo;

const El = ro;

const pl = so;

const Sl = uo;

const Rl = fo;

const Il = ho;

const gl = Eo;

const Al = Ro;

const vl = Ao;

const yl = yo;

const Nl = To;

const Tl = bo;

const Ol = Do;

const bl = Lo;

const Dl = Yo;

const Pl = Xo;

const Ll = Uo;

const Cl = Bo;

const Ml = ko;

const Yl = Go;

const wl = Ho;

const Fl = zo;

const Xl = Zo;

const jl = ei;

const Kl = ri;

const Ul = si;

const Bl = oi;

const xl = ui;

const kl = fi;

const Gl = hi;

const Hl = Ei;

const Wl = Ri;

const Vl = Ai;

const zl = Ni;

const Zl = Oi;

const ql = Di;

const $l = Ci;

const Ql = wi;

const Jl = ji;

const em = Ui;

const tm = Bi;

const rm = Hi;

const nm = Wi;

const sm = Vi;

const om = qi;

const im = Qi;

const um = Ji;

const am = tu;

const cm = ru;

const fm = su;

const lm = uu;

const mm = fu;

const dm = hu;

const hm = Eu;

const _m = Ru;

const Em = Au;

const pm = vu;

const Sm = yu;

const Rm = Nu;

const Im = Tu;

const gm = bu;

const Am = Pu;

const vm = Lu;

const ym = Mu;

const Nm = Fu;

const Tm = Xu;

const Om = Uu;

const bm = ku;

const Dm = Gu;

const Pm = Hu;

const Lm = zu;

const Cm = $u;

const Mm = ea;

const Ym = Ce;

const wm = ra;

const Fm = na;

const Xm = sa;

const jm = oa;

const Km = ia;

const Um = ua;

const Bm = aa;

const xm = ca;

const km = la;

const Gm = ma;

const Hm = _a;

const Wm = Sa;

const Vm = Ra;

const zm = Aa;

const Zm = Ta;

const qm = ba;

const $m = La;

const Qm = Ya;

const Jm = Fa;

const ed = Ka;

const td = Ba;

const rd = Ha;

const nd = Wa;

const sd = Va;

const od = qa;

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

var id = {};

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

id.transformArguments = void 0;

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

id.transformArguments = ud;

var ad = {};

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

ad.transformArguments = void 0;

const cd = y;

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

ad.transformArguments = fd;

var ld = {};

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

ld.transformArguments = ld.IS_READ_ONLY = void 0;

ld.IS_READ_ONLY = true;

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

ld.transformArguments = md;

var dd = {};

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

dd.transformArguments = void 0;

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

dd.transformArguments = hd;

var _d = {};

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

_d.transformReply = _d.transformArguments = void 0;

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

_d.transformArguments = Ed;

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

_d.transformReply = pd;

var Sd = {};

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

Sd.transformArguments = void 0;

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

Sd.transformArguments = Rd;

var Id = {};

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

Id.transformArguments = void 0;

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

Id.transformArguments = gd;

var Ad = {};

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

Ad.transformArguments = void 0;

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

Ad.transformArguments = vd;

var yd = {};

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

yd.transformReply = yd.transformArguments = void 0;

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

yd.transformArguments = Nd;

function Td(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]
    }));
}

yd.transformReply = Td;

var Od = {};

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

Od.transformArguments = void 0;

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

Od.transformArguments = bd;

var Dd = {};

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

Dd.transformArguments = void 0;

const Pd = y;

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

Dd.transformArguments = Ld;

var Cd = {};

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

Cd.transformArguments = void 0;

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

Cd.transformArguments = Md;

var Yd = {};

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

Yd.transformArguments = void 0;

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

Yd.transformArguments = wd;

var Fd = {};

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

Fd.transformArguments = void 0;

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

Fd.transformArguments = Xd;

var jd = {};

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

jd.transformArguments = void 0;

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

jd.transformArguments = Kd;

var Ud = {};

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

Ud.transformArguments = void 0;

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

Ud.transformArguments = Bd;

var xd = {};

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

xd.transformArguments = void 0;

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

xd.transformArguments = kd;

var Gd = {};

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

Gd.transformArguments = void 0;

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

Gd.transformArguments = Hd;

var Wd = {};

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

Wd.transformArguments = void 0;

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

Wd.transformArguments = Vd;

var zd = {};

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

zd.transformArguments = void 0;

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

zd.transformArguments = Zd;

var qd = {};

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

qd.transformArguments = qd.IS_READ_ONLY = void 0;

qd.IS_READ_ONLY = true;

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

qd.transformArguments = $d;

var Qd = {};

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

Qd.transformArguments = Qd.ClientKillFilters = void 0;

var Jd;

(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";
})(Jd || (Qd.ClientKillFilters = Jd = {}));

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

Qd.transformArguments = eh;

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

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

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

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

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

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

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

var rh = {};

var nh = {};

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

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

nh.IS_READ_ONLY = true;

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

nh.transformArguments = sh;

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

function ih(e) {
    const t = {};
    for (const r of e.matchAll(oh)) {
        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;
}

nh.transformReply = ih;

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

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

const uh = y;

const ah = nh;

rh.IS_READ_ONLY = true;

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

rh.transformArguments = ch;

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

rh.transformReply = fh;

var lh = {};

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

lh.transformArguments = void 0;

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

lh.transformArguments = mh;

var dh = {};

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

dh.transformArguments = void 0;

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

dh.transformArguments = hh;

var _h = {};

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

_h.transformArguments = void 0;

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

_h.transformArguments = Eh;

var ph = {};

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

ph.transformArguments = void 0;

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

ph.transformArguments = Sh;

var Rh = {};

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

Rh.transformArguments = void 0;

function Ih(e, t) {
    const r = [ "CLIENT", "TRACKING", e ? "ON" : "OFF" ];
    if (e) {
        if (t?.REDIRECT) {
            r.push("REDIRECT", t.REDIRECT.toString());
        }
        if (gh(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 (Ah(t)) {
            r.push("OPTIN");
        } else if (vh(t)) {
            r.push("OPTOUT");
        }
        if (t?.NOLOOP) {
            r.push("NOLOOP");
        }
    }
    return r;
}

Rh.transformArguments = Ih;

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

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

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

var yh = {};

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

yh.transformReply = yh.transformArguments = void 0;

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

yh.transformArguments = Nh;

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

yh.transformReply = Th;

var Oh = {};

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

Oh.transformArguments = void 0;

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

Oh.transformArguments = bh;

var Dh = {};

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

Dh.transformArguments = void 0;

const Ph = y;

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

Dh.transformArguments = Lh;

var Ch = {};

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

Ch.transformArguments = void 0;

const Mh = y;

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

Ch.transformArguments = Yh;

var wh = {};

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

wh.transformArguments = void 0;

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

wh.transformArguments = Fh;

var Xh = {};

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

Xh.transformArguments = void 0;

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

Xh.transformArguments = jh;

var Kh = {};

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

Kh.transformArguments = void 0;

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

Kh.transformArguments = Uh;

var Bh = {};

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

Bh.transformArguments = void 0;

const xh = y;

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

Bh.transformArguments = kh;

var Gh = {};

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

Gh.transformArguments = void 0;

const Hh = y;

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

Gh.transformArguments = Wh;

var Vh = {};

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

Vh.transformArguments = Vh.FailoverModes = void 0;

var zh;

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

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

Vh.transformArguments = Zh;

var qh = {};

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

qh.transformArguments = void 0;

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

qh.transformArguments = $h;

var Qh = {};

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

Qh.transformArguments = void 0;

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

Qh.transformArguments = Jh;

var e_ = {};

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

e_.transformArguments = void 0;

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

e_.transformArguments = t_;

var r_ = {};

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

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

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

r_.transformArguments = n_;

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

r_.transformReply = s_;

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

r_.extractLineValue = o_;

var i_ = {};

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

i_.transformArguments = void 0;

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

i_.transformArguments = u_;

var a_ = {};

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

a_.transformReply = a_.transformArguments = void 0;

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

a_.transformArguments = c_;

function f_(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])
    }));
}

a_.transformReply = f_;

var l_ = {};

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

l_.transformArguments = void 0;

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

l_.transformArguments = m_;

var d_ = {};

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

d_.transformArguments = void 0;

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

d_.transformArguments = h_;

var __ = {};

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

__.transformArguments = __.IS_READ_ONLY = void 0;

__.IS_READ_ONLY = true;

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

__.transformArguments = E_;

var p_ = {};

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

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

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

p_.transformArguments = S_;

var R_;

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

function I_(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,
            ...g_(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() ];
}

p_.transformReply = I_;

function g_(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 A_ = {};

(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 = p_;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformReply;
        }
    });
})(A_);

var v_ = {};

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

v_.transformArguments = void 0;

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

v_.transformArguments = y_;

var N_ = {};

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

N_.transformArguments = void 0;

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

N_.transformArguments = T_;

var O_ = {};

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

O_.transformArguments = void 0;

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

O_.transformArguments = b_;

var D_ = {};

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

D_.transformArguments = void 0;

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

D_.transformArguments = P_;

var L_ = {};

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

L_.transformArguments = L_.ClusterSlotStates = void 0;

var C_;

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

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

L_.transformArguments = M_;

var Y_ = {};

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

Y_.transformReply = Y_.transformArguments = void 0;

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

Y_.transformArguments = w_;

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

Y_.transformReply = F_;

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

var j_ = {};

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

j_.transformArguments = j_.IS_READ_ONLY = void 0;

j_.IS_READ_ONLY = true;

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

j_.transformArguments = K_;

var U_ = {};

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

U_.transformArguments = U_.IS_READ_ONLY = void 0;

U_.IS_READ_ONLY = true;

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

U_.transformArguments = B_;

var x_ = {};

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

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

x_.IS_READ_ONLY = true;

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

x_.transformArguments = k_;

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

x_.transformReply = G_;

var H_ = {};

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

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

const W_ = y;

H_.IS_READ_ONLY = true;

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

H_.transformArguments = V_;

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

H_.transformReply = z_;

var Z_ = {};

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

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

Z_.IS_READ_ONLY = true;

var q_;

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

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

Z_.transformArguments = $_;

var Q_ = {};

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

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

const J_ = y;

Q_.IS_READ_ONLY = true;

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

Q_.transformArguments = eE;

function tE(e) {
    return e.map(J_.transformCommandReply);
}

Q_.transformReply = tE;

var rE = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformTuplesReply;
        }
    });
})(rE);

var nE = {};

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

nE.transformArguments = void 0;

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

nE.transformArguments = sE;

var oE = {};

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

oE.transformArguments = void 0;

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

oE.transformArguments = iE;

var uE = {};

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

uE.transformArguments = void 0;

function aE(...[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;
}

uE.transformArguments = aE;

var cE = {};

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

cE.transformArguments = cE.IS_READ_ONLY = void 0;

cE.IS_READ_ONLY = true;

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

cE.transformArguments = fE;

var lE = {};

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

lE.transformArguments = void 0;

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

lE.transformArguments = mE;

var dE = {};

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

dE.transformArguments = dE.IS_READ_ONLY = void 0;

dE.IS_READ_ONLY = true;

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

dE.transformArguments = hE;

var _E = {};

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

_E.transformArguments = void 0;

function EE(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;
}

_E.transformArguments = EE;

var pE = {};

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

pE.transformArguments = pE.RedisFlushModes = void 0;

var SE;

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

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

pE.transformArguments = RE;

var IE = {};

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

IE.transformArguments = void 0;

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

IE.transformArguments = gE;

var AE = {};

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

AE.transformArguments = void 0;

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

AE.transformArguments = vE;

var yE = {};

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

yE.transformArguments = void 0;

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

yE.transformArguments = NE;

var TE = {};

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

TE.transformArguments = void 0;

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

TE.transformArguments = OE;

var bE = {};

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

bE.transformArguments = void 0;

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

bE.transformArguments = DE;

var PE = {};

var LE = {};

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

LE.transformReply = LE.transformArguments = void 0;

const CE = y;

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

LE.transformArguments = ME;

function YE(e) {
    return e.map(CE.transformFunctionListItemReply);
}

LE.transformReply = YE;

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

PE.transformReply = PE.transformArguments = void 0;

const wE = LE;

const FE = y;

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

PE.transformArguments = XE;

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

PE.transformReply = jE;

var KE = {};

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

KE.transformArguments = void 0;

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

KE.transformArguments = UE;

var BE = {};

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

BE.transformArguments = void 0;

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

BE.transformArguments = xE;

var kE = {};

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

kE.transformReply = kE.transformArguments = void 0;

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

kE.transformArguments = GE;

function HE(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
    };
}

kE.transformReply = HE;

var WE = {};

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

WE.transformReply = WE.transformArguments = void 0;

function VE(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;
}

WE.transformArguments = VE;

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

WE.transformReply = zE;

var ZE = {};

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

ZE.transformArguments = ZE.IS_READ_ONLY = void 0;

ZE.IS_READ_ONLY = true;

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

ZE.transformArguments = qE;

var $E = {};

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

$E.transformArguments = void 0;

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

$E.transformArguments = QE;

var JE = {};

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

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

JE.IS_READ_ONLY = true;

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

JE.transformArguments = ep;

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

JE.transformReply = tp;

var rp = {};

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

rp.transformArguments = void 0;

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

rp.transformArguments = np;

var sp = {};

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

sp.transformArguments = void 0;

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

sp.transformArguments = op;

var ip = {};

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

ip.transformArguments = void 0;

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

ip.transformArguments = up;

var ap = {};

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

ap.transformArguments = void 0;

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

ap.transformArguments = cp;

var fp = {};

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

fp.transformArguments = fp.IS_READ_ONLY = void 0;

fp.IS_READ_ONLY = true;

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

fp.transformArguments = lp;

var mp = {};

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

mp.transformArguments = void 0;

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

mp.transformArguments = dp;

var hp = {};

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

hp.transformArguments = void 0;

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

hp.transformArguments = _p;

var Ep = {};

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

Ep.transformArguments = void 0;

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

Ep.transformArguments = pp;

var Sp = {};

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

Sp.transformReply = Sp.transformArguments = void 0;

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

Sp.transformArguments = Rp;

const Ip = {
    "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"
}, gp = {
    "overhead.hashtable.main": "overheadHashtableMain",
    "overhead.hashtable.expires": "overheadHashtableExpires"
};

function Ap(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[gp[s[e]]] = s[e + 1];
            }
            t.db[n.substring(3)] = o;
            continue;
        }
        t[Ip[n]] = Number(e[r + 1]);
    }
    return t;
}

Sp.transformReply = Ap;

var vp = {};

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

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

vp.FIRST_KEY_INDEX = 1;

vp.IS_READ_ONLY = true;

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

vp.transformArguments = yp;

var Np = {};

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

Np.transformArguments = void 0;

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

Np.transformArguments = Tp;

var Op = {};

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

Op.transformArguments = void 0;

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

Op.transformArguments = bp;

var Dp = {};

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

Dp.transformArguments = void 0;

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

Dp.transformArguments = Pp;

var Lp = {};

(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 = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return r.transformBooleanReply;
        }
    });
})(Lp);

var Cp = {};

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

Cp.transformArguments = void 0;

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

Cp.transformArguments = Mp;

var Yp = {};

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

Yp.transformArguments = Yp.IS_READ_ONLY = void 0;

Yp.IS_READ_ONLY = true;

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

Yp.transformArguments = wp;

var Fp = {};

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

Fp.transformArguments = Fp.IS_READ_ONLY = void 0;

Fp.IS_READ_ONLY = true;

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

Fp.transformArguments = Xp;

var jp = {};

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

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

const Kp = y;

jp.IS_READ_ONLY = true;

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

jp.transformArguments = Up;

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

jp.transformReply = Bp;

var xp = {};

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

xp.transformArguments = xp.IS_READ_ONLY = void 0;

xp.IS_READ_ONLY = true;

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

xp.transformArguments = kp;

var Gp = {};

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

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

const Hp = y;

Gp.IS_READ_ONLY = true;

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

Gp.transformArguments = Wp;

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

Gp.transformReply = Vp;

var zp = {};

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

zp.transformArguments = zp.IS_READ_ONLY = void 0;

zp.IS_READ_ONLY = true;

function Zp() {
    return [ "RANDOMKEY" ];
}

zp.transformArguments = Zp;

var qp = {};

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

qp.transformArguments = void 0;

function $p() {
    return [ "READONLY" ];
}

qp.transformArguments = $p;

var Qp = {};

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

Qp.transformArguments = void 0;

function Jp() {
    return [ "READWRITE" ];
}

Qp.transformArguments = Jp;

var eS = {};

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

eS.transformArguments = void 0;

function tS(e, t) {
    return [ "REPLICAOF", e, t.toString() ];
}

eS.transformArguments = tS;

var rS = {};

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

rS.transformArguments = void 0;

function nS() {
    return [ "RESTORE-ASKING" ];
}

rS.transformArguments = nS;

var sS = {};

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

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

sS.IS_READ_ONLY = true;

function oS() {
    return [ "ROLE" ];
}

sS.transformArguments = oS;

function iS(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]
        };
    }
}

sS.transformReply = iS;

var uS = {};

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

uS.transformArguments = void 0;

function aS() {
    return [ "SAVE" ];
}

uS.transformArguments = aS;

var cS = {};

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

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

const fS = y;

cS.IS_READ_ONLY = true;

function lS(e, t) {
    const r = (0, fS.pushScanArguments)([ "SCAN" ], e, t);
    if (t?.TYPE) {
        r.push("TYPE", t.TYPE);
    }
    return r;
}

cS.transformArguments = lS;

function mS([e, t]) {
    return {
        cursor: Number(e),
        keys: t
    };
}

cS.transformReply = mS;

var dS = {};

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

dS.transformArguments = void 0;

function hS(e) {
    return [ "SCRIPT", "DEBUG", e ];
}

dS.transformArguments = hS;

var _S = {};

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.transformReply = e.transformArguments = void 0;
    const t = y;
    function r(e) {
        return (0, t.pushVerdictArguments)([ "SCRIPT", "EXISTS" ], e);
    }
    e.transformArguments = r;
    var n = y;
    Object.defineProperty(e, "transformReply", {
        enumerable: true,
        get: function() {
            return n.transformBooleanArrayReply;
        }
    });
})(_S);

var ES = {};

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

ES.transformArguments = void 0;

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

ES.transformArguments = pS;

var SS = {};

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

SS.transformArguments = void 0;

function RS() {
    return [ "SCRIPT", "KILL" ];
}

SS.transformArguments = RS;

var IS = {};

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

IS.transformArguments = void 0;

function gS(e) {
    return [ "SCRIPT", "LOAD", e ];
}

IS.transformArguments = gS;

var AS = {};

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

AS.transformArguments = void 0;

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

AS.transformArguments = vS;

var yS = {};

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

yS.transformArguments = void 0;

function NS(e, t) {
    return [ "SWAPDB", e.toString(), t.toString() ];
}

yS.transformArguments = NS;

var TS = {};

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

TS.transformReply = TS.transformArguments = void 0;

function OS() {
    return [ "TIME" ];
}

TS.transformArguments = OS;

function bS(e) {
    const t = Number(e[0]), r = Number(e[1]), n = new Date(t * 1e3 + r / 1e3);
    n.microseconds = r;
    return n;
}

TS.transformReply = bS;

var DS = {};

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

DS.transformArguments = void 0;

function PS() {
    return [ "UNWATCH" ];
}

DS.transformArguments = PS;

var LS = {};

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

LS.transformArguments = LS.FIRST_KEY_INDEX = void 0;

LS.FIRST_KEY_INDEX = 1;

function CS(e, t) {
    return [ "WAIT", e.toString(), t.toString() ];
}

LS.transformArguments = CS;

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

const MS = h;

const YS = id;

const wS = ad;

const FS = ld;

const XS = dd;

const jS = _d;

const KS = Sd;

const US = Id;

const BS = Ad;

const xS = yd;

const kS = Od;

const GS = Dd;

const HS = Cd;

const WS = Yd;

const VS = Fd;

const zS = jd;

const ZS = Ud;

const qS = xd;

const $S = Gd;

const QS = Wd;

const JS = zd;

const eR = qd;

const tR = Qd;

const rR = rh;

const nR = lh;

const sR = dh;

const oR = _h;

const iR = ph;

const uR = Rh;

const aR = yh;

const cR = Oh;

const fR = nh;

const lR = Dh;

const mR = Ch;

const dR = wh;

const hR = Xh;

const _R = Kh;

const ER = Bh;

const pR = Gh;

const SR = Vh;

const RR = qh;

const IR = Qh;

const gR = e_;

const AR = r_;

const vR = i_;

const yR = a_;

const NR = l_;

const TR = d_;

const OR = __;

const bR = p_;

const DR = A_;

const PR = v_;

const LR = N_;

const CR = O_;

const MR = D_;

const YR = L_;

const wR = Y_;

const FR = j_;

const XR = U_;

const jR = x_;

const KR = H_;

const UR = Z_;

const BR = Q_;

const xR = rE;

const kR = nE;

const GR = oE;

const HR = uE;

const WR = cE;

const VR = lE;

const zR = dE;

const ZR = _E;

const qR = pE;

const $R = IE;

const QR = AE;

const JR = yE;

const eI = TE;

const tI = bE;

const rI = PE;

const nI = LE;

const sI = KE;

const oI = BE;

const iI = kE;

const uI = WE;

const aI = ZE;

const cI = $E;

const fI = JE;

const lI = rp;

const mI = sp;

const dI = ip;

const hI = ap;

const _I = fp;

const EI = mp;

const pI = hp;

const SI = Ep;

const RI = Sp;

const II = vp;

const gI = Np;

const AI = Op;

const vI = Dp;

const yI = Lp;

const NI = Cp;

const TI = Yp;

const OI = Fp;

const bI = jp;

const DI = xp;

const PI = Gp;

const LI = zp;

const CI = qp;

const MI = Qp;

const YI = eS;

const wI = rS;

const FI = sS;

const XI = uS;

const jI = cS;

const KI = dS;

const UI = _S;

const BI = ES;

const xI = SS;

const kI = IS;

const GI = AS;

const HI = yS;

const WI = TS;

const VI = DS;

const zI = LS;

d.default = {
    ...MS.default,
    ACL_CAT: YS,
    aclCat: YS,
    ACL_DELUSER: wS,
    aclDelUser: wS,
    ACL_DRYRUN: FS,
    aclDryRun: FS,
    ACL_GENPASS: XS,
    aclGenPass: XS,
    ACL_GETUSER: jS,
    aclGetUser: jS,
    ACL_LIST: KS,
    aclList: KS,
    ACL_LOAD: US,
    aclLoad: US,
    ACL_LOG_RESET: BS,
    aclLogReset: BS,
    ACL_LOG: xS,
    aclLog: xS,
    ACL_SAVE: kS,
    aclSave: kS,
    ACL_SETUSER: GS,
    aclSetUser: GS,
    ACL_USERS: HS,
    aclUsers: HS,
    ACL_WHOAMI: WS,
    aclWhoAmI: WS,
    ASKING: VS,
    asking: VS,
    AUTH: zS,
    auth: zS,
    BGREWRITEAOF: ZS,
    bgRewriteAof: ZS,
    BGSAVE: qS,
    bgSave: qS,
    CLIENT_CACHING: $S,
    clientCaching: $S,
    CLIENT_GETNAME: QS,
    clientGetName: QS,
    CLIENT_GETREDIR: JS,
    clientGetRedir: JS,
    CLIENT_ID: eR,
    clientId: eR,
    CLIENT_KILL: tR,
    clientKill: tR,
    "CLIENT_NO-EVICT": nR,
    clientNoEvict: nR,
    "CLIENT_NO-TOUCH": sR,
    clientNoTouch: sR,
    CLIENT_LIST: rR,
    clientList: rR,
    CLIENT_PAUSE: oR,
    clientPause: oR,
    CLIENT_SETNAME: iR,
    clientSetName: iR,
    CLIENT_TRACKING: uR,
    clientTracking: uR,
    CLIENT_TRACKINGINFO: aR,
    clientTrackingInfo: aR,
    CLIENT_UNPAUSE: cR,
    clientUnpause: cR,
    CLIENT_INFO: fR,
    clientInfo: fR,
    CLUSTER_ADDSLOTS: lR,
    clusterAddSlots: lR,
    CLUSTER_ADDSLOTSRANGE: mR,
    clusterAddSlotsRange: mR,
    CLUSTER_BUMPEPOCH: dR,
    clusterBumpEpoch: dR,
    CLUSTER_COUNT_FAILURE_REPORTS: hR,
    clusterCountFailureReports: hR,
    CLUSTER_COUNTKEYSINSLOT: _R,
    clusterCountKeysInSlot: _R,
    CLUSTER_DELSLOTS: ER,
    clusterDelSlots: ER,
    CLUSTER_DELSLOTSRANGE: pR,
    clusterDelSlotsRange: pR,
    CLUSTER_FAILOVER: SR,
    clusterFailover: SR,
    CLUSTER_FLUSHSLOTS: RR,
    clusterFlushSlots: RR,
    CLUSTER_FORGET: IR,
    clusterForget: IR,
    CLUSTER_GETKEYSINSLOT: gR,
    clusterGetKeysInSlot: gR,
    CLUSTER_INFO: AR,
    clusterInfo: AR,
    CLUSTER_KEYSLOT: vR,
    clusterKeySlot: vR,
    CLUSTER_LINKS: yR,
    clusterLinks: yR,
    CLUSTER_MEET: NR,
    clusterMeet: NR,
    CLUSTER_MYID: TR,
    clusterMyId: TR,
    CLUSTER_MYSHARDID: OR,
    clusterMyShardId: OR,
    CLUSTER_NODES: bR,
    clusterNodes: bR,
    CLUSTER_REPLICAS: DR,
    clusterReplicas: DR,
    CLUSTER_REPLICATE: PR,
    clusterReplicate: PR,
    CLUSTER_RESET: LR,
    clusterReset: LR,
    CLUSTER_SAVECONFIG: CR,
    clusterSaveConfig: CR,
    CLUSTER_SET_CONFIG_EPOCH: MR,
    clusterSetConfigEpoch: MR,
    CLUSTER_SETSLOT: YR,
    clusterSetSlot: YR,
    CLUSTER_SLOTS: wR,
    clusterSlots: wR,
    COMMAND_COUNT: FR,
    commandCount: FR,
    COMMAND_GETKEYS: XR,
    commandGetKeys: XR,
    COMMAND_GETKEYSANDFLAGS: jR,
    commandGetKeysAndFlags: jR,
    COMMAND_INFO: KR,
    commandInfo: KR,
    COMMAND_LIST: UR,
    commandList: UR,
    COMMAND: BR,
    command: BR,
    CONFIG_GET: xR,
    configGet: xR,
    CONFIG_RESETASTAT: kR,
    configResetStat: kR,
    CONFIG_REWRITE: GR,
    configRewrite: GR,
    CONFIG_SET: HR,
    configSet: HR,
    DBSIZE: WR,
    dbSize: WR,
    DISCARD: VR,
    discard: VR,
    ECHO: zR,
    echo: zR,
    FAILOVER: ZR,
    failover: ZR,
    FLUSHALL: qR,
    flushAll: qR,
    FLUSHDB: $R,
    flushDb: $R,
    FUNCTION_DELETE: QR,
    functionDelete: QR,
    FUNCTION_DUMP: JR,
    functionDump: JR,
    FUNCTION_FLUSH: eI,
    functionFlush: eI,
    FUNCTION_KILL: tI,
    functionKill: tI,
    FUNCTION_LIST_WITHCODE: rI,
    functionListWithCode: rI,
    FUNCTION_LIST: nI,
    functionList: nI,
    FUNCTION_LOAD: sI,
    functionLoad: sI,
    FUNCTION_RESTORE: oI,
    functionRestore: oI,
    FUNCTION_STATS: iI,
    functionStats: iI,
    HELLO: uI,
    hello: uI,
    INFO: aI,
    info: aI,
    KEYS: cI,
    keys: cI,
    LASTSAVE: fI,
    lastSave: fI,
    LATENCY_DOCTOR: lI,
    latencyDoctor: lI,
    LATENCY_GRAPH: mI,
    latencyGraph: mI,
    LATENCY_HISTORY: dI,
    latencyHistory: dI,
    LATENCY_LATEST: hI,
    latencyLatest: hI,
    LOLWUT: _I,
    lolwut: _I,
    MEMORY_DOCTOR: EI,
    memoryDoctor: EI,
    "MEMORY_MALLOC-STATS": pI,
    memoryMallocStats: pI,
    MEMORY_PURGE: SI,
    memoryPurge: SI,
    MEMORY_STATS: RI,
    memoryStats: RI,
    MEMORY_USAGE: II,
    memoryUsage: II,
    MODULE_LIST: gI,
    moduleList: gI,
    MODULE_LOAD: AI,
    moduleLoad: AI,
    MODULE_UNLOAD: vI,
    moduleUnload: vI,
    MOVE: yI,
    move: yI,
    PING: NI,
    ping: NI,
    PUBSUB_CHANNELS: TI,
    pubSubChannels: TI,
    PUBSUB_NUMPAT: OI,
    pubSubNumPat: OI,
    PUBSUB_NUMSUB: bI,
    pubSubNumSub: bI,
    PUBSUB_SHARDCHANNELS: DI,
    pubSubShardChannels: DI,
    PUBSUB_SHARDNUMSUB: PI,
    pubSubShardNumSub: PI,
    RANDOMKEY: LI,
    randomKey: LI,
    READONLY: CI,
    readonly: CI,
    READWRITE: MI,
    readwrite: MI,
    REPLICAOF: YI,
    replicaOf: YI,
    "RESTORE-ASKING": wI,
    restoreAsking: wI,
    ROLE: FI,
    role: FI,
    SAVE: XI,
    save: XI,
    SCAN: jI,
    scan: jI,
    SCRIPT_DEBUG: KI,
    scriptDebug: KI,
    SCRIPT_EXISTS: UI,
    scriptExists: UI,
    SCRIPT_FLUSH: BI,
    scriptFlush: BI,
    SCRIPT_KILL: xI,
    scriptKill: xI,
    SCRIPT_LOAD: kI,
    scriptLoad: kI,
    SHUTDOWN: GI,
    shutdown: GI,
    SWAPDB: HI,
    swapDb: HI,
    TIME: WI,
    time: WI,
    UNWATCH: VI,
    unwatch: VI,
    WAIT: zI,
    wait: zI
};

var ZI = {};

var qI = {};

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

qI.MultiErrorReply = qI.ErrorReply = qI.ReconnectStrategyError = qI.RootNodesUnavailableError = qI.SocketClosedUnexpectedlyError = qI.DisconnectsClientError = qI.ClientOfflineError = qI.ClientClosedError = qI.ConnectionTimeoutError = qI.WatchError = qI.AbortError = void 0;

class AbortError extends Error {
    constructor() {
        super("The command was aborted");
    }
}

qI.AbortError = AbortError;

class WatchError extends Error {
    constructor() {
        super("One (or more) of the watched keys has been changed");
    }
}

qI.WatchError = WatchError;

class ConnectionTimeoutError extends Error {
    constructor() {
        super("Connection timeout");
    }
}

qI.ConnectionTimeoutError = ConnectionTimeoutError;

class ClientClosedError extends Error {
    constructor() {
        super("The client is closed");
    }
}

qI.ClientClosedError = ClientClosedError;

class ClientOfflineError extends Error {
    constructor() {
        super("The client is offline");
    }
}

qI.ClientOfflineError = ClientOfflineError;

class DisconnectsClientError extends Error {
    constructor() {
        super("Disconnects client");
    }
}

qI.DisconnectsClientError = DisconnectsClientError;

class SocketClosedUnexpectedlyError extends Error {
    constructor() {
        super("Socket closed unexpectedly");
    }
}

qI.SocketClosedUnexpectedlyError = SocketClosedUnexpectedlyError;

class RootNodesUnavailableError extends Error {
    constructor() {
        super("All the root nodes are unavailable");
    }
}

qI.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;
    }
}

qI.ReconnectStrategyError = ReconnectStrategyError;

class ErrorReply extends Error {
    constructor(e) {
        super(e);
        this.stack = undefined;
    }
}

qI.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];
        }
    }
}

qI.MultiErrorReply = MultiErrorReply;

var $I = {};

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

$I.promiseTimeout = void 0;

function QI(e) {
    return new Promise(t => setTimeout(t, e));
}

$I.promiseTimeout = QI;

var JI = e && e.__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 eg = e && e.__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 tg, rg, ng, sg, og, ig, ug, ag, cg, fg, lg, mg, dg, hg, _g, Eg, pg, Sg, Rg, Ig;

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

const gg = r;

const Ag = n;

const vg = s;

const yg = qI;

const Ng = $I;

class RedisSocket extends gg.EventEmitter {
    get isOpen() {
        return JI(this, ag, "f");
    }
    get isReady() {
        return JI(this, cg, "f");
    }
    get writableNeedDrain() {
        return JI(this, fg, "f");
    }
    constructor(e, t) {
        super();
        tg.add(this);
        og.set(this, void 0);
        ig.set(this, void 0);
        ug.set(this, void 0);
        ag.set(this, false);
        cg.set(this, false);
        fg.set(this, false);
        lg.set(this, false);
        Ig.set(this, false);
        eg(this, og, e, "f");
        eg(this, ig, JI(rg, rg, "m", ng).call(rg, t), "f");
    }
    async connect() {
        if (JI(this, ag, "f")) {
            throw new Error("Socket already opened");
        }
        eg(this, ag, true, "f");
        return JI(this, tg, "m", hg).call(this);
    }
    writeCommand(e) {
        if (!JI(this, ug, "f")) {
            throw new yg.ClientClosedError;
        }
        for (const t of e) {
            eg(this, fg, !JI(this, ug, "f").write(t), "f");
        }
    }
    disconnect() {
        if (!JI(this, ag, "f")) {
            throw new yg.ClientClosedError;
        }
        eg(this, ag, false, "f");
        JI(this, tg, "m", Rg).call(this);
    }
    async quit(e) {
        if (!JI(this, ag, "f")) {
            throw new yg.ClientClosedError;
        }
        eg(this, ag, false, "f");
        const t = await e();
        JI(this, tg, "m", Rg).call(this);
        return t;
    }
    cork() {
        if (!JI(this, ug, "f") || JI(this, Ig, "f")) {
            return;
        }
        JI(this, ug, "f").cork();
        eg(this, Ig, true, "f");
        setImmediate(() => {
            JI(this, ug, "f")?.uncork();
            eg(this, Ig, false, "f");
        });
    }
    ref() {
        eg(this, lg, false, "f");
        JI(this, ug, "f")?.ref();
    }
    unref() {
        eg(this, lg, true, "f");
        JI(this, ug, "f")?.unref();
    }
}

rg = RedisSocket, og = new WeakMap, ig = new WeakMap, ug = new WeakMap, ag = new WeakMap, 
cg = new WeakMap, fg = new WeakMap, lg = new WeakMap, Ig = new WeakMap, tg = new WeakSet, 
ng = 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;
}, sg = function e(t) {
    return t.tls === true;
}, mg = function e(t, r) {
    if (JI(this, ig, "f").reconnectStrategy === false) {
        return false;
    } else if (typeof JI(this, ig, "f").reconnectStrategy === "number") {
        return JI(this, ig, "f").reconnectStrategy;
    } else if (JI(this, ig, "f").reconnectStrategy) {
        try {
            const e = JI(this, ig, "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);
}, dg = function e(t, r) {
    const n = JI(this, tg, "m", mg).call(this, t, r);
    if (n === false) {
        eg(this, ag, false, "f");
        this.emit("error", r);
        return r;
    } else if (n instanceof Error) {
        eg(this, ag, false, "f");
        this.emit("error", r);
        return new yg.ReconnectStrategyError(n, r);
    }
    return n;
}, hg = async function e() {
    let t = 0;
    do {
        try {
            eg(this, ug, await JI(this, tg, "m", _g).call(this), "f");
            eg(this, fg, false, "f");
            this.emit("connect");
            try {
                await JI(this, og, "f").call(this);
            } catch (e) {
                JI(this, ug, "f").destroy();
                eg(this, ug, undefined, "f");
                throw e;
            }
            eg(this, cg, true, "f");
            this.emit("ready");
        } catch (e) {
            const r = JI(this, tg, "m", dg).call(this, t++, e);
            if (typeof r !== "number") {
                throw r;
            }
            this.emit("error", e);
            await (0, Ng.promiseTimeout)(r);
            this.emit("reconnecting");
        }
    } while (JI(this, ag, "f") && !JI(this, cg, "f"));
}, _g = function e() {
    return new Promise((e, t) => {
        const {connectEvent: r, socket: n} = JI(rg, rg, "m", sg).call(rg, JI(this, ig, "f")) ? JI(this, tg, "m", pg).call(this) : JI(this, tg, "m", Eg).call(this);
        if (JI(this, ig, "f").connectTimeout) {
            n.setTimeout(JI(this, ig, "f").connectTimeout, () => n.destroy(new yg.ConnectionTimeoutError));
        }
        if (JI(this, lg, "f")) {
            n.unref();
        }
        n.setNoDelay(JI(this, ig, "f").noDelay).once("error", t).once(r, () => {
            n.setTimeout(0).setKeepAlive(JI(this, ig, "f").keepAlive !== false, JI(this, ig, "f").keepAlive || 0).off("error", t).once("error", e => JI(this, tg, "m", Sg).call(this, e)).once("close", e => {
                if (!e && JI(this, ag, "f") && JI(this, ug, "f") === n) {
                    JI(this, tg, "m", Sg).call(this, new yg.SocketClosedUnexpectedlyError);
                }
            }).on("drain", () => {
                eg(this, fg, false, "f");
                this.emit("drain");
            }).on("data", e => this.emit("data", e));
            e(n);
        });
    });
}, Eg = function e() {
    return {
        connectEvent: "connect",
        socket: Ag.connect(JI(this, ig, "f"))
    };
}, pg = function e() {
    return {
        connectEvent: "secureConnect",
        socket: vg.connect(JI(this, ig, "f"))
    };
}, Sg = function e(t) {
    const r = JI(this, cg, "f");
    eg(this, cg, false, "f");
    this.emit("error", t);
    if (!r || !JI(this, ag, "f") || typeof JI(this, tg, "m", dg).call(this, 0, t) !== "number") return;
    this.emit("reconnecting");
    JI(this, tg, "m", hg).call(this).catch(() => {});
}, Rg = function e() {
    eg(this, cg, false, "f");
    if (JI(this, ug, "f")) {
        JI(this, ug, "f").destroy();
        eg(this, ug, undefined, "f");
    }
    this.emit("end");
};

ZI.default = RedisSocket;

var Tg = {};

var Og;

var bg;

function Dg() {
    if (bg) return Og;
    bg = 1;
    Og = function(e) {
        e.prototype[Symbol.iterator] = function*() {
            for (let e = this.head; e; e = e.next) {
                yield e.value;
            }
        };
    };
    return Og;
}

var Pg = Lg;

Lg.Node = wg;

Lg.create = Lg;

function Lg(e) {
    var t = this;
    if (!(t instanceof Lg)) {
        t = new Lg;
    }
    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;
}

Lg.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;
};

Lg.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++;
};

Lg.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++;
};

Lg.prototype.push = function() {
    for (var e = 0, t = arguments.length; e < t; e++) {
        Mg(this, arguments[e]);
    }
    return this.length;
};

Lg.prototype.unshift = function() {
    for (var e = 0, t = arguments.length; e < t; e++) {
        Yg(this, arguments[e]);
    }
    return this.length;
};

Lg.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;
};

Lg.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;
};

Lg.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;
    }
};

Lg.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;
    }
};

Lg.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;
    }
};

Lg.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;
    }
};

Lg.prototype.map = function(e, t) {
    t = t || this;
    var r = new Lg;
    for (var n = this.head; n !== null; ) {
        r.push(e.call(t, n.value, this));
        n = n.next;
    }
    return r;
};

Lg.prototype.mapReverse = function(e, t) {
    t = t || this;
    var r = new Lg;
    for (var n = this.tail; n !== null; ) {
        r.push(e.call(t, n.value, this));
        n = n.prev;
    }
    return r;
};

Lg.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;
};

Lg.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;
};

Lg.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;
};

Lg.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;
};

Lg.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 Lg;
    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;
};

Lg.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 Lg;
    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;
};

Lg.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 = Cg(this, s, r[n]);
    }
    return o;
};

Lg.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 Cg(e, t, r) {
    var n = t === e.head ? new wg(r, null, t, e) : new wg(r, t, t.next, e);
    if (n.next === null) {
        e.tail = n;
    }
    if (n.prev === null) {
        e.head = n;
    }
    e.length++;
    return n;
}

function Mg(e, t) {
    e.tail = new wg(t, e.tail, null, e);
    if (!e.head) {
        e.head = e.tail;
    }
    e.length++;
}

function Yg(e, t) {
    e.head = new wg(t, null, e.head, e);
    if (!e.tail) {
        e.tail = e.head;
    }
    e.length++;
}

function wg(e, t, r, n) {
    if (!(this instanceof wg)) {
        return new wg(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 {
    Dg()(Lg);
} catch (e) {}

var Fg = {};

var Xg = {};

Object.defineProperty(Xg, "__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 = [];
    }
}

Xg.default = BufferComposer;

var jg = {};

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

const Kg = o;

class StringComposer {
    constructor() {
        Object.defineProperty(this, "decoder", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Kg.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 = "";
    }
}

jg.default = StringComposer;

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

const Ug = qI;

const Bg = Xg;

const xg = jg;

var kg;

(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";
})(kg || (kg = {}));

var Gg;

(function(e) {
    e[e["CR"] = 13] = "CR";
    e[e["ZERO"] = 48] = "ZERO";
    e[e["MINUS"] = 45] = "MINUS";
})(Gg || (Gg = {}));

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 Bg.default
        });
        Object.defineProperty(this, "stringComposer", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new xg.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 kg.SIMPLE_STRING:
            return this.parseSimpleString(e);

          case kg.ERROR:
            return this.parseError(e);

          case kg.INTEGER:
            return this.parseInteger(e);

          case kg.BULK_STRING:
            return this.parseBulkString(e);

          case kg.ARRAY:
            return this.parseArray(e, r);
        }
    }
    compose(e, t) {
        for (let r = this.cursor; r < e.length; r++) {
            if (e[r] === Gg.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 Ug.ErrorReply(t);
        }
    }
    parseInteger(e) {
        if (this.isNegativeInteger === undefined) {
            this.isNegativeInteger = e[this.cursor] === Gg.MINUS;
            if (this.isNegativeInteger && ++this.cursor === e.length) return;
        }
        do {
            const t = e[this.cursor];
            if (t === Gg.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 - Gg.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);
        }
    }
}

Fg.default = RESP2Decoder;

var Hg = {};

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

const Wg = "\r\n";

function Vg(e) {
    const t = [];
    let r = "*" + e.length + Wg;
    for (let n = 0; n < e.length; n++) {
        const s = e[n];
        if (typeof s === "string") {
            r += "$" + Buffer.byteLength(s) + Wg + s + Wg;
        } else if (s instanceof Buffer) {
            t.push(r + "$" + s.length.toString() + Wg, s);
            r = Wg;
        } else {
            throw new TypeError("Invalid argument type");
        }
    }
    t.push(r);
    return t;
}

Hg.default = Vg;

var zg = {};

var Zg = e && e.__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 qg = e && e.__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 $g, Qg, Jg, eA, tA, rA, nA, sA, oA, iA, uA;

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

zg.PubSub = zg.PubSubType = void 0;

var aA;

(function(e) {
    e["CHANNELS"] = "CHANNELS";
    e["PATTERNS"] = "PATTERNS";
    e["SHARDED"] = "SHARDED";
})(aA || (zg.PubSubType = aA = {}));

const cA = {
    [aA.CHANNELS]: {
        subscribe: Buffer.from("subscribe"),
        unsubscribe: Buffer.from("unsubscribe"),
        message: Buffer.from("message")
    },
    [aA.PATTERNS]: {
        subscribe: Buffer.from("psubscribe"),
        unsubscribe: Buffer.from("punsubscribe"),
        message: Buffer.from("pmessage")
    },
    [aA.SHARDED]: {
        subscribe: Buffer.from("ssubscribe"),
        unsubscribe: Buffer.from("sunsubscribe"),
        message: Buffer.from("smessage")
    }
};

class PubSub {
    constructor() {
        $g.add(this);
        tA.set(this, 0);
        rA.set(this, false);
        nA.set(this, {
            [aA.CHANNELS]: new Map,
            [aA.PATTERNS]: new Map,
            [aA.SHARDED]: new Map
        });
    }
    static isStatusReply(e) {
        return cA[aA.CHANNELS].subscribe.equals(e[0]) || cA[aA.CHANNELS].unsubscribe.equals(e[0]) || cA[aA.PATTERNS].subscribe.equals(e[0]) || cA[aA.PATTERNS].unsubscribe.equals(e[0]) || cA[aA.SHARDED].subscribe.equals(e[0]);
    }
    static isShardedUnsubscribe(e) {
        return cA[aA.SHARDED].unsubscribe.equals(e[0]);
    }
    get isActive() {
        return Zg(this, rA, "f");
    }
    subscribe(e, t, r, n) {
        var s;
        const o = [ cA[e].subscribe ], i = Zg(Qg, Qg, "m", Jg).call(Qg, t);
        for (const t of i) {
            let r = Zg(this, nA, "f")[e].get(t);
            if (!r || r.unsubscribing) {
                o.push(t);
            }
        }
        if (o.length === 1) {
            for (const t of i) {
                Zg(Qg, Qg, "m", eA).call(Qg, Zg(this, nA, "f")[e].get(t), n).add(r);
            }
            return;
        }
        qg(this, rA, true, "f");
        qg(this, tA, (s = Zg(this, tA, "f"), s++, s), "f");
        return {
            args: o,
            channelsCounter: o.length - 1,
            resolve: () => {
                var t;
                qg(this, tA, (t = Zg(this, tA, "f"), t--, t), "f");
                for (const t of i) {
                    let s = Zg(this, nA, "f")[e].get(t);
                    if (!s) {
                        s = {
                            unsubscribing: false,
                            buffers: new Set,
                            strings: new Set
                        };
                        Zg(this, nA, "f")[e].set(t, s);
                    }
                    Zg(Qg, Qg, "m", eA).call(Qg, s, n).add(r);
                }
            },
            reject: () => {
                var e;
                qg(this, tA, (e = Zg(this, tA, "f"), e--, e), "f");
                Zg(this, $g, "m", iA).call(this);
            }
        };
    }
    extendChannelListeners(e, t, r) {
        var n;
        if (!Zg(this, $g, "m", sA).call(this, e, t, r)) return;
        qg(this, rA, true, "f");
        qg(this, tA, (n = Zg(this, tA, "f"), n++, n), "f");
        return {
            args: [ cA[e].subscribe, t ],
            channelsCounter: 1,
            resolve: () => {
                var e, t;
                return qg(this, tA, (t = Zg(this, tA, "f"), e = t--, t), "f"), e;
            },
            reject: () => {
                var e;
                qg(this, tA, (e = Zg(this, tA, "f"), e--, e), "f");
                Zg(this, $g, "m", iA).call(this);
            }
        };
    }
    extendTypeListeners(e, t) {
        var r;
        const n = [ cA[e].subscribe ];
        for (const [r, s] of t) {
            if (Zg(this, $g, "m", sA).call(this, e, r, s)) {
                n.push(r);
            }
        }
        if (n.length === 1) return;
        qg(this, rA, true, "f");
        qg(this, tA, (r = Zg(this, tA, "f"), r++, r), "f");
        return {
            args: n,
            channelsCounter: n.length - 1,
            resolve: () => {
                var e, t;
                return qg(this, tA, (t = Zg(this, tA, "f"), e = t--, t), "f"), e;
            },
            reject: () => {
                var e;
                qg(this, tA, (e = Zg(this, tA, "f"), e--, e), "f");
                Zg(this, $g, "m", iA).call(this);
            }
        };
    }
    unsubscribe(e, t, r, n) {
        const s = Zg(this, nA, "f")[e];
        if (!t) {
            return Zg(this, $g, "m", oA).call(this, [ cA[e].unsubscribe ], NaN, () => s.clear());
        }
        const o = Zg(Qg, Qg, "m", Jg).call(Qg, t);
        if (!r) {
            return Zg(this, $g, "m", oA).call(this, [ cA[e].unsubscribe, ...o ], o.length, () => {
                for (const e of o) {
                    s.delete(e);
                }
            });
        }
        const i = [ cA[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) {
                Zg(Qg, Qg, "m", eA).call(Qg, s.get(e), n).delete(r);
            }
            return;
        }
        return Zg(this, $g, "m", oA).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() {
        qg(this, rA, false, "f");
        qg(this, tA, 0, "f");
    }
    resubscribe() {
        var e;
        const t = [];
        for (const [r, n] of Object.entries(Zg(this, nA, "f"))) {
            if (!n.size) continue;
            qg(this, rA, true, "f");
            qg(this, tA, (e = Zg(this, tA, "f"), e++, e), "f");
            const s = () => {
                var e, t;
                return qg(this, tA, (t = Zg(this, tA, "f"), e = t--, t), "f"), e;
            };
            t.push({
                args: [ cA[r].subscribe, ...n.keys() ],
                channelsCounter: n.size,
                resolve: s,
                reject: s
            });
        }
        return t;
    }
    handleMessageReply(e) {
        if (cA[aA.CHANNELS].message.equals(e[0])) {
            Zg(this, $g, "m", uA).call(this, aA.CHANNELS, e[2], e[1]);
            return true;
        } else if (cA[aA.PATTERNS].message.equals(e[0])) {
            Zg(this, $g, "m", uA).call(this, aA.PATTERNS, e[3], e[2], e[1]);
            return true;
        } else if (cA[aA.SHARDED].message.equals(e[0])) {
            Zg(this, $g, "m", uA).call(this, aA.SHARDED, e[2], e[1]);
            return true;
        }
        return false;
    }
    removeShardedListeners(e) {
        const t = Zg(this, nA, "f")[aA.SHARDED].get(e);
        Zg(this, nA, "f")[aA.SHARDED].delete(e);
        Zg(this, $g, "m", iA).call(this);
        return t;
    }
    getTypeListeners(e) {
        return Zg(this, nA, "f")[e];
    }
}

zg.PubSub = PubSub;

Qg = PubSub, tA = new WeakMap, rA = new WeakMap, nA = new WeakMap, $g = new WeakSet, 
Jg = function e(t) {
    return Array.isArray(t) ? t : [ t ];
}, eA = function e(t, r) {
    return r ? t.buffers : t.strings;
}, sA = function e(t, r, n) {
    const s = Zg(this, nA, "f")[t].get(r);
    if (!s) {
        Zg(this, nA, "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;
}, oA = function e(t, r, n) {
    return {
        args: t,
        channelsCounter: r,
        resolve: () => {
            n();
            Zg(this, $g, "m", iA).call(this);
        },
        reject: undefined
    };
}, iA = function e() {
    qg(this, rA, Zg(this, nA, "f")[aA.CHANNELS].size !== 0 || Zg(this, nA, "f")[aA.PATTERNS].size !== 0 || Zg(this, nA, "f")[aA.SHARDED].size !== 0 || Zg(this, tA, "f") !== 0, "f");
}, uA = function e(t, r, n, s) {
    const o = (s ?? n).toString(), i = Zg(this, nA, "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 fA = e && e.__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 lA = e && e.__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 mA, dA, hA, _A, EA, pA, SA, RA, IA, gA, AA;

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

const vA = Pg;

const yA = qI;

const NA = Fg;

const TA = Hg;

const OA = zg;

const bA = Buffer.from("pong");

class RedisCommandsQueue {
    get isPubSubActive() {
        return fA(this, RA, "f").isActive;
    }
    constructor(e, t) {
        mA.add(this);
        _A.set(this, void 0);
        EA.set(this, new vA);
        pA.set(this, new vA);
        SA.set(this, void 0);
        RA.set(this, new OA.PubSub);
        IA.set(this, void 0);
        gA.set(this, new NA.default({
            returnStringsAsBuffers: () => !!fA(this, pA, "f").head?.value.returnBuffers || fA(this, RA, "f").isActive,
            onReply: e => {
                if (fA(this, RA, "f").isActive && Array.isArray(e)) {
                    if (fA(this, RA, "f").handleMessageReply(e)) return;
                    const t = OA.PubSub.isShardedUnsubscribe(e);
                    if (t && !fA(this, pA, "f").length) {
                        const t = e[1].toString();
                        fA(this, SA, "f").call(this, t, fA(this, RA, "f").removeShardedListeners(t));
                        return;
                    } else if (t || OA.PubSub.isStatusReply(e)) {
                        const t = fA(this, pA, "f").head.value;
                        if (Number.isNaN(t.channelsCounter) && e[2] === 0 || --t.channelsCounter === 0) {
                            fA(this, pA, "f").shift().resolve();
                        }
                        return;
                    }
                    if (bA.equals(e[0])) {
                        const {resolve: t, returnBuffers: r} = fA(this, pA, "f").shift(), n = e[1].length === 0 ? e[0] : e[1];
                        t(r ? n : n.toString());
                        return;
                    }
                }
                const {resolve: t, reject: r} = fA(this, pA, "f").shift();
                if (e instanceof yA.ErrorReply) {
                    r(e);
                } else {
                    t(e);
                }
            }
        }));
        lA(this, _A, e, "f");
        lA(this, SA, t, "f");
    }
    addCommand(e, t) {
        if (fA(this, _A, "f") && fA(this, EA, "f").length + fA(this, pA, "f").length >= fA(this, _A, "f")) {
            return Promise.reject(new Error("The queue is full"));
        } else if (t?.signal?.aborted) {
            return Promise.reject(new yA.AbortError);
        }
        return new Promise((r, n) => {
            const s = new vA.Node({
                args: e,
                chainId: t?.chainId,
                returnBuffers: t?.returnBuffers,
                resolve: r,
                reject: n
            });
            if (t?.signal) {
                const e = () => {
                    fA(this, EA, "f").removeNode(s);
                    s.value.reject(new yA.AbortError);
                };
                s.value.abort = {
                    signal: t.signal,
                    listener: e
                };
                t.signal.addEventListener("abort", e, {
                    once: true
                });
            }
            if (t?.asap) {
                fA(this, EA, "f").unshiftNode(s);
            } else {
                fA(this, EA, "f").pushNode(s);
            }
        });
    }
    subscribe(e, t, r, n) {
        return fA(this, mA, "m", AA).call(this, fA(this, RA, "f").subscribe(e, t, r, n));
    }
    unsubscribe(e, t, r, n) {
        return fA(this, mA, "m", AA).call(this, fA(this, RA, "f").unsubscribe(e, t, r, n));
    }
    resubscribe() {
        const e = fA(this, RA, "f").resubscribe();
        if (!e.length) return;
        return Promise.all(e.map(e => fA(this, mA, "m", AA).call(this, e)));
    }
    extendPubSubChannelListeners(e, t, r) {
        return fA(this, mA, "m", AA).call(this, fA(this, RA, "f").extendChannelListeners(e, t, r));
    }
    extendPubSubListeners(e, t) {
        return fA(this, mA, "m", AA).call(this, fA(this, RA, "f").extendTypeListeners(e, t));
    }
    getPubSubListeners(e) {
        return fA(this, RA, "f").getTypeListeners(e);
    }
    getCommandToSend() {
        const e = fA(this, EA, "f").shift();
        if (!e) return;
        let t;
        try {
            t = (0, TA.default)(e.args);
        } catch (t) {
            e.reject(t);
            return;
        }
        fA(this, pA, "f").push({
            resolve: e.resolve,
            reject: e.reject,
            channelsCounter: e.channelsCounter,
            returnBuffers: e.returnBuffers
        });
        lA(this, IA, e.chainId, "f");
        return t;
    }
    onReplyChunk(e) {
        fA(this, gA, "f").write(e);
    }
    flushWaitingForReply(e) {
        fA(this, gA, "f").reset();
        fA(this, RA, "f").reset();
        fA(dA, dA, "m", hA).call(dA, fA(this, pA, "f"), e);
        if (!fA(this, IA, "f")) return;
        while (fA(this, EA, "f").head?.value.chainId === fA(this, IA, "f")) {
            fA(this, EA, "f").shift();
        }
        lA(this, IA, undefined, "f");
    }
    flushAll(e) {
        fA(this, gA, "f").reset();
        fA(this, RA, "f").reset();
        fA(dA, dA, "m", hA).call(dA, fA(this, pA, "f"), e);
        fA(dA, dA, "m", hA).call(dA, fA(this, EA, "f"), e);
    }
}

dA = RedisCommandsQueue, _A = new WeakMap, EA = new WeakMap, pA = new WeakMap, SA = new WeakMap, 
RA = new WeakMap, IA = new WeakMap, gA = new WeakMap, mA = new WeakSet, hA = function e(t, r) {
    while (t.length) {
        t.shift().reject(r);
    }
}, AA = function e(t) {
    if (t === undefined) return;
    return new Promise((e, r) => {
        fA(this, EA, "f").push({
            args: t.args,
            channelsCounter: t.channelsCounter,
            returnBuffers: true,
            resolve: () => {
                t.resolve();
                e();
            },
            reject: e => {
                t.reject?.();
                r(e);
            }
        });
    });
};

Tg.default = RedisCommandsQueue;

var DA = {};

var PA = {};

var LA = {};

var CA = {};

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

CA.isCommandOptions = CA.commandOptions = void 0;

const MA = Symbol("Command Options");

function YA(e) {
    e[MA] = true;
    return e;
}

CA.commandOptions = YA;

function wA(e) {
    return e?.[MA] === true;
}

CA.isCommandOptions = wA;

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

LA.fCallArguments = LA.transformCommandReply = LA.transformLegacyCommandArguments = LA.transformCommandArguments = LA.attachExtensions = LA.attachCommands = void 0;

const FA = CA;

function XA({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);
        };
    }
}

LA.attachCommands = XA;

function jA(e) {
    let t;
    if (e.modules) {
        t = KA({
            BaseClass: e.BaseClass,
            namespaces: e.modules,
            executor: e.modulesExecutor
        });
    }
    if (e.functions) {
        t = KA({
            BaseClass: t ?? e.BaseClass,
            namespaces: e.functions,
            executor: e.functionsExecutor
        });
    }
    if (e.scripts) {
        t ?? (t = class extends e.BaseClass {});
        XA({
            BaseClass: t,
            commands: e.scripts,
            executor: e.scriptsExecutor
        });
    }
    return t ?? e.BaseClass;
}

LA.attachExtensions = jA;

function KA({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 UA(e, t) {
    let r;
    if ((0, FA.isCommandOptions)(t[0])) {
        r = t[0];
        t = t.slice(1);
    }
    return {
        jsArgs: t,
        args: e.transformArguments(...t),
        options: r
    };
}

LA.transformCommandArguments = UA;

function BA(e) {
    return e.flat().map(e => typeof e === "number" || e instanceof Date ? e.toString() : e);
}

LA.transformLegacyCommandArguments = BA;

function xA(e, t, r) {
    if (!e.transformReply) {
        return t;
    }
    return e.transformReply(t, r);
}

LA.transformCommandReply = xA;

function kA(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;
}

LA.fCallArguments = kA;

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

const GA = LA;

const HA = qI;

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, GA.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 HA.WatchError;
        }
        return this.transformReplies(t);
    }
    transformReplies(e) {
        const t = [], r = e.map((e, r) => {
            if (e instanceof HA.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 HA.MultiErrorReply(r, t);
        return r;
    }
}

PA.default = RedisMultiCommand;

var WA = e && e.__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 VA = e && e.__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 zA, ZA, qA, $A, QA, JA;

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

const ev = d;

const tv = PA;

const rv = LA;

class RedisClientMultiCommand {
    static extend(e) {
        return (0, rv.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) {
        zA.add(this);
        ZA.set(this, new tv.default);
        qA.set(this, void 0);
        Object.defineProperty(this, "v4", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: {}
        });
        $A.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
        });
        WA(this, qA, e, "f");
        if (t) {
            VA(this, zA, "m", QA).call(this);
        }
    }
    commandsExecutor(e, t) {
        return this.addCommand(e.transformArguments(...t), e.transformReply);
    }
    SELECT(e, t) {
        WA(this, $A, e, "f");
        return this.addCommand([ "SELECT", e.toString() ], t);
    }
    addCommand(e, t) {
        VA(this, ZA, "f").addCommand(e, t);
        return this;
    }
    functionsExecutor(e, t, r) {
        VA(this, ZA, "f").addFunction(r, e, t);
        return this;
    }
    scriptsExecutor(e, t) {
        VA(this, ZA, "f").addScript(e, t);
        return this;
    }
    async exec(e = false) {
        if (e) {
            return this.execAsPipeline();
        }
        return VA(this, ZA, "f").handleExecReplies(await VA(this, qA, "f").call(this, VA(this, ZA, "f").queue, VA(this, $A, "f"), tv.default.generateChainId()));
    }
    async execAsPipeline() {
        if (VA(this, ZA, "f").queue.length === 0) return [];
        return VA(this, ZA, "f").transformReplies(await VA(this, qA, "f").call(this, VA(this, ZA, "f").queue, VA(this, $A, "f")));
    }
}

ZA = new WeakMap, qA = new WeakMap, $A = new WeakMap, zA = new WeakSet, QA = function e() {
    var t, r;
    this.v4.addCommand = this.addCommand.bind(this);
    this.addCommand = (...e) => {
        VA(this, ZA, "f").addCommand((0, rv.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(ev.default)) {
        VA(this, zA, "m", JA).call(this, e, n);
        (t = this)[r = e.toLowerCase()] ?? (t[r] = this[e]);
    }
}, JA = function e(t, r) {
    this.v4[t] = this[t].bind(this.v4);
    this[t] = r && r.TRANSFORM_LEGACY_REPLY && r.transformReply ? (...e) => {
        VA(this, ZA, "f").addCommand([ t, ...(0, rv.transformLegacyCommandArguments)(e) ], r.transformReply);
        return this;
    } : (...e) => this.addCommand(t, ...e);
};

DA.default = RedisClientMultiCommand;

(0, rv.attachCommands)({
    BaseClass: RedisClientMultiCommand,
    commands: ev.default,
    executor: RedisClientMultiCommand.prototype.commandsExecutor
});

var nv = 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 sv = 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 ov = sv;

const iv = ov;

let uv = class PoolOptions {
    constructor(e) {
        const t = new iv;
        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 av = uv;

let cv = 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);
    }
};

cv.PENDING = "PENDING";

cv.FULFILLED = "FULFILLED";

cv.REJECTED = "REJECTED";

var fv = cv;

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 lv = {
    TimeoutError: TimeoutError
};

const mv = fv;

const dv = lv;

function hv(e, t) {
    return function r() {
        return e.apply(t, arguments);
    };
}

let _v = class ResourceRequest extends mv {
    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(hv(this._fireTimeout, this), Math.max(t - r, 0));
    }
    removeTimeout() {
        if (this._timeout) {
            clearTimeout(this._timeout);
        }
        this._timeout = null;
    }
    _fireTimeout() {
        this.reject(new dv.TimeoutError("ResourceRequest timed out"));
    }
    reject(e) {
        this.removeTimeout();
        super.reject(e);
    }
    resolve(e) {
        this.removeTimeout();
        super.resolve(e);
    }
};

var Ev = _v;

const pv = fv;

let Sv = class ResourceLoan extends pv {
    constructor(e, t) {
        super(t);
        this._creationTimestamp = Date.now();
        this.pooledResource = e;
    }
    reject() {}
};

var Rv = Sv;

const Iv = {
    ALLOCATED: "ALLOCATED",
    IDLE: "IDLE",
    INVALID: "INVALID",
    RETURNING: "RETURNING",
    VALIDATION: "VALIDATION"
};

var gv = Iv;

const Av = gv;

let vv = class PooledResource {
    constructor(e) {
        this.creationTime = Date.now();
        this.lastReturnTime = null;
        this.lastBorrowTime = null;
        this.lastIdleTime = null;
        this.obj = e;
        this.state = Av.IDLE;
    }
    allocate() {
        this.lastBorrowTime = Date.now();
        this.state = Av.ALLOCATED;
    }
    deallocate() {
        this.lastReturnTime = Date.now();
        this.state = Av.IDLE;
    }
    invalidate() {
        this.state = Av.INVALID;
    }
    test() {
        this.state = Av.VALIDATION;
    }
    idle() {
        this.lastIdleTime = Date.now();
        this.state = Av.IDLE;
    }
    returning() {
        this.state = Av.RETURNING;
    }
};

var yv = vv;

let Nv = 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 Tv = Nv;

let Ov = 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 bv = Ov;

let Dv = 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 Pv = Dv;

const Lv = Pv;

let Cv = class DequeIterator extends Lv {
    next() {
        const e = super.next();
        if (e.value) {
            e.value = e.value.data;
        }
        return e;
    }
};

var Mv = Cv;

const Yv = bv;

const wv = Mv;

let Fv = class Deque {
    constructor() {
        this._list = new Yv;
    }
    shift() {
        if (this.length === 0) {
            return undefined;
        }
        const e = this._list.head;
        this._list.remove(e);
        return e.data;
    }
    unshift(e) {
        const t = Yv.createNode(e);
        this._list.insertBeginning(t);
    }
    push(e) {
        const t = Yv.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 wv(this._list);
    }
    iterator() {
        return new wv(this._list);
    }
    reverseIterator() {
        return new wv(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 Xv = Fv;

const jv = bv;

const Kv = Xv;

let Uv = class Queue extends Kv {
    push(e) {
        const t = jv.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 Bv = Uv;

const xv = Bv;

let kv = 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 xv);
        }
    }
    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 Gv = kv;

var Hv = {};

function Wv() {}

Hv.reflector = function(e) {
    return e.then(Wv, Wv);
};

const Vv = r.EventEmitter;

const zv = nv;

const Zv = av;

const qv = Ev;

const $v = Rv;

const Qv = yv;

const Jv = fv;

const ey = Hv.reflector;

const ty = "factoryCreateError";

const ry = "factoryDestroyError";

let ny = class Pool extends Vv {
    constructor(e, t, r, n, s) {
        super();
        zv(n);
        this._config = new Zv(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(ry, 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 !== Jv.PENDING) {
            this._addPooledResourceToAvailableObjects(e);
            return false;
        }
        const r = new $v(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 Qv(e);
            this._allObjects.add(t);
            this._addPooledResourceToAvailableObjects(t);
        });
        this._trackOperation(t, this._factoryCreateOperations).then(() => {
            this._dispense();
            return null;
        }).catch(e => {
            this.emit(ty, 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 qv(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 ey(this._waitingClientsQueue.tail.promise);
        }
        return this._Promise.resolve();
    }
    __allResourcesReturned() {
        const e = Array.from(this._resourceLoans.values()).map(e => e.promise).map(ey);
        return this._Promise.all(e);
    }
    clear() {
        const e = Array.from(this._factoryCreateOperations).map(ey);
        return this._Promise.all(e).then(() => {
            for (const e of this._availableObjects) {
                this._destroy(e);
            }
            const e = Array.from(this._factoryDestroyOperations).map(ey);
            return ey(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 sy = ny;

const oy = sy;

const iy = Xv;

const uy = Gv;

const ay = Tv;

var cy = {
    Pool: oy,
    Deque: iy,
    PriorityQueue: uy,
    DefaultEvictor: ay,
    createPool: function(e, t) {
        return new oy(ay, iy, uy, e, t);
    }
};

var fy = "1.6.0";

const ly = {
    version: fy
};

var my = e && e.__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 dy = e && e.__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 hy, _y, Ey, py, Sy, Ry, Iy, gy, Ay, vy, yy, Ny, Ty, Oy, by, Dy, Py, Ly, Cy, My, Yy, wy;

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

const Fy = d;

const Xy = ZI;

const jy = Tg;

const Ky = DA;

const Uy = r;

const By = CA;

const xy = LA;

const ky = cy;

const Gy = qI;

const Hy = i;

const Wy = zg;

const Vy = ly;

class RedisClient extends Uy.EventEmitter {
    static commandOptions(e) {
        return (0, By.commandOptions)(e);
    }
    static extend(e) {
        const t = (0, xy.attachExtensions)({
            BaseClass: _y,
            modulesExecutor: _y.prototype.commandsExecutor,
            modules: e?.modules,
            functionsExecutor: _y.prototype.functionsExecuter,
            functions: e?.functions,
            scriptsExecutor: _y.prototype.scriptsExecuter,
            scripts: e?.scripts
        });
        if (t !== _y) {
            t.prototype.Multi = Ky.default.extend(e);
        }
        return t;
    }
    static create(e) {
        return new (_y.extend(e))(e);
    }
    static parseURL(e) {
        const {hostname: t, port: r, protocol: n, username: s, password: o, pathname: i} = new Hy.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 my(this, Ey, "f");
    }
    get isOpen() {
        return my(this, py, "f").isOpen;
    }
    get isReady() {
        return my(this, py, "f").isReady;
    }
    get isPubSubActive() {
        return my(this, Sy, "f").isPubSubActive;
    }
    get v4() {
        if (!my(this, Ey, "f")?.legacyMode) {
            throw new Error('the client is not in "legacy mode"');
        }
        return my(this, Iy, "f");
    }
    constructor(e) {
        super();
        hy.add(this);
        Object.defineProperty(this, "commandOptions", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: _y.commandOptions
        });
        Ey.set(this, void 0);
        py.set(this, void 0);
        Sy.set(this, void 0);
        Ry.set(this, void 0);
        Iy.set(this, {});
        gy.set(this, 0);
        Dy.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
        });
        dy(this, Ey, my(this, hy, "m", Ay).call(this, e), "f");
        dy(this, Sy, my(this, hy, "m", vy).call(this), "f");
        dy(this, py, my(this, hy, "m", yy).call(this), "f");
        dy(this, Ry, my(this, hy, "m", Ny).call(this), "f");
        my(this, hy, "m", Ty).call(this);
    }
    duplicate(e) {
        return new (Object.getPrototypeOf(this).constructor)({
            ...my(this, Ey, "f"),
            ...e
        });
    }
    async connect() {
        dy(this, Ry, my(this, Ry, "f") ?? my(this, hy, "m", Ny).call(this), "f");
        await my(this, py, "f").connect();
        return this;
    }
    async commandsExecutor(e, t) {
        const {args: r, options: n} = (0, xy.transformCommandArguments)(e, t);
        return (0, xy.transformCommandReply)(e, await my(this, hy, "m", Ly).call(this, r, n), r.preserve);
    }
    sendCommand(e, t) {
        return my(this, hy, "m", Ly).call(this, e, t);
    }
    async functionsExecuter(e, t, r) {
        const {args: n, options: s} = (0, xy.transformCommandArguments)(e, t);
        return (0, xy.transformCommandReply)(e, await this.executeFunction(r, e, n, s), n.preserve);
    }
    executeFunction(e, t, r, n) {
        return my(this, hy, "m", Ly).call(this, (0, xy.fCallArguments)(e, t, r), n);
    }
    async scriptsExecuter(e, t) {
        const {args: r, options: n} = (0, xy.transformCommandArguments)(e, t);
        return (0, xy.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 my(this, hy, "m", Ly).call(this, n, r);
        } catch (t) {
            if (!t?.message?.startsWith?.("NOSCRIPT")) {
                throw t;
            }
            n[0] = "EVAL";
            n[1] = e.SCRIPT;
            return my(this, hy, "m", Ly).call(this, n, r);
        }
    }
    async SELECT(e, t) {
        if (!(0, By.isCommandOptions)(e)) {
            t = e;
            e = null;
        }
        await my(this, hy, "m", Ly).call(this, [ "SELECT", t.toString() ], e);
        dy(this, gy, t, "f");
    }
    SUBSCRIBE(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").subscribe(Wy.PubSubType.CHANNELS, e, t, r));
    }
    UNSUBSCRIBE(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").unsubscribe(Wy.PubSubType.CHANNELS, e, t, r));
    }
    PSUBSCRIBE(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").subscribe(Wy.PubSubType.PATTERNS, e, t, r));
    }
    PUNSUBSCRIBE(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").unsubscribe(Wy.PubSubType.PATTERNS, e, t, r));
    }
    SSUBSCRIBE(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").subscribe(Wy.PubSubType.SHARDED, e, t, r));
    }
    SUNSUBSCRIBE(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").unsubscribe(Wy.PubSubType.SHARDED, e, t, r));
    }
    getPubSubListeners(e) {
        return my(this, Sy, "f").getPubSubListeners(e);
    }
    extendPubSubChannelListeners(e, t, r) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").extendPubSubChannelListeners(e, t, r));
    }
    extendPubSubListeners(e, t) {
        return my(this, hy, "m", Cy).call(this, my(this, Sy, "f").extendPubSubListeners(e, t));
    }
    QUIT() {
        return my(this, py, "f").quit(async () => {
            if (my(this, Dy, "f")) clearTimeout(my(this, Dy, "f"));
            const e = my(this, Sy, "f").addCommand([ "QUIT" ]);
            my(this, hy, "m", My).call(this);
            const [t] = await Promise.all([ e, my(this, hy, "m", wy).call(this) ]);
            return t;
        });
    }
    executeIsolated(e) {
        if (!my(this, Ry, "f")) return Promise.reject(new Gy.ClientClosedError);
        return my(this, Ry, "f").use(e);
    }
    MULTI() {
        return new this.Multi(this.multiExecutor.bind(this), my(this, Ey, "f")?.legacyMode);
    }
    async multiExecutor(e, t, r) {
        if (!my(this, py, "f").isOpen) {
            return Promise.reject(new Gy.ClientClosedError);
        }
        const n = r ? Promise.all([ my(this, Sy, "f").addCommand([ "MULTI" ], {
            chainId: r
        }), my(this, hy, "m", Yy).call(this, e, r), my(this, Sy, "f").addCommand([ "EXEC" ], {
            chainId: r
        }) ]) : my(this, hy, "m", Yy).call(this, e);
        my(this, hy, "m", My).call(this);
        const s = await n;
        if (t !== undefined) {
            dy(this, gy, 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 (my(this, Dy, "f")) clearTimeout(my(this, Dy, "f"));
        my(this, Sy, "f").flushAll(new Gy.DisconnectsClientError);
        my(this, py, "f").disconnect();
        await my(this, hy, "m", wy).call(this);
    }
    ref() {
        my(this, py, "f").ref();
    }
    unref() {
        my(this, py, "f").unref();
    }
}

_y = RedisClient, Ey = new WeakMap, py = new WeakMap, Sy = new WeakMap, Ry = new WeakMap, 
Iy = new WeakMap, gy = new WeakMap, Dy = new WeakMap, hy = new WeakSet, Ay = function e(t) {
    if (t?.url) {
        const e = _y.parseURL(t.url);
        if (t.socket) {
            e.socket = Object.assign(t.socket, e.socket);
        }
        Object.assign(t, e);
    }
    if (t?.database) {
        dy(this, gy, t.database, "f");
    }
    return t;
}, vy = function e() {
    return new jy.default(my(this, Ey, "f")?.commandsQueueMaxLength, (e, t) => this.emit("sharded-channel-moved", e, t));
}, yy = function e() {
    const t = async () => {
        const e = [];
        if (my(this, gy, "f") !== 0) {
            e.push(my(this, Sy, "f").addCommand([ "SELECT", my(this, gy, "f").toString() ], {
                asap: true
            }));
        }
        if (my(this, Ey, "f")?.readonly) {
            e.push(my(this, Sy, "f").addCommand(Fy.default.READONLY.transformArguments(), {
                asap: true
            }));
        }
        if (!my(this, Ey, "f")?.disableClientInfo) {
            e.push(my(this, Sy, "f").addCommand([ "CLIENT", "SETINFO", "LIB-VER", Vy.version ], {
                asap: true
            }).catch(e => {
                if (!(e instanceof Gy.ErrorReply)) {
                    throw e;
                }
            }));
            e.push(my(this, Sy, "f").addCommand([ "CLIENT", "SETINFO", "LIB-NAME", my(this, Ey, "f")?.clientInfoTag ? `node-redis(${my(this, Ey, "f").clientInfoTag})` : "node-redis" ], {
                asap: true
            }).catch(e => {
                if (!(e instanceof Gy.ErrorReply)) {
                    throw e;
                }
            }));
        }
        if (my(this, Ey, "f")?.name) {
            e.push(my(this, Sy, "f").addCommand(Fy.default.CLIENT_SETNAME.transformArguments(my(this, Ey, "f").name), {
                asap: true
            }));
        }
        if (my(this, Ey, "f")?.username || my(this, Ey, "f")?.password) {
            e.push(my(this, Sy, "f").addCommand(Fy.default.AUTH.transformArguments({
                username: my(this, Ey, "f").username,
                password: my(this, Ey, "f").password ?? ""
            }), {
                asap: true
            }));
        }
        const t = my(this, Sy, "f").resubscribe();
        if (t) {
            e.push(t);
        }
        if (e.length) {
            my(this, hy, "m", My).call(this, true);
            await Promise.all(e);
        }
    };
    return new Xy.default(t, my(this, Ey, "f")?.socket).on("data", e => my(this, Sy, "f").onReplyChunk(e)).on("error", e => {
        this.emit("error", e);
        if (my(this, py, "f").isOpen && !my(this, Ey, "f")?.disableOfflineQueue) {
            my(this, Sy, "f").flushWaitingForReply(e);
        } else {
            my(this, Sy, "f").flushAll(e);
        }
    }).on("connect", () => {
        this.emit("connect");
    }).on("ready", () => {
        this.emit("ready");
        my(this, hy, "m", Py).call(this);
        my(this, hy, "m", My).call(this);
    }).on("reconnecting", () => this.emit("reconnecting")).on("drain", () => my(this, hy, "m", My).call(this)).on("end", () => this.emit("end"));
}, Ny = function e() {
    return (0, ky.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()
    }, my(this, Ey, "f")?.isolationPoolOptions);
}, Ty = function e() {
    var t, r;
    if (!my(this, Ey, "f")?.legacyMode) return;
    my(this, Iy, "f").sendCommand = my(this, hy, "m", Ly).bind(this);
    this.sendCommand = (...e) => {
        const t = my(this, hy, "m", Oy).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(Fy.default)) {
        my(this, hy, "m", by).call(this, e, n);
        (t = this)[r = e.toLowerCase()] ?? (t[r] = this[e]);
    }
    my(this, hy, "m", by).call(this, "SELECT");
    my(this, hy, "m", by).call(this, "select");
    my(this, hy, "m", by).call(this, "SUBSCRIBE");
    my(this, hy, "m", by).call(this, "subscribe");
    my(this, hy, "m", by).call(this, "PSUBSCRIBE");
    my(this, hy, "m", by).call(this, "pSubscribe");
    my(this, hy, "m", by).call(this, "UNSUBSCRIBE");
    my(this, hy, "m", by).call(this, "unsubscribe");
    my(this, hy, "m", by).call(this, "PUNSUBSCRIBE");
    my(this, hy, "m", by).call(this, "pUnsubscribe");
    my(this, hy, "m", by).call(this, "QUIT");
    my(this, hy, "m", by).call(this, "quit");
}, Oy = function e(...t) {
    const r = typeof t[t.length - 1] === "function" ? t.pop() : undefined;
    const n = my(this, hy, "m", Ly).call(this, (0, xy.transformLegacyCommandArguments)(t));
    if (r) return {
        promise: n,
        callback: r
    };
    n.catch(e => this.emit("error", e));
}, by = function e(t, r) {
    my(this, Iy, "f")[t] = this[t].bind(this);
    this[t] = r && r.TRANSFORM_LEGACY_REPLY && r.transformReply ? (...e) => {
        const n = my(this, hy, "m", Oy).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);
}, Py = function e() {
    if (!my(this, Ey, "f")?.pingInterval || !my(this, py, "f").isReady) return;
    clearTimeout(my(this, Dy, "f"));
    dy(this, Dy, setTimeout(() => {
        if (!my(this, py, "f").isReady) return;
        my(this, hy, "m", Ly).call(this, [ "PING" ]).then(e => this.emit("ping-interval", e)).catch(e => this.emit("error", e)).finally(() => my(this, hy, "m", e).call(this));
    }, my(this, Ey, "f").pingInterval), "f");
}, Ly = function e(t, r) {
    if (!my(this, py, "f").isOpen) {
        return Promise.reject(new Gy.ClientClosedError);
    } else if (r?.isolated) {
        return this.executeIsolated(e => e.sendCommand(t, {
            ...r,
            isolated: false
        }));
    } else if (!my(this, py, "f").isReady && my(this, Ey, "f")?.disableOfflineQueue) {
        return Promise.reject(new Gy.ClientOfflineError);
    }
    const n = my(this, Sy, "f").addCommand(t, r);
    my(this, hy, "m", My).call(this);
    return n;
}, Cy = function e(t) {
    if (t === undefined) return Promise.resolve();
    my(this, hy, "m", My).call(this);
    return t;
}, My = function e(t = false) {
    if (my(this, py, "f").writableNeedDrain || !t && !my(this, py, "f").isReady) {
        return;
    }
    my(this, py, "f").cork();
    while (!my(this, py, "f").writableNeedDrain) {
        const e = my(this, Sy, "f").getCommandToSend();
        if (e === undefined) break;
        my(this, py, "f").writeCommand(e);
    }
}, Yy = function e(t, r) {
    return Promise.all(t.map(({args: e}) => my(this, Sy, "f").addCommand(e, {
        chainId: r
    })));
}, wy = async function e() {
    await my(this, Ry, "f").drain();
    await my(this, Ry, "f").clear();
    dy(this, Ry, undefined, "f");
};

m.default = RedisClient;

(0, xy.attachCommands)({
    BaseClass: RedisClient,
    commands: Fy.default,
    executor: RedisClient.prototype.commandsExecutor
});

RedisClient.prototype.Multi = Ky.default;

var zy = {};

var Zy = {};

var qy = {
    exports: {}
};

qy.exports;

var $y = [ 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 Qy = 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 Jy = qy.exports = function e(t) {
    var r;
    var n = 0;
    var s = -1;
    var o = 0;
    var i = 0;
    var u = typeof t === "string" ? Qy(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 = $y[(r ^ i >> 8) & 255] ^ i << 8;
        } else if (n - 1 !== s) {
            return i & 16383;
        }
        o = $y[(r ^ o >> 8) & 255] ^ o << 8;
    }
    return o & 16383;
};

qy.exports.generateMulti = function e(t) {
    var r = 1;
    var n = t.length;
    var s = Jy(t[0]);
    while (r < n) {
        if (Jy(t[r++]) !== s) return -1;
    }
    return s;
};

var eN = qy.exports;

const tN = t(eN);

var rN = e && e.__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 nN = e && e.__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 sN, oN, iN, uN, aN, cN, fN, lN, mN, dN, hN, _N, EN, pN, SN, RN, IN, gN, AN, vN, yN, NN, TN, ON, bN;

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

const DN = m;

const PN = qI;

const LN = u;

const CN = zg;

const MN = eN;

class RedisClusterSlots {
    get isOpen() {
        return rN(this, fN, "f");
    }
    constructor(e, t) {
        sN.add(this);
        uN.set(this, void 0);
        aN.set(this, void 0);
        cN.set(this, void 0);
        Object.defineProperty(this, "slots", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Array(rN(oN, oN, "f", iN))
        });
        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
        });
        fN.set(this, false);
        IN.set(this, void 0);
        NN.set(this, void 0);
        nN(this, uN, e, "f");
        nN(this, aN, DN.default.extend(e), "f");
        nN(this, cN, t, "f");
    }
    async connect() {
        if (rN(this, fN, "f")) {
            throw new Error("Cluster already open");
        }
        nN(this, fN, true, "f");
        try {
            await rN(this, sN, "m", lN).call(this);
        } catch (e) {
            nN(this, fN, false, "f");
            throw e;
        }
    }
    nodeClient(e) {
        return e.client ?? rN(this, sN, "m", RN).call(this, e);
    }
    async rediscover(e) {
        nN(this, IN, rN(this, IN, "f") ?? rN(this, sN, "m", gN).call(this, e).finally(() => nN(this, IN, undefined, "f")), "f");
        return rN(this, IN, "f");
    }
    quit() {
        return rN(this, sN, "m", AN).call(this, e => e.quit());
    }
    disconnect() {
        return rN(this, sN, "m", AN).call(this, e => e.disconnect());
    }
    getClient(e, t) {
        if (!e) {
            return this.nodeClient(this.getRandomNode());
        }
        const r = MN(e);
        if (!t) {
            return this.nodeClient(this.slots[r].master);
        }
        return this.nodeClient(this.getSlotRandomNode(r));
    }
    getRandomNode() {
        nN(this, NN, rN(this, NN, "f") ?? rN(this, sN, "m", yN).call(this), "f");
        return rN(this, NN, "f").next().value;
    }
    getSlotRandomNode(e) {
        const t = this.slots[e];
        if (!t.replicas?.length) {
            return t.master;
        }
        t.nodesIterator ?? (t.nodesIterator = rN(this, sN, "m", TN).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 : rN(this, sN, "m", ON).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[MN(e)];
        return t.pubSubClient ?? rN(this, sN, "m", bN).call(this, t);
    }
    async executeShardedUnsubscribeCommand(e, t) {
        const {master: r} = this.slots[MN(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;
        }
    }
}

oN = RedisClusterSlots, uN = new WeakMap, aN = new WeakMap, cN = new WeakMap, fN = new WeakMap, 
IN = new WeakMap, NN = new WeakMap, sN = new WeakSet, lN = async function e() {
    let t = Math.floor(Math.random() * rN(this, uN, "f").rootNodes.length);
    for (let e = t; e < rN(this, uN, "f").rootNodes.length; e++) {
        if (await rN(this, sN, "m", dN).call(this, rN(this, uN, "f").rootNodes[e])) return;
    }
    for (let e = 0; e < t; e++) {
        if (await rN(this, sN, "m", dN).call(this, rN(this, uN, "f").rootNodes[e])) return;
    }
    throw new PN.RootNodesUnavailableError;
}, mN = function e() {
    this.slots = new Array(rN(oN, oN, "f", iN));
    this.shards = [];
    this.masters = [];
    this.replicas = [];
    nN(this, NN, undefined, "f");
}, dN = async function e(t) {
    const r = new Set;
    try {
        const e = await rN(this, sN, "m", hN).call(this, t), n = [], s = rN(this, uN, "f").minimizeConnections !== true;
        rN(this, sN, "m", mN).call(this);
        for (const {from: t, to: o, master: i, replicas: u} of e) {
            const e = {
                master: rN(this, sN, "m", pN).call(this, i, false, s, r, n)
            };
            if (rN(this, uN, "f").useReplicas) {
                e.replicas = u.map(e => rN(this, sN, "m", pN).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 (LN.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(CN.PubSubType.CHANNELS), t = this.pubSubNode.client.getPubSubListeners(CN.PubSubType.PATTERNS);
                if (e.size || t.size) {
                    n.push(rN(this, sN, "m", ON).call(this, {
                        [CN.PubSubType.CHANNELS]: e,
                        [CN.PubSubType.PATTERNS]: t
                    }));
                }
            }
        }
        for (const [e, t] of this.nodeByAddress.entries()) {
            if (r.has(e)) continue;
            if (t.client) {
                n.push(rN(this, sN, "m", vN).call(this, t.client, e => e.disconnect()));
            }
            const {pubSubClient: s} = t;
            if (s) {
                n.push(rN(this, sN, "m", vN).call(this, s, e => e.disconnect()));
            }
            this.nodeByAddress.delete(e);
        }
        await Promise.all(n);
        return true;
    } catch (e) {
        rN(this, cN, "f").call(this, "error", e);
        return false;
    }
}, hN = async function e(t) {
    const r = new (rN(this, aN, "f"))(rN(this, sN, "m", EN).call(this, t, true));
    r.on("error", e => rN(this, cN, "f").call(this, "error", e));
    await r.connect();
    try {
        return await r.clusterSlots();
    } finally {
        await r.disconnect();
    }
}, _N = function e(t) {
    switch (typeof rN(this, uN, "f").nodeAddressMap) {
      case "object":
        return rN(this, uN, "f").nodeAddressMap[t];

      case "function":
        return rN(this, uN, "f").nodeAddressMap(t);
    }
}, EN = function e(t, r) {
    let n;
    if (rN(this, uN, "f").defaults) {
        let e;
        if (rN(this, uN, "f").defaults.socket) {
            e = {
                ...rN(this, uN, "f").defaults.socket,
                ...t?.socket
            };
        } else {
            e = t?.socket;
        }
        n = {
            ...rN(this, uN, "f").defaults,
            ...t,
            socket: e
        };
    } else {
        n = t;
    }
    if (r) {
        n ?? (n = {});
        n.socket ?? (n.socket = {});
        n.socket.reconnectStrategy = false;
    }
    return n;
}, pN = 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(rN(this, sN, "m", RN).call(this, c));
        }
        this.nodeByAddress.set(a, c);
    }
    (s ? this.replicas : this.masters).push(c);
    return c;
}, SN = async function e(t, r = t.readonly) {
    const n = new (rN(this, aN, "f"))(rN(this, sN, "m", EN).call(this, {
        socket: rN(this, sN, "m", _N).call(this, t.address) ?? {
            host: t.host,
            port: t.port
        },
        readonly: r
    }));
    n.on("error", e => rN(this, cN, "f").call(this, "error", e));
    await n.connect();
    return n;
}, RN = function e(t) {
    const r = rN(this, sN, "m", SN).call(this, t).then(e => {
        t.client = e;
        return e;
    }).catch(e => {
        t.client = undefined;
        throw e;
    });
    t.client = r;
    return r;
}, gN = async function e(t) {
    if (await rN(this, sN, "m", dN).call(this, t.options)) return;
    return rN(this, sN, "m", lN).call(this);
}, AN = async function e(t) {
    nN(this, fN, false, "f");
    const r = [];
    for (const {master: e, replicas: n} of this.shards) {
        if (e.client) {
            r.push(rN(this, sN, "m", vN).call(this, e.client, t));
        }
        if (e.pubSubClient) {
            r.push(rN(this, sN, "m", vN).call(this, e.pubSubClient, t));
        }
        if (n) {
            for (const {client: e} of n) {
                if (e) {
                    r.push(rN(this, sN, "m", vN).call(this, e, t));
                }
            }
        }
    }
    if (this.pubSubNode) {
        r.push(rN(this, sN, "m", vN).call(this, this.pubSubNode.client, t));
        this.pubSubNode = undefined;
    }
    rN(this, sN, "m", mN).call(this);
    this.nodeByAddress.clear();
    await Promise.allSettled(r);
}, vN = function e(t, r) {
    return LN.types.isPromise(t) ? t.then(r) : r(t);
}, yN = 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;
        }
    }
}, TN = 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;
        }
    }
}, ON = 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: rN(this, sN, "m", SN).call(this, n, false).then(async e => {
            if (t) {
                await Promise.all([ e.extendPubSubListeners(CN.PubSubType.CHANNELS, t[CN.PubSubType.CHANNELS]), e.extendPubSubListeners(CN.PubSubType.PATTERNS, t[CN.PubSubType.PATTERNS]) ]);
            }
            this.pubSubNode.client = e;
            return e;
        }).catch(e => {
            this.pubSubNode = undefined;
            throw e;
        })
    };
    return this.pubSubNode.client;
}, bN = function e(t) {
    const r = rN(this, sN, "m", SN).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(CN.PubSubType.SHARDED, t, r);
            } catch (e) {
                rN(this, cN, "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;
};

iN = {
    value: 16384
};

Zy.default = RedisClusterSlots;

var YN = {};

var wN;

function FN() {
    if (wN) return YN;
    wN = 1;
    var t = e && e.__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 && e.__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(YN, "__esModule", {
        value: true
    });
    const i = h;
    const u = PA;
    const a = LA;
    const c = jN();
    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;
    YN.default = RedisClusterMultiCommand;
    (0, a.attachCommands)({
        BaseClass: RedisClusterMultiCommand,
        commands: i.default,
        executor: RedisClusterMultiCommand.prototype.commandsExecutor
    });
    return YN;
}

var XN;

function jN() {
    if (XN) return zy;
    XN = 1;
    var t = e && e.__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 = e && e.__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 s, o, i, u, a;
    Object.defineProperty(zy, "__esModule", {
        value: true
    });
    const c = h;
    const f = Zy;
    const l = LA;
    const m = r;
    const d = FN();
    const _ = qI;
    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, i, "f").slots;
        }
        get shards() {
            return t(this, i, "f").shards;
        }
        get masters() {
            return t(this, i, "f").masters;
        }
        get replicas() {
            return t(this, i, "f").replicas;
        }
        get nodeByAddress() {
            return t(this, i, "f").nodeByAddress;
        }
        get pubSubNode() {
            return t(this, i, "f").pubSubNode;
        }
        get isOpen() {
            return t(this, i, "f").isOpen;
        }
        constructor(e) {
            super();
            s.add(this);
            o.set(this, void 0);
            i.set(this, void 0);
            u.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
            });
            n(this, o, e, "f");
            n(this, i, new f.default(e, this.emit.bind(this)), "f");
            n(this, u, d.default.extend(e), "f");
        }
        duplicate(e) {
            return new (Object.getPrototypeOf(this).constructor)({
                ...t(this, o, "f"),
                ...e
            });
        }
        connect() {
            return t(this, i, "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, n, o) {
            return t(this, s, "m", a).call(this, e, r, e => e.sendCommand(n, 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, n, o, i) {
            return t(this, s, "m", a).call(this, RedisCluster.extractFirstKey(r, n, 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, n, o) {
            return t(this, s, "m", a).call(this, RedisCluster.extractFirstKey(e, r, n), e.IS_READ_ONLY, t => t.executeScript(e, n, o));
        }
        MULTI(e) {
            return new (t(this, u, "f"))((e, r, n) => t(this, s, "m", a).call(this, r, false, t => t.multiExecutor(e, undefined, n)), e);
        }
        async SUBSCRIBE(e, r, n) {
            return (await t(this, i, "f").getPubSubClient()).SUBSCRIBE(e, r, n);
        }
        async UNSUBSCRIBE(e, r, n) {
            return t(this, i, "f").executeUnsubscribeCommand(t => t.UNSUBSCRIBE(e, r, n));
        }
        async PSUBSCRIBE(e, r, n) {
            return (await t(this, i, "f").getPubSubClient()).PSUBSCRIBE(e, r, n);
        }
        async PUNSUBSCRIBE(e, r, n) {
            return t(this, i, "f").executeUnsubscribeCommand(t => t.PUNSUBSCRIBE(e, r, n));
        }
        async SSUBSCRIBE(e, r, n) {
            const s = t(this, o, "f").maxCommandRedirections ?? 16, u = Array.isArray(e) ? e[0] : e;
            let a = await t(this, i, "f").getShardedPubSubClient(u);
            for (let o = 0; ;o++) {
                try {
                    return await a.SSUBSCRIBE(e, r, n);
                } catch (e) {
                    if (++o > s || !(e instanceof _.ErrorReply)) {
                        throw e;
                    }
                    if (e.message.startsWith("MOVED")) {
                        await t(this, i, "f").rediscover(a);
                        a = await t(this, i, "f").getShardedPubSubClient(u);
                        continue;
                    }
                    throw e;
                }
            }
        }
        SUNSUBSCRIBE(e, r, n) {
            return t(this, i, "f").executeShardedUnsubscribeCommand(Array.isArray(e) ? e[0] : e, t => t.SUNSUBSCRIBE(e, r, n));
        }
        quit() {
            return t(this, i, "f").quit();
        }
        disconnect() {
            return t(this, i, "f").disconnect();
        }
        nodeClient(e) {
            return t(this, i, "f").nodeClient(e);
        }
        getRandomNode() {
            return t(this, i, "f").getRandomNode();
        }
        getSlotRandomNode(e) {
            return t(this, i, "f").getSlotRandomNode(e);
        }
        getMasters() {
            return this.masters;
        }
        getSlotMaster(e) {
            return this.slots[e].master;
        }
    }
    o = new WeakMap, i = new WeakMap, u = new WeakMap, s = new WeakSet, a = async function e(r, n, s) {
        const u = t(this, o, "f").maxCommandRedirections ?? 16;
        let a = await t(this, i, "f").getClient(r, n);
        for (let e = 0; ;e++) {
            try {
                return await s(a);
            } catch (s) {
                if (++e > u || !(s instanceof _.ErrorReply)) {
                    throw s;
                }
                if (s.message.startsWith("ASK")) {
                    const e = s.message.substring(s.message.lastIndexOf(" ") + 1);
                    let r = await t(this, i, "f").getMasterByAddress(e);
                    if (!r) {
                        await t(this, i, "f").rediscover(a);
                        r = await t(this, i, "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, i, "f").rediscover(a);
                    a = await t(this, i, "f").getClient(r, n);
                    continue;
                }
                throw s;
            }
        }
    };
    zy.default = RedisCluster;
    (0, l.attachCommands)({
        BaseClass: RedisCluster,
        commands: c.default,
        executor: RedisCluster.prototype.commandsExecutor
    });
    return zy;
}

var KN = {};

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

KN.scriptSha1 = KN.defineScript = void 0;

const UN = a;

function BN(e) {
    return {
        ...e,
        SHA1: xN(e.SCRIPT)
    };
}

KN.defineScript = BN;

function xN(e) {
    return (0, UN.createHash)("sha1").update(e).digest("hex");
}

KN.scriptSha1 = xN;

(function(t) {
    var r = e && e.__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 && e.__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 = m;
    const o = jN();
    t.createClient = s.default.create;
    t.commandOptions = s.default.commandOptions;
    t.createCluster = o.default.create;
    var i = KN;
    Object.defineProperty(t, "defineScript", {
        enumerable: true,
        get: function() {
            return i.defineScript;
        }
    });
    n(qI, t);
    var u = y;
    Object.defineProperty(t, "GeoReplyWith", {
        enumerable: true,
        get: function() {
            return u.GeoReplyWith;
        }
    });
    var a = pE;
    Object.defineProperty(t, "RedisFlushModes", {
        enumerable: true,
        get: function() {
            return a.RedisFlushModes;
        }
    });
})(l);

var kN = e => {
    const t = Math.min(2 ** e * 100, 2e3);
    const r = (Math.random() - .5) * 100;
    return t + r;
};

var GN = class extends f {
    _client=l.createClient();
    _namespace;
    _keyPrefixSeparator="::";
    _clearBatchSize=1e3;
    _useUnlink=true;
    _noNamespaceAffectsAll=false;
    _throwOnConnectError=true;
    _throwErrors=false;
    _connectionTimeout;
    constructor(e, t) {
        super();
        const r = {
            reconnectStrategy: kN
        };
        if (e) {
            if (typeof e === "string") {
                this._client = l.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 ? l.createClient(e) : l.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 = tN(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));
    }
};

const HN = l.createClient;

const WN = l.createCluster;

export { HN as createClient, WN as createCluster, GN as default, kN as defaultReconnectStrategy };