@upstash/redis 0.2.1 → 1.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1750 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// pkg/index.ts
+var pkg_exports = {};
+__export(pkg_exports, {
+  Redis: () => Redis,
+  UpstashError: () => UpstashError
+});
+
+// pkg/http.ts
+var import_isomorphic_fetch = require("isomorphic-fetch");
+
+// pkg/error.ts
+var UpstashError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UpstashError";
+  }
+};
+
+// pkg/http.ts
+var HttpClient = class {
+  constructor(config) {
+    var _a;
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.headers = (_a = config.headers) != null ? _a : {};
+  }
+  async request(method, req) {
+    if (!req.path) {
+      req.path = [];
+    }
+    const headers = __spreadValues(__spreadValues({
+      "Content-Type": "application/json"
+    }, this.headers), req.headers);
+    const res = await fetch([this.baseUrl, ...req.path].join("/"), {
+      method,
+      headers,
+      body: JSON.stringify(req.body)
+    });
+    const body = await res.json();
+    if (!res.ok) {
+      throw new UpstashError(body.error);
+    }
+    return body;
+  }
+  async post(req) {
+    return await this.request("POST", req);
+  }
+};
+
+// pkg/util.ts
+function parseRecursive(obj) {
+  return Array.isArray(obj) ? obj.map((o) => {
+    try {
+      return parseRecursive(o);
+    } catch {
+      return o;
+    }
+  }) : JSON.parse(obj);
+}
+function parseResponse(result) {
+  try {
+    return parseRecursive(result);
+  } catch {
+    return result;
+  }
+}
+
+// pkg/command.ts
+var Command = class {
+  constructor(command, opts) {
+    var _a;
+    this.command = command.map((c) => typeof c === "string" ? c : JSON.stringify(c));
+    this.deserialize = (_a = opts == null ? void 0 : opts.deserialize) != null ? _a : parseResponse;
+  }
+  async exec(client) {
+    const { result, error } = await client.post({
+      body: this.command
+    });
+    if (error) {
+      throw new UpstashError(error);
+    }
+    if (typeof result === "undefined") {
+      throw new Error(`Request did not return a result`);
+    }
+    return this.deserialize(result);
+  }
+};
+
+// pkg/commands/append.ts
+var AppendCommand = class extends Command {
+  constructor(key, value) {
+    super(["append", key, value]);
+  }
+};
+
+// pkg/commands/bitcount.ts
+var BitCountCommand = class extends Command {
+  constructor(key, start, end) {
+    const command = ["bitcount", key];
+    if (typeof start === "number") {
+      command.push(start);
+    }
+    if (typeof end === "number") {
+      command.push(end);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/bitop.ts
+var BitOpCommand = class extends Command {
+  constructor(op, destinationKey, sourceKey, ...sourceKeys) {
+    super(["bitop", op, destinationKey, sourceKey, ...sourceKeys]);
+  }
+};
+
+// pkg/commands/bitpos.ts
+var BitPosCommand = class extends Command {
+  constructor(key, start, end) {
+    super(["bitpos", key, start, end]);
+  }
+};
+
+// pkg/commands/dbsize.ts
+var DBSizeCommand = class extends Command {
+  constructor() {
+    super(["dbsize"]);
+  }
+};
+
+// pkg/commands/decr.ts
+var DecrCommand = class extends Command {
+  constructor(key) {
+    super(["decr", key]);
+  }
+};
+
+// pkg/commands/decrby.ts
+var DecrByCommand = class extends Command {
+  constructor(key, decrement) {
+    super(["decrby", key, decrement]);
+  }
+};
+
+// pkg/commands/del.ts
+var DelCommand = class extends Command {
+  constructor(...keys) {
+    super(["del", ...keys]);
+  }
+};
+
+// pkg/commands/echo.ts
+var EchoCommand = class extends Command {
+  constructor(message) {
+    super(["echo", message]);
+  }
+};
+
+// pkg/commands/exists.ts
+var ExistsCommand = class extends Command {
+  constructor(...keys) {
+    super(["exists", ...keys]);
+  }
+};
+
+// pkg/commands/expire.ts
+var ExpireCommand = class extends Command {
+  constructor(key, seconds) {
+    super(["expire", key, seconds]);
+  }
+};
+
+// pkg/commands/expireat.ts
+var ExpireAtCommand = class extends Command {
+  constructor(key, unix) {
+    super(["expireat", key, unix]);
+  }
+};
+
+// pkg/commands/flushall.ts
+var FlushAllCommand = class extends Command {
+  constructor(opts) {
+    const command = ["flushall"];
+    if (opts == null ? void 0 : opts.async) {
+      command.push("async");
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/flushdb.ts
+var FlushDBCommand = class extends Command {
+  constructor(opts) {
+    const command = ["flushdb"];
+    if (opts == null ? void 0 : opts.async) {
+      command.push("async");
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/get.ts
+var GetCommand = class extends Command {
+  constructor(key) {
+    super(["get", key]);
+  }
+};
+
+// pkg/commands/getbit.ts
+var GetBitCommand = class extends Command {
+  constructor(key, offset) {
+    super(["getbit", key, offset]);
+  }
+};
+
+// pkg/commands/getrange.ts
+var GetRangeCommand = class extends Command {
+  constructor(key, start, end) {
+    super(["getrange", key, start, end]);
+  }
+};
+
+// pkg/commands/getset.ts
+var GetSetCommand = class extends Command {
+  constructor(key, value) {
+    super(["getset", key, value]);
+  }
+};
+
+// pkg/commands/hdel.ts
+var HDelCommand = class extends Command {
+  constructor(key, field) {
+    super(["hdel", key, field]);
+  }
+};
+
+// pkg/commands/hexists.ts
+var HExistsCommand = class extends Command {
+  constructor(key, field) {
+    super(["hexists", key, field]);
+  }
+};
+
+// pkg/commands/hget.ts
+var HGetCommand = class extends Command {
+  constructor(key, field) {
+    super(["hget", key, field]);
+  }
+};
+
+// pkg/commands/hgetall.ts
+function deserialize(result) {
+  if (result.length === 0) {
+    return null;
+  }
+  const obj = {};
+  while (result.length >= 2) {
+    const key = result.shift();
+    const value = result.shift();
+    try {
+      obj[key] = JSON.parse(value);
+    } catch {
+      obj[key] = value;
+    }
+  }
+  return obj;
+}
+var HGetAllCommand = class extends Command {
+  constructor(key) {
+    super(["hgetall", key], { deserialize: (result) => deserialize(result) });
+  }
+};
+
+// pkg/commands/hincrby.ts
+var HIncrByCommand = class extends Command {
+  constructor(key, field, increment) {
+    super(["hincrby", key, field, increment]);
+  }
+};
+
+// pkg/commands/hincrbyfloat.ts
+var HIncrByFloatCommand = class extends Command {
+  constructor(key, field, increment) {
+    super(["hincrbyfloat", key, field, increment]);
+  }
+};
+
+// pkg/commands/hkeys.ts
+var HKeysCommand = class extends Command {
+  constructor(key) {
+    super(["hkeys", key]);
+  }
+};
+
+// pkg/commands/hlen.ts
+var HLenCommand = class extends Command {
+  constructor(key) {
+    super(["hlen", key]);
+  }
+};
+
+// pkg/commands/hmget.ts
+function deserialize2(fields, result) {
+  if (result.length === 0 || result.every((field) => field === null)) {
+    return null;
+  }
+  const obj = {};
+  for (let i = 0; i < fields.length; i++) {
+    try {
+      obj[fields[i]] = JSON.parse(result[i]);
+    } catch {
+      obj[fields[i]] = result[i];
+    }
+  }
+  return obj;
+}
+var HMGetCommand = class extends Command {
+  constructor(key, ...fields) {
+    super(["hmget", key, ...fields], {
+      deserialize: (result) => deserialize2(fields, result)
+    });
+  }
+};
+
+// pkg/commands/hmset.ts
+var HMSetCommand = class extends Command {
+  constructor(key, kv) {
+    super(["hmset", key, ...Object.entries(kv).flatMap(([field, value]) => [field, value])]);
+  }
+};
+
+// pkg/commands/hscan.ts
+var HScanCommand = class extends Command {
+  constructor(key, cursor, opts) {
+    const command = ["hscan", key, cursor];
+    if (opts == null ? void 0 : opts.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof (opts == null ? void 0 : opts.count) === "number") {
+      command.push("count", opts.count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/hset.ts
+var HSetCommand = class extends Command {
+  constructor(key, field, value) {
+    super(["hset", key, field, value]);
+  }
+};
+
+// pkg/commands/hsetnx.ts
+var HSetNXCommand = class extends Command {
+  constructor(key, field, value) {
+    super(["hsetnx", key, field, value]);
+  }
+};
+
+// pkg/commands/hstrlen.ts
+var HStrLenCommand = class extends Command {
+  constructor(key, field) {
+    super(["hstrlen", key, field]);
+  }
+};
+
+// pkg/commands/hvals.ts
+var HValsCommand = class extends Command {
+  constructor(key) {
+    super(["hvals", key]);
+  }
+};
+
+// pkg/commands/incr.ts
+var IncrCommand = class extends Command {
+  constructor(key) {
+    super(["incr", key]);
+  }
+};
+
+// pkg/commands/incrby.ts
+var IncrByCommand = class extends Command {
+  constructor(key, value) {
+    super(["incrby", key, value]);
+  }
+};
+
+// pkg/commands/incrbyfloat.ts
+var IncrByFloatCommand = class extends Command {
+  constructor(key, value) {
+    super(["incrbyfloat", key, value]);
+  }
+};
+
+// pkg/commands/keys.ts
+var KeysCommand = class extends Command {
+  constructor(pattern) {
+    super(["keys", pattern]);
+  }
+};
+
+// pkg/commands/lindex.ts
+var LIndexCommand = class extends Command {
+  constructor(key, index) {
+    super(["lindex", key, index]);
+  }
+};
+
+// pkg/commands/linsert.ts
+var LInsertCommand = class extends Command {
+  constructor(key, direction, pivot, value) {
+    super(["linsert", key, direction, pivot, value]);
+  }
+};
+
+// pkg/commands/llen.ts
+var LLenCommand = class extends Command {
+  constructor(key) {
+    super(["llen", key]);
+  }
+};
+
+// pkg/commands/lpop.ts
+var LPopCommand = class extends Command {
+  constructor(key) {
+    super(["lpop", key]);
+  }
+};
+
+// pkg/commands/lpush.ts
+var LPushCommand = class extends Command {
+  constructor(key, ...elements) {
+    super(["lpush", key, ...elements]);
+  }
+};
+
+// pkg/commands/lpushx.ts
+var LPushXCommand = class extends Command {
+  constructor(key, ...elements) {
+    super(["lpushx", key, ...elements]);
+  }
+};
+
+// pkg/commands/lrange.ts
+var LRangeCommand = class extends Command {
+  constructor(key, start, end) {
+    super(["lrange", key, start, end]);
+  }
+};
+
+// pkg/commands/lrem.ts
+var LRemCommand = class extends Command {
+  constructor(key, count, value) {
+    super(["lrem", key, count, value]);
+  }
+};
+
+// pkg/commands/lset.ts
+var LSetCommand = class extends Command {
+  constructor(key, value, index) {
+    super(["lset", key, index, value]);
+  }
+};
+
+// pkg/commands/ltrim.ts
+var LTrimCommand = class extends Command {
+  constructor(key, start, end) {
+    super(["ltrim", key, start, end]);
+  }
+};
+
+// pkg/commands/mget.ts
+var MGetCommand = class extends Command {
+  constructor(...keys) {
+    super(["mget", ...keys]);
+  }
+};
+
+// pkg/commands/mset.ts
+var MSetCommand = class extends Command {
+  constructor(kv) {
+    super(["mset", ...Object.entries(kv).flatMap(([key, value]) => [key, value])]);
+  }
+};
+
+// pkg/commands/msetnx.ts
+var MSetNXCommand = class extends Command {
+  constructor(kv) {
+    super(["msetnx", ...Object.entries(kv).flatMap((_) => _)]);
+  }
+};
+
+// pkg/commands/persist.ts
+var PersistCommand = class extends Command {
+  constructor(key) {
+    super(["persist", key]);
+  }
+};
+
+// pkg/commands/pexpire.ts
+var PExpireCommand = class extends Command {
+  constructor(key, milliseconds) {
+    super(["pexpire", key, milliseconds]);
+  }
+};
+
+// pkg/commands/pexpireat.ts
+var PExpireAtCommand = class extends Command {
+  constructor(key, unix) {
+    super(["pexpireat", key, unix]);
+  }
+};
+
+// pkg/commands/ping.ts
+var PingCommand = class extends Command {
+  constructor(message) {
+    const command = ["ping"];
+    if (typeof message !== "undefined") {
+      command.push(message);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/psetex.ts
+var PSetEXCommand = class extends Command {
+  constructor(key, ttl, value) {
+    super(["psetex", key, ttl, value]);
+  }
+};
+
+// pkg/commands/pttl.ts
+var PTtlCommand = class extends Command {
+  constructor(key) {
+    super(["pttl", key]);
+  }
+};
+
+// pkg/commands/randomkey.ts
+var RandomKeyCommand = class extends Command {
+  constructor() {
+    super(["randomkey"]);
+  }
+};
+
+// pkg/commands/rename.ts
+var RenameCommand = class extends Command {
+  constructor(source, destination) {
+    super(["rename", source, destination]);
+  }
+};
+
+// pkg/commands/renamenx.ts
+var RenameNXCommand = class extends Command {
+  constructor(source, destination) {
+    super(["renamenx", source, destination]);
+  }
+};
+
+// pkg/commands/rpop.ts
+var RPopCommand = class extends Command {
+  constructor(key) {
+    super(["rpop", key]);
+  }
+};
+
+// pkg/commands/rpush.ts
+var RPushCommand = class extends Command {
+  constructor(key, ...elements) {
+    super(["rpush", key, ...elements]);
+  }
+};
+
+// pkg/commands/rpushx.ts
+var RPushXCommand = class extends Command {
+  constructor(key, ...elements) {
+    super(["rpushx", key, ...elements]);
+  }
+};
+
+// pkg/commands/sadd.ts
+var SAddCommand = class extends Command {
+  constructor(key, ...members) {
+    super(["sadd", key, ...members]);
+  }
+};
+
+// pkg/commands/scan.ts
+var ScanCommand = class extends Command {
+  constructor(cursor, opts) {
+    const command = ["scan", cursor];
+    if (opts == null ? void 0 : opts.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof (opts == null ? void 0 : opts.count) === "number") {
+      command.push("count", opts.count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/scard.ts
+var SCardCommand = class extends Command {
+  constructor(key) {
+    super(["scard", key]);
+  }
+};
+
+// pkg/commands/sdiff.ts
+var SDiffCommand = class extends Command {
+  constructor(key, ...keys) {
+    super(["sdiff", key, ...keys]);
+  }
+};
+
+// pkg/commands/sdiffstore.ts
+var SDiffStoreCommand = class extends Command {
+  constructor(destination, ...keys) {
+    super(["sdiffstore", destination, ...keys]);
+  }
+};
+
+// pkg/commands/set.ts
+var SetCommand = class extends Command {
+  constructor(key, value, opts) {
+    const command = ["set", key, value];
+    if (opts) {
+      if ("ex" in opts && typeof opts.ex === "number") {
+        command.push("ex", opts.ex);
+      } else if ("px" in opts && typeof opts.px === "number") {
+        command.push("px", opts.px);
+      }
+      if ("nx" in opts && opts.nx) {
+        command.push("nx");
+      } else if ("xx" in opts && opts.xx) {
+        command.push("xx");
+      }
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/setbit.ts
+var SetBitCommand = class extends Command {
+  constructor(key, offset, value) {
+    super(["setbit", key, offset, value]);
+  }
+};
+
+// pkg/commands/setex.ts
+var SetExCommand = class extends Command {
+  constructor(key, ttl, value) {
+    super(["setex", key, ttl, value]);
+  }
+};
+
+// pkg/commands/setnx.ts
+var SetNxCommand = class extends Command {
+  constructor(key, value) {
+    super(["setnx", key, value]);
+  }
+};
+
+// pkg/commands/setrange.ts
+var SetRangeCommand = class extends Command {
+  constructor(key, offset, value) {
+    super(["setrange", key, offset, value]);
+  }
+};
+
+// pkg/commands/sinter.ts
+var SInterCommand = class extends Command {
+  constructor(key, ...keys) {
+    super(["sinter", key, ...keys]);
+  }
+};
+
+// pkg/commands/sinterstore.ts
+var SInterStoreCommand = class extends Command {
+  constructor(destination, key, ...keys) {
+    super(["sinterstore", destination, key, ...keys]);
+  }
+};
+
+// pkg/commands/sismember.ts
+var SIsMemberCommand = class extends Command {
+  constructor(key, member) {
+    super(["sismember", key, member]);
+  }
+};
+
+// pkg/commands/smembers.ts
+var SMembersCommand = class extends Command {
+  constructor(key) {
+    super(["smembers", key]);
+  }
+};
+
+// pkg/commands/smove.ts
+var SMoveCommand = class extends Command {
+  constructor(source, destination, member) {
+    super(["smove", source, destination, member]);
+  }
+};
+
+// pkg/commands/spop.ts
+var SPopCommand = class extends Command {
+  constructor(key, count) {
+    const command = ["spop", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/srandmember.ts
+var SRandMemberCommand = class extends Command {
+  constructor(key, count) {
+    const command = ["srandmember", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/srem.ts
+var SRemCommand = class extends Command {
+  constructor(key, ...members) {
+    super(["srem", key, ...members]);
+  }
+};
+
+// pkg/commands/sscan.ts
+var SScanCommand = class extends Command {
+  constructor(key, cursor, opts) {
+    const command = ["sscan", key, cursor];
+    if (opts == null ? void 0 : opts.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof (opts == null ? void 0 : opts.count) === "number") {
+      command.push("count", opts.count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/strlen.ts
+var StrLenCommand = class extends Command {
+  constructor(key) {
+    super(["strlen", key]);
+  }
+};
+
+// pkg/commands/sunion.ts
+var SUnionCommand = class extends Command {
+  constructor(key, ...keys) {
+    super(["sunion", key, ...keys]);
+  }
+};
+
+// pkg/commands/sunionstore.ts
+var SUnionStoreCommand = class extends Command {
+  constructor(destination, key, ...keys) {
+    super(["sunionstore", destination, key, ...keys]);
+  }
+};
+
+// pkg/commands/time.ts
+var TimeCommand = class extends Command {
+  constructor() {
+    super(["time"]);
+  }
+};
+
+// pkg/commands/touch.ts
+var TouchCommand = class extends Command {
+  constructor(...keys) {
+    super(["touch", ...keys]);
+  }
+};
+
+// pkg/commands/ttl.ts
+var TtlCommand = class extends Command {
+  constructor(key) {
+    super(["ttl", key]);
+  }
+};
+
+// pkg/commands/type.ts
+var TypeCommand = class extends Command {
+  constructor(key) {
+    super(["type", key]);
+  }
+};
+
+// pkg/commands/unlink.ts
+var UnlinkCommand = class extends Command {
+  constructor(...keys) {
+    super(["unlink", ...keys]);
+  }
+};
+
+// pkg/commands/zadd.ts
+var ZAddCommand = class extends Command {
+  constructor(key, arg1, ...arg2) {
+    const command = ["zadd", key];
+    if ("nx" in arg1 && arg1.nx) {
+      command.push("nx");
+    } else if ("xx" in arg1 && arg1.xx) {
+      command.push("xx");
+    }
+    if ("ch" in arg1 && arg1.ch) {
+      command.push("ch");
+    }
+    if ("incr" in arg1 && arg1.incr) {
+      command.push("incr");
+    }
+    if ("score" in arg1 && "member" in arg1) {
+      command.push(arg1.score, arg1.member);
+    }
+    command.push(...arg2.flatMap(({ score, member }) => [score, member]));
+    super(command);
+  }
+};
+
+// pkg/commands/zcard.ts
+var ZCardCommand = class extends Command {
+  constructor(key) {
+    super(["zcard", key]);
+  }
+};
+
+// pkg/commands/zcount.ts
+var ZCountCommand = class extends Command {
+  constructor(key, min, max) {
+    super(["zcount", key, min, max]);
+  }
+};
+
+// pkg/commands/zincrby.ts
+var ZIncrByComand = class extends Command {
+  constructor(key, increment, member) {
+    super(["zincrby", key, increment, member]);
+  }
+};
+
+// pkg/commands/zinterstore.ts
+var ZInterStoreCommand = class extends Command {
+  constructor(destination, numKeys, keyOrKeys, opts) {
+    const command = ["zinterstore", destination, numKeys];
+    if (Array.isArray(keyOrKeys)) {
+      command.push(...keyOrKeys);
+    } else {
+      command.push(keyOrKeys);
+    }
+    if (opts) {
+      if ("weights" in opts && opts.weights) {
+        command.push("weights", ...opts.weights);
+      } else if ("weight" in opts && typeof opts.weight === "number") {
+        command.push("weights", opts.weight);
+      }
+      if ("aggregate" in opts) {
+        command.push("aggregate", opts.aggregate);
+      }
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/zlexcount.ts
+var ZLexCountCommand = class extends Command {
+  constructor(key, min, max) {
+    super(["zlexcount", key, min, max]);
+  }
+};
+
+// pkg/commands/zpopmax.ts
+var ZPopMaxCommand = class extends Command {
+  constructor(key, count) {
+    const command = ["zpopmax", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/zpopmin.ts
+var ZPopMinCommand = class extends Command {
+  constructor(key, count) {
+    const command = ["zpopmin", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/zrange.ts
+var ZRangeCommand = class extends Command {
+  constructor(key, min, max, opts) {
+    const command = ["zrange", key, min, max];
+    if (opts == null ? void 0 : opts.withScores) {
+      command.push("withscores");
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/zrank.ts
+var ZRankCommand = class extends Command {
+  constructor(key, member) {
+    super(["zrank", key, member]);
+  }
+};
+
+// pkg/commands/zrem.ts
+var ZRemCommand = class extends Command {
+  constructor(key, ...members) {
+    super(["zrem", key, ...members]);
+  }
+};
+
+// pkg/commands/zremrangebylex.ts
+var ZRemRangeByLexCommand = class extends Command {
+  constructor(key, min, max) {
+    super(["zremrangebylex", key, min, max]);
+  }
+};
+
+// pkg/commands/zremrangebyrank.ts
+var ZRemRangeByRankCommand = class extends Command {
+  constructor(key, start, stop) {
+    super(["zremrangebyrank", key, start, stop]);
+  }
+};
+
+// pkg/commands/zremrangebyscore.ts
+var ZRemRangeByScoreCommand = class extends Command {
+  constructor(key, min, max) {
+    super(["zremrangebyscore", key, min, max]);
+  }
+};
+
+// pkg/commands/zrevrank.ts
+var ZRevRankCommand = class extends Command {
+  constructor(key, member) {
+    super(["zrevrank", key, member]);
+  }
+};
+
+// pkg/commands/zscan.ts
+var ZScanCommand = class extends Command {
+  constructor(key, cursor, opts) {
+    const command = ["zscan", key, cursor];
+    if (opts == null ? void 0 : opts.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof (opts == null ? void 0 : opts.count) === "number") {
+      command.push("count", opts.count);
+    }
+    super(command);
+  }
+};
+
+// pkg/commands/zscore.ts
+var ZScoreCommand = class extends Command {
+  constructor(key, member) {
+    super(["zscore", key, member]);
+  }
+};
+
+// pkg/commands/zunionstore.ts
+var ZUnionStoreCommand = class extends Command {
+  constructor(destination, numKeys, keyOrKeys, opts) {
+    const command = ["zunionstore", destination, numKeys];
+    if (Array.isArray(keyOrKeys)) {
+      command.push(...keyOrKeys);
+    } else {
+      command.push(keyOrKeys);
+    }
+    if (opts) {
+      if ("weights" in opts && opts.weights) {
+        command.push("weights", ...opts.weights);
+      } else if ("weight" in opts && typeof opts.weight === "number") {
+        command.push("weights", opts.weight);
+      }
+      if ("aggregate" in opts) {
+        command.push("aggregate", opts.aggregate);
+      }
+    }
+    super(command);
+  }
+};
+
+// pkg/pipeline.ts
+var Pipeline = class {
+  constructor(client) {
+    this.client = client;
+    this.commands = [];
+  }
+  async exec() {
+    if (this.commands.length === 0) {
+      throw new Error("Pipeline is empty");
+    }
+    const res = await this.client.post({
+      path: ["pipeline"],
+      body: Object.values(this.commands).map((c) => c.command)
+    });
+    return res.map(({ error, result }, i) => {
+      if (error) {
+        throw new UpstashError(`Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`);
+      }
+      return this.commands[i].deserialize(result);
+    });
+  }
+  chain(command) {
+    this.commands.push(command);
+    return this;
+  }
+  append(...args) {
+    return this.chain(new AppendCommand(...args));
+  }
+  bitcount(...args) {
+    return this.chain(new BitCountCommand(...args));
+  }
+  bitop(op, destinationKey, sourceKey, ...sourceKeys) {
+    return this.chain(new BitOpCommand(op, destinationKey, sourceKey, ...sourceKeys));
+  }
+  bitpos(...args) {
+    return this.chain(new BitPosCommand(...args));
+  }
+  dbsize() {
+    return this.chain(new DBSizeCommand());
+  }
+  decr(...args) {
+    return this.chain(new DecrCommand(...args));
+  }
+  decrby(...args) {
+    return this.chain(new DecrByCommand(...args));
+  }
+  del(...args) {
+    return this.chain(new DelCommand(...args));
+  }
+  echo(...args) {
+    return this.chain(new EchoCommand(...args));
+  }
+  exists(...args) {
+    return this.chain(new ExistsCommand(...args));
+  }
+  expire(...args) {
+    return this.chain(new ExpireCommand(...args));
+  }
+  expireat(...args) {
+    return this.chain(new ExpireAtCommand(...args));
+  }
+  flushall(...args) {
+    return this.chain(new FlushAllCommand(...args));
+  }
+  flushdb(...args) {
+    return this.chain(new FlushDBCommand(...args));
+  }
+  get(...args) {
+    return this.chain(new GetCommand(...args));
+  }
+  getbit(...args) {
+    return this.chain(new GetBitCommand(...args));
+  }
+  getrange(...args) {
+    return this.chain(new GetRangeCommand(...args));
+  }
+  getset(key, value) {
+    return this.chain(new GetSetCommand(key, value));
+  }
+  hdel(...args) {
+    return this.chain(new HDelCommand(...args));
+  }
+  hexists(...args) {
+    return this.chain(new HExistsCommand(...args));
+  }
+  hget(...args) {
+    return this.chain(new HGetCommand(...args));
+  }
+  hgetall(...args) {
+    return this.chain(new HGetAllCommand(...args));
+  }
+  hincrby(...args) {
+    return this.chain(new HIncrByCommand(...args));
+  }
+  hincrbyfloat(...args) {
+    return this.chain(new HIncrByFloatCommand(...args));
+  }
+  hkeys(...args) {
+    return this.chain(new HKeysCommand(...args));
+  }
+  hlen(...args) {
+    return this.chain(new HLenCommand(...args));
+  }
+  hmget(...args) {
+    return this.chain(new HMGetCommand(...args));
+  }
+  hmset(key, kv) {
+    return this.chain(new HMSetCommand(key, kv));
+  }
+  hscan(...args) {
+    return this.chain(new HScanCommand(...args));
+  }
+  hset(key, field, value) {
+    return this.chain(new HSetCommand(key, field, value));
+  }
+  hsetnx(key, field, value) {
+    return this.chain(new HSetNXCommand(key, field, value));
+  }
+  hstrlen(...args) {
+    return this.chain(new HStrLenCommand(...args));
+  }
+  hvals(...args) {
+    return this.chain(new HValsCommand(...args));
+  }
+  incr(...args) {
+    return this.chain(new IncrCommand(...args));
+  }
+  incrby(...args) {
+    return this.chain(new IncrByCommand(...args));
+  }
+  incrbyfloat(...args) {
+    return this.chain(new IncrByFloatCommand(...args));
+  }
+  keys(...args) {
+    return this.chain(new KeysCommand(...args));
+  }
+  lindex(...args) {
+    return this.chain(new LIndexCommand(...args));
+  }
+  linsert(key, direction, pivot, value) {
+    return this.chain(new LInsertCommand(key, direction, pivot, value));
+  }
+  llen(...args) {
+    return this.chain(new LLenCommand(...args));
+  }
+  lpop(...args) {
+    return this.chain(new LPopCommand(...args));
+  }
+  lpush(key, ...elements) {
+    return this.chain(new LPushCommand(key, ...elements));
+  }
+  lpushx(key, ...elements) {
+    return this.chain(new LPushXCommand(key, ...elements));
+  }
+  lrange(...args) {
+    return this.chain(new LRangeCommand(...args));
+  }
+  lrem(key, count, value) {
+    return this.chain(new LRemCommand(key, count, value));
+  }
+  lset(key, value, index) {
+    return this.chain(new LSetCommand(key, value, index));
+  }
+  ltrim(...args) {
+    return this.chain(new LTrimCommand(...args));
+  }
+  mget(...args) {
+    return this.chain(new MGetCommand(...args));
+  }
+  mset(kv) {
+    return this.chain(new MSetCommand(kv));
+  }
+  msetnx(kv) {
+    return this.chain(new MSetNXCommand(kv));
+  }
+  persist(...args) {
+    return this.chain(new PersistCommand(...args));
+  }
+  pexpire(...args) {
+    return this.chain(new PExpireCommand(...args));
+  }
+  pexpireat(...args) {
+    return this.chain(new PExpireAtCommand(...args));
+  }
+  ping(...args) {
+    return this.chain(new PingCommand(...args));
+  }
+  psetex(key, ttl, value) {
+    return this.chain(new PSetEXCommand(key, ttl, value));
+  }
+  pttl(...args) {
+    return this.chain(new PTtlCommand(...args));
+  }
+  randomkey() {
+    return this.chain(new RandomKeyCommand());
+  }
+  rename(...args) {
+    return this.chain(new RenameCommand(...args));
+  }
+  renamenx(...args) {
+    return this.chain(new RenameNXCommand(...args));
+  }
+  rpop(...args) {
+    return this.chain(new RPopCommand(...args));
+  }
+  rpush(key, ...elements) {
+    return this.chain(new RPushCommand(key, ...elements));
+  }
+  rpushx(key, ...elements) {
+    return this.chain(new RPushXCommand(key, ...elements));
+  }
+  sadd(key, ...members) {
+    return this.chain(new SAddCommand(key, ...members));
+  }
+  scan(...args) {
+    return this.chain(new ScanCommand(...args));
+  }
+  scard(...args) {
+    return this.chain(new SCardCommand(...args));
+  }
+  sdiff(...args) {
+    return this.chain(new SDiffCommand(...args));
+  }
+  sdiffstore(...args) {
+    return this.chain(new SDiffStoreCommand(...args));
+  }
+  set(key, value, opts) {
+    return this.chain(new SetCommand(key, value, opts));
+  }
+  setbit(...args) {
+    return this.chain(new SetBitCommand(...args));
+  }
+  setex(key, ttl, value) {
+    return this.chain(new SetExCommand(key, ttl, value));
+  }
+  setnx(key, value) {
+    return this.chain(new SetNxCommand(key, value));
+  }
+  setrange(...args) {
+    return this.chain(new SetRangeCommand(...args));
+  }
+  sinter(...args) {
+    return this.chain(new SInterCommand(...args));
+  }
+  sinterstore(...args) {
+    return this.chain(new SInterStoreCommand(...args));
+  }
+  sismember(key, member) {
+    return this.chain(new SIsMemberCommand(key, member));
+  }
+  smembers(...args) {
+    return this.chain(new SMembersCommand(...args));
+  }
+  smove(source, destination, member) {
+    return this.chain(new SMoveCommand(source, destination, member));
+  }
+  spop(...args) {
+    return this.chain(new SPopCommand(...args));
+  }
+  srandmember(...args) {
+    return this.chain(new SRandMemberCommand(...args));
+  }
+  srem(key, ...members) {
+    return this.chain(new SRemCommand(key, ...members));
+  }
+  sscan(...args) {
+    return this.chain(new SScanCommand(...args));
+  }
+  strlen(...args) {
+    return this.chain(new StrLenCommand(...args));
+  }
+  sunion(...args) {
+    return this.chain(new SUnionCommand(...args));
+  }
+  sunionstore(...args) {
+    return this.chain(new SUnionStoreCommand(...args));
+  }
+  time() {
+    return this.chain(new TimeCommand());
+  }
+  touch(...args) {
+    return this.chain(new TouchCommand(...args));
+  }
+  ttl(...args) {
+    return this.chain(new TtlCommand(...args));
+  }
+  type(...args) {
+    return this.chain(new TypeCommand(...args));
+  }
+  unlink(...args) {
+    return this.chain(new UnlinkCommand(...args));
+  }
+  zadd(key, arg1, ...arg2) {
+    return this.chain(new ZAddCommand(key, arg1, ...arg2));
+  }
+  zcard(...args) {
+    return this.chain(new ZCardCommand(...args));
+  }
+  zcount(...args) {
+    return this.chain(new ZCountCommand(...args));
+  }
+  zincrby(key, increment, member) {
+    return this.chain(new ZIncrByComand(key, increment, member));
+  }
+  zinterstore(...args) {
+    return this.chain(new ZInterStoreCommand(...args));
+  }
+  zlexcount(...args) {
+    return this.chain(new ZLexCountCommand(...args));
+  }
+  zpopmax(...args) {
+    return this.chain(new ZPopMaxCommand(...args));
+  }
+  zpopmin(...args) {
+    return this.chain(new ZPopMinCommand(...args));
+  }
+  zrange(...args) {
+    return this.chain(new ZRangeCommand(...args));
+  }
+  zrank(key, member) {
+    return this.chain(new ZRankCommand(key, member));
+  }
+  zrem(key, ...members) {
+    return this.chain(new ZRemCommand(key, ...members));
+  }
+  zremrangebylex(...args) {
+    return this.chain(new ZRemRangeByLexCommand(...args));
+  }
+  zremrangebyrank(...args) {
+    return this.chain(new ZRemRangeByRankCommand(...args));
+  }
+  zremrangebyscore(...args) {
+    return this.chain(new ZRemRangeByScoreCommand(...args));
+  }
+  zrevrank(key, member) {
+    return this.chain(new ZRevRankCommand(key, member));
+  }
+  zscan(...args) {
+    return this.chain(new ZScanCommand(...args));
+  }
+  zscore(key, member) {
+    return this.chain(new ZScoreCommand(key, member));
+  }
+  zunionstore(...args) {
+    return this.chain(new ZUnionStoreCommand(...args));
+  }
+};
+
+// pkg/redis.ts
+var Redis = class {
+  constructor(config) {
+    this.client = new HttpClient({
+      baseUrl: config.url,
+      headers: {
+        authorization: `Bearer ${config.token}`
+      }
+    });
+  }
+  static fromEnv() {
+    if (typeof (process == null ? void 0 : process.env) === "undefined") {
+      throw new Error("Unable to get environment variables, `process.env` is undefined. If you are deploying to cloudflare, please use `fromCloudflareEnv()` instead");
+    }
+    const url = process.env["UPSTASH_REDIS_REST_URL"];
+    if (!url) {
+      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_URL`");
+    }
+    const token = process.env["UPSTASH_REDIS_REST_TOKEN"];
+    if (!token) {
+      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`");
+    }
+    return new Redis({ url, token });
+  }
+  static fromCloudflareEnv() {
+    const url = UPSTASH_REDIS_REST_URL;
+    const token = UPSTASH_REDIS_REST_TOKEN;
+    if (!url) {
+      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_URL`");
+    }
+    if (!token) {
+      throw new Error("Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`");
+    }
+    return new Redis({ url, token });
+  }
+  pipeline() {
+    return new Pipeline(this.client);
+  }
+  append(...args) {
+    return new AppendCommand(...args).exec(this.client);
+  }
+  bitcount(...args) {
+    return new BitCountCommand(...args).exec(this.client);
+  }
+  bitop(op, destinationKey, sourceKey, ...sourceKeys) {
+    return new BitOpCommand(op, destinationKey, sourceKey, ...sourceKeys).exec(this.client);
+  }
+  bitpos(...args) {
+    return new BitPosCommand(...args).exec(this.client);
+  }
+  dbsize() {
+    return new DBSizeCommand().exec(this.client);
+  }
+  decr(...args) {
+    return new DecrCommand(...args).exec(this.client);
+  }
+  decrby(...args) {
+    return new DecrByCommand(...args).exec(this.client);
+  }
+  del(...args) {
+    return new DelCommand(...args).exec(this.client);
+  }
+  echo(...args) {
+    return new EchoCommand(...args).exec(this.client);
+  }
+  exists(...args) {
+    return new ExistsCommand(...args).exec(this.client);
+  }
+  expire(...args) {
+    return new ExpireCommand(...args).exec(this.client);
+  }
+  expireat(...args) {
+    return new ExpireAtCommand(...args).exec(this.client);
+  }
+  flushall(...args) {
+    return new FlushAllCommand(...args).exec(this.client);
+  }
+  flushdb(...args) {
+    return new FlushDBCommand(...args).exec(this.client);
+  }
+  get(...args) {
+    return new GetCommand(...args).exec(this.client);
+  }
+  getbit(...args) {
+    return new GetBitCommand(...args).exec(this.client);
+  }
+  getrange(...args) {
+    return new GetRangeCommand(...args).exec(this.client);
+  }
+  getset(key, value) {
+    return new GetSetCommand(key, value).exec(this.client);
+  }
+  hdel(...args) {
+    return new HDelCommand(...args).exec(this.client);
+  }
+  hexists(...args) {
+    return new HExistsCommand(...args).exec(this.client);
+  }
+  hget(...args) {
+    return new HGetCommand(...args).exec(this.client);
+  }
+  hgetall(...args) {
+    return new HGetAllCommand(...args).exec(this.client);
+  }
+  hincrby(...args) {
+    return new HIncrByCommand(...args).exec(this.client);
+  }
+  hincrbyfloat(...args) {
+    return new HIncrByFloatCommand(...args).exec(this.client);
+  }
+  hkeys(...args) {
+    return new HKeysCommand(...args).exec(this.client);
+  }
+  hlen(...args) {
+    return new HLenCommand(...args).exec(this.client);
+  }
+  hmget(...args) {
+    return new HMGetCommand(...args).exec(this.client);
+  }
+  hmset(key, kv) {
+    return new HMSetCommand(key, kv).exec(this.client);
+  }
+  hscan(...args) {
+    return new HScanCommand(...args).exec(this.client);
+  }
+  hset(key, field, value) {
+    return new HSetCommand(key, field, value).exec(this.client);
+  }
+  hsetnx(key, field, value) {
+    return new HSetNXCommand(key, field, value).exec(this.client);
+  }
+  hstrlen(...args) {
+    return new HStrLenCommand(...args).exec(this.client);
+  }
+  hvals(...args) {
+    return new HValsCommand(...args).exec(this.client);
+  }
+  incr(...args) {
+    return new IncrCommand(...args).exec(this.client);
+  }
+  incrby(...args) {
+    return new IncrByCommand(...args).exec(this.client);
+  }
+  incrbyfloat(...args) {
+    return new IncrByFloatCommand(...args).exec(this.client);
+  }
+  keys(...args) {
+    return new KeysCommand(...args).exec(this.client);
+  }
+  lindex(...args) {
+    return new LIndexCommand(...args).exec(this.client);
+  }
+  linsert(key, direction, pivot, value) {
+    return new LInsertCommand(key, direction, pivot, value).exec(this.client);
+  }
+  llen(...args) {
+    return new LLenCommand(...args).exec(this.client);
+  }
+  lpop(...args) {
+    return new LPopCommand(...args).exec(this.client);
+  }
+  lpush(key, ...elements) {
+    return new LPushCommand(key, ...elements).exec(this.client);
+  }
+  lpushx(key, ...elements) {
+    return new LPushXCommand(key, ...elements).exec(this.client);
+  }
+  lrange(...args) {
+    return new LRangeCommand(...args).exec(this.client);
+  }
+  lrem(key, count, value) {
+    return new LRemCommand(key, count, value).exec(this.client);
+  }
+  lset(key, value, index) {
+    return new LSetCommand(key, value, index).exec(this.client);
+  }
+  ltrim(...args) {
+    return new LTrimCommand(...args).exec(this.client);
+  }
+  mget(...args) {
+    return new MGetCommand(...args).exec(this.client);
+  }
+  mset(kv) {
+    return new MSetCommand(kv).exec(this.client);
+  }
+  msetnx(kv) {
+    return new MSetNXCommand(kv).exec(this.client);
+  }
+  persist(...args) {
+    return new PersistCommand(...args).exec(this.client);
+  }
+  pexpire(...args) {
+    return new PExpireCommand(...args).exec(this.client);
+  }
+  pexpireat(...args) {
+    return new PExpireAtCommand(...args).exec(this.client);
+  }
+  ping(...args) {
+    return new PingCommand(...args).exec(this.client);
+  }
+  psetex(key, ttl, value) {
+    return new PSetEXCommand(key, ttl, value).exec(this.client);
+  }
+  pttl(...args) {
+    return new PTtlCommand(...args).exec(this.client);
+  }
+  randomkey() {
+    return new RandomKeyCommand().exec(this.client);
+  }
+  rename(...args) {
+    return new RenameCommand(...args).exec(this.client);
+  }
+  renamenx(...args) {
+    return new RenameNXCommand(...args).exec(this.client);
+  }
+  rpop(...args) {
+    return new RPopCommand(...args).exec(this.client);
+  }
+  rpush(key, ...elements) {
+    return new RPushCommand(key, ...elements).exec(this.client);
+  }
+  rpushx(key, ...elements) {
+    return new RPushXCommand(key, ...elements).exec(this.client);
+  }
+  sadd(key, ...members) {
+    return new SAddCommand(key, ...members).exec(this.client);
+  }
+  scan(...args) {
+    return new ScanCommand(...args).exec(this.client);
+  }
+  scard(...args) {
+    return new SCardCommand(...args).exec(this.client);
+  }
+  sdiff(...args) {
+    return new SDiffCommand(...args).exec(this.client);
+  }
+  sdiffstore(...args) {
+    return new SDiffStoreCommand(...args).exec(this.client);
+  }
+  set(key, value, opts) {
+    return new SetCommand(key, value, opts).exec(this.client);
+  }
+  setbit(...args) {
+    return new SetBitCommand(...args).exec(this.client);
+  }
+  setex(key, ttl, value) {
+    return new SetExCommand(key, ttl, value).exec(this.client);
+  }
+  setnx(key, value) {
+    return new SetNxCommand(key, value).exec(this.client);
+  }
+  setrange(...args) {
+    return new SetRangeCommand(...args).exec(this.client);
+  }
+  sinter(...args) {
+    return new SInterCommand(...args).exec(this.client);
+  }
+  sinterstore(...args) {
+    return new SInterStoreCommand(...args).exec(this.client);
+  }
+  sismember(key, member) {
+    return new SIsMemberCommand(key, member).exec(this.client);
+  }
+  smembers(...args) {
+    return new SMembersCommand(...args).exec(this.client);
+  }
+  smove(source, destination, member) {
+    return new SMoveCommand(source, destination, member).exec(this.client);
+  }
+  spop(...args) {
+    return new SPopCommand(...args).exec(this.client);
+  }
+  srandmember(...args) {
+    return new SRandMemberCommand(...args).exec(this.client);
+  }
+  srem(key, ...members) {
+    return new SRemCommand(key, ...members).exec(this.client);
+  }
+  sscan(...args) {
+    return new SScanCommand(...args).exec(this.client);
+  }
+  strlen(...args) {
+    return new StrLenCommand(...args).exec(this.client);
+  }
+  sunion(...args) {
+    return new SUnionCommand(...args).exec(this.client);
+  }
+  sunionstore(...args) {
+    return new SUnionStoreCommand(...args).exec(this.client);
+  }
+  time() {
+    return new TimeCommand().exec(this.client);
+  }
+  touch(...args) {
+    return new TouchCommand(...args).exec(this.client);
+  }
+  ttl(...args) {
+    return new TtlCommand(...args).exec(this.client);
+  }
+  type(...args) {
+    return new TypeCommand(...args).exec(this.client);
+  }
+  unlink(...args) {
+    return new UnlinkCommand(...args).exec(this.client);
+  }
+  zadd(key, arg1, ...arg2) {
+    if ("score" in arg1) {
+      return new ZAddCommand(key, arg1, ...arg2).exec(this.client);
+    }
+    return new ZAddCommand(key, arg1, ...arg2).exec(this.client);
+  }
+  zcard(...args) {
+    return new ZCardCommand(...args).exec(this.client);
+  }
+  zcount(...args) {
+    return new ZCountCommand(...args).exec(this.client);
+  }
+  zincrby(key, increment, member) {
+    return new ZIncrByComand(key, increment, member).exec(this.client);
+  }
+  zinterstore(...args) {
+    return new ZInterStoreCommand(...args).exec(this.client);
+  }
+  zlexcount(...args) {
+    return new ZLexCountCommand(...args).exec(this.client);
+  }
+  zpopmax(...args) {
+    return new ZPopMaxCommand(...args).exec(this.client);
+  }
+  zpopmin(...args) {
+    return new ZPopMinCommand(...args).exec(this.client);
+  }
+  zrange(...args) {
+    return new ZRangeCommand(...args).exec(this.client);
+  }
+  zrank(key, member) {
+    return new ZRankCommand(key, member).exec(this.client);
+  }
+  zrem(key, ...members) {
+    return new ZRemCommand(key, ...members).exec(this.client);
+  }
+  zremrangebylex(...args) {
+    return new ZRemRangeByLexCommand(...args).exec(this.client);
+  }
+  zremrangebyrank(...args) {
+    return new ZRemRangeByRankCommand(...args).exec(this.client);
+  }
+  zremrangebyscore(...args) {
+    return new ZRemRangeByScoreCommand(...args).exec(this.client);
+  }
+  zrevrank(key, member) {
+    return new ZRevRankCommand(key, member).exec(this.client);
+  }
+  zscan(...args) {
+    return new ZScanCommand(...args).exec(this.client);
+  }
+  zscore(key, member) {
+    return new ZScoreCommand(key, member).exec(this.client);
+  }
+  zunionstore(...args) {
+    return new ZUnionStoreCommand(...args).exec(this.client);
+  }
+};
+module.exports = __toCommonJS(pkg_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Redis,
+  UpstashError
+});