@ooneex/rate-limit 1.2.0 → 1.2.2

package/dist/index.js

@@ -132,7 +132,3521 @@ RedisRateLimiter = __legacyDecorateClassTS([
 import { AppEnv as AppEnv2 } from "@ooneex/app-env";
 import { inject as inject2 } from "@ooneex/container";
 import { Ratelimit } from "@upstash/ratelimit";
-import { Redis } from "@upstash/redis";
+
+// ../../node_modules/.bun/uncrypto@0.1.3/node_modules/uncrypto/dist/crypto.web.mjs
+var webCrypto = globalThis.crypto;
+var subtle = webCrypto.subtle;
+
+// ../../node_modules/.bun/@upstash+redis@1.37.0/node_modules/@upstash/redis/chunk-IH7W44G6.mjs
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var error_exports = {};
+__export(error_exports, {
+  UpstashError: () => UpstashError,
+  UpstashJSONParseError: () => UpstashJSONParseError,
+  UrlError: () => UrlError
+});
+var UpstashError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UpstashError";
+  }
+};
+var UrlError = class extends Error {
+  constructor(url) {
+    super(`Upstash Redis client was passed an invalid URL. You should pass a URL starting with https. Received: "${url}". `);
+    this.name = "UrlError";
+  }
+};
+var UpstashJSONParseError = class extends UpstashError {
+  constructor(body, options) {
+    const truncatedBody = body.length > 200 ? body.slice(0, 200) + "..." : body;
+    super(`Unable to parse response body: ${truncatedBody}`, options);
+    this.name = "UpstashJSONParseError";
+  }
+};
+function parseRecursive(obj) {
+  const parsed = Array.isArray(obj) ? obj.map((o) => {
+    try {
+      return parseRecursive(o);
+    } catch {
+      return o;
+    }
+  }) : JSON.parse(obj);
+  if (typeof parsed === "number" && parsed.toString() !== obj) {
+    return obj;
+  }
+  return parsed;
+}
+function parseResponse(result) {
+  try {
+    return parseRecursive(result);
+  } catch {
+    return result;
+  }
+}
+function deserializeScanResponse(result) {
+  return [result[0], ...parseResponse(result.slice(1))];
+}
+function deserializeScanWithTypesResponse(result) {
+  const [cursor, keys] = result;
+  const parsedKeys = [];
+  for (let i = 0;i < keys.length; i += 2) {
+    parsedKeys.push({ key: keys[i], type: keys[i + 1] });
+  }
+  return [cursor, parsedKeys];
+}
+function mergeHeaders(...headers) {
+  const merged = {};
+  for (const header of headers) {
+    if (!header)
+      continue;
+    for (const [key, value] of Object.entries(header)) {
+      if (value !== undefined && value !== null) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+function kvArrayToObject(v) {
+  if (typeof v === "object" && v !== null && !Array.isArray(v))
+    return v;
+  if (!Array.isArray(v))
+    return {};
+  const obj = {};
+  for (let i = 0;i < v.length; i += 2) {
+    if (typeof v[i] === "string")
+      obj[v[i]] = v[i + 1];
+  }
+  return obj;
+}
+var MAX_BUFFER_SIZE = 1024 * 1024;
+var HttpClient = class {
+  baseUrl;
+  headers;
+  options;
+  readYourWrites;
+  upstashSyncToken = "";
+  hasCredentials;
+  retry;
+  constructor(config) {
+    this.options = {
+      backend: config.options?.backend,
+      agent: config.agent,
+      responseEncoding: config.responseEncoding ?? "base64",
+      cache: config.cache,
+      signal: config.signal,
+      keepAlive: config.keepAlive ?? true
+    };
+    this.upstashSyncToken = "";
+    this.readYourWrites = config.readYourWrites ?? true;
+    this.baseUrl = (config.baseUrl || "").replace(/\/$/, "");
+    const urlRegex = /^https?:\/\/[^\s#$./?].\S*$/;
+    if (this.baseUrl && !urlRegex.test(this.baseUrl)) {
+      throw new UrlError(this.baseUrl);
+    }
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+    this.hasCredentials = Boolean(this.baseUrl && this.headers.authorization.split(" ")[1]);
+    if (this.options.responseEncoding === "base64") {
+      this.headers["Upstash-Encoding"] = "base64";
+    }
+    this.retry = typeof config.retry === "boolean" && !config.retry ? {
+      attempts: 1,
+      backoff: () => 0
+    } : {
+      attempts: config.retry?.retries ?? 5,
+      backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
+    };
+  }
+  mergeTelemetry(telemetry) {
+    this.headers = merge(this.headers, "Upstash-Telemetry-Runtime", telemetry.runtime);
+    this.headers = merge(this.headers, "Upstash-Telemetry-Platform", telemetry.platform);
+    this.headers = merge(this.headers, "Upstash-Telemetry-Sdk", telemetry.sdk);
+  }
+  async request(req) {
+    const requestHeaders = mergeHeaders(this.headers, req.headers ?? {});
+    const requestUrl = [this.baseUrl, ...req.path ?? []].join("/");
+    const isEventStream = requestHeaders.Accept === "text/event-stream";
+    const signal = req.signal ?? this.options.signal;
+    const isSignalFunction = typeof signal === "function";
+    const requestOptions = {
+      cache: this.options.cache,
+      method: "POST",
+      headers: requestHeaders,
+      body: JSON.stringify(req.body),
+      keepalive: this.options.keepAlive,
+      agent: this.options.agent,
+      signal: isSignalFunction ? signal() : signal,
+      backend: this.options.backend
+    };
+    if (!this.hasCredentials) {}
+    if (this.readYourWrites) {
+      const newHeader = this.upstashSyncToken;
+      this.headers["upstash-sync-token"] = newHeader;
+    }
+    let res = null;
+    let error = null;
+    for (let i = 0;i <= this.retry.attempts; i++) {
+      try {
+        res = await fetch(requestUrl, requestOptions);
+        break;
+      } catch (error_) {
+        if (requestOptions.signal?.aborted && isSignalFunction) {
+          throw error_;
+        } else if (requestOptions.signal?.aborted) {
+          const myBlob = new Blob([
+            JSON.stringify({ result: requestOptions.signal.reason ?? "Aborted" })
+          ]);
+          const myOptions = {
+            status: 200,
+            statusText: requestOptions.signal.reason ?? "Aborted"
+          };
+          res = new Response(myBlob, myOptions);
+          break;
+        }
+        error = error_;
+        if (i < this.retry.attempts) {
+          await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+        }
+      }
+    }
+    if (!res) {
+      throw error ?? new Error("Exhausted all retries");
+    }
+    if (!res.ok) {
+      let body2;
+      const rawBody2 = await res.text();
+      try {
+        body2 = JSON.parse(rawBody2);
+      } catch (error2) {
+        throw new UpstashJSONParseError(rawBody2, { cause: error2 });
+      }
+      throw new UpstashError(`${body2.error}, command was: ${JSON.stringify(req.body)}`);
+    }
+    if (this.readYourWrites) {
+      const headers = res.headers;
+      this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
+    }
+    if (isEventStream && req && req.onMessage && res.body) {
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder;
+      (async () => {
+        try {
+          let buffer = "";
+          while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            if (buffer.length > MAX_BUFFER_SIZE) {
+              throw new Error("Buffer size exceeded (1MB)");
+            }
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                req.onMessage?.(data);
+              }
+            }
+          }
+        } catch (error2) {
+          if (error2 instanceof Error && error2.name === "AbortError") {} else {}
+        } finally {
+          try {
+            await reader.cancel();
+          } catch {}
+        }
+      })();
+      return { result: 1 };
+    }
+    let body;
+    const rawBody = await res.text();
+    try {
+      body = JSON.parse(rawBody);
+    } catch (error2) {
+      throw new UpstashJSONParseError(rawBody, { cause: error2 });
+    }
+    if (this.readYourWrites) {
+      const headers = res.headers;
+      this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
+    }
+    if (this.options.responseEncoding === "base64") {
+      if (Array.isArray(body)) {
+        return body.map(({ result: result2, error: error2 }) => ({
+          result: decode(result2),
+          error: error2
+        }));
+      }
+      const result = decode(body.result);
+      return { result, error: body.error };
+    }
+    return body;
+  }
+};
+function base64decode(b64) {
+  let dec = "";
+  try {
+    const binString = atob(b64);
+    const size = binString.length;
+    const bytes = new Uint8Array(size);
+    for (let i = 0;i < size; i++) {
+      bytes[i] = binString.charCodeAt(i);
+    }
+    dec = new TextDecoder().decode(bytes);
+  } catch {
+    dec = b64;
+  }
+  return dec;
+}
+function decode(raw) {
+  let result = undefined;
+  switch (typeof raw) {
+    case "undefined": {
+      return raw;
+    }
+    case "number": {
+      result = raw;
+      break;
+    }
+    case "object": {
+      if (Array.isArray(raw)) {
+        result = raw.map((v) => typeof v === "string" ? base64decode(v) : Array.isArray(v) ? v.map((element) => decode(element)) : v);
+      } else {
+        result = null;
+      }
+      break;
+    }
+    case "string": {
+      result = raw === "OK" ? "OK" : base64decode(raw);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return result;
+}
+function merge(obj, key, value) {
+  if (!value) {
+    return obj;
+  }
+  obj[key] = obj[key] ? [obj[key], value].join(",") : value;
+  return obj;
+}
+var defaultSerializer = (c) => {
+  switch (typeof c) {
+    case "string":
+    case "number":
+    case "boolean": {
+      return c;
+    }
+    default: {
+      return JSON.stringify(c);
+    }
+  }
+};
+var Command = class {
+  command;
+  serialize;
+  deserialize;
+  headers;
+  path;
+  onMessage;
+  isStreaming;
+  signal;
+  constructor(command, opts) {
+    this.serialize = defaultSerializer;
+    this.deserialize = opts?.automaticDeserialization === undefined || opts.automaticDeserialization ? opts?.deserialize ?? parseResponse : (x) => x;
+    this.command = command.map((c) => this.serialize(c));
+    this.headers = opts?.headers;
+    this.path = opts?.path;
+    this.onMessage = opts?.streamOptions?.onMessage;
+    this.isStreaming = opts?.streamOptions?.isStreaming ?? false;
+    this.signal = opts?.streamOptions?.signal;
+    if (opts?.latencyLogging) {
+      const originalExec = this.exec.bind(this);
+      this.exec = async (client) => {
+        const start = performance.now();
+        const result = await originalExec(client);
+        const end = performance.now();
+        const loggerResult = (end - start).toFixed(2);
+        return result;
+      };
+    }
+  }
+  async exec(client) {
+    const { result, error } = await client.request({
+      body: this.command,
+      path: this.path,
+      upstashSyncToken: client.upstashSyncToken,
+      headers: this.headers,
+      onMessage: this.onMessage,
+      isStreaming: this.isStreaming,
+      signal: this.signal
+    });
+    if (error) {
+      throw new UpstashError(error);
+    }
+    if (result === undefined) {
+      throw new TypeError("Request did not return a result");
+    }
+    return this.deserialize(result);
+  }
+};
+var ExecCommand = class extends Command {
+  constructor(cmd, opts) {
+    const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
+    super(normalizedCmd, opts);
+  }
+};
+var FIELD_TYPES = [
+  "TEXT",
+  "U64",
+  "I64",
+  "F64",
+  "BOOL",
+  "DATE",
+  "KEYWORD",
+  "FACET"
+];
+function isFieldType(value) {
+  return typeof value === "string" && FIELD_TYPES.includes(value);
+}
+function isDetailedField(value) {
+  return typeof value === "object" && value !== null && "type" in value && isFieldType(value.type);
+}
+function isNestedSchema(value) {
+  return typeof value === "object" && value !== null && !isDetailedField(value);
+}
+function flattenSchema(schema, pathPrefix = []) {
+  const fields = [];
+  for (const [key, value] of Object.entries(schema)) {
+    const currentPath = [...pathPrefix, key];
+    const pathString = currentPath.join(".");
+    if (isFieldType(value)) {
+      fields.push({
+        path: pathString,
+        type: value
+      });
+    } else if (isDetailedField(value)) {
+      fields.push({
+        path: pathString,
+        type: value.type,
+        fast: "fast" in value ? value.fast : undefined,
+        noTokenize: "noTokenize" in value ? value.noTokenize : undefined,
+        noStem: "noStem" in value ? value.noStem : undefined,
+        from: "from" in value ? value.from : undefined
+      });
+    } else if (isNestedSchema(value)) {
+      const nestedFields = flattenSchema(value, currentPath);
+      fields.push(...nestedFields);
+    }
+  }
+  return fields;
+}
+function deserializeQueryResponse(rawResponse) {
+  return rawResponse.map((itemRaw) => {
+    const raw = itemRaw;
+    const key = raw[0];
+    const score = Number(raw[1]);
+    const rawFields = raw[2];
+    if (rawFields === undefined) {
+      return { key, score };
+    }
+    if (!Array.isArray(rawFields) || rawFields.length === 0) {
+      return { key, score, data: {} };
+    }
+    let data = {};
+    for (const fieldRaw of rawFields) {
+      const key2 = fieldRaw[0];
+      const value = fieldRaw[1];
+      const pathParts = key2.split(".");
+      if (pathParts.length === 1) {
+        data[key2] = value;
+      } else {
+        let currentObj = data;
+        for (let i = 0;i < pathParts.length - 1; i++) {
+          const pathPart = pathParts[i];
+          if (!(pathPart in currentObj)) {
+            currentObj[pathPart] = {};
+          }
+          currentObj = currentObj[pathPart];
+        }
+        currentObj[pathParts.at(-1)] = value;
+      }
+    }
+    if ("$" in data) {
+      data = data["$"];
+    }
+    return { key, score, data };
+  });
+}
+function deserializeDescribeResponse(rawResponse) {
+  const description = {};
+  for (let i = 0;i < rawResponse.length; i += 2) {
+    const descriptor = rawResponse[i];
+    switch (descriptor) {
+      case "name": {
+        description["name"] = rawResponse[i + 1];
+        break;
+      }
+      case "type": {
+        description["dataType"] = rawResponse[i + 1].toLowerCase();
+        break;
+      }
+      case "prefixes": {
+        description["prefixes"] = rawResponse[i + 1];
+        break;
+      }
+      case "language": {
+        description["language"] = rawResponse[i + 1];
+        break;
+      }
+      case "schema": {
+        const schema = {};
+        for (const fieldDescription of rawResponse[i + 1]) {
+          const fieldName = fieldDescription[0];
+          const fieldInfo = { type: fieldDescription[1] };
+          if (fieldDescription.length > 2) {
+            for (let j = 2;j < fieldDescription.length; j++) {
+              const fieldOption = fieldDescription[j];
+              switch (fieldOption) {
+                case "NOSTEM": {
+                  fieldInfo.noStem = true;
+                  break;
+                }
+                case "NOTOKENIZE": {
+                  fieldInfo.noTokenize = true;
+                  break;
+                }
+                case "FAST": {
+                  fieldInfo.fast = true;
+                  break;
+                }
+                case "FROM": {
+                  fieldInfo.from = fieldDescription[++j];
+                  break;
+                }
+              }
+            }
+          }
+          schema[fieldName] = fieldInfo;
+        }
+        description["schema"] = schema;
+        break;
+      }
+    }
+  }
+  return description;
+}
+function parseCountResponse(rawResponse) {
+  return typeof rawResponse === "number" ? rawResponse : Number.parseInt(rawResponse, 10);
+}
+function deserializeAggregateResponse(rawResponse) {
+  return parseAggregationArray(rawResponse);
+}
+function parseAggregationArray(arr) {
+  const result = {};
+  for (let i = 0;i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+    if (Array.isArray(value)) {
+      if (value.length > 0 && typeof value[0] === "string") {
+        result[key] = value[0] === "buckets" ? parseBucketsValue(value) : parseStatsValue(value);
+      } else {
+        result[key] = parseAggregationArray(value);
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function coerceNumericString(value) {
+  if (typeof value === "string" && value !== "" && !Number.isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+function parseStatsValue(arr) {
+  const result = {};
+  for (let i = 0;i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+    if (Array.isArray(value) && value.length > 0) {
+      if (typeof value[0] === "string") {
+        result[key] = parseStatsValue(value);
+      } else if (Array.isArray(value[0]) && typeof value[0][0] === "string") {
+        result[key] = value.map((item) => parseStatsValue(item));
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = coerceNumericString(value);
+    }
+  }
+  return result;
+}
+function parseBucketsValue(arr) {
+  if (arr[0] === "buckets" && Array.isArray(arr[1])) {
+    const result = {
+      buckets: arr[1].map((bucket) => {
+        const bucketObj = {};
+        for (let i = 0;i < bucket.length; i += 2) {
+          const key = bucket[i];
+          const value = bucket[i + 1];
+          bucketObj[key] = Array.isArray(value) && value.length > 0 && typeof value[0] === "string" ? parseStatsValue(value) : value;
+        }
+        return bucketObj;
+      })
+    };
+    for (let i = 2;i < arr.length; i += 2) {
+      result[arr[i]] = arr[i + 1];
+    }
+    return result;
+  }
+  return arr;
+}
+function buildQueryCommand(redisCommand, name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const command = [redisCommand, name, query];
+  if (options?.limit !== undefined) {
+    command.push("LIMIT", options.limit.toString());
+  }
+  if (options?.offset !== undefined) {
+    command.push("OFFSET", options.offset.toString());
+  }
+  if (options?.select && Object.keys(options.select).length === 0) {
+    command.push("NOCONTENT");
+  }
+  if (options) {
+    if ("orderBy" in options && options.orderBy) {
+      command.push("ORDERBY");
+      for (const [field, direction] of Object.entries(options.orderBy)) {
+        command.push(field, direction);
+      }
+    } else if ("scoreFunc" in options && options.scoreFunc) {
+      command.push("SCOREFUNC", ...buildScoreFunc(options.scoreFunc));
+    }
+  }
+  if (options?.highlight) {
+    command.push("HIGHLIGHT", "FIELDS", options.highlight.fields.length.toString(), ...options.highlight.fields);
+    if (options.highlight.preTag && options.highlight.postTag) {
+      command.push("TAGS", options.highlight.preTag, options.highlight.postTag);
+    }
+  }
+  if (options?.select && Object.keys(options.select).length > 0) {
+    command.push("SELECT", Object.keys(options.select).length.toString(), ...Object.keys(options.select));
+  }
+  return command;
+}
+function buildScoreFunc(scoreBy) {
+  const result = [];
+  if (typeof scoreBy === "string") {
+    result.push("FIELDVALUE", scoreBy);
+  } else if ("fields" in scoreBy) {
+    if (scoreBy.combineMode) {
+      result.push("COMBINEMODE", scoreBy.combineMode.toUpperCase());
+    }
+    if (scoreBy.scoreMode) {
+      result.push("SCOREMODE", scoreBy.scoreMode.toUpperCase());
+    }
+    for (const field of scoreBy.fields) {
+      result.push(...buildScoreFuncField(field));
+    }
+  } else {
+    result.push(...buildScoreFuncField(scoreBy));
+  }
+  return result;
+}
+function buildScoreFuncField(field) {
+  const result = [];
+  if (typeof field === "string") {
+    result.push("FIELDVALUE", field);
+  } else {
+    if (field.scoreMode) {
+      result.push("SCOREMODE", field.scoreMode.toUpperCase());
+    }
+    result.push("FIELDVALUE", field.field);
+    if (field.modifier) {
+      result.push("MODIFIER", field.modifier.toUpperCase());
+    }
+    if (field.factor !== undefined) {
+      result.push("FACTOR", field.factor.toString());
+    }
+    if (field.missing !== undefined) {
+      result.push("MISSING", field.missing.toString());
+    }
+  }
+  return result;
+}
+function buildCreateIndexCommand(params) {
+  const { name, schema, dataType, prefix, language, skipInitialScan, existsOk } = params;
+  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
+  const payload = [
+    name,
+    ...skipInitialScan ? ["SKIPINITIALSCAN"] : [],
+    ...existsOk ? ["EXISTSOK"] : [],
+    "ON",
+    dataType.toUpperCase(),
+    "PREFIX",
+    prefixArray.length.toString(),
+    ...prefixArray,
+    ...language ? ["LANGUAGE", language] : [],
+    "SCHEMA"
+  ];
+  const fields = flattenSchema(schema);
+  for (const field of fields) {
+    payload.push(field.path, field.type);
+    if (field.fast) {
+      payload.push("FAST");
+    }
+    if (field.noTokenize) {
+      payload.push("NOTOKENIZE");
+    }
+    if (field.noStem) {
+      payload.push("NOSTEM");
+    }
+    if (field.from) {
+      payload.push("FROM", field.from);
+    }
+  }
+  return ["SEARCH.CREATE", ...payload];
+}
+function buildAggregateCommand(name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const aggregations = JSON.stringify(options.aggregations);
+  return ["SEARCH.AGGREGATE", name, query, aggregations];
+}
+var SearchIndex = class {
+  name;
+  schema;
+  client;
+  constructor({ name, schema, client }) {
+    this.name = name;
+    this.schema = schema;
+    this.client = client;
+  }
+  async waitIndexing() {
+    const command = ["SEARCH.WAITINDEXING", this.name];
+    return await new ExecCommand(command).exec(this.client);
+  }
+  async describe() {
+    const command = ["SEARCH.DESCRIBE", this.name];
+    const rawResult = await new ExecCommand(command).exec(this.client);
+    if (!rawResult)
+      return null;
+    return deserializeDescribeResponse(rawResult);
+  }
+  async query(options) {
+    const command = buildQueryCommand("SEARCH.QUERY", this.name, options);
+    const rawResult = await new ExecCommand(command).exec(this.client);
+    if (!rawResult)
+      return rawResult;
+    return deserializeQueryResponse(rawResult);
+  }
+  async aggregate(options) {
+    const command = buildAggregateCommand(this.name, options);
+    const rawResult = await new ExecCommand(command).exec(this.client);
+    return deserializeAggregateResponse(rawResult);
+  }
+  async count({ filter }) {
+    const command = buildQueryCommand("SEARCH.COUNT", this.name, { filter });
+    const rawResult = await new ExecCommand(command).exec(this.client);
+    return { count: parseCountResponse(rawResult) };
+  }
+  async drop() {
+    const command = ["SEARCH.DROP", this.name];
+    const result = await new ExecCommand(command).exec(this.client);
+    return result;
+  }
+  async addAlias({ alias }) {
+    const command = ["SEARCH.ALIASADD", alias, this.name];
+    const result = await new ExecCommand(command).exec(this.client);
+    return result;
+  }
+};
+async function createIndex(client, params) {
+  const { name, schema } = params;
+  const createIndexCommand = buildCreateIndexCommand(params);
+  await new ExecCommand(createIndexCommand).exec(client);
+  return initIndex(client, { name, schema });
+}
+function initIndex(client, params) {
+  const { name, schema } = params;
+  return new SearchIndex({ name, schema, client });
+}
+async function listAliases(client) {
+  const command = ["SEARCH.LISTALIASES"];
+  const rawResult = await new ExecCommand(command).exec(client);
+  if (rawResult === 0 || Array.isArray(rawResult) && rawResult.length === 0) {
+    return {};
+  }
+  if (!Array.isArray(rawResult)) {
+    return {};
+  }
+  const aliases = {};
+  for (const pair of rawResult) {
+    if (Array.isArray(pair) && pair.length === 2) {
+      const [alias, index] = pair;
+      aliases[alias] = index;
+    }
+  }
+  return aliases;
+}
+async function addAlias(client, { indexName, alias }) {
+  const command = ["SEARCH.ALIASADD", alias, indexName];
+  const result = await new ExecCommand(command).exec(client);
+  return result;
+}
+async function delAlias(client, { alias }) {
+  const command = ["SEARCH.ALIASDEL", alias];
+  const result = await new ExecCommand(command).exec(client);
+  return result;
+}
+function deserialize(result) {
+  if (result.length === 0) {
+    return null;
+  }
+  const obj = {};
+  for (let i = 0;i < result.length; i += 2) {
+    const key = result[i];
+    const value = result[i + 1];
+    try {
+      obj[key] = JSON.parse(value);
+    } catch {
+      obj[key] = value;
+    }
+  }
+  return obj;
+}
+var HRandFieldCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["hrandfield", cmd[0]];
+    if (typeof cmd[1] === "number") {
+      command.push(cmd[1]);
+    }
+    if (cmd[2]) {
+      command.push("WITHVALUES");
+    }
+    super(command, {
+      deserialize: cmd[2] ? (result) => deserialize(result) : opts?.deserialize,
+      ...opts
+    });
+  }
+};
+var AppendCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["append", ...cmd], opts);
+  }
+};
+var BitCountCommand = class extends Command {
+  constructor([key, start, end], opts) {
+    const command = ["bitcount", key];
+    if (typeof start === "number") {
+      command.push(start);
+    }
+    if (typeof end === "number") {
+      command.push(end);
+    }
+    super(command, opts);
+  }
+};
+var BitFieldCommand = class {
+  constructor(args, client, opts, execOperation = (command) => command.exec(this.client)) {
+    this.client = client;
+    this.opts = opts;
+    this.execOperation = execOperation;
+    this.command = ["bitfield", ...args];
+  }
+  command;
+  chain(...args) {
+    this.command.push(...args);
+    return this;
+  }
+  get(...args) {
+    return this.chain("get", ...args);
+  }
+  set(...args) {
+    return this.chain("set", ...args);
+  }
+  incrby(...args) {
+    return this.chain("incrby", ...args);
+  }
+  overflow(overflow) {
+    return this.chain("overflow", overflow);
+  }
+  exec() {
+    const command = new Command(this.command, this.opts);
+    return this.execOperation(command);
+  }
+};
+var BitOpCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["bitop", ...cmd], opts);
+  }
+};
+var BitPosCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["bitpos", ...cmd], opts);
+  }
+};
+var ClientSetInfoCommand = class extends Command {
+  constructor([attribute, value], opts) {
+    super(["CLIENT", "SETINFO", attribute.toUpperCase(), value], opts);
+  }
+};
+var CopyCommand = class extends Command {
+  constructor([key, destinationKey, opts], commandOptions) {
+    super(["COPY", key, destinationKey, ...opts?.replace ? ["REPLACE"] : []], {
+      ...commandOptions,
+      deserialize(result) {
+        if (result > 0) {
+          return "COPIED";
+        }
+        return "NOT_COPIED";
+      }
+    });
+  }
+};
+var DBSizeCommand = class extends Command {
+  constructor(opts) {
+    super(["dbsize"], opts);
+  }
+};
+var DecrCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["decr", ...cmd], opts);
+  }
+};
+var DecrByCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["decrby", ...cmd], opts);
+  }
+};
+var DelCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["del", ...cmd], opts);
+  }
+};
+var EchoCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["echo", ...cmd], opts);
+  }
+};
+var EvalROCommand = class extends Command {
+  constructor([script, keys, args], opts) {
+    super(["eval_ro", script, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+var EvalCommand = class extends Command {
+  constructor([script, keys, args], opts) {
+    super(["eval", script, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+var EvalshaROCommand = class extends Command {
+  constructor([sha, keys, args], opts) {
+    super(["evalsha_ro", sha, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+var EvalshaCommand = class extends Command {
+  constructor([sha, keys, args], opts) {
+    super(["evalsha", sha, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+var ExistsCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["exists", ...cmd], opts);
+  }
+};
+var ExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["expire", ...cmd.filter(Boolean)], opts);
+  }
+};
+var ExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["expireat", ...cmd], opts);
+  }
+};
+var FCallCommand = class extends Command {
+  constructor([functionName, keys, args], opts) {
+    super(["fcall", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
+  }
+};
+var FCallRoCommand = class extends Command {
+  constructor([functionName, keys, args], opts) {
+    super(["fcall_ro", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
+  }
+};
+var FlushAllCommand = class extends Command {
+  constructor(args, opts) {
+    const command = ["flushall"];
+    if (args && args.length > 0 && args[0].async) {
+      command.push("async");
+    }
+    super(command, opts);
+  }
+};
+var FlushDBCommand = class extends Command {
+  constructor([opts], cmdOpts) {
+    const command = ["flushdb"];
+    if (opts?.async) {
+      command.push("async");
+    }
+    super(command, cmdOpts);
+  }
+};
+var FunctionDeleteCommand = class extends Command {
+  constructor([libraryName], opts) {
+    super(["function", "delete", libraryName], opts);
+  }
+};
+var FunctionFlushCommand = class extends Command {
+  constructor(opts) {
+    super(["function", "flush"], opts);
+  }
+};
+var FunctionListCommand = class extends Command {
+  constructor([args], opts) {
+    const command = ["function", "list"];
+    if (args?.libraryName) {
+      command.push("libraryname", args.libraryName);
+    }
+    if (args?.withCode) {
+      command.push("withcode");
+    }
+    super(command, { deserialize: deserialize2, ...opts });
+  }
+};
+function deserialize2(result) {
+  if (!Array.isArray(result))
+    return [];
+  return result.map((libRaw) => {
+    const lib = kvArrayToObject(libRaw);
+    const functionsParsed = lib.functions.map((fnRaw) => kvArrayToObject(fnRaw));
+    return {
+      libraryName: lib.library_name,
+      engine: lib.engine,
+      functions: functionsParsed.map((fn) => ({
+        name: fn.name,
+        description: fn.description ?? undefined,
+        flags: fn.flags
+      })),
+      libraryCode: lib.library_code
+    };
+  });
+}
+var FunctionLoadCommand = class extends Command {
+  constructor([args], opts) {
+    super(["function", "load", ...args.replace ? ["replace"] : [], args.code], opts);
+  }
+};
+var FunctionStatsCommand = class extends Command {
+  constructor(opts) {
+    super(["function", "stats"], { deserialize: deserialize3, ...opts });
+  }
+};
+function deserialize3(result) {
+  const rawEngines = kvArrayToObject(kvArrayToObject(result).engines);
+  const parsedEngines = Object.fromEntries(Object.entries(rawEngines).map(([key, value]) => [key, kvArrayToObject(value)]));
+  const final = {
+    engines: Object.fromEntries(Object.entries(parsedEngines).map(([key, value]) => [
+      key,
+      {
+        librariesCount: value.libraries_count,
+        functionsCount: value.functions_count
+      }
+    ]))
+  };
+  return final;
+}
+var GeoAddCommand = class extends Command {
+  constructor([key, arg1, ...arg2], opts) {
+    const command = ["geoadd", 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 ("latitude" in arg1 && arg1.latitude) {
+      command.push(arg1.longitude, arg1.latitude, arg1.member);
+    }
+    command.push(...arg2.flatMap(({ latitude, longitude, member }) => [longitude, latitude, member]));
+    super(command, opts);
+  }
+};
+var GeoDistCommand = class extends Command {
+  constructor([key, member1, member2, unit = "M"], opts) {
+    super(["GEODIST", key, member1, member2, unit], opts);
+  }
+};
+var GeoHashCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key] = cmd;
+    const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
+    super(["GEOHASH", key, ...members], opts);
+  }
+};
+var GeoPosCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key] = cmd;
+    const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
+    super(["GEOPOS", key, ...members], {
+      deserialize: (result) => transform(result),
+      ...opts
+    });
+  }
+};
+function transform(result) {
+  const final = [];
+  for (const pos of result) {
+    if (!pos?.[0] || !pos?.[1]) {
+      continue;
+    }
+    final.push({ lng: Number.parseFloat(pos[0]), lat: Number.parseFloat(pos[1]) });
+  }
+  return final;
+}
+var GeoSearchCommand = class extends Command {
+  constructor([key, centerPoint, shape, order, opts], commandOptions) {
+    const command = ["GEOSEARCH", key];
+    if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
+      command.push(centerPoint.type, centerPoint.member);
+    }
+    if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
+      command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
+    }
+    if (shape.type === "BYRADIUS" || shape.type === "byradius") {
+      command.push(shape.type, shape.radius, shape.radiusType);
+    }
+    if (shape.type === "BYBOX" || shape.type === "bybox") {
+      command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
+    }
+    command.push(order);
+    if (opts?.count) {
+      command.push("COUNT", opts.count.limit, ...opts.count.any ? ["ANY"] : []);
+    }
+    const transform2 = (result) => {
+      if (!opts?.withCoord && !opts?.withDist && !opts?.withHash) {
+        return result.map((member) => {
+          try {
+            return { member: JSON.parse(member) };
+          } catch {
+            return { member };
+          }
+        });
+      }
+      return result.map((members) => {
+        let counter = 1;
+        const obj = {};
+        try {
+          obj.member = JSON.parse(members[0]);
+        } catch {
+          obj.member = members[0];
+        }
+        if (opts.withDist) {
+          obj.dist = Number.parseFloat(members[counter++]);
+        }
+        if (opts.withHash) {
+          obj.hash = members[counter++].toString();
+        }
+        if (opts.withCoord) {
+          obj.coord = {
+            long: Number.parseFloat(members[counter][0]),
+            lat: Number.parseFloat(members[counter][1])
+          };
+        }
+        return obj;
+      });
+    };
+    super([
+      ...command,
+      ...opts?.withCoord ? ["WITHCOORD"] : [],
+      ...opts?.withDist ? ["WITHDIST"] : [],
+      ...opts?.withHash ? ["WITHHASH"] : []
+    ], {
+      deserialize: transform2,
+      ...commandOptions
+    });
+  }
+};
+var GeoSearchStoreCommand = class extends Command {
+  constructor([destination, key, centerPoint, shape, order, opts], commandOptions) {
+    const command = ["GEOSEARCHSTORE", destination, key];
+    if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
+      command.push(centerPoint.type, centerPoint.member);
+    }
+    if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
+      command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
+    }
+    if (shape.type === "BYRADIUS" || shape.type === "byradius") {
+      command.push(shape.type, shape.radius, shape.radiusType);
+    }
+    if (shape.type === "BYBOX" || shape.type === "bybox") {
+      command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
+    }
+    command.push(order);
+    if (opts?.count) {
+      command.push("COUNT", opts.count.limit, ...opts.count.any ? ["ANY"] : []);
+    }
+    super([...command, ...opts?.storeDist ? ["STOREDIST"] : []], commandOptions);
+  }
+};
+var GetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["get", ...cmd], opts);
+  }
+};
+var GetBitCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["getbit", ...cmd], opts);
+  }
+};
+var GetDelCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["getdel", ...cmd], opts);
+  }
+};
+var GetExCommand = class extends Command {
+  constructor([key, opts], cmdOpts) {
+    const command = ["getex", key];
+    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);
+      } else if ("exat" in opts && typeof opts.exat === "number") {
+        command.push("exat", opts.exat);
+      } else if ("pxat" in opts && typeof opts.pxat === "number") {
+        command.push("pxat", opts.pxat);
+      } else if ("persist" in opts && opts.persist) {
+        command.push("persist");
+      }
+    }
+    super(command, cmdOpts);
+  }
+};
+var GetRangeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["getrange", ...cmd], opts);
+  }
+};
+var GetSetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["getset", ...cmd], opts);
+  }
+};
+var HDelCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hdel", ...cmd], opts);
+  }
+};
+var HExistsCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hexists", ...cmd], opts);
+  }
+};
+var HExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, seconds, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super([
+      "hexpire",
+      key,
+      seconds,
+      ...option ? [option] : [],
+      "FIELDS",
+      fieldArray.length,
+      ...fieldArray
+    ], opts);
+  }
+};
+var HExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, timestamp, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super([
+      "hexpireat",
+      key,
+      timestamp,
+      ...option ? [option] : [],
+      "FIELDS",
+      fieldArray.length,
+      ...fieldArray
+    ], opts);
+  }
+};
+var HExpireTimeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+var HPersistCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpersist", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+var HPExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, milliseconds, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super([
+      "hpexpire",
+      key,
+      milliseconds,
+      ...option ? [option] : [],
+      "FIELDS",
+      fieldArray.length,
+      ...fieldArray
+    ], opts);
+  }
+};
+var HPExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, timestamp, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super([
+      "hpexpireat",
+      key,
+      timestamp,
+      ...option ? [option] : [],
+      "FIELDS",
+      fieldArray.length,
+      ...fieldArray
+    ], opts);
+  }
+};
+var HPExpireTimeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+var HPTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpttl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+var HGetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hget", ...cmd], opts);
+  }
+};
+function deserialize4(result) {
+  if (result.length === 0) {
+    return null;
+  }
+  const obj = {};
+  for (let i = 0;i < result.length; i += 2) {
+    const key = result[i];
+    const value = result[i + 1];
+    try {
+      const valueIsNumberAndNotSafeInteger = !Number.isNaN(Number(value)) && !Number.isSafeInteger(Number(value));
+      obj[key] = valueIsNumberAndNotSafeInteger ? value : JSON.parse(value);
+    } catch {
+      obj[key] = value;
+    }
+  }
+  return obj;
+}
+var HGetAllCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hgetall", ...cmd], {
+      deserialize: (result) => deserialize4(result),
+      ...opts
+    });
+  }
+};
+function deserialize5(fields, result) {
+  if (result.every((field) => field === null)) {
+    return null;
+  }
+  const obj = {};
+  for (const [i, field] of fields.entries()) {
+    try {
+      obj[field] = JSON.parse(result[i]);
+    } catch {
+      obj[field] = result[i];
+    }
+  }
+  return obj;
+}
+var HMGetCommand = class extends Command {
+  constructor([key, ...fields], opts) {
+    super(["hmget", key, ...fields], {
+      deserialize: (result) => deserialize5(fields, result),
+      ...opts
+    });
+  }
+};
+var HGetDelCommand = class extends Command {
+  constructor([key, ...fields], opts) {
+    super(["hgetdel", key, "FIELDS", fields.length, ...fields], {
+      deserialize: (result) => deserialize5(fields.map(String), result),
+      ...opts
+    });
+  }
+};
+var HGetExCommand = class extends Command {
+  constructor([key, opts, ...fields], cmdOpts) {
+    const command = ["hgetex", key];
+    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);
+    } else if ("exat" in opts && typeof opts.exat === "number") {
+      command.push("EXAT", opts.exat);
+    } else if ("pxat" in opts && typeof opts.pxat === "number") {
+      command.push("PXAT", opts.pxat);
+    } else if ("persist" in opts && opts.persist) {
+      command.push("PERSIST");
+    }
+    command.push("FIELDS", fields.length, ...fields);
+    super(command, {
+      deserialize: (result) => deserialize5(fields.map(String), result),
+      ...cmdOpts
+    });
+  }
+};
+var HIncrByCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hincrby", ...cmd], opts);
+  }
+};
+var HIncrByFloatCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hincrbyfloat", ...cmd], opts);
+  }
+};
+var HKeysCommand = class extends Command {
+  constructor([key], opts) {
+    super(["hkeys", key], opts);
+  }
+};
+var HLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hlen", ...cmd], opts);
+  }
+};
+var HMSetCommand = class extends Command {
+  constructor([key, kv], opts) {
+    super(["hmset", key, ...Object.entries(kv).flatMap(([field, value]) => [field, value])], opts);
+  }
+};
+var HScanCommand = class extends Command {
+  constructor([key, cursor, cmdOpts], opts) {
+    const command = ["hscan", key, cursor];
+    if (cmdOpts?.match) {
+      command.push("match", cmdOpts.match);
+    }
+    if (typeof cmdOpts?.count === "number") {
+      command.push("count", cmdOpts.count);
+    }
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...opts
+    });
+  }
+};
+var HSetCommand = class extends Command {
+  constructor([key, kv], opts) {
+    super(["hset", key, ...Object.entries(kv).flatMap(([field, value]) => [field, value])], opts);
+  }
+};
+var HSetExCommand = class extends Command {
+  constructor([key, opts, kv], cmdOpts) {
+    const command = ["hsetex", key];
+    if (opts.conditional) {
+      command.push(opts.conditional.toUpperCase());
+    }
+    if (opts.expiration) {
+      if ("ex" in opts.expiration && typeof opts.expiration.ex === "number") {
+        command.push("EX", opts.expiration.ex);
+      } else if ("px" in opts.expiration && typeof opts.expiration.px === "number") {
+        command.push("PX", opts.expiration.px);
+      } else if ("exat" in opts.expiration && typeof opts.expiration.exat === "number") {
+        command.push("EXAT", opts.expiration.exat);
+      } else if ("pxat" in opts.expiration && typeof opts.expiration.pxat === "number") {
+        command.push("PXAT", opts.expiration.pxat);
+      } else if ("keepttl" in opts.expiration && opts.expiration.keepttl) {
+        command.push("KEEPTTL");
+      }
+    }
+    const entries = Object.entries(kv);
+    command.push("FIELDS", entries.length);
+    for (const [field, value] of entries) {
+      command.push(field, value);
+    }
+    super(command, cmdOpts);
+  }
+};
+var HSetNXCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hsetnx", ...cmd], opts);
+  }
+};
+var HStrLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hstrlen", ...cmd], opts);
+  }
+};
+var HTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["httl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+var HValsCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hvals", ...cmd], opts);
+  }
+};
+var IncrCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["incr", ...cmd], opts);
+  }
+};
+var IncrByCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["incrby", ...cmd], opts);
+  }
+};
+var IncrByFloatCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["incrbyfloat", ...cmd], opts);
+  }
+};
+var JsonArrAppendCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.ARRAPPEND", ...cmd], opts);
+  }
+};
+var JsonArrIndexCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.ARRINDEX", ...cmd], opts);
+  }
+};
+var JsonArrInsertCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.ARRINSERT", ...cmd], opts);
+  }
+};
+var JsonArrLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.ARRLEN", cmd[0], cmd[1] ?? "$"], opts);
+  }
+};
+var JsonArrPopCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.ARRPOP", ...cmd], opts);
+  }
+};
+var JsonArrTrimCommand = class extends Command {
+  constructor(cmd, opts) {
+    const path = cmd[1] ?? "$";
+    const start = cmd[2] ?? 0;
+    const stop = cmd[3] ?? 0;
+    super(["JSON.ARRTRIM", cmd[0], path, start, stop], opts);
+  }
+};
+var JsonClearCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.CLEAR", ...cmd], opts);
+  }
+};
+var JsonDelCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.DEL", ...cmd], opts);
+  }
+};
+var JsonForgetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.FORGET", ...cmd], opts);
+  }
+};
+var JsonGetCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.GET"];
+    if (typeof cmd[1] === "string") {
+      command.push(...cmd);
+    } else {
+      command.push(cmd[0]);
+      if (cmd[1]) {
+        if (cmd[1].indent) {
+          command.push("INDENT", cmd[1].indent);
+        }
+        if (cmd[1].newline) {
+          command.push("NEWLINE", cmd[1].newline);
+        }
+        if (cmd[1].space) {
+          command.push("SPACE", cmd[1].space);
+        }
+      }
+      command.push(...cmd.slice(2));
+    }
+    super(command, opts);
+  }
+};
+var JsonMergeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.MERGE", ...cmd];
+    super(command, opts);
+  }
+};
+var JsonMGetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.MGET", ...cmd[0], cmd[1]], opts);
+  }
+};
+var JsonMSetCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.MSET"];
+    for (const c of cmd) {
+      command.push(c.key, c.path, c.value);
+    }
+    super(command, opts);
+  }
+};
+var JsonNumIncrByCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.NUMINCRBY", ...cmd], opts);
+  }
+};
+var JsonNumMultByCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.NUMMULTBY", ...cmd], opts);
+  }
+};
+var JsonObjKeysCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.OBJKEYS", ...cmd], opts);
+  }
+};
+var JsonObjLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.OBJLEN", ...cmd], opts);
+  }
+};
+var JsonRespCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.RESP", ...cmd], opts);
+  }
+};
+var JsonSetCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.SET", cmd[0], cmd[1], cmd[2]];
+    if (cmd[3]) {
+      if (cmd[3].nx) {
+        command.push("NX");
+      } else if (cmd[3].xx) {
+        command.push("XX");
+      }
+    }
+    super(command, opts);
+  }
+};
+var JsonStrAppendCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.STRAPPEND", ...cmd], opts);
+  }
+};
+var JsonStrLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.STRLEN", ...cmd], opts);
+  }
+};
+var JsonToggleCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.TOGGLE", ...cmd], opts);
+  }
+};
+var JsonTypeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["JSON.TYPE", ...cmd], opts);
+  }
+};
+var KeysCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["keys", ...cmd], opts);
+  }
+};
+var LIndexCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lindex", ...cmd], opts);
+  }
+};
+var LInsertCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["linsert", ...cmd], opts);
+  }
+};
+var LLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["llen", ...cmd], opts);
+  }
+};
+var LMoveCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lmove", ...cmd], opts);
+  }
+};
+var LmPopCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [numkeys, keys, direction, count] = cmd;
+    super(["LMPOP", numkeys, ...keys, direction, ...count ? ["COUNT", count] : []], opts);
+  }
+};
+var LPopCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lpop", ...cmd], opts);
+  }
+};
+var LPosCommand = class extends Command {
+  constructor(cmd, opts) {
+    const args = ["lpos", cmd[0], cmd[1]];
+    if (typeof cmd[2]?.rank === "number") {
+      args.push("rank", cmd[2].rank);
+    }
+    if (typeof cmd[2]?.count === "number") {
+      args.push("count", cmd[2].count);
+    }
+    if (typeof cmd[2]?.maxLen === "number") {
+      args.push("maxLen", cmd[2].maxLen);
+    }
+    super(args, opts);
+  }
+};
+var LPushCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lpush", ...cmd], opts);
+  }
+};
+var LPushXCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lpushx", ...cmd], opts);
+  }
+};
+var LRangeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lrange", ...cmd], opts);
+  }
+};
+var LRemCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lrem", ...cmd], opts);
+  }
+};
+var LSetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["lset", ...cmd], opts);
+  }
+};
+var LTrimCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ltrim", ...cmd], opts);
+  }
+};
+var MGetCommand = class extends Command {
+  constructor(cmd, opts) {
+    const keys = Array.isArray(cmd[0]) ? cmd[0] : cmd;
+    super(["mget", ...keys], opts);
+  }
+};
+var MSetCommand = class extends Command {
+  constructor([kv], opts) {
+    super(["mset", ...Object.entries(kv).flatMap(([key, value]) => [key, value])], opts);
+  }
+};
+var MSetNXCommand = class extends Command {
+  constructor([kv], opts) {
+    super(["msetnx", ...Object.entries(kv).flat()], opts);
+  }
+};
+var PersistCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["persist", ...cmd], opts);
+  }
+};
+var PExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pexpire", ...cmd], opts);
+  }
+};
+var PExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pexpireat", ...cmd], opts);
+  }
+};
+var PfAddCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pfadd", ...cmd], opts);
+  }
+};
+var PfCountCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pfcount", ...cmd], opts);
+  }
+};
+var PfMergeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pfmerge", ...cmd], opts);
+  }
+};
+var PingCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["ping"];
+    if (cmd?.[0] !== undefined) {
+      command.push(cmd[0]);
+    }
+    super(command, opts);
+  }
+};
+var PSetEXCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["psetex", ...cmd], opts);
+  }
+};
+var PTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["pttl", ...cmd], opts);
+  }
+};
+var PublishCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["publish", ...cmd], opts);
+  }
+};
+var RandomKeyCommand = class extends Command {
+  constructor(opts) {
+    super(["randomkey"], opts);
+  }
+};
+var RenameCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["rename", ...cmd], opts);
+  }
+};
+var RenameNXCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["renamenx", ...cmd], opts);
+  }
+};
+var RPopCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["rpop", ...cmd], opts);
+  }
+};
+var RPushCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["rpush", ...cmd], opts);
+  }
+};
+var RPushXCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["rpushx", ...cmd], opts);
+  }
+};
+var SAddCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sadd", ...cmd], opts);
+  }
+};
+var ScanCommand = class extends Command {
+  constructor([cursor, opts], cmdOpts) {
+    const command = ["scan", cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+    if (opts && "withType" in opts && opts.withType === true) {
+      command.push("withtype");
+    } else if (opts && "type" in opts && opts.type && opts.type.length > 0) {
+      command.push("type", opts.type);
+    }
+    super(command, {
+      deserialize: opts?.withType ? deserializeScanWithTypesResponse : deserializeScanResponse,
+      ...cmdOpts
+    });
+  }
+};
+var SCardCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["scard", ...cmd], opts);
+  }
+};
+var ScriptExistsCommand = class extends Command {
+  constructor(hashes, opts) {
+    super(["script", "exists", ...hashes], {
+      deserialize: (result) => result,
+      ...opts
+    });
+  }
+};
+var ScriptFlushCommand = class extends Command {
+  constructor([opts], cmdOpts) {
+    const cmd = ["script", "flush"];
+    if (opts?.sync) {
+      cmd.push("sync");
+    } else if (opts?.async) {
+      cmd.push("async");
+    }
+    super(cmd, cmdOpts);
+  }
+};
+var ScriptLoadCommand = class extends Command {
+  constructor(args, opts) {
+    super(["script", "load", ...args], opts);
+  }
+};
+var SDiffCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sdiff", ...cmd], opts);
+  }
+};
+var SDiffStoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sdiffstore", ...cmd], opts);
+  }
+};
+var SetCommand = class extends Command {
+  constructor([key, value, opts], cmdOpts) {
+    const command = ["set", key, value];
+    if (opts) {
+      if ("nx" in opts && opts.nx) {
+        command.push("nx");
+      } else if ("xx" in opts && opts.xx) {
+        command.push("xx");
+      }
+      if ("get" in opts && opts.get) {
+        command.push("get");
+      }
+      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);
+      } else if ("exat" in opts && typeof opts.exat === "number") {
+        command.push("exat", opts.exat);
+      } else if ("pxat" in opts && typeof opts.pxat === "number") {
+        command.push("pxat", opts.pxat);
+      } else if ("keepTtl" in opts && opts.keepTtl) {
+        command.push("keepTtl");
+      }
+    }
+    super(command, cmdOpts);
+  }
+};
+var SetBitCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["setbit", ...cmd], opts);
+  }
+};
+var SetExCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["setex", ...cmd], opts);
+  }
+};
+var SetNxCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["setnx", ...cmd], opts);
+  }
+};
+var SetRangeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["setrange", ...cmd], opts);
+  }
+};
+var SInterCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sinter", ...cmd], opts);
+  }
+};
+var SInterCardCommand = class extends Command {
+  constructor(cmd, cmdOpts) {
+    const [keys, opts] = cmd;
+    const command = ["sintercard", keys.length, ...keys];
+    if (opts?.limit !== undefined) {
+      command.push("LIMIT", opts.limit);
+    }
+    super(command, cmdOpts);
+  }
+};
+var SInterStoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sinterstore", ...cmd], opts);
+  }
+};
+var SIsMemberCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sismember", ...cmd], opts);
+  }
+};
+var SMembersCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["smembers", ...cmd], opts);
+  }
+};
+var SMIsMemberCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["smismember", cmd[0], ...cmd[1]], opts);
+  }
+};
+var SMoveCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["smove", ...cmd], opts);
+  }
+};
+var SPopCommand = class extends Command {
+  constructor([key, count], opts) {
+    const command = ["spop", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+};
+var SRandMemberCommand = class extends Command {
+  constructor([key, count], opts) {
+    const command = ["srandmember", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+};
+var SRemCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["srem", ...cmd], opts);
+  }
+};
+var SScanCommand = class extends Command {
+  constructor([key, cursor, opts], cmdOpts) {
+    const command = ["sscan", key, cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts
+    });
+  }
+};
+var StrLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["strlen", ...cmd], opts);
+  }
+};
+var SUnionCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sunion", ...cmd], opts);
+  }
+};
+var SUnionStoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["sunionstore", ...cmd], opts);
+  }
+};
+var TimeCommand = class extends Command {
+  constructor(opts) {
+    super(["time"], opts);
+  }
+};
+var TouchCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["touch", ...cmd], opts);
+  }
+};
+var TtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ttl", ...cmd], opts);
+  }
+};
+var TypeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["type", ...cmd], opts);
+  }
+};
+var UnlinkCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["unlink", ...cmd], opts);
+  }
+};
+var XAckCommand = class extends Command {
+  constructor([key, group, id], opts) {
+    const ids = Array.isArray(id) ? [...id] : [id];
+    super(["XACK", key, group, ...ids], opts);
+  }
+};
+var XAckDelCommand = class extends Command {
+  constructor([key, group, opts, ...ids], cmdOpts) {
+    const command = ["XACKDEL", key, group];
+    command.push(opts.toUpperCase(), "IDS", ids.length, ...ids);
+    super(command, cmdOpts);
+  }
+};
+var XAddCommand = class extends Command {
+  constructor([key, id, entries, opts], commandOptions) {
+    const command = ["XADD", key];
+    if (opts) {
+      if (opts.nomkStream) {
+        command.push("NOMKSTREAM");
+      }
+      if (opts.trim) {
+        command.push(opts.trim.type, opts.trim.comparison, opts.trim.threshold);
+        if (opts.trim.limit !== undefined) {
+          command.push("LIMIT", opts.trim.limit);
+        }
+      }
+    }
+    command.push(id);
+    for (const [k, v] of Object.entries(entries)) {
+      command.push(k, v);
+    }
+    super(command, commandOptions);
+  }
+};
+var XAutoClaim = class extends Command {
+  constructor([key, group, consumer, minIdleTime, start, options], opts) {
+    const commands = [];
+    if (options?.count) {
+      commands.push("COUNT", options.count);
+    }
+    if (options?.justId) {
+      commands.push("JUSTID");
+    }
+    super(["XAUTOCLAIM", key, group, consumer, minIdleTime, start, ...commands], opts);
+  }
+};
+var XClaimCommand = class extends Command {
+  constructor([key, group, consumer, minIdleTime, id, options], opts) {
+    const ids = Array.isArray(id) ? [...id] : [id];
+    const commands = [];
+    if (options?.idleMS) {
+      commands.push("IDLE", options.idleMS);
+    }
+    if (options?.idleMS) {
+      commands.push("TIME", options.timeMS);
+    }
+    if (options?.retryCount) {
+      commands.push("RETRYCOUNT", options.retryCount);
+    }
+    if (options?.force) {
+      commands.push("FORCE");
+    }
+    if (options?.justId) {
+      commands.push("JUSTID");
+    }
+    if (options?.lastId) {
+      commands.push("LASTID", options.lastId);
+    }
+    super(["XCLAIM", key, group, consumer, minIdleTime, ...ids, ...commands], opts);
+  }
+};
+var XDelCommand = class extends Command {
+  constructor([key, ids], opts) {
+    const cmds = Array.isArray(ids) ? [...ids] : [ids];
+    super(["XDEL", key, ...cmds], opts);
+  }
+};
+var XDelExCommand = class extends Command {
+  constructor([key, opts, ...ids], cmdOpts) {
+    const command = ["XDELEX", key];
+    if (opts) {
+      command.push(opts.toUpperCase());
+    }
+    command.push("IDS", ids.length, ...ids);
+    super(command, cmdOpts);
+  }
+};
+var XGroupCommand = class extends Command {
+  constructor([key, opts], commandOptions) {
+    const command = ["XGROUP"];
+    switch (opts.type) {
+      case "CREATE": {
+        command.push("CREATE", key, opts.group, opts.id);
+        if (opts.options) {
+          if (opts.options.MKSTREAM) {
+            command.push("MKSTREAM");
+          }
+          if (opts.options.ENTRIESREAD !== undefined) {
+            command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
+          }
+        }
+        break;
+      }
+      case "CREATECONSUMER": {
+        command.push("CREATECONSUMER", key, opts.group, opts.consumer);
+        break;
+      }
+      case "DELCONSUMER": {
+        command.push("DELCONSUMER", key, opts.group, opts.consumer);
+        break;
+      }
+      case "DESTROY": {
+        command.push("DESTROY", key, opts.group);
+        break;
+      }
+      case "SETID": {
+        command.push("SETID", key, opts.group, opts.id);
+        if (opts.options?.ENTRIESREAD !== undefined) {
+          command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
+        }
+        break;
+      }
+      default: {
+        throw new Error("Invalid XGROUP");
+      }
+    }
+    super(command, commandOptions);
+  }
+};
+var XInfoCommand = class extends Command {
+  constructor([key, options], opts) {
+    const cmds = [];
+    if (options.type === "CONSUMERS") {
+      cmds.push("CONSUMERS", key, options.group);
+    } else {
+      cmds.push("GROUPS", key);
+    }
+    super(["XINFO", ...cmds], opts);
+  }
+};
+var XLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["XLEN", ...cmd], opts);
+  }
+};
+var XPendingCommand = class extends Command {
+  constructor([key, group, start, end, count, options], opts) {
+    const consumers = options?.consumer === undefined ? [] : Array.isArray(options.consumer) ? [...options.consumer] : [options.consumer];
+    super([
+      "XPENDING",
+      key,
+      group,
+      ...options?.idleTime ? ["IDLE", options.idleTime] : [],
+      start,
+      end,
+      count,
+      ...consumers
+    ], opts);
+  }
+};
+function deserialize6(result) {
+  const obj = {};
+  for (const e of result) {
+    for (let i = 0;i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
+      if (!(streamId in obj)) {
+        obj[streamId] = {};
+      }
+      for (let j = 0;j < entries.length; j += 2) {
+        const field = entries[j];
+        const value = entries[j + 1];
+        try {
+          obj[streamId][field] = JSON.parse(value);
+        } catch {
+          obj[streamId][field] = value;
+        }
+      }
+    }
+  }
+  return obj;
+}
+var XRangeCommand = class extends Command {
+  constructor([key, start, end, count], opts) {
+    const command = ["XRANGE", key, start, end];
+    if (typeof count === "number") {
+      command.push("COUNT", count);
+    }
+    super(command, {
+      deserialize: (result) => deserialize6(result),
+      ...opts
+    });
+  }
+};
+var UNBALANCED_XREAD_ERR = "ERR Unbalanced XREAD list of streams: for each stream key an ID or '$' must be specified";
+var XReadCommand = class extends Command {
+  constructor([key, id, options], opts) {
+    if (Array.isArray(key) && Array.isArray(id) && key.length !== id.length) {
+      throw new Error(UNBALANCED_XREAD_ERR);
+    }
+    const commands = [];
+    if (typeof options?.count === "number") {
+      commands.push("COUNT", options.count);
+    }
+    if (typeof options?.blockMS === "number") {
+      commands.push("BLOCK", options.blockMS);
+    }
+    commands.push("STREAMS", ...Array.isArray(key) ? [...key] : [key], ...Array.isArray(id) ? [...id] : [id]);
+    super(["XREAD", ...commands], opts);
+  }
+};
+var UNBALANCED_XREADGROUP_ERR = "ERR Unbalanced XREADGROUP list of streams: for each stream key an ID or '$' must be specified";
+var XReadGroupCommand = class extends Command {
+  constructor([group, consumer, key, id, options], opts) {
+    if (Array.isArray(key) && Array.isArray(id) && key.length !== id.length) {
+      throw new Error(UNBALANCED_XREADGROUP_ERR);
+    }
+    const commands = [];
+    if (typeof options?.count === "number") {
+      commands.push("COUNT", options.count);
+    }
+    if (typeof options?.blockMS === "number") {
+      commands.push("BLOCK", options.blockMS);
+    }
+    if (typeof options?.NOACK === "boolean" && options.NOACK) {
+      commands.push("NOACK");
+    }
+    commands.push("STREAMS", ...Array.isArray(key) ? [...key] : [key], ...Array.isArray(id) ? [...id] : [id]);
+    super(["XREADGROUP", "GROUP", group, consumer, ...commands], opts);
+  }
+};
+var XRevRangeCommand = class extends Command {
+  constructor([key, end, start, count], opts) {
+    const command = ["XREVRANGE", key, end, start];
+    if (typeof count === "number") {
+      command.push("COUNT", count);
+    }
+    super(command, {
+      deserialize: (result) => deserialize7(result),
+      ...opts
+    });
+  }
+};
+function deserialize7(result) {
+  const obj = {};
+  for (const e of result) {
+    for (let i = 0;i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
+      if (!(streamId in obj)) {
+        obj[streamId] = {};
+      }
+      for (let j = 0;j < entries.length; j += 2) {
+        const field = entries[j];
+        const value = entries[j + 1];
+        try {
+          obj[streamId][field] = JSON.parse(value);
+        } catch {
+          obj[streamId][field] = value;
+        }
+      }
+    }
+  }
+  return obj;
+}
+var XTrimCommand = class extends Command {
+  constructor([key, options], opts) {
+    const { limit, strategy, threshold, exactness = "~" } = options;
+    super(["XTRIM", key, strategy, exactness, threshold, ...limit ? ["LIMIT", limit] : []], opts);
+  }
+};
+var ZAddCommand = class extends Command {
+  constructor([key, arg1, ...arg2], opts) {
+    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 ("lt" in arg1 && arg1.lt) {
+      command.push("lt");
+    } else if ("gt" in arg1 && arg1.gt) {
+      command.push("gt");
+    }
+    if ("score" in arg1 && "member" in arg1) {
+      command.push(arg1.score, arg1.member);
+    }
+    command.push(...arg2.flatMap(({ score, member }) => [score, member]));
+    super(command, opts);
+  }
+};
+var ZCardCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zcard", ...cmd], opts);
+  }
+};
+var ZCountCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zcount", ...cmd], opts);
+  }
+};
+var ZIncrByCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zincrby", ...cmd], opts);
+  }
+};
+var ZInterStoreCommand = class extends Command {
+  constructor([destination, numKeys, keyOrKeys, opts], cmdOpts) {
+    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, cmdOpts);
+  }
+};
+var ZLexCountCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zlexcount", ...cmd], opts);
+  }
+};
+var ZPopMaxCommand = class extends Command {
+  constructor([key, count], opts) {
+    const command = ["zpopmax", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+};
+var ZPopMinCommand = class extends Command {
+  constructor([key, count], opts) {
+    const command = ["zpopmin", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+};
+var ZRangeCommand = class extends Command {
+  constructor([key, min, max, opts], cmdOpts) {
+    const command = ["zrange", key, min, max];
+    if (opts?.byScore) {
+      command.push("byscore");
+    }
+    if (opts?.byLex) {
+      command.push("bylex");
+    }
+    if (opts?.rev) {
+      command.push("rev");
+    }
+    if (opts?.count !== undefined && opts.offset !== undefined) {
+      command.push("limit", opts.offset, opts.count);
+    }
+    if (opts?.withScores) {
+      command.push("withscores");
+    }
+    super(command, cmdOpts);
+  }
+};
+var ZRankCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zrank", ...cmd], opts);
+  }
+};
+var ZRemCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zrem", ...cmd], opts);
+  }
+};
+var ZRemRangeByLexCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zremrangebylex", ...cmd], opts);
+  }
+};
+var ZRemRangeByRankCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zremrangebyrank", ...cmd], opts);
+  }
+};
+var ZRemRangeByScoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zremrangebyscore", ...cmd], opts);
+  }
+};
+var ZRevRankCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zrevrank", ...cmd], opts);
+  }
+};
+var ZScanCommand = class extends Command {
+  constructor([key, cursor, opts], cmdOpts) {
+    const command = ["zscan", key, cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts
+    });
+  }
+};
+var ZScoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zscore", ...cmd], opts);
+  }
+};
+var ZUnionCommand = class extends Command {
+  constructor([numKeys, keyOrKeys, opts], cmdOpts) {
+    const command = ["zunion", 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);
+      }
+      if (opts.withScores) {
+        command.push("withscores");
+      }
+    }
+    super(command, cmdOpts);
+  }
+};
+var ZUnionStoreCommand = class extends Command {
+  constructor([destination, numKeys, keyOrKeys, opts], cmdOpts) {
+    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, cmdOpts);
+  }
+};
+var ZDiffStoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["zdiffstore", ...cmd], opts);
+  }
+};
+var ZMScoreCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, members] = cmd;
+    super(["zmscore", key, ...members], opts);
+  }
+};
+var Pipeline = class {
+  client;
+  commands;
+  commandOptions;
+  multiExec;
+  constructor(opts) {
+    this.client = opts.client;
+    this.commands = [];
+    this.commandOptions = opts.commandOptions;
+    this.multiExec = opts.multiExec ?? false;
+    if (this.commandOptions?.latencyLogging) {
+      const originalExec = this.exec.bind(this);
+      this.exec = async (options) => {
+        const start = performance.now();
+        const result = await (options ? originalExec(options) : originalExec());
+        const end = performance.now();
+        const loggerResult = (end - start).toFixed(2);
+        return result;
+      };
+    }
+  }
+  exec = async (options) => {
+    if (this.commands.length === 0) {
+      throw new Error("Pipeline is empty");
+    }
+    const path = this.multiExec ? ["multi-exec"] : ["pipeline"];
+    const res = await this.client.request({
+      path,
+      body: Object.values(this.commands).map((c) => c.command)
+    });
+    return options?.keepErrors ? res.map(({ error, result }, i) => {
+      return {
+        error,
+        result: this.commands[i].deserialize(result)
+      };
+    }) : 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);
+    });
+  };
+  length() {
+    return this.commands.length;
+  }
+  chain(command) {
+    this.commands.push(command);
+    return this;
+  }
+  append = (...args) => this.chain(new AppendCommand(args, this.commandOptions));
+  bitcount = (...args) => this.chain(new BitCountCommand(args, this.commandOptions));
+  bitfield = (...args) => new BitFieldCommand(args, this.client, this.commandOptions, this.chain.bind(this));
+  bitop = (op, destinationKey, sourceKey, ...sourceKeys) => this.chain(new BitOpCommand([op, destinationKey, sourceKey, ...sourceKeys], this.commandOptions));
+  bitpos = (...args) => this.chain(new BitPosCommand(args, this.commandOptions));
+  clientSetinfo = (...args) => this.chain(new ClientSetInfoCommand(args, this.commandOptions));
+  copy = (...args) => this.chain(new CopyCommand(args, this.commandOptions));
+  zdiffstore = (...args) => this.chain(new ZDiffStoreCommand(args, this.commandOptions));
+  dbsize = () => this.chain(new DBSizeCommand(this.commandOptions));
+  decr = (...args) => this.chain(new DecrCommand(args, this.commandOptions));
+  decrby = (...args) => this.chain(new DecrByCommand(args, this.commandOptions));
+  del = (...args) => this.chain(new DelCommand(args, this.commandOptions));
+  echo = (...args) => this.chain(new EchoCommand(args, this.commandOptions));
+  evalRo = (...args) => this.chain(new EvalROCommand(args, this.commandOptions));
+  eval = (...args) => this.chain(new EvalCommand(args, this.commandOptions));
+  evalshaRo = (...args) => this.chain(new EvalshaROCommand(args, this.commandOptions));
+  evalsha = (...args) => this.chain(new EvalshaCommand(args, this.commandOptions));
+  exists = (...args) => this.chain(new ExistsCommand(args, this.commandOptions));
+  expire = (...args) => this.chain(new ExpireCommand(args, this.commandOptions));
+  expireat = (...args) => this.chain(new ExpireAtCommand(args, this.commandOptions));
+  flushall = (args) => this.chain(new FlushAllCommand(args, this.commandOptions));
+  flushdb = (...args) => this.chain(new FlushDBCommand(args, this.commandOptions));
+  geoadd = (...args) => this.chain(new GeoAddCommand(args, this.commandOptions));
+  geodist = (...args) => this.chain(new GeoDistCommand(args, this.commandOptions));
+  geopos = (...args) => this.chain(new GeoPosCommand(args, this.commandOptions));
+  geohash = (...args) => this.chain(new GeoHashCommand(args, this.commandOptions));
+  geosearch = (...args) => this.chain(new GeoSearchCommand(args, this.commandOptions));
+  geosearchstore = (...args) => this.chain(new GeoSearchStoreCommand(args, this.commandOptions));
+  get = (...args) => this.chain(new GetCommand(args, this.commandOptions));
+  getbit = (...args) => this.chain(new GetBitCommand(args, this.commandOptions));
+  getdel = (...args) => this.chain(new GetDelCommand(args, this.commandOptions));
+  getex = (...args) => this.chain(new GetExCommand(args, this.commandOptions));
+  getrange = (...args) => this.chain(new GetRangeCommand(args, this.commandOptions));
+  getset = (key, value) => this.chain(new GetSetCommand([key, value], this.commandOptions));
+  hdel = (...args) => this.chain(new HDelCommand(args, this.commandOptions));
+  hexists = (...args) => this.chain(new HExistsCommand(args, this.commandOptions));
+  hexpire = (...args) => this.chain(new HExpireCommand(args, this.commandOptions));
+  hexpireat = (...args) => this.chain(new HExpireAtCommand(args, this.commandOptions));
+  hexpiretime = (...args) => this.chain(new HExpireTimeCommand(args, this.commandOptions));
+  httl = (...args) => this.chain(new HTtlCommand(args, this.commandOptions));
+  hpexpire = (...args) => this.chain(new HPExpireCommand(args, this.commandOptions));
+  hpexpireat = (...args) => this.chain(new HPExpireAtCommand(args, this.commandOptions));
+  hpexpiretime = (...args) => this.chain(new HPExpireTimeCommand(args, this.commandOptions));
+  hpttl = (...args) => this.chain(new HPTtlCommand(args, this.commandOptions));
+  hpersist = (...args) => this.chain(new HPersistCommand(args, this.commandOptions));
+  hget = (...args) => this.chain(new HGetCommand(args, this.commandOptions));
+  hgetall = (...args) => this.chain(new HGetAllCommand(args, this.commandOptions));
+  hgetdel = (...args) => this.chain(new HGetDelCommand(args, this.commandOptions));
+  hgetex = (...args) => this.chain(new HGetExCommand(args, this.commandOptions));
+  hincrby = (...args) => this.chain(new HIncrByCommand(args, this.commandOptions));
+  hincrbyfloat = (...args) => this.chain(new HIncrByFloatCommand(args, this.commandOptions));
+  hkeys = (...args) => this.chain(new HKeysCommand(args, this.commandOptions));
+  hlen = (...args) => this.chain(new HLenCommand(args, this.commandOptions));
+  hmget = (...args) => this.chain(new HMGetCommand(args, this.commandOptions));
+  hmset = (key, kv) => this.chain(new HMSetCommand([key, kv], this.commandOptions));
+  hrandfield = (key, count, withValues) => this.chain(new HRandFieldCommand([key, count, withValues], this.commandOptions));
+  hscan = (...args) => this.chain(new HScanCommand(args, this.commandOptions));
+  hset = (key, kv) => this.chain(new HSetCommand([key, kv], this.commandOptions));
+  hsetex = (...args) => this.chain(new HSetExCommand(args, this.commandOptions));
+  hsetnx = (key, field, value) => this.chain(new HSetNXCommand([key, field, value], this.commandOptions));
+  hstrlen = (...args) => this.chain(new HStrLenCommand(args, this.commandOptions));
+  hvals = (...args) => this.chain(new HValsCommand(args, this.commandOptions));
+  incr = (...args) => this.chain(new IncrCommand(args, this.commandOptions));
+  incrby = (...args) => this.chain(new IncrByCommand(args, this.commandOptions));
+  incrbyfloat = (...args) => this.chain(new IncrByFloatCommand(args, this.commandOptions));
+  keys = (...args) => this.chain(new KeysCommand(args, this.commandOptions));
+  lindex = (...args) => this.chain(new LIndexCommand(args, this.commandOptions));
+  linsert = (key, direction, pivot, value) => this.chain(new LInsertCommand([key, direction, pivot, value], this.commandOptions));
+  llen = (...args) => this.chain(new LLenCommand(args, this.commandOptions));
+  lmove = (...args) => this.chain(new LMoveCommand(args, this.commandOptions));
+  lpop = (...args) => this.chain(new LPopCommand(args, this.commandOptions));
+  lmpop = (...args) => this.chain(new LmPopCommand(args, this.commandOptions));
+  lpos = (...args) => this.chain(new LPosCommand(args, this.commandOptions));
+  lpush = (key, ...elements) => this.chain(new LPushCommand([key, ...elements], this.commandOptions));
+  lpushx = (key, ...elements) => this.chain(new LPushXCommand([key, ...elements], this.commandOptions));
+  lrange = (...args) => this.chain(new LRangeCommand(args, this.commandOptions));
+  lrem = (key, count, value) => this.chain(new LRemCommand([key, count, value], this.commandOptions));
+  lset = (key, index, value) => this.chain(new LSetCommand([key, index, value], this.commandOptions));
+  ltrim = (...args) => this.chain(new LTrimCommand(args, this.commandOptions));
+  mget = (...args) => this.chain(new MGetCommand(args, this.commandOptions));
+  mset = (kv) => this.chain(new MSetCommand([kv], this.commandOptions));
+  msetnx = (kv) => this.chain(new MSetNXCommand([kv], this.commandOptions));
+  persist = (...args) => this.chain(new PersistCommand(args, this.commandOptions));
+  pexpire = (...args) => this.chain(new PExpireCommand(args, this.commandOptions));
+  pexpireat = (...args) => this.chain(new PExpireAtCommand(args, this.commandOptions));
+  pfadd = (...args) => this.chain(new PfAddCommand(args, this.commandOptions));
+  pfcount = (...args) => this.chain(new PfCountCommand(args, this.commandOptions));
+  pfmerge = (...args) => this.chain(new PfMergeCommand(args, this.commandOptions));
+  ping = (args) => this.chain(new PingCommand(args, this.commandOptions));
+  psetex = (key, ttl, value) => this.chain(new PSetEXCommand([key, ttl, value], this.commandOptions));
+  pttl = (...args) => this.chain(new PTtlCommand(args, this.commandOptions));
+  publish = (...args) => this.chain(new PublishCommand(args, this.commandOptions));
+  randomkey = () => this.chain(new RandomKeyCommand(this.commandOptions));
+  rename = (...args) => this.chain(new RenameCommand(args, this.commandOptions));
+  renamenx = (...args) => this.chain(new RenameNXCommand(args, this.commandOptions));
+  rpop = (...args) => this.chain(new RPopCommand(args, this.commandOptions));
+  rpush = (key, ...elements) => this.chain(new RPushCommand([key, ...elements], this.commandOptions));
+  rpushx = (key, ...elements) => this.chain(new RPushXCommand([key, ...elements], this.commandOptions));
+  sadd = (key, member, ...members) => this.chain(new SAddCommand([key, member, ...members], this.commandOptions));
+  scan = (...args) => this.chain(new ScanCommand(args, this.commandOptions));
+  scard = (...args) => this.chain(new SCardCommand(args, this.commandOptions));
+  scriptExists = (...args) => this.chain(new ScriptExistsCommand(args, this.commandOptions));
+  scriptFlush = (...args) => this.chain(new ScriptFlushCommand(args, this.commandOptions));
+  scriptLoad = (...args) => this.chain(new ScriptLoadCommand(args, this.commandOptions));
+  sdiff = (...args) => this.chain(new SDiffCommand(args, this.commandOptions));
+  sdiffstore = (...args) => this.chain(new SDiffStoreCommand(args, this.commandOptions));
+  set = (key, value, opts) => this.chain(new SetCommand([key, value, opts], this.commandOptions));
+  setbit = (...args) => this.chain(new SetBitCommand(args, this.commandOptions));
+  setex = (key, ttl, value) => this.chain(new SetExCommand([key, ttl, value], this.commandOptions));
+  setnx = (key, value) => this.chain(new SetNxCommand([key, value], this.commandOptions));
+  setrange = (...args) => this.chain(new SetRangeCommand(args, this.commandOptions));
+  sinter = (...args) => this.chain(new SInterCommand(args, this.commandOptions));
+  sintercard = (...args) => this.chain(new SInterCardCommand(args, this.commandOptions));
+  sinterstore = (...args) => this.chain(new SInterStoreCommand(args, this.commandOptions));
+  sismember = (key, member) => this.chain(new SIsMemberCommand([key, member], this.commandOptions));
+  smembers = (...args) => this.chain(new SMembersCommand(args, this.commandOptions));
+  smismember = (key, members) => this.chain(new SMIsMemberCommand([key, members], this.commandOptions));
+  smove = (source, destination, member) => this.chain(new SMoveCommand([source, destination, member], this.commandOptions));
+  spop = (...args) => this.chain(new SPopCommand(args, this.commandOptions));
+  srandmember = (...args) => this.chain(new SRandMemberCommand(args, this.commandOptions));
+  srem = (key, ...members) => this.chain(new SRemCommand([key, ...members], this.commandOptions));
+  sscan = (...args) => this.chain(new SScanCommand(args, this.commandOptions));
+  strlen = (...args) => this.chain(new StrLenCommand(args, this.commandOptions));
+  sunion = (...args) => this.chain(new SUnionCommand(args, this.commandOptions));
+  sunionstore = (...args) => this.chain(new SUnionStoreCommand(args, this.commandOptions));
+  time = () => this.chain(new TimeCommand(this.commandOptions));
+  touch = (...args) => this.chain(new TouchCommand(args, this.commandOptions));
+  ttl = (...args) => this.chain(new TtlCommand(args, this.commandOptions));
+  type = (...args) => this.chain(new TypeCommand(args, this.commandOptions));
+  unlink = (...args) => this.chain(new UnlinkCommand(args, this.commandOptions));
+  zadd = (...args) => {
+    if ("score" in args[1]) {
+      return this.chain(new ZAddCommand([args[0], args[1], ...args.slice(2)], this.commandOptions));
+    }
+    return this.chain(new ZAddCommand([args[0], args[1], ...args.slice(2)], this.commandOptions));
+  };
+  xadd = (...args) => this.chain(new XAddCommand(args, this.commandOptions));
+  xack = (...args) => this.chain(new XAckCommand(args, this.commandOptions));
+  xackdel = (...args) => this.chain(new XAckDelCommand(args, this.commandOptions));
+  xdel = (...args) => this.chain(new XDelCommand(args, this.commandOptions));
+  xdelex = (...args) => this.chain(new XDelExCommand(args, this.commandOptions));
+  xgroup = (...args) => this.chain(new XGroupCommand(args, this.commandOptions));
+  xread = (...args) => this.chain(new XReadCommand(args, this.commandOptions));
+  xreadgroup = (...args) => this.chain(new XReadGroupCommand(args, this.commandOptions));
+  xinfo = (...args) => this.chain(new XInfoCommand(args, this.commandOptions));
+  xlen = (...args) => this.chain(new XLenCommand(args, this.commandOptions));
+  xpending = (...args) => this.chain(new XPendingCommand(args, this.commandOptions));
+  xclaim = (...args) => this.chain(new XClaimCommand(args, this.commandOptions));
+  xautoclaim = (...args) => this.chain(new XAutoClaim(args, this.commandOptions));
+  xtrim = (...args) => this.chain(new XTrimCommand(args, this.commandOptions));
+  xrange = (...args) => this.chain(new XRangeCommand(args, this.commandOptions));
+  xrevrange = (...args) => this.chain(new XRevRangeCommand(args, this.commandOptions));
+  zcard = (...args) => this.chain(new ZCardCommand(args, this.commandOptions));
+  zcount = (...args) => this.chain(new ZCountCommand(args, this.commandOptions));
+  zincrby = (key, increment, member) => this.chain(new ZIncrByCommand([key, increment, member], this.commandOptions));
+  zinterstore = (...args) => this.chain(new ZInterStoreCommand(args, this.commandOptions));
+  zlexcount = (...args) => this.chain(new ZLexCountCommand(args, this.commandOptions));
+  zmscore = (...args) => this.chain(new ZMScoreCommand(args, this.commandOptions));
+  zpopmax = (...args) => this.chain(new ZPopMaxCommand(args, this.commandOptions));
+  zpopmin = (...args) => this.chain(new ZPopMinCommand(args, this.commandOptions));
+  zrange = (...args) => this.chain(new ZRangeCommand(args, this.commandOptions));
+  zrank = (key, member) => this.chain(new ZRankCommand([key, member], this.commandOptions));
+  zrem = (key, ...members) => this.chain(new ZRemCommand([key, ...members], this.commandOptions));
+  zremrangebylex = (...args) => this.chain(new ZRemRangeByLexCommand(args, this.commandOptions));
+  zremrangebyrank = (...args) => this.chain(new ZRemRangeByRankCommand(args, this.commandOptions));
+  zremrangebyscore = (...args) => this.chain(new ZRemRangeByScoreCommand(args, this.commandOptions));
+  zrevrank = (key, member) => this.chain(new ZRevRankCommand([key, member], this.commandOptions));
+  zscan = (...args) => this.chain(new ZScanCommand(args, this.commandOptions));
+  zscore = (key, member) => this.chain(new ZScoreCommand([key, member], this.commandOptions));
+  zunionstore = (...args) => this.chain(new ZUnionStoreCommand(args, this.commandOptions));
+  zunion = (...args) => this.chain(new ZUnionCommand(args, this.commandOptions));
+  get json() {
+    return {
+      arrappend: (...args) => this.chain(new JsonArrAppendCommand(args, this.commandOptions)),
+      arrindex: (...args) => this.chain(new JsonArrIndexCommand(args, this.commandOptions)),
+      arrinsert: (...args) => this.chain(new JsonArrInsertCommand(args, this.commandOptions)),
+      arrlen: (...args) => this.chain(new JsonArrLenCommand(args, this.commandOptions)),
+      arrpop: (...args) => this.chain(new JsonArrPopCommand(args, this.commandOptions)),
+      arrtrim: (...args) => this.chain(new JsonArrTrimCommand(args, this.commandOptions)),
+      clear: (...args) => this.chain(new JsonClearCommand(args, this.commandOptions)),
+      del: (...args) => this.chain(new JsonDelCommand(args, this.commandOptions)),
+      forget: (...args) => this.chain(new JsonForgetCommand(args, this.commandOptions)),
+      get: (...args) => this.chain(new JsonGetCommand(args, this.commandOptions)),
+      merge: (...args) => this.chain(new JsonMergeCommand(args, this.commandOptions)),
+      mget: (...args) => this.chain(new JsonMGetCommand(args, this.commandOptions)),
+      mset: (...args) => this.chain(new JsonMSetCommand(args, this.commandOptions)),
+      numincrby: (...args) => this.chain(new JsonNumIncrByCommand(args, this.commandOptions)),
+      nummultby: (...args) => this.chain(new JsonNumMultByCommand(args, this.commandOptions)),
+      objkeys: (...args) => this.chain(new JsonObjKeysCommand(args, this.commandOptions)),
+      objlen: (...args) => this.chain(new JsonObjLenCommand(args, this.commandOptions)),
+      resp: (...args) => this.chain(new JsonRespCommand(args, this.commandOptions)),
+      set: (...args) => this.chain(new JsonSetCommand(args, this.commandOptions)),
+      strappend: (...args) => this.chain(new JsonStrAppendCommand(args, this.commandOptions)),
+      strlen: (...args) => this.chain(new JsonStrLenCommand(args, this.commandOptions)),
+      toggle: (...args) => this.chain(new JsonToggleCommand(args, this.commandOptions)),
+      type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
+    };
+  }
+  get functions() {
+    return {
+      load: (...args) => this.chain(new FunctionLoadCommand(args, this.commandOptions)),
+      list: (...args) => this.chain(new FunctionListCommand(args, this.commandOptions)),
+      delete: (...args) => this.chain(new FunctionDeleteCommand(args, this.commandOptions)),
+      flush: () => this.chain(new FunctionFlushCommand(this.commandOptions)),
+      stats: () => this.chain(new FunctionStatsCommand(this.commandOptions)),
+      call: (...args) => this.chain(new FCallCommand(args, this.commandOptions)),
+      callRo: (...args) => this.chain(new FCallRoCommand(args, this.commandOptions))
+    };
+  }
+};
+var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
+  "scan",
+  "keys",
+  "flushdb",
+  "flushall",
+  "dbsize",
+  "hscan",
+  "hgetall",
+  "hkeys",
+  "lrange",
+  "sscan",
+  "smembers",
+  "xrange",
+  "xrevrange",
+  "zscan",
+  "zrange",
+  "exec"
+]);
+function createAutoPipelineProxy(_redis, namespace = "root") {
+  const redis = _redis;
+  if (!redis.autoPipelineExecutor) {
+    redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
+  }
+  return new Proxy(redis, {
+    get: (redis2, command) => {
+      if (command === "pipelineCounter") {
+        return redis2.autoPipelineExecutor.pipelineCounter;
+      }
+      if (namespace === "root" && command === "json") {
+        return createAutoPipelineProxy(redis2, "json");
+      }
+      if (namespace === "root" && command === "functions") {
+        return createAutoPipelineProxy(redis2, "functions");
+      }
+      if (namespace === "root") {
+        const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
+        const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
+        if (commandInRedisButNotPipeline || isCommandExcluded) {
+          return redis2[command];
+        }
+      }
+      const pipeline = redis2.autoPipelineExecutor.pipeline;
+      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
+      const isFunction = typeof targetFunction === "function";
+      if (isFunction) {
+        return (...args) => {
+          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline2) => {
+            const targetFunction2 = namespace === "json" ? pipeline2.json[command] : namespace === "functions" ? pipeline2.functions[command] : pipeline2[command];
+            targetFunction2(...args);
+          });
+        };
+      }
+      return targetFunction;
+    }
+  });
+}
+var AutoPipelineExecutor = class {
+  pipelinePromises = /* @__PURE__ */ new WeakMap;
+  activePipeline = null;
+  indexInCurrentPipeline = 0;
+  redis;
+  pipeline;
+  pipelineCounter = 0;
+  constructor(redis) {
+    this.redis = redis;
+    this.pipeline = redis.pipeline();
+  }
+  async withAutoPipeline(executeWithPipeline) {
+    const pipeline = this.activePipeline ?? this.redis.pipeline();
+    if (!this.activePipeline) {
+      this.activePipeline = pipeline;
+      this.indexInCurrentPipeline = 0;
+    }
+    const index = this.indexInCurrentPipeline++;
+    executeWithPipeline(pipeline);
+    const pipelineDone = this.deferExecution().then(() => {
+      if (!this.pipelinePromises.has(pipeline)) {
+        const pipelinePromise = pipeline.exec({ keepErrors: true });
+        this.pipelineCounter += 1;
+        this.pipelinePromises.set(pipeline, pipelinePromise);
+        this.activePipeline = null;
+      }
+      return this.pipelinePromises.get(pipeline);
+    });
+    const results = await pipelineDone;
+    const commandResult = results[index];
+    if (commandResult.error) {
+      throw new UpstashError(`Command failed: ${commandResult.error}`);
+    }
+    return commandResult.result;
+  }
+  async deferExecution() {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+};
+var PSubscribeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["psubscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal
+      }
+    });
+  }
+};
+var Subscriber = class extends EventTarget {
+  subscriptions;
+  client;
+  listeners;
+  opts;
+  constructor(client, channels, isPattern = false, opts) {
+    super();
+    this.client = client;
+    this.subscriptions = /* @__PURE__ */ new Map;
+    this.listeners = /* @__PURE__ */ new Map;
+    this.opts = opts;
+    for (const channel of channels) {
+      if (isPattern) {
+        this.subscribeToPattern(channel);
+      } else {
+        this.subscribeToChannel(channel);
+      }
+    }
+  }
+  subscribeToChannel(channel) {
+    const controller = new AbortController;
+    const command = new SubscribeCommand([channel], {
+      streamOptions: {
+        signal: controller.signal,
+        onMessage: (data) => this.handleMessage(data, false)
+      }
+    });
+    command.exec(this.client).catch((error) => {
+      if (error.name !== "AbortError") {
+        this.dispatchToListeners("error", error);
+      }
+    });
+    this.subscriptions.set(channel, {
+      command,
+      controller,
+      isPattern: false
+    });
+  }
+  subscribeToPattern(pattern) {
+    const controller = new AbortController;
+    const command = new PSubscribeCommand([pattern], {
+      streamOptions: {
+        signal: controller.signal,
+        onMessage: (data) => this.handleMessage(data, true)
+      }
+    });
+    command.exec(this.client).catch((error) => {
+      if (error.name !== "AbortError") {
+        this.dispatchToListeners("error", error);
+      }
+    });
+    this.subscriptions.set(pattern, {
+      command,
+      controller,
+      isPattern: true
+    });
+  }
+  handleMessage(data, isPattern) {
+    const messageData = data.replace(/^data:\s*/, "");
+    const firstCommaIndex = messageData.indexOf(",");
+    const secondCommaIndex = messageData.indexOf(",", firstCommaIndex + 1);
+    const thirdCommaIndex = isPattern ? messageData.indexOf(",", secondCommaIndex + 1) : -1;
+    if (firstCommaIndex !== -1 && secondCommaIndex !== -1) {
+      const type = messageData.slice(0, firstCommaIndex);
+      if (isPattern && type === "pmessage" && thirdCommaIndex !== -1) {
+        const pattern = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
+        const channel = messageData.slice(secondCommaIndex + 1, thirdCommaIndex);
+        const messageStr = messageData.slice(thirdCommaIndex + 1);
+        try {
+          const message = this.opts?.automaticDeserialization === false ? messageStr : JSON.parse(messageStr);
+          this.dispatchToListeners("pmessage", { pattern, channel, message });
+          this.dispatchToListeners(`pmessage:${pattern}`, { pattern, channel, message });
+        } catch (error) {
+          this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
+        }
+      } else {
+        const channel = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
+        const messageStr = messageData.slice(secondCommaIndex + 1);
+        try {
+          if (type === "subscribe" || type === "psubscribe" || type === "unsubscribe" || type === "punsubscribe") {
+            const count = Number.parseInt(messageStr);
+            this.dispatchToListeners(type, count);
+          } else {
+            const message = this.opts?.automaticDeserialization === false ? messageStr : parseWithTryCatch(messageStr);
+            this.dispatchToListeners(type, { channel, message });
+            this.dispatchToListeners(`${type}:${channel}`, { channel, message });
+          }
+        } catch (error) {
+          this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
+        }
+      }
+    }
+  }
+  dispatchToListeners(type, data) {
+    const listeners = this.listeners.get(type);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(data);
+      }
+    }
+  }
+  on(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set);
+    }
+    this.listeners.get(type)?.add(listener);
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  async unsubscribe(channels) {
+    if (channels) {
+      for (const channel of channels) {
+        const subscription = this.subscriptions.get(channel);
+        if (subscription) {
+          try {
+            subscription.controller.abort();
+          } catch {}
+          this.subscriptions.delete(channel);
+        }
+      }
+    } else {
+      for (const subscription of this.subscriptions.values()) {
+        try {
+          subscription.controller.abort();
+        } catch {}
+      }
+      this.subscriptions.clear();
+      this.removeAllListeners();
+    }
+  }
+  getSubscribedChannels() {
+    return [...this.subscriptions.keys()];
+  }
+};
+var SubscribeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["subscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal
+      }
+    });
+  }
+};
+var parseWithTryCatch = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+};
+var Script = class {
+  script;
+  sha1;
+  initPromise;
+  redis;
+  constructor(redis, script) {
+    this.redis = redis;
+    this.script = script;
+    this.sha1 = "";
+    this.init(script);
+  }
+  init(script) {
+    if (!this.initPromise) {
+      this.initPromise = this.digest(script).then((sha1) => {
+        this.sha1 = sha1;
+      });
+    }
+    return this.initPromise;
+  }
+  async eval(keys, args) {
+    await this.init(this.script);
+    return await this.redis.eval(this.script, keys, args);
+  }
+  async evalsha(keys, args) {
+    await this.init(this.script);
+    return await this.redis.evalsha(this.sha1, keys, args);
+  }
+  async exec(keys, args) {
+    await this.init(this.script);
+    const res = await this.redis.evalsha(this.sha1, keys, args).catch(async (error) => {
+      if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
+        return await this.redis.eval(this.script, keys, args);
+      }
+      throw error;
+    });
+    return res;
+  }
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
+    const hashBuffer = await subtle.digest("SHA-1", data);
+    const hashArray = [...new Uint8Array(hashBuffer)];
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+var ScriptRO = class {
+  script;
+  sha1;
+  initPromise;
+  redis;
+  constructor(redis, script) {
+    this.redis = redis;
+    this.sha1 = "";
+    this.script = script;
+    this.init(script);
+  }
+  init(script) {
+    if (!this.initPromise) {
+      this.initPromise = this.digest(script).then((sha1) => {
+        this.sha1 = sha1;
+      });
+    }
+    return this.initPromise;
+  }
+  async evalRo(keys, args) {
+    await this.init(this.script);
+    return await this.redis.evalRo(this.script, keys, args);
+  }
+  async evalshaRo(keys, args) {
+    await this.init(this.script);
+    return await this.redis.evalshaRo(this.sha1, keys, args);
+  }
+  async exec(keys, args) {
+    await this.init(this.script);
+    const res = await this.redis.evalshaRo(this.sha1, keys, args).catch(async (error) => {
+      if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
+        return await this.redis.evalRo(this.script, keys, args);
+      }
+      throw error;
+    });
+    return res;
+  }
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
+    const hashBuffer = await subtle.digest("SHA-1", data);
+    const hashArray = [...new Uint8Array(hashBuffer)];
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+};
+var Redis = class {
+  client;
+  opts;
+  enableTelemetry;
+  enableAutoPipelining;
+  constructor(client, opts) {
+    this.client = client;
+    this.opts = opts;
+    this.enableTelemetry = opts?.enableTelemetry ?? true;
+    if (opts?.readYourWrites === false) {
+      this.client.readYourWrites = false;
+    }
+    this.enableAutoPipelining = opts?.enableAutoPipelining ?? true;
+  }
+  get readYourWritesSyncToken() {
+    return this.client.upstashSyncToken;
+  }
+  set readYourWritesSyncToken(session) {
+    this.client.upstashSyncToken = session;
+  }
+  get json() {
+    return {
+      arrappend: (...args) => new JsonArrAppendCommand(args, this.opts).exec(this.client),
+      arrindex: (...args) => new JsonArrIndexCommand(args, this.opts).exec(this.client),
+      arrinsert: (...args) => new JsonArrInsertCommand(args, this.opts).exec(this.client),
+      arrlen: (...args) => new JsonArrLenCommand(args, this.opts).exec(this.client),
+      arrpop: (...args) => new JsonArrPopCommand(args, this.opts).exec(this.client),
+      arrtrim: (...args) => new JsonArrTrimCommand(args, this.opts).exec(this.client),
+      clear: (...args) => new JsonClearCommand(args, this.opts).exec(this.client),
+      del: (...args) => new JsonDelCommand(args, this.opts).exec(this.client),
+      forget: (...args) => new JsonForgetCommand(args, this.opts).exec(this.client),
+      get: (...args) => new JsonGetCommand(args, this.opts).exec(this.client),
+      merge: (...args) => new JsonMergeCommand(args, this.opts).exec(this.client),
+      mget: (...args) => new JsonMGetCommand(args, this.opts).exec(this.client),
+      mset: (...args) => new JsonMSetCommand(args, this.opts).exec(this.client),
+      numincrby: (...args) => new JsonNumIncrByCommand(args, this.opts).exec(this.client),
+      nummultby: (...args) => new JsonNumMultByCommand(args, this.opts).exec(this.client),
+      objkeys: (...args) => new JsonObjKeysCommand(args, this.opts).exec(this.client),
+      objlen: (...args) => new JsonObjLenCommand(args, this.opts).exec(this.client),
+      resp: (...args) => new JsonRespCommand(args, this.opts).exec(this.client),
+      set: (...args) => new JsonSetCommand(args, this.opts).exec(this.client),
+      strappend: (...args) => new JsonStrAppendCommand(args, this.opts).exec(this.client),
+      strlen: (...args) => new JsonStrLenCommand(args, this.opts).exec(this.client),
+      toggle: (...args) => new JsonToggleCommand(args, this.opts).exec(this.client),
+      type: (...args) => new JsonTypeCommand(args, this.opts).exec(this.client)
+    };
+  }
+  get functions() {
+    return {
+      load: (...args) => new FunctionLoadCommand(args, this.opts).exec(this.client),
+      list: (...args) => new FunctionListCommand(args, this.opts).exec(this.client),
+      delete: (...args) => new FunctionDeleteCommand(args, this.opts).exec(this.client),
+      flush: () => new FunctionFlushCommand(this.opts).exec(this.client),
+      stats: () => new FunctionStatsCommand(this.opts).exec(this.client),
+      call: (...args) => new FCallCommand(args, this.opts).exec(this.client),
+      callRo: (...args) => new FCallRoCommand(args, this.opts).exec(this.client)
+    };
+  }
+  use = (middleware) => {
+    const makeRequest = this.client.request.bind(this.client);
+    this.client.request = (req) => middleware(req, makeRequest);
+  };
+  addTelemetry = (telemetry) => {
+    if (!this.enableTelemetry) {
+      return;
+    }
+    try {
+      this.client.mergeTelemetry(telemetry);
+    } catch {}
+  };
+  createScript(script, opts) {
+    return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
+  }
+  get search() {
+    return {
+      createIndex: (params) => {
+        return createIndex(this.client, params);
+      },
+      index: (params) => {
+        return initIndex(this.client, params);
+      },
+      alias: {
+        list: () => {
+          return listAliases(this.client);
+        },
+        add: ({ indexName, alias }) => {
+          return addAlias(this.client, { indexName, alias });
+        },
+        delete: ({ alias }) => {
+          return delAlias(this.client, { alias });
+        }
+      }
+    };
+  }
+  pipeline = () => new Pipeline({
+    client: this.client,
+    commandOptions: this.opts,
+    multiExec: false
+  });
+  autoPipeline = () => {
+    return createAutoPipelineProxy(this);
+  };
+  multi = () => new Pipeline({
+    client: this.client,
+    commandOptions: this.opts,
+    multiExec: true
+  });
+  bitfield = (...args) => new BitFieldCommand(args, this.client, this.opts);
+  append = (...args) => new AppendCommand(args, this.opts).exec(this.client);
+  bitcount = (...args) => new BitCountCommand(args, this.opts).exec(this.client);
+  bitop = (op, destinationKey, sourceKey, ...sourceKeys) => new BitOpCommand([op, destinationKey, sourceKey, ...sourceKeys], this.opts).exec(this.client);
+  bitpos = (...args) => new BitPosCommand(args, this.opts).exec(this.client);
+  clientSetinfo = (...args) => new ClientSetInfoCommand(args, this.opts).exec(this.client);
+  copy = (...args) => new CopyCommand(args, this.opts).exec(this.client);
+  dbsize = () => new DBSizeCommand(this.opts).exec(this.client);
+  decr = (...args) => new DecrCommand(args, this.opts).exec(this.client);
+  decrby = (...args) => new DecrByCommand(args, this.opts).exec(this.client);
+  del = (...args) => new DelCommand(args, this.opts).exec(this.client);
+  echo = (...args) => new EchoCommand(args, this.opts).exec(this.client);
+  evalRo = (...args) => new EvalROCommand(args, this.opts).exec(this.client);
+  eval = (...args) => new EvalCommand(args, this.opts).exec(this.client);
+  evalshaRo = (...args) => new EvalshaROCommand(args, this.opts).exec(this.client);
+  evalsha = (...args) => new EvalshaCommand(args, this.opts).exec(this.client);
+  exec = (args) => new ExecCommand(args, this.opts).exec(this.client);
+  exists = (...args) => new ExistsCommand(args, this.opts).exec(this.client);
+  expire = (...args) => new ExpireCommand(args, this.opts).exec(this.client);
+  expireat = (...args) => new ExpireAtCommand(args, this.opts).exec(this.client);
+  flushall = (args) => new FlushAllCommand(args, this.opts).exec(this.client);
+  flushdb = (...args) => new FlushDBCommand(args, this.opts).exec(this.client);
+  geoadd = (...args) => new GeoAddCommand(args, this.opts).exec(this.client);
+  geopos = (...args) => new GeoPosCommand(args, this.opts).exec(this.client);
+  geodist = (...args) => new GeoDistCommand(args, this.opts).exec(this.client);
+  geohash = (...args) => new GeoHashCommand(args, this.opts).exec(this.client);
+  geosearch = (...args) => new GeoSearchCommand(args, this.opts).exec(this.client);
+  geosearchstore = (...args) => new GeoSearchStoreCommand(args, this.opts).exec(this.client);
+  get = (...args) => new GetCommand(args, this.opts).exec(this.client);
+  getbit = (...args) => new GetBitCommand(args, this.opts).exec(this.client);
+  getdel = (...args) => new GetDelCommand(args, this.opts).exec(this.client);
+  getex = (...args) => new GetExCommand(args, this.opts).exec(this.client);
+  getrange = (...args) => new GetRangeCommand(args, this.opts).exec(this.client);
+  getset = (key, value) => new GetSetCommand([key, value], this.opts).exec(this.client);
+  hdel = (...args) => new HDelCommand(args, this.opts).exec(this.client);
+  hexists = (...args) => new HExistsCommand(args, this.opts).exec(this.client);
+  hexpire = (...args) => new HExpireCommand(args, this.opts).exec(this.client);
+  hexpireat = (...args) => new HExpireAtCommand(args, this.opts).exec(this.client);
+  hexpiretime = (...args) => new HExpireTimeCommand(args, this.opts).exec(this.client);
+  httl = (...args) => new HTtlCommand(args, this.opts).exec(this.client);
+  hpexpire = (...args) => new HPExpireCommand(args, this.opts).exec(this.client);
+  hpexpireat = (...args) => new HPExpireAtCommand(args, this.opts).exec(this.client);
+  hpexpiretime = (...args) => new HPExpireTimeCommand(args, this.opts).exec(this.client);
+  hpttl = (...args) => new HPTtlCommand(args, this.opts).exec(this.client);
+  hpersist = (...args) => new HPersistCommand(args, this.opts).exec(this.client);
+  hget = (...args) => new HGetCommand(args, this.opts).exec(this.client);
+  hgetall = (...args) => new HGetAllCommand(args, this.opts).exec(this.client);
+  hgetdel = (...args) => new HGetDelCommand(args, this.opts).exec(this.client);
+  hgetex = (...args) => new HGetExCommand(args, this.opts).exec(this.client);
+  hincrby = (...args) => new HIncrByCommand(args, this.opts).exec(this.client);
+  hincrbyfloat = (...args) => new HIncrByFloatCommand(args, this.opts).exec(this.client);
+  hkeys = (...args) => new HKeysCommand(args, this.opts).exec(this.client);
+  hlen = (...args) => new HLenCommand(args, this.opts).exec(this.client);
+  hmget = (...args) => new HMGetCommand(args, this.opts).exec(this.client);
+  hmset = (key, kv) => new HMSetCommand([key, kv], this.opts).exec(this.client);
+  hrandfield = (key, count, withValues) => new HRandFieldCommand([key, count, withValues], this.opts).exec(this.client);
+  hscan = (...args) => new HScanCommand(args, this.opts).exec(this.client);
+  hset = (key, kv) => new HSetCommand([key, kv], this.opts).exec(this.client);
+  hsetex = (...args) => new HSetExCommand(args, this.opts).exec(this.client);
+  hsetnx = (key, field, value) => new HSetNXCommand([key, field, value], this.opts).exec(this.client);
+  hstrlen = (...args) => new HStrLenCommand(args, this.opts).exec(this.client);
+  hvals = (...args) => new HValsCommand(args, this.opts).exec(this.client);
+  incr = (...args) => new IncrCommand(args, this.opts).exec(this.client);
+  incrby = (...args) => new IncrByCommand(args, this.opts).exec(this.client);
+  incrbyfloat = (...args) => new IncrByFloatCommand(args, this.opts).exec(this.client);
+  keys = (...args) => new KeysCommand(args, this.opts).exec(this.client);
+  lindex = (...args) => new LIndexCommand(args, this.opts).exec(this.client);
+  linsert = (key, direction, pivot, value) => new LInsertCommand([key, direction, pivot, value], this.opts).exec(this.client);
+  llen = (...args) => new LLenCommand(args, this.opts).exec(this.client);
+  lmove = (...args) => new LMoveCommand(args, this.opts).exec(this.client);
+  lpop = (...args) => new LPopCommand(args, this.opts).exec(this.client);
+  lmpop = (...args) => new LmPopCommand(args, this.opts).exec(this.client);
+  lpos = (...args) => new LPosCommand(args, this.opts).exec(this.client);
+  lpush = (key, ...elements) => new LPushCommand([key, ...elements], this.opts).exec(this.client);
+  lpushx = (key, ...elements) => new LPushXCommand([key, ...elements], this.opts).exec(this.client);
+  lrange = (...args) => new LRangeCommand(args, this.opts).exec(this.client);
+  lrem = (key, count, value) => new LRemCommand([key, count, value], this.opts).exec(this.client);
+  lset = (key, index, value) => new LSetCommand([key, index, value], this.opts).exec(this.client);
+  ltrim = (...args) => new LTrimCommand(args, this.opts).exec(this.client);
+  mget = (...args) => new MGetCommand(args, this.opts).exec(this.client);
+  mset = (kv) => new MSetCommand([kv], this.opts).exec(this.client);
+  msetnx = (kv) => new MSetNXCommand([kv], this.opts).exec(this.client);
+  persist = (...args) => new PersistCommand(args, this.opts).exec(this.client);
+  pexpire = (...args) => new PExpireCommand(args, this.opts).exec(this.client);
+  pexpireat = (...args) => new PExpireAtCommand(args, this.opts).exec(this.client);
+  pfadd = (...args) => new PfAddCommand(args, this.opts).exec(this.client);
+  pfcount = (...args) => new PfCountCommand(args, this.opts).exec(this.client);
+  pfmerge = (...args) => new PfMergeCommand(args, this.opts).exec(this.client);
+  ping = (args) => new PingCommand(args, this.opts).exec(this.client);
+  psetex = (key, ttl, value) => new PSetEXCommand([key, ttl, value], this.opts).exec(this.client);
+  psubscribe = (patterns) => {
+    const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+    return new Subscriber(this.client, patternArray, true, this.opts);
+  };
+  pttl = (...args) => new PTtlCommand(args, this.opts).exec(this.client);
+  publish = (...args) => new PublishCommand(args, this.opts).exec(this.client);
+  randomkey = () => new RandomKeyCommand().exec(this.client);
+  rename = (...args) => new RenameCommand(args, this.opts).exec(this.client);
+  renamenx = (...args) => new RenameNXCommand(args, this.opts).exec(this.client);
+  rpop = (...args) => new RPopCommand(args, this.opts).exec(this.client);
+  rpush = (key, ...elements) => new RPushCommand([key, ...elements], this.opts).exec(this.client);
+  rpushx = (key, ...elements) => new RPushXCommand([key, ...elements], this.opts).exec(this.client);
+  sadd = (key, member, ...members) => new SAddCommand([key, member, ...members], this.opts).exec(this.client);
+  scan(cursor, opts) {
+    return new ScanCommand([cursor, opts], this.opts).exec(this.client);
+  }
+  scard = (...args) => new SCardCommand(args, this.opts).exec(this.client);
+  scriptExists = (...args) => new ScriptExistsCommand(args, this.opts).exec(this.client);
+  scriptFlush = (...args) => new ScriptFlushCommand(args, this.opts).exec(this.client);
+  scriptLoad = (...args) => new ScriptLoadCommand(args, this.opts).exec(this.client);
+  sdiff = (...args) => new SDiffCommand(args, this.opts).exec(this.client);
+  sdiffstore = (...args) => new SDiffStoreCommand(args, this.opts).exec(this.client);
+  set = (key, value, opts) => new SetCommand([key, value, opts], this.opts).exec(this.client);
+  setbit = (...args) => new SetBitCommand(args, this.opts).exec(this.client);
+  setex = (key, ttl, value) => new SetExCommand([key, ttl, value], this.opts).exec(this.client);
+  setnx = (key, value) => new SetNxCommand([key, value], this.opts).exec(this.client);
+  setrange = (...args) => new SetRangeCommand(args, this.opts).exec(this.client);
+  sinter = (...args) => new SInterCommand(args, this.opts).exec(this.client);
+  sintercard = (...args) => new SInterCardCommand(args, this.opts).exec(this.client);
+  sinterstore = (...args) => new SInterStoreCommand(args, this.opts).exec(this.client);
+  sismember = (key, member) => new SIsMemberCommand([key, member], this.opts).exec(this.client);
+  smismember = (key, members) => new SMIsMemberCommand([key, members], this.opts).exec(this.client);
+  smembers = (...args) => new SMembersCommand(args, this.opts).exec(this.client);
+  smove = (source, destination, member) => new SMoveCommand([source, destination, member], this.opts).exec(this.client);
+  spop = (...args) => new SPopCommand(args, this.opts).exec(this.client);
+  srandmember = (...args) => new SRandMemberCommand(args, this.opts).exec(this.client);
+  srem = (key, ...members) => new SRemCommand([key, ...members], this.opts).exec(this.client);
+  sscan = (...args) => new SScanCommand(args, this.opts).exec(this.client);
+  strlen = (...args) => new StrLenCommand(args, this.opts).exec(this.client);
+  subscribe = (channels) => {
+    const channelArray = Array.isArray(channels) ? channels : [channels];
+    return new Subscriber(this.client, channelArray, false, this.opts);
+  };
+  sunion = (...args) => new SUnionCommand(args, this.opts).exec(this.client);
+  sunionstore = (...args) => new SUnionStoreCommand(args, this.opts).exec(this.client);
+  time = () => new TimeCommand().exec(this.client);
+  touch = (...args) => new TouchCommand(args, this.opts).exec(this.client);
+  ttl = (...args) => new TtlCommand(args, this.opts).exec(this.client);
+  type = (...args) => new TypeCommand(args, this.opts).exec(this.client);
+  unlink = (...args) => new UnlinkCommand(args, this.opts).exec(this.client);
+  xadd = (...args) => new XAddCommand(args, this.opts).exec(this.client);
+  xack = (...args) => new XAckCommand(args, this.opts).exec(this.client);
+  xackdel = (...args) => new XAckDelCommand(args, this.opts).exec(this.client);
+  xdel = (...args) => new XDelCommand(args, this.opts).exec(this.client);
+  xdelex = (...args) => new XDelExCommand(args, this.opts).exec(this.client);
+  xgroup = (...args) => new XGroupCommand(args, this.opts).exec(this.client);
+  xread = (...args) => new XReadCommand(args, this.opts).exec(this.client);
+  xreadgroup = (...args) => new XReadGroupCommand(args, this.opts).exec(this.client);
+  xinfo = (...args) => new XInfoCommand(args, this.opts).exec(this.client);
+  xlen = (...args) => new XLenCommand(args, this.opts).exec(this.client);
+  xpending = (...args) => new XPendingCommand(args, this.opts).exec(this.client);
+  xclaim = (...args) => new XClaimCommand(args, this.opts).exec(this.client);
+  xautoclaim = (...args) => new XAutoClaim(args, this.opts).exec(this.client);
+  xtrim = (...args) => new XTrimCommand(args, this.opts).exec(this.client);
+  xrange = (...args) => new XRangeCommand(args, this.opts).exec(this.client);
+  xrevrange = (...args) => new XRevRangeCommand(args, this.opts).exec(this.client);
+  zadd = (...args) => {
+    if ("score" in args[1]) {
+      return new ZAddCommand([args[0], args[1], ...args.slice(2)], this.opts).exec(this.client);
+    }
+    return new ZAddCommand([args[0], args[1], ...args.slice(2)], this.opts).exec(this.client);
+  };
+  zcard = (...args) => new ZCardCommand(args, this.opts).exec(this.client);
+  zcount = (...args) => new ZCountCommand(args, this.opts).exec(this.client);
+  zdiffstore = (...args) => new ZDiffStoreCommand(args, this.opts).exec(this.client);
+  zincrby = (key, increment, member) => new ZIncrByCommand([key, increment, member], this.opts).exec(this.client);
+  zinterstore = (...args) => new ZInterStoreCommand(args, this.opts).exec(this.client);
+  zlexcount = (...args) => new ZLexCountCommand(args, this.opts).exec(this.client);
+  zmscore = (...args) => new ZMScoreCommand(args, this.opts).exec(this.client);
+  zpopmax = (...args) => new ZPopMaxCommand(args, this.opts).exec(this.client);
+  zpopmin = (...args) => new ZPopMinCommand(args, this.opts).exec(this.client);
+  zrange = (...args) => new ZRangeCommand(args, this.opts).exec(this.client);
+  zrank = (key, member) => new ZRankCommand([key, member], this.opts).exec(this.client);
+  zrem = (key, ...members) => new ZRemCommand([key, ...members], this.opts).exec(this.client);
+  zremrangebylex = (...args) => new ZRemRangeByLexCommand(args, this.opts).exec(this.client);
+  zremrangebyrank = (...args) => new ZRemRangeByRankCommand(args, this.opts).exec(this.client);
+  zremrangebyscore = (...args) => new ZRemRangeByScoreCommand(args, this.opts).exec(this.client);
+  zrevrank = (key, member) => new ZRevRankCommand([key, member], this.opts).exec(this.client);
+  zscan = (...args) => new ZScanCommand(args, this.opts).exec(this.client);
+  zscore = (key, member) => new ZScoreCommand([key, member], this.opts).exec(this.client);
+  zunion = (...args) => new ZUnionCommand(args, this.opts).exec(this.client);
+  zunionstore = (...args) => new ZUnionStoreCommand(args, this.opts).exec(this.client);
+};
+var VERSION = "v1.30.2";
+
+// ../../node_modules/.bun/@upstash+redis@1.37.0/node_modules/@upstash/redis/nodejs.mjs
+if (typeof atob === "undefined") {
+  global.atob = (b64) => Buffer.from(b64, "base64").toString("utf8");
+}
+var Redis2 = class _Redis extends Redis {
+  constructor(configOrRequester) {
+    if ("request" in configOrRequester) {
+      super(configOrRequester);
+      return;
+    }
+    if (!configOrRequester.url) {} else if (configOrRequester.url.startsWith(" ") || configOrRequester.url.endsWith(" ") || /\r|\n/.test(configOrRequester.url)) {}
+    if (!configOrRequester.token) {} else if (configOrRequester.token.startsWith(" ") || configOrRequester.token.endsWith(" ") || /\r|\n/.test(configOrRequester.token)) {}
+    const client = new HttpClient({
+      baseUrl: configOrRequester.url,
+      retry: configOrRequester.retry,
+      headers: { authorization: `Bearer ${configOrRequester.token}` },
+      agent: configOrRequester.agent,
+      responseEncoding: configOrRequester.responseEncoding,
+      cache: configOrRequester.cache ?? "no-store",
+      signal: configOrRequester.signal,
+      keepAlive: configOrRequester.keepAlive,
+      readYourWrites: configOrRequester.readYourWrites
+    });
+    const safeEnv = typeof process === "object" && process && typeof process.env === "object" && process.env ? process.env : {};
+    super(client, {
+      automaticDeserialization: configOrRequester.automaticDeserialization,
+      enableTelemetry: configOrRequester.enableTelemetry ?? !safeEnv.UPSTASH_DISABLE_TELEMETRY,
+      latencyLogging: configOrRequester.latencyLogging,
+      enableAutoPipelining: configOrRequester.enableAutoPipelining
+    });
+    const nodeVersion = typeof process === "object" && process ? process.version : undefined;
+    this.addTelemetry({
+      runtime: typeof EdgeRuntime === "string" ? "edge-light" : nodeVersion ? `node@${nodeVersion}` : "unknown",
+      platform: safeEnv.UPSTASH_CONSOLE ? "console" : safeEnv.VERCEL ? "vercel" : safeEnv.AWS_REGION ? "aws" : "unknown",
+      sdk: `@upstash/redis@${VERSION}`
+    });
+    if (this.enableAutoPipelining) {
+      return this.autoPipeline();
+    }
+  }
+  static fromEnv(config) {
+    if (typeof process !== "object" || !process || typeof process.env !== "object" || !process.env) {
+      throw new TypeError('[Upstash Redis] Unable to get environment variables, `process.env` is undefined. If you are deploying to cloudflare, please import from "@upstash/redis/cloudflare" instead');
+    }
+    const url = process.env.UPSTASH_REDIS_REST_URL || process.env.KV_REST_API_URL;
+    if (!url) {}
+    const token = process.env.UPSTASH_REDIS_REST_TOKEN || process.env.KV_REST_API_TOKEN;
+    if (!token) {}
+    return new _Redis({ ...config, url, token });
+  }
+};
+
+// src/UpstashRedisRateLimiter.ts
 class UpstashRedisRateLimiter {
   env;
   ratelimit;
@@ -148,7 +3662,7 @@ class UpstashRedisRateLimiter {
     if (!url || !token) {
       throw new RateLimitException("Upstash Redis URL and token are required. Please provide them through the constructor options or set the RATE_LIMIT_UPSTASH_REDIS_URL and RATE_LIMIT_UPSTASH_REDIS_TOKEN environment variables.", "RATE_LIMIT_CONNECTION_FAILED");
     }
-    const redis = new Redis({ url, token });
+    const redis = new Redis2({ url, token });
     const limiter = this.buildLimiter(options.algorithm);
     this.ratelimit = new Ratelimit({
       redis,
@@ -216,4 +3730,4 @@ export {
   RateLimitException
 };
 
-//# debugId=8F06C17BF8E11C5C64756E2164756E21
+//# debugId=6B308BC01FD0CA0B64756E2164756E21