@fluixi/api 0.0.0-stage → 0.1.0-alpha.2

package/dist/rate-limit.mjs

@@ -0,0 +1,4935 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/BlockedKeys.js
+var require_BlockedKeys = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/BlockedKeys.js"(exports, module) {
+    "use strict";
+    module.exports = class BlockedKeys {
+      constructor() {
+        this._keys = /* @__PURE__ */ new Map();
+      }
+      collectExpired() {
+        const now = Date.now();
+        for (const [key, expire] of this._keys) {
+          if (expire <= now) {
+            this._keys.delete(key);
+          }
+        }
+      }
+      /**
+       * Add new blocked key
+       *
+       * @param key String
+       * @param sec Number
+       */
+      add(key, sec) {
+        this.addMs(key, sec * 1e3);
+      }
+      /**
+       * Add new blocked key for ms
+       *
+       * @param key String
+       * @param ms Number
+       */
+      addMs(key, ms) {
+        this._keys.set(key, Date.now() + ms);
+        if (this._keys.size > 999) {
+          this.collectExpired();
+        }
+      }
+      /**
+       * 0 means not blocked
+       *
+       * @param key
+       * @returns {number}
+       */
+      msBeforeExpire(key) {
+        const expire = this._keys.get(key);
+        const now = Date.now();
+        if (expire && expire >= now) {
+          return expire - now;
+        }
+        return 0;
+      }
+      /**
+       * If key is not given, delete all data in memory
+       *
+       * @param {string|undefined} key
+       */
+      delete(key) {
+        if (key) {
+          this._keys.delete(key);
+        } else {
+          this._keys.clear();
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/index.js
+var require_BlockedKeys2 = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/index.js"(exports, module) {
+    "use strict";
+    var BlockedKeys = require_BlockedKeys();
+    module.exports = BlockedKeys;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterRes.js
+var require_RateLimiterRes = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterRes.js"(exports, module) {
+    "use strict";
+    module.exports = class RateLimiterRes {
+      constructor(remainingPoints, msBeforeNext, consumedPoints, isFirstInDuration) {
+        this.remainingPoints = typeof remainingPoints === "undefined" ? 0 : remainingPoints;
+        this.msBeforeNext = typeof msBeforeNext === "undefined" ? 0 : msBeforeNext;
+        this.consumedPoints = typeof consumedPoints === "undefined" ? 0 : consumedPoints;
+        this.isFirstInDuration = typeof isFirstInDuration === "undefined" ? false : isFirstInDuration;
+      }
+      get msBeforeNext() {
+        return this._msBeforeNext;
+      }
+      set msBeforeNext(ms) {
+        this._msBeforeNext = ms;
+        return this;
+      }
+      get remainingPoints() {
+        return this._remainingPoints;
+      }
+      set remainingPoints(p) {
+        this._remainingPoints = p;
+        return this;
+      }
+      get consumedPoints() {
+        return this._consumedPoints;
+      }
+      set consumedPoints(p) {
+        this._consumedPoints = p;
+        return this;
+      }
+      get isFirstInDuration() {
+        return this._isFirstInDuration;
+      }
+      set isFirstInDuration(value) {
+        this._isFirstInDuration = Boolean(value);
+      }
+      _getDecoratedProperties() {
+        return {
+          remainingPoints: this.remainingPoints,
+          msBeforeNext: this.msBeforeNext,
+          consumedPoints: this.consumedPoints,
+          isFirstInDuration: this.isFirstInDuration
+        };
+      }
+      [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+        return this._getDecoratedProperties();
+      }
+      toString() {
+        return JSON.stringify(this._getDecoratedProperties());
+      }
+      toJSON() {
+        return this._getDecoratedProperties();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterAbstract.js
+var require_RateLimiterAbstract = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterAbstract.js"(exports, module) {
+    "use strict";
+    module.exports = class RateLimiterAbstract {
+      /**
+       *
+       * @param opts Object {
+       *   points: <required>, // Number of points (must be a number, can be negative)
+       *   duration: <required>, // Per seconds (must be a non-negative number, 0 = never expires)
+       *   blockDuration: 0, // Block if consumed more than points in current duration for blockDuration seconds
+       *   execEvenly: false, // Execute allowed actions evenly over duration
+       *   execEvenlyMinDelayMs: duration * 1000 / points, // ms, works with execEvenly=true option
+       *   keyPrefix: 'rlflx',
+       * }
+       */
+      constructor(opts = {}) {
+        this.points = opts.points;
+        this.duration = opts.duration;
+        this.blockDuration = opts.blockDuration;
+        this.execEvenly = opts.execEvenly;
+        this.execEvenlyMinDelayMs = opts.execEvenlyMinDelayMs;
+        this.keyPrefix = opts.keyPrefix;
+      }
+      get points() {
+        return this._points;
+      }
+      set points(value) {
+        if (Number.isFinite(value)) {
+          this._points = value;
+        } else {
+          throw new Error("points must be set and must be a finite number");
+        }
+      }
+      get duration() {
+        return this._duration;
+      }
+      set duration(value) {
+        if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+          this._duration = value;
+        } else {
+          throw new Error("duration must be set and must be a finite, non-negative number");
+        }
+      }
+      get msDuration() {
+        return this.duration * 1e3;
+      }
+      get blockDuration() {
+        return this._blockDuration;
+      }
+      set blockDuration(value) {
+        this._blockDuration = typeof value === "undefined" ? 0 : value;
+      }
+      get msBlockDuration() {
+        return this.blockDuration * 1e3;
+      }
+      get execEvenly() {
+        return this._execEvenly;
+      }
+      set execEvenly(value) {
+        this._execEvenly = typeof value === "undefined" ? false : Boolean(value);
+      }
+      get execEvenlyMinDelayMs() {
+        return this._execEvenlyMinDelayMs === void 0 ? this._getExecEvenlyMinDelayMsDefault() : this._execEvenlyMinDelayMs;
+      }
+      set execEvenlyMinDelayMs(value) {
+        this._execEvenlyMinDelayMs = value;
+      }
+      _getExecEvenlyMinDelayMsDefault() {
+        return this.points > 0 ? Math.ceil(this.msDuration / this.points) : 0;
+      }
+      get keyPrefix() {
+        return this._keyPrefix;
+      }
+      set keyPrefix(value) {
+        if (typeof value === "undefined") {
+          value = "rlflx";
+        }
+        if (typeof value !== "string") {
+          throw new Error("keyPrefix must be string");
+        }
+        this._keyPrefix = value;
+      }
+      _getKeySecDuration(options = {}) {
+        return options && options.customDuration >= 0 ? options.customDuration : this.duration;
+      }
+      getKey(key) {
+        return this.keyPrefix.length > 0 ? `${this.keyPrefix}:${key}` : key;
+      }
+      parseKey(rlKey) {
+        return this.keyPrefix.length > 0 ? rlKey.substring(this.keyPrefix.length + 1) : rlKey;
+      }
+      consume() {
+        throw new Error("You have to implement the method 'consume'!");
+      }
+      penalty() {
+        throw new Error("You have to implement the method 'penalty'!");
+      }
+      reward() {
+        throw new Error("You have to implement the method 'reward'!");
+      }
+      get() {
+        throw new Error("You have to implement the method 'get'!");
+      }
+      set() {
+        throw new Error("You have to implement the method 'set'!");
+      }
+      block() {
+        throw new Error("You have to implement the method 'block'!");
+      }
+      delete() {
+        throw new Error("You have to implement the method 'delete'!");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterCompatibleAbstract.js
+var require_RateLimiterCompatibleAbstract = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterCompatibleAbstract.js"(exports, module) {
+    "use strict";
+    module.exports = class RateLimiterCompatibleAbstract {
+      get keyPrefix() {
+        throw new Error("You have to implement the getter 'keyPrefix'!");
+      }
+      get blockDuration() {
+        throw new Error("You have to implement the getter 'blockDuration'!");
+      }
+      set blockDuration(value) {
+        throw new Error("You have to implement the setter 'blockDuration'!");
+      }
+      get execEvenly() {
+        throw new Error("You have to implement the getter 'execEvenly'!");
+      }
+      set execEvenly(value) {
+        throw new Error("You have to implement the setter 'execEvenly'!");
+      }
+      consume() {
+        throw new Error("You have to implement the method 'consume'!");
+      }
+      penalty() {
+        throw new Error("You have to implement the method 'penalty'!");
+      }
+      reward() {
+        throw new Error("You have to implement the method 'reward'!");
+      }
+      get() {
+        throw new Error("You have to implement the method 'get'!");
+      }
+      set() {
+        throw new Error("You have to implement the method 'set'!");
+      }
+      block() {
+        throw new Error("You have to implement the method 'block'!");
+      }
+      delete() {
+        throw new Error("You have to implement the method 'delete'!");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/helper/isRateLimiterCompatible.js
+var require_isRateLimiterCompatible = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/helper/isRateLimiterCompatible.js"(exports, module) {
+    "use strict";
+    var RateLimiterAbstract = require_RateLimiterAbstract();
+    var RateLimiterCompatibleAbstract = require_RateLimiterCompatibleAbstract();
+    module.exports = function isRateLimiterCompatible(obj) {
+      return obj instanceof RateLimiterAbstract || obj instanceof RateLimiterCompatibleAbstract;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterInsuredAbstract.js
+var require_RateLimiterInsuredAbstract = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterInsuredAbstract.js"(exports, module) {
+    "use strict";
+    var RateLimiterAbstract = require_RateLimiterAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var isRateLimiterCompatible = require_isRateLimiterCompatible();
+    module.exports = class RateLimiterInsuredAbstract extends RateLimiterAbstract {
+      constructor(opts = {}) {
+        super(opts);
+        this.insuranceLimiter = opts.insuranceLimiter;
+      }
+      get insuranceLimiter() {
+        return this._insuranceLimiter;
+      }
+      set insuranceLimiter(value) {
+        if (typeof value !== "undefined" && !isRateLimiterCompatible(value)) {
+          throw new Error("insuranceLimiter must be instance of RateLimiterAbstract or RateLimiterCompatibleAbstract");
+        }
+        this._insuranceLimiter = value;
+        if (this._insuranceLimiter) {
+          this._insuranceLimiter.blockDuration = this.blockDuration;
+          this._insuranceLimiter.execEvenly = this.execEvenly;
+        }
+      }
+      _handleError(err, funcName, resolve, reject, params) {
+        if (err instanceof RateLimiterRes2) {
+          reject(err);
+        } else if (!isRateLimiterCompatible(this.insuranceLimiter)) {
+          reject(err);
+        } else {
+          this.insuranceLimiter[funcName](...params).then((res) => {
+            resolve(res);
+          }).catch((res) => {
+            reject(res);
+          });
+        }
+      }
+      _operation(funcName, params) {
+        const promise = this[funcName](...params);
+        return new Promise((resolve, reject) => {
+          return promise.then((res) => {
+            resolve(res);
+          }).catch((err) => {
+            if (funcName.startsWith("_")) {
+              funcName = funcName.slice(1);
+            }
+            this._handleError(err, funcName, resolve, reject, params);
+          });
+        });
+      }
+      consume(key, pointsToConsume = 1, options = {}) {
+        return this._operation("_consume", [key, pointsToConsume, options]);
+      }
+      penalty(key, points = 1, options = {}) {
+        return this._operation("_penalty", [key, points, options]);
+      }
+      reward(key, points = 1, options = {}) {
+        return this._operation("_reward", [key, points, options]);
+      }
+      get(key, options = {}) {
+        return this._operation("_get", [key, options]);
+      }
+      set(key, points, secDuration, options = {}) {
+        return this._operation("_set", [key, points, secDuration, options]);
+      }
+      block(key, secDuration, options = {}) {
+        return this._operation("_block", [key, secDuration, options]);
+      }
+      delete(key, options = {}) {
+        return this._operation("_delete", [key, options]);
+      }
+      _consume() {
+        throw new Error("You have to implement the method '_consume'!");
+      }
+      _penalty() {
+        throw new Error("You have to implement the method '_penalty'!");
+      }
+      _reward() {
+        throw new Error("You have to implement the method '_reward'!");
+      }
+      _get() {
+        throw new Error("You have to implement the method '_get'!");
+      }
+      _set() {
+        throw new Error("You have to implement the method '_set'!");
+      }
+      _block() {
+        throw new Error("You have to implement the method '_block'!");
+      }
+      _delete() {
+        throw new Error("You have to implement the method '_delete'!");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterStoreAbstract.js
+var require_RateLimiterStoreAbstract = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterStoreAbstract.js"(exports, module) {
+    "use strict";
+    var BlockedKeys = require_BlockedKeys2();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterInsuredAbstract = require_RateLimiterInsuredAbstract();
+    module.exports = class RateLimiterStoreAbstract extends RateLimiterInsuredAbstract {
+      /**
+       *
+       * @param opts Object Defaults {
+       *   ... see other in RateLimiterAbstract
+       *
+       *   inMemoryBlockOnConsumed: 40, // Number of points when key is blocked
+       *   inMemoryBlockDuration: 10, // Block duration in seconds
+       *   insuranceLimiter: RateLimiterAbstract
+       * }
+       */
+      constructor(opts = {}) {
+        super(opts);
+        this.inMemoryBlockOnConsumed = opts.inMemoryBlockOnConsumed;
+        this.inMemoryBlockDuration = opts.inMemoryBlockDuration;
+        this._inMemoryBlockedKeys = new BlockedKeys();
+      }
+      get client() {
+        return this._client;
+      }
+      set client(value) {
+        if (typeof value === "undefined") {
+          throw new Error("storeClient is not set");
+        }
+        this._client = value;
+      }
+      /**
+       * Have to be launched after consume
+       * It blocks key and execute evenly depending on result from store
+       *
+       * It uses _getRateLimiterRes function to prepare RateLimiterRes from store result
+       *
+       * @param resolve
+       * @param reject
+       * @param rlKey
+       * @param changedPoints
+       * @param storeResult
+       * @param {Object} options
+       * @private
+       */
+      _afterConsume(resolve, reject, rlKey, changedPoints, storeResult, options = {}) {
+        const res = this._getRateLimiterRes(rlKey, changedPoints, storeResult);
+        if (this.inMemoryBlockOnConsumed > 0 && !(this.inMemoryBlockDuration > 0) && res.consumedPoints >= this.inMemoryBlockOnConsumed) {
+          this._inMemoryBlockedKeys.addMs(rlKey, res.msBeforeNext);
+          if (res.consumedPoints > this.points) {
+            return reject(res);
+          } else {
+            return resolve(res);
+          }
+        } else if (res.consumedPoints > this.points) {
+          let blockPromise = Promise.resolve();
+          if (this.blockDuration > 0 && res.consumedPoints <= this.points + changedPoints) {
+            res.msBeforeNext = this.msBlockDuration;
+            blockPromise = this._block(rlKey, res.consumedPoints, this.msBlockDuration, options);
+          }
+          if (this.inMemoryBlockOnConsumed > 0 && res.consumedPoints >= this.inMemoryBlockOnConsumed) {
+            this._inMemoryBlockedKeys.add(rlKey, this.inMemoryBlockDuration);
+            res.msBeforeNext = this.msInMemoryBlockDuration;
+          }
+          blockPromise.then(() => {
+            reject(res);
+          }).catch((err) => {
+            reject(err);
+          });
+        } else if (this.execEvenly && this.points > 0 && res.msBeforeNext > 0 && !res.isFirstInDuration) {
+          let delay = Math.ceil(res.msBeforeNext / (res.remainingPoints + 2));
+          if (delay < this.execEvenlyMinDelayMs) {
+            delay = res.consumedPoints * this.execEvenlyMinDelayMs;
+          }
+          res.msBeforeNext = Math.max(res.msBeforeNext - delay, 0);
+          setTimeout(resolve, delay, res);
+        } else {
+          resolve(res);
+        }
+      }
+      getInMemoryBlockMsBeforeExpire(rlKey) {
+        if (this.inMemoryBlockOnConsumed > 0) {
+          return this._inMemoryBlockedKeys.msBeforeExpire(rlKey);
+        }
+        return 0;
+      }
+      get inMemoryBlockOnConsumed() {
+        return this._inMemoryBlockOnConsumed;
+      }
+      set inMemoryBlockOnConsumed(value) {
+        this._inMemoryBlockOnConsumed = value ? parseInt(value) : 0;
+        if (this.inMemoryBlockOnConsumed > 0 && this.points > this.inMemoryBlockOnConsumed) {
+          throw new Error('inMemoryBlockOnConsumed option must be greater or equal "points" option');
+        }
+      }
+      get inMemoryBlockDuration() {
+        return this._inMemoryBlockDuration;
+      }
+      set inMemoryBlockDuration(value) {
+        this._inMemoryBlockDuration = value ? parseInt(value) : 0;
+        if (this.inMemoryBlockDuration > 0 && this.inMemoryBlockOnConsumed === 0) {
+          throw new Error("inMemoryBlockOnConsumed option must be set up");
+        }
+      }
+      get msInMemoryBlockDuration() {
+        return this._inMemoryBlockDuration * 1e3;
+      }
+      /**
+       * Block any key for secDuration seconds
+       *
+       * @param key
+       * @param secDuration
+       * @param {Object} options
+       *
+       * @return Promise<RateLimiterRes>
+       */
+      block(key, secDuration, options = {}) {
+        const msDuration = secDuration * 1e3;
+        return this._block(this.getKey(key), this.points + 1, msDuration, options);
+      }
+      /**
+       * Set points by key for any duration
+       *
+       * @param key
+       * @param points
+       * @param secDuration
+       * @param {Object} options
+       *
+       * @return Promise<RateLimiterRes>
+       */
+      set(key, points, secDuration, options = {}) {
+        const msDuration = (secDuration >= 0 ? secDuration : this.duration) * 1e3;
+        return this._set(this.getKey(key), points, msDuration, options);
+      }
+      /**
+       *
+       * @param key
+       * @param pointsToConsume
+       * @param {Object} options
+       * @returns Promise<RateLimiterRes>
+       */
+      _consume(key, pointsToConsume = 1, options = {}) {
+        return new Promise((resolve, reject) => {
+          const rlKey = this.getKey(key);
+          const inMemoryBlockMsBeforeExpire = this.getInMemoryBlockMsBeforeExpire(rlKey);
+          if (inMemoryBlockMsBeforeExpire > 0) {
+            return reject(new RateLimiterRes2(0, inMemoryBlockMsBeforeExpire));
+          }
+          this._upsert(rlKey, pointsToConsume, this._getKeySecDuration(options) * 1e3, false, options).then((res) => {
+            this._afterConsume(resolve, reject, rlKey, pointsToConsume, res);
+          }).catch((err) => reject(err));
+        });
+      }
+      /**
+       *
+       * @param key
+       * @param points
+       * @param {Object} options
+       * @returns Promise<RateLimiterRes>
+       */
+      _penalty(key, points = 1, options = {}) {
+        const rlKey = this.getKey(key);
+        return new Promise((resolve, reject) => {
+          this._upsert(rlKey, points, this._getKeySecDuration(options) * 1e3, false, options).then((res) => {
+            resolve(this._getRateLimiterRes(rlKey, points, res));
+          }).catch((res) => reject(res));
+        });
+      }
+      /**
+       *
+       * @param key
+       * @param points
+       * @param {Object} options
+       * @returns Promise<RateLimiterRes>
+       */
+      _reward(key, points = 1, options = {}) {
+        const rlKey = this.getKey(key);
+        return new Promise((resolve, reject) => {
+          this._upsert(rlKey, -points, this._getKeySecDuration(options) * 1e3, false, options).then((res) => {
+            resolve(this._getRateLimiterRes(rlKey, -points, res));
+          }).catch((res) => reject(res));
+        });
+      }
+      /**
+       *
+       * @param key
+       * @param {Object} options
+       * @returns Promise<RateLimiterRes>|null
+       */
+      get(key, options = {}) {
+        const rlKey = this.getKey(key);
+        return new Promise((resolve, reject) => {
+          this._get(rlKey, options).then((res) => {
+            if (res === null || typeof res === "undefined") {
+              resolve(null);
+            } else {
+              resolve(this._getRateLimiterRes(rlKey, 0, res));
+            }
+          }).catch((err) => {
+            this._handleError(err, "get", resolve, reject, [key, options]);
+          });
+        });
+      }
+      /**
+       *
+       * @param key
+       * @param {Object} options
+       * @returns Promise<boolean>
+       */
+      delete(key, options = {}) {
+        const rlKey = this.getKey(key);
+        return new Promise((resolve, reject) => {
+          this._delete(rlKey, options).then((res) => {
+            this._inMemoryBlockedKeys.delete(rlKey);
+            resolve(res);
+          }).catch((err) => {
+            this._handleError(err, "delete", resolve, reject, [key, options]);
+          });
+        });
+      }
+      /**
+       * Cleanup keys no-matter expired or not.
+       */
+      deleteInMemoryBlockedAll() {
+        this._inMemoryBlockedKeys.delete();
+      }
+      /**
+       * Get RateLimiterRes object filled depending on storeResult, which specific for exact store
+       *
+       * @param rlKey
+       * @param changedPoints
+       * @param storeResult
+       * @private
+       */
+      _getRateLimiterRes(rlKey, changedPoints, storeResult) {
+        throw new Error("You have to implement the method '_getRateLimiterRes'!");
+      }
+      /**
+       * Block key for this.msBlockDuration milliseconds
+       * Usually, it just prolongs lifetime of key
+       *
+       * @param rlKey
+       * @param initPoints
+       * @param msDuration
+       * @param {Object} options
+       *
+       * @return Promise<any>
+       */
+      _block(rlKey, initPoints, msDuration, options = {}) {
+        return new Promise((resolve, reject) => {
+          this._upsert(rlKey, initPoints, msDuration, true, options).then(() => {
+            resolve(new RateLimiterRes2(0, msDuration > 0 ? msDuration : -1, initPoints));
+          }).catch((err) => {
+            this._handleError(err, "block", resolve, reject, [this.parseKey(rlKey), msDuration / 1e3, options]);
+          });
+        });
+      }
+      /**
+       * @param rlKey
+       * @param points
+       * @param msDuration
+       * @param {Object} options
+       *
+       * @return Promise<any>
+       */
+      _set(rlKey, points, msDuration, options = {}) {
+        return new Promise((resolve, reject) => {
+          this._upsert(rlKey, points, msDuration, true, options).then(() => {
+            resolve(new RateLimiterRes2(0, msDuration > 0 ? msDuration : -1, points));
+          }).catch((err) => {
+            this._handleError(err, "set", resolve, reject, [this.parseKey(rlKey), points, msDuration / 1e3, options]);
+          });
+        });
+      }
+      /**
+       * Have to be implemented in every limiter
+       * Resolve with raw result from Store OR null if rlKey is not set
+       * or Reject with error
+       *
+       * @param rlKey
+       * @param {Object} options
+       * @private
+       *
+       * @return Promise<any>
+       */
+      _get(rlKey, options = {}) {
+        throw new Error("You have to implement the method '_get'!");
+      }
+      /**
+       * Have to be implemented
+       * Resolve with true OR false if rlKey doesn't exist
+       * or Reject with error
+       *
+       * @param rlKey
+       * @param {Object} options
+       * @private
+       *
+       * @return Promise<any>
+       */
+      _delete(rlKey, options = {}) {
+        throw new Error("You have to implement the method '_delete'!");
+      }
+      /**
+       * Have to be implemented
+       * Resolve with object used for {@link _getRateLimiterRes} to generate {@link RateLimiterRes}
+       *
+       * @param {string} rlKey
+       * @param {number} points
+       * @param {number} msDuration
+       * @param {boolean} forceExpire
+       * @param {Object} options
+       * @abstract
+       *
+       * @return Promise<Object>
+       */
+      _upsert(rlKey, points, msDuration, forceExpire = false, options = {}) {
+        throw new Error("You have to implement the method '_upsert'!");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedis.js
+var require_RateLimiterRedis = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedis.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var incrTtlLuaScript = `redis.call('set', KEYS[1], 0, 'EX', ARGV[2], 'NX') local consumed = redis.call('incrby', KEYS[1], ARGV[1]) local ttl = redis.call('pttl', KEYS[1]) if ttl == -1 then   redis.call('expire', KEYS[1], ARGV[2])   ttl = 1000 * ARGV[2] end return {consumed, ttl} `;
+    var RateLimiterRedis = class extends RateLimiterStoreAbstract {
+      /**
+       *
+       * @param {Object} opts
+       * Defaults {
+       *   ... see other in RateLimiterStoreAbstract
+       *
+       *   redis: RedisClient
+       *   rejectIfRedisNotReady: boolean = false - reject / invoke insuranceLimiter immediately when redis connection is not "ready"
+       * }
+       */
+      constructor(opts) {
+        super(opts);
+        this.client = opts.storeClient;
+        this._rejectIfRedisNotReady = !!opts.rejectIfRedisNotReady;
+        this._incrTtlLuaScript = opts.customIncrTtlLuaScript || incrTtlLuaScript;
+        this.useRedisPackage = opts.useRedisPackage || this.client.constructor.name === "Commander" || false;
+        this.useRedis3AndLowerPackage = opts.useRedis3AndLowerPackage;
+        if (typeof this.client.defineCommand === "function") {
+          this.client.defineCommand("rlflxIncr", {
+            numberOfKeys: 1,
+            lua: this._incrTtlLuaScript
+          });
+        }
+      }
+      /**
+       * Prevent actual redis call if redis connection is not ready
+       * Because of different connection state checks for ioredis and node-redis, only this clients would be actually checked.
+       * For any other clients all the requests would be passed directly to redis client
+       * @param {String} rlKey
+       * @param {Boolean} isReadonly
+       * @return {boolean}
+       * @private
+       */
+      _isRedisReady(rlKey, isReadonly) {
+        if (!this._rejectIfRedisNotReady) {
+          return true;
+        }
+        if (this.client.status) {
+          return this.client.status === "ready";
+        }
+        if (typeof this.client.isReady === "function") {
+          return this.client.isReady();
+        }
+        if (typeof this.client.isReady === "boolean") {
+          return this.client.isReady === true;
+        }
+        if (this.client._slots && typeof this.client._slots.getClient === "function") {
+          if (typeof this.client.isOpen === "boolean" && this.client.isOpen !== true) {
+            return false;
+          }
+          try {
+            const slotClient = this.client._slots.getClient(rlKey, isReadonly);
+            return slotClient && slotClient.isReady === true;
+          } catch (error) {
+            return false;
+          }
+        }
+        return true;
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        let [consumed, resTtlMs] = result;
+        if (Array.isArray(consumed)) {
+          [, consumed] = consumed;
+          [, resTtlMs] = resTtlMs;
+        }
+        const res = new RateLimiterRes2();
+        res.consumedPoints = parseInt(consumed);
+        res.isFirstInDuration = res.consumedPoints === changedPoints;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = resTtlMs;
+        return res;
+      }
+      async _upsert(rlKey, points, msDuration, forceExpire = false) {
+        if (typeof points == "string") {
+          if (!RegExp("^[1-9][0-9]*$").test(points)) {
+            throw new Error("Consuming string different than integer values is not supported by this package");
+          }
+        } else if (!Number.isInteger(points)) {
+          throw new Error("Consuming decimal number of points is not supported by this package");
+        }
+        if (!this._isRedisReady(rlKey, false)) {
+          throw new Error("Redis connection is not ready");
+        }
+        const secDuration = Math.floor(msDuration / 1e3);
+        const multi = this.client.multi();
+        if (forceExpire) {
+          if (secDuration > 0) {
+            if (!this.useRedisPackage && !this.useRedis3AndLowerPackage) {
+              multi.set(rlKey, points, "EX", secDuration);
+            } else {
+              multi.set(rlKey, points, { EX: secDuration });
+            }
+          } else {
+            multi.set(rlKey, points);
+          }
+          if (!this.useRedisPackage && !this.useRedis3AndLowerPackage) {
+            return multi.pttl(rlKey).exec(true);
+          }
+          return multi.pTTL(rlKey).exec(true);
+        }
+        if (secDuration > 0) {
+          if (!this.useRedisPackage && !this.useRedis3AndLowerPackage) {
+            return this.client.rlflxIncr(
+              [rlKey].concat([String(points), String(secDuration), String(this.points), String(this.duration)])
+            );
+          }
+          if (this.useRedis3AndLowerPackage) {
+            return new Promise((resolve, reject) => {
+              const incrCallback = function(err, result) {
+                if (err) {
+                  return reject(err);
+                }
+                return resolve(result);
+              };
+              if (typeof this.client.rlflxIncr === "function") {
+                this.client.rlflxIncr(rlKey, points, secDuration, this.points, this.duration, incrCallback);
+              } else {
+                this.client.eval(this._incrTtlLuaScript, 1, rlKey, points, secDuration, this.points, this.duration, incrCallback);
+              }
+            });
+          } else {
+            return this.client.eval(this._incrTtlLuaScript, {
+              keys: [rlKey],
+              arguments: [String(points), String(secDuration), String(this.points), String(this.duration)]
+            });
+          }
+        } else {
+          if (!this.useRedisPackage && !this.useRedis3AndLowerPackage) {
+            return multi.incrby(rlKey, points).pttl(rlKey).exec(true);
+          }
+          return multi.incrBy(rlKey, points).pTTL(rlKey).exec(true);
+        }
+      }
+      async _get(rlKey) {
+        if (!this._isRedisReady(rlKey, true)) {
+          throw new Error("Redis connection is not ready");
+        }
+        if (!this.useRedisPackage && !this.useRedis3AndLowerPackage) {
+          return this.client.multi().get(rlKey).pttl(rlKey).exec().then((result) => {
+            const [[, points]] = result;
+            if (points === null) return null;
+            return result;
+          });
+        }
+        return this.client.multi().get(rlKey).pTTL(rlKey).exec(true).then((result) => {
+          const [points] = result;
+          if (points === null) return null;
+          return result;
+        });
+      }
+      _delete(rlKey) {
+        return this.client.del(rlKey).then((result) => result > 0);
+      }
+    };
+    module.exports = RateLimiterRedis;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedisNonAtomic.js
+var require_RateLimiterRedisNonAtomic = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedisNonAtomic.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterRedisNonAtomic = class extends RateLimiterStoreAbstract {
+      constructor(opts) {
+        super(opts);
+        this.client = opts.storeClient;
+        this._rejectIfRedisNotReady = !!opts.rejectIfRedisNotReady;
+        this.useRedisPackage = opts.useRedisPackage || this.client.constructor.name === "Commander" || false;
+      }
+      _isRedisReady(rlKey, isReadonly) {
+        if (!this._rejectIfRedisNotReady) {
+          return true;
+        }
+        if (this.client.status) {
+          return this.client.status === "ready";
+        }
+        if (typeof this.client.isReady === "function") {
+          return this.client.isReady();
+        }
+        if (typeof this.client.isReady === "boolean") {
+          return this.client.isReady === true;
+        }
+        if (this.client._slots && typeof this.client._slots.getClient === "function") {
+          if (typeof this.client.isOpen === "boolean" && this.client.isOpen !== true) {
+            return false;
+          }
+          try {
+            const slotClient = this.client._slots.getClient(rlKey, isReadonly);
+            return slotClient && slotClient.isReady === true;
+          } catch (error) {
+            return false;
+          }
+        }
+        return true;
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        let [consumed, resTtlMs] = result;
+        if (Array.isArray(consumed)) {
+          [, consumed] = consumed;
+          [, resTtlMs] = resTtlMs;
+        }
+        const res = new RateLimiterRes2();
+        res.consumedPoints = parseInt(consumed);
+        res.isFirstInDuration = res.consumedPoints === changedPoints;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = resTtlMs;
+        return res;
+      }
+      _parseStoreResult(result) {
+        let points;
+        let ttlMs;
+        if (Array.isArray(result[0])) {
+          [, points] = result[0];
+          [, ttlMs] = result[1];
+        } else {
+          [points, ttlMs] = result;
+        }
+        return {
+          points: parseInt(points, 10),
+          ttlMs
+        };
+      }
+      _execMulti(multi) {
+        return multi.exec();
+      }
+      _setKey(rlKey, points, secDuration) {
+        const multi = this.client.multi();
+        if (secDuration > 0) {
+          if (!this.useRedisPackage) {
+            multi.set(rlKey, points, "EX", secDuration);
+          } else {
+            multi.set(rlKey, points, { EX: secDuration });
+          }
+        } else {
+          multi.set(rlKey, points);
+        }
+        return this._execMulti(multi);
+      }
+      _setKeyWithTtlMs(rlKey, points, ttlMs) {
+        const multi = this.client.multi();
+        multi.set(rlKey, points);
+        if (ttlMs > 0) {
+          if (!this.useRedisPackage) {
+            multi.pexpire(rlKey, ttlMs);
+          } else {
+            multi.pExpire(rlKey, ttlMs);
+          }
+        }
+        return this._execMulti(multi);
+      }
+      async _upsert(rlKey, points, msDuration, forceExpire = false) {
+        if (typeof points == "string") {
+          if (!RegExp("^[1-9][0-9]*$").test(points)) {
+            throw new Error("Consuming string different than integer values is not supported by this package");
+          }
+        } else if (!Number.isInteger(points)) {
+          throw new Error("Consuming decimal number of points is not supported by this package");
+        }
+        if (!this._isRedisReady(rlKey, false)) {
+          throw new Error("Redis connection is not ready");
+        }
+        const parsedPoints = typeof points === "string" ? parseInt(points, 10) : points;
+        const secDuration = Math.floor(msDuration / 1e3);
+        if (forceExpire) {
+          await this._setKey(rlKey, parsedPoints, secDuration);
+          return [parsedPoints, secDuration > 0 ? secDuration * 1e3 : -1];
+        }
+        const currentResult = await this._get(rlKey);
+        const hasCurrent = currentResult !== null;
+        const current = hasCurrent ? this._parseStoreResult(currentResult) : { points: 0, ttlMs: -1 };
+        const newPoints = current.points + parsedPoints;
+        if (secDuration > 0) {
+          if (!hasCurrent) {
+            await this._setKey(rlKey, newPoints, secDuration);
+            return [newPoints, secDuration * 1e3];
+          }
+          if (current.ttlMs <= 0) {
+            await this._setKey(rlKey, newPoints, secDuration);
+            return [newPoints, secDuration * 1e3];
+          }
+          await this._setKeyWithTtlMs(rlKey, newPoints, current.ttlMs);
+          return [newPoints, current.ttlMs];
+        }
+        await this._setKey(rlKey, newPoints, 0);
+        return [newPoints, -1];
+      }
+      async _get(rlKey) {
+        if (!this._isRedisReady(rlKey, true)) {
+          throw new Error("Redis connection is not ready");
+        }
+        const multi = this.client.multi().get(rlKey);
+        if (!this.useRedisPackage) {
+          multi.pttl(rlKey);
+        } else {
+          multi.pTTL(rlKey);
+        }
+        return this._execMulti(multi).then((result) => {
+          if (Array.isArray(result[0])) {
+            const [, points2] = result[0];
+            if (points2 === null) return null;
+            return result;
+          }
+          const [points] = result;
+          if (points === null) return null;
+          return result;
+        });
+      }
+      _delete(rlKey) {
+        return this.client.del(rlKey).then((result) => result > 0);
+      }
+    };
+    module.exports = RateLimiterRedisNonAtomic;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMongo.js
+var require_RateLimiterMongo = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMongo.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterMongo = class _RateLimiterMongo extends RateLimiterStoreAbstract {
+      /**
+       *
+       * @param {Object} opts
+       * Defaults {
+       *   indexKeyPrefix: {attr1: 1, attr2: 1}
+       *   ... see other in RateLimiterStoreAbstract
+       *
+       *   mongo: MongoClient
+       * }
+       */
+      constructor(opts) {
+        super(opts);
+        this.dbName = opts.dbName;
+        this.tableName = opts.tableName;
+        this.indexKeyPrefix = opts.indexKeyPrefix;
+        this.disableIndexesCreation = opts.disableIndexesCreation;
+        if (opts.mongo) {
+          this.client = opts.mongo;
+        } else {
+          this.client = opts.storeClient;
+        }
+        if (typeof this.client.then === "function") {
+          this.client.then((conn) => {
+            this.client = conn;
+            this._initCollection();
+          });
+        } else {
+          this._initCollection();
+        }
+      }
+      get dbName() {
+        return this._dbName;
+      }
+      set dbName(value) {
+        this._dbName = typeof value === "undefined" ? _RateLimiterMongo.getDbName() : value;
+      }
+      static getDbName() {
+        return "node-rate-limiter-flexible";
+      }
+      get tableName() {
+        return this._tableName;
+      }
+      set tableName(value) {
+        this._tableName = typeof value === "undefined" ? this.keyPrefix : value;
+      }
+      get client() {
+        return this._client;
+      }
+      set client(value) {
+        if (typeof value === "undefined") {
+          throw new Error("mongo is not set");
+        }
+        this._client = value;
+      }
+      get indexKeyPrefix() {
+        return this._indexKeyPrefix;
+      }
+      set indexKeyPrefix(obj) {
+        this._indexKeyPrefix = obj || {};
+      }
+      get disableIndexesCreation() {
+        return this._disableIndexesCreation;
+      }
+      set disableIndexesCreation(value) {
+        this._disableIndexesCreation = !!value;
+      }
+      async createIndexes() {
+        const db = typeof this.client.db === "function" ? this.client.db(this.dbName) : this.client;
+        const collection = db.collection(this.tableName);
+        await collection.createIndex({ expire: -1 }, { expireAfterSeconds: 0 });
+        await collection.createIndex(Object.assign({}, this.indexKeyPrefix, { key: 1 }), { unique: true });
+      }
+      _initCollection() {
+        const db = typeof this.client.db === "function" ? this.client.db(this.dbName) : this.client;
+        const collection = db.collection(this.tableName);
+        if (!this.disableIndexesCreation) {
+          this.createIndexes().catch((err) => {
+            console.error(`Cannot create indexes for mongo collection ${this.tableName}`, err);
+          });
+        }
+        this._collection = collection;
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        let doc;
+        if (typeof result.value === "undefined") {
+          doc = result;
+        } else {
+          doc = result.value;
+        }
+        res.isFirstInDuration = doc.points === changedPoints;
+        res.consumedPoints = doc.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = doc.expire !== null ? Math.max(new Date(doc.expire).getTime() - Date.now(), 0) : -1;
+        return res;
+      }
+      _upsert(key, points, msDuration, forceExpire = false, options = {}) {
+        if (!this._collection) {
+          return Promise.reject(Error("Mongo connection is not established"));
+        }
+        const docAttrs = options.attrs || {};
+        let where;
+        let upsertData;
+        if (forceExpire) {
+          where = { key };
+          where = Object.assign(where, docAttrs);
+          upsertData = {
+            $set: {
+              key,
+              points,
+              expire: msDuration > 0 ? new Date(Date.now() + msDuration) : null
+            }
+          };
+          upsertData.$set = Object.assign(upsertData.$set, docAttrs);
+        } else {
+          where = {
+            $or: [
+              { expire: { $gt: /* @__PURE__ */ new Date() } },
+              { expire: { $eq: null } }
+            ],
+            key
+          };
+          where = Object.assign(where, docAttrs);
+          upsertData = {
+            $setOnInsert: {
+              key,
+              expire: msDuration > 0 ? new Date(Date.now() + msDuration) : null
+            },
+            $inc: { points }
+          };
+          upsertData.$setOnInsert = Object.assign(upsertData.$setOnInsert, docAttrs);
+        }
+        const upsertOptions = {
+          upsert: true,
+          returnDocument: "after"
+        };
+        return new Promise((resolve, reject) => {
+          this._collection.findOneAndUpdate(
+            where,
+            upsertData,
+            upsertOptions
+          ).then((res) => {
+            resolve(res);
+          }).catch((errUpsert) => {
+            if (errUpsert && errUpsert.code === 11e3) {
+              const replaceWhere = Object.assign({
+                // try to replace OLD limit doc
+                $or: [
+                  { expire: { $lte: /* @__PURE__ */ new Date() } },
+                  { expire: { $eq: null } }
+                ],
+                key
+              }, docAttrs);
+              const replaceTo = {
+                $set: Object.assign({
+                  key,
+                  points,
+                  expire: msDuration > 0 ? new Date(Date.now() + msDuration) : null
+                }, docAttrs)
+              };
+              this._collection.findOneAndUpdate(
+                replaceWhere,
+                replaceTo,
+                upsertOptions
+              ).then((res) => {
+                resolve(res);
+              }).catch((errReplace) => {
+                if (errReplace && errReplace.code === 11e3) {
+                  this._upsert(key, points, msDuration, forceExpire).then((res) => resolve(res)).catch((err) => reject(err));
+                } else {
+                  reject(errReplace);
+                }
+              });
+            } else {
+              reject(errUpsert);
+            }
+          });
+        });
+      }
+      _get(rlKey, options = {}) {
+        if (!this._collection) {
+          return Promise.reject(Error("Mongo connection is not established"));
+        }
+        const docAttrs = options.attrs || {};
+        const where = Object.assign({
+          key: rlKey,
+          $or: [
+            { expire: { $gt: /* @__PURE__ */ new Date() } },
+            { expire: { $eq: null } }
+          ]
+        }, docAttrs);
+        return this._collection.findOne(where);
+      }
+      _delete(rlKey, options = {}) {
+        if (!this._collection) {
+          return Promise.reject(Error("Mongo connection is not established"));
+        }
+        const docAttrs = options.attrs || {};
+        const where = Object.assign({ key: rlKey }, docAttrs);
+        return this._collection.deleteOne(where).then((res) => res.deletedCount > 0);
+      }
+    };
+    module.exports = RateLimiterMongo;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMySQL.js
+var require_RateLimiterMySQL = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMySQL.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterMySQL = class extends RateLimiterStoreAbstract {
+      /**
+       * @callback callback
+       * @param {Object} err
+       *
+       * @param {Object} opts
+       * @param {callback} cb
+       * Defaults {
+       *   ... see other in RateLimiterStoreAbstract
+       *
+       *   storeClient: anySqlClient,
+       *   storeType: 'knex', // required only for Knex instance
+       *   dbName: 'string',
+       *   tableName: 'string',
+       * }
+       */
+      constructor(opts, cb = null) {
+        super(opts);
+        this.client = opts.storeClient;
+        this.clientType = opts.storeType;
+        this.dbName = opts.dbName;
+        this.tableName = opts.tableName;
+        this.clearExpiredByTimeout = opts.clearExpiredByTimeout;
+        this.tableCreated = opts.tableCreated;
+        if (!this.tableCreated) {
+          this._createDbAndTable().then(() => {
+            this.tableCreated = true;
+            if (this.clearExpiredByTimeout) {
+              this._clearExpiredHourAgo();
+            }
+            if (typeof cb === "function") {
+              cb();
+            }
+          }).catch((err) => {
+            if (typeof cb === "function") {
+              cb(err);
+            } else {
+              throw err;
+            }
+          });
+        } else {
+          if (this.clearExpiredByTimeout) {
+            this._clearExpiredHourAgo();
+          }
+          if (typeof cb === "function") {
+            cb();
+          }
+        }
+      }
+      clearExpired(expire) {
+        return new Promise((resolve) => {
+          this._getConnection().then((conn) => {
+            conn.query(`DELETE FROM ??.?? WHERE expire < ?`, [this.dbName, this.tableName, expire], () => {
+              this._releaseConnection(conn);
+              resolve();
+            });
+          }).catch(() => {
+            resolve();
+          });
+        });
+      }
+      _clearExpiredHourAgo() {
+        if (this._clearExpiredTimeoutId) {
+          clearTimeout(this._clearExpiredTimeoutId);
+        }
+        this._clearExpiredTimeoutId = setTimeout(() => {
+          this.clearExpired(Date.now() - 36e5).then(() => {
+            this._clearExpiredHourAgo();
+          });
+        }, 3e5);
+        this._clearExpiredTimeoutId.unref();
+      }
+      /**
+       *
+       * @return Promise<any>
+       * @private
+       */
+      _getConnection() {
+        switch (this.clientType) {
+          case "pool":
+            return new Promise((resolve, reject) => {
+              this.client.getConnection((errConn, conn) => {
+                if (errConn) {
+                  return reject(errConn);
+                }
+                resolve(conn);
+              });
+            });
+          case "sequelize":
+            return this._getSequelizeConnectionManager().getConnection();
+          case "knex":
+            return this.client.client.acquireConnection();
+          default:
+            return Promise.resolve(this.client);
+        }
+      }
+      _releaseConnection(conn) {
+        switch (this.clientType) {
+          case "pool":
+            return conn.release();
+          case "sequelize":
+            return this._getSequelizeConnectionManager().releaseConnection(conn);
+          case "knex":
+            return this.client.client.releaseConnection(conn);
+          default:
+            return true;
+        }
+      }
+      _getSequelizeConnectionManager() {
+        let connectionManager;
+        let originalError;
+        try {
+          connectionManager = this.client.connectionManager;
+        } catch (err) {
+          originalError = err;
+        }
+        if (connectionManager) {
+          return connectionManager;
+        }
+        if (this.client.dialect && this.client.dialect.connectionManager) {
+          return this.client.dialect.connectionManager;
+        }
+        if (originalError) {
+          throw originalError;
+        }
+        throw new Error("Sequelize connection manager is not available");
+      }
+      /**
+       *
+       * @returns {Promise<any>}
+       * @private
+       */
+      _createDbAndTable() {
+        return new Promise((resolve, reject) => {
+          this._getConnection().then((conn) => {
+            conn.query(`CREATE DATABASE IF NOT EXISTS \`${this.dbName}\`;`, (errDb) => {
+              if (errDb) {
+                this._releaseConnection(conn);
+                return reject(errDb);
+              }
+              conn.query(this._getCreateTableStmt(), (err) => {
+                if (err) {
+                  this._releaseConnection(conn);
+                  return reject(err);
+                }
+                this._releaseConnection(conn);
+                resolve();
+              });
+            });
+          }).catch((err) => {
+            reject(err);
+          });
+        });
+      }
+      _getCreateTableStmt() {
+        return `CREATE TABLE IF NOT EXISTS \`${this.dbName}\`.\`${this.tableName}\` (\`key\` VARCHAR(255) CHARACTER SET utf8 NOT NULL,\`points\` INT(9) NOT NULL default 0,\`expire\` BIGINT UNSIGNED,PRIMARY KEY (\`key\`)) ENGINE = INNODB;`;
+      }
+      get clientType() {
+        return this._clientType;
+      }
+      set clientType(value) {
+        if (typeof value === "undefined") {
+          if (this.client.constructor.name === "Connection") {
+            value = "connection";
+          } else if (this.client.constructor.name === "Pool") {
+            value = "pool";
+          } else if (this.client.constructor.name === "Sequelize") {
+            value = "sequelize";
+          } else {
+            throw new Error("storeType is not defined");
+          }
+        }
+        this._clientType = value.toLowerCase();
+      }
+      get dbName() {
+        return this._dbName;
+      }
+      set dbName(value) {
+        this._dbName = typeof value === "undefined" ? "rtlmtrflx" : value;
+      }
+      get tableName() {
+        return this._tableName;
+      }
+      set tableName(value) {
+        this._tableName = typeof value === "undefined" ? this.keyPrefix : value;
+      }
+      get tableCreated() {
+        return this._tableCreated;
+      }
+      set tableCreated(value) {
+        this._tableCreated = typeof value === "undefined" ? false : !!value;
+      }
+      get clearExpiredByTimeout() {
+        return this._clearExpiredByTimeout;
+      }
+      set clearExpiredByTimeout(value) {
+        this._clearExpiredByTimeout = typeof value === "undefined" ? true : Boolean(value);
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        const [row] = result;
+        res.isFirstInDuration = changedPoints === row.points;
+        res.consumedPoints = res.isFirstInDuration ? changedPoints : row.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = row.expire ? Math.max(row.expire - Date.now(), 0) : -1;
+        return res;
+      }
+      _upsertTransaction(conn, key, points, msDuration, forceExpire) {
+        return new Promise((resolve, reject) => {
+          conn.query("BEGIN", (errBegin) => {
+            if (errBegin) {
+              conn.rollback();
+              return reject(errBegin);
+            }
+            const dateNow = Date.now();
+            const newExpire = msDuration > 0 ? dateNow + msDuration : null;
+            let q;
+            let values;
+            if (forceExpire) {
+              q = `INSERT INTO ??.?? VALUES (?, ?, ?)
+          ON DUPLICATE KEY UPDATE 
+            points = ?, 
+            expire = ?;`;
+              values = [
+                this.dbName,
+                this.tableName,
+                key,
+                points,
+                newExpire,
+                points,
+                newExpire
+              ];
+            } else {
+              q = `INSERT INTO ??.?? VALUES (?, ?, ?)
+          ON DUPLICATE KEY UPDATE 
+            points = IF(expire <= ?, ?, points + (?)), 
+            expire = IF(expire <= ?, ?, expire);`;
+              values = [
+                this.dbName,
+                this.tableName,
+                key,
+                points,
+                newExpire,
+                dateNow,
+                points,
+                points,
+                dateNow,
+                newExpire
+              ];
+            }
+            conn.query(q, values, (errUpsert) => {
+              if (errUpsert) {
+                conn.rollback();
+                return reject(errUpsert);
+              }
+              conn.query("SELECT points, expire FROM ??.?? WHERE `key` = ?;", [this.dbName, this.tableName, key], (errSelect, res) => {
+                if (errSelect) {
+                  conn.rollback();
+                  return reject(errSelect);
+                }
+                conn.query("COMMIT", (err) => {
+                  if (err) {
+                    conn.rollback();
+                    return reject(err);
+                  }
+                  resolve(res);
+                });
+              });
+            });
+          });
+        });
+      }
+      _upsert(key, points, msDuration, forceExpire = false) {
+        if (!this.tableCreated) {
+          return Promise.reject(Error("Table is not created yet"));
+        }
+        return new Promise((resolve, reject) => {
+          this._getConnection().then((conn) => {
+            this._upsertTransaction(conn, key, points, msDuration, forceExpire).then((res) => {
+              resolve(res);
+              this._releaseConnection(conn);
+            }).catch((err) => {
+              reject(err);
+              this._releaseConnection(conn);
+            });
+          }).catch((err) => {
+            reject(err);
+          });
+        });
+      }
+      _get(rlKey) {
+        if (!this.tableCreated) {
+          return Promise.reject(Error("Table is not created yet"));
+        }
+        return new Promise((resolve, reject) => {
+          this._getConnection().then((conn) => {
+            conn.query(
+              "SELECT points, expire FROM ??.?? WHERE `key` = ? AND (`expire` > ? OR `expire` IS NULL)",
+              [this.dbName, this.tableName, rlKey, Date.now()],
+              (err, res) => {
+                if (err) {
+                  reject(err);
+                } else if (res.length === 0) {
+                  resolve(null);
+                } else {
+                  resolve(res);
+                }
+                this._releaseConnection(conn);
+              }
+              // eslint-disable-line
+            );
+          }).catch((err) => {
+            reject(err);
+          });
+        });
+      }
+      _delete(rlKey) {
+        if (!this.tableCreated) {
+          return Promise.reject(Error("Table is not created yet"));
+        }
+        return new Promise((resolve, reject) => {
+          this._getConnection().then((conn) => {
+            conn.query(
+              "DELETE FROM ??.?? WHERE `key` = ?",
+              [this.dbName, this.tableName, rlKey],
+              (err, res) => {
+                if (err) {
+                  reject(err);
+                } else {
+                  resolve(res.affectedRows > 0);
+                }
+                this._releaseConnection(conn);
+              }
+              // eslint-disable-line
+            );
+          }).catch((err) => {
+            reject(err);
+          });
+        });
+      }
+    };
+    module.exports = RateLimiterMySQL;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterPostgres.js
+var require_RateLimiterPostgres = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterPostgres.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterPostgres2 = class extends RateLimiterStoreAbstract {
+      /**
+       * @callback callback
+       * @param {Object} err
+       *
+       * @param {Object} opts
+       * @param {callback} cb
+       * Defaults {
+       *   ... see other in RateLimiterStoreAbstract
+       *
+       *   storeClient: postgresClient,
+       *   storeType: 'knex', // required only for Knex instance
+       *   tableName: 'string',
+       *   schemaName: 'string', // optional
+       * }
+       */
+      constructor(opts, cb = null) {
+        super(opts);
+        this.client = opts.storeClient;
+        this.clientType = opts.storeType;
+        this.tableName = opts.tableName;
+        this.schemaName = opts.schemaName;
+        this.clearExpiredByTimeout = opts.clearExpiredByTimeout;
+        this.tableCreated = opts.tableCreated;
+        if (!this.tableCreated) {
+          this._createTable().then(() => {
+            this.tableCreated = true;
+            if (this.clearExpiredByTimeout) {
+              this._clearExpiredHourAgo();
+            }
+            if (typeof cb === "function") {
+              cb();
+            }
+          }).catch((err) => {
+            if (typeof cb === "function") {
+              cb(err);
+            } else {
+              throw err;
+            }
+          });
+        } else {
+          if (this.clearExpiredByTimeout) {
+            this._clearExpiredHourAgo();
+          }
+          if (typeof cb === "function") {
+            cb();
+          }
+        }
+      }
+      _getTableIdentifier() {
+        return this.schemaName ? `"${this.schemaName}"."${this.tableName}"` : `"${this.tableName}"`;
+      }
+      clearExpired(expire) {
+        return new Promise((resolve) => {
+          const q = {
+            name: "rlflx-clear-expired",
+            text: `DELETE FROM ${this._getTableIdentifier()} WHERE expire < $1`,
+            values: [expire]
+          };
+          this._query(q).then(() => {
+            resolve();
+          }).catch(() => {
+            resolve();
+          });
+        });
+      }
+      /**
+       * Delete all rows expired 1 hour ago once per 5 minutes
+       *
+       * @private
+       */
+      _clearExpiredHourAgo() {
+        if (this._clearExpiredTimeoutId) {
+          clearTimeout(this._clearExpiredTimeoutId);
+        }
+        this._clearExpiredTimeoutId = setTimeout(() => {
+          this.clearExpired(Date.now() - 36e5).then(() => {
+            this._clearExpiredHourAgo();
+          });
+        }, 3e5);
+        this._clearExpiredTimeoutId.unref();
+      }
+      /**
+       *
+       * @return Promise<any>
+       * @private
+       */
+      _getConnection() {
+        switch (this.clientType) {
+          case "pool":
+            return Promise.resolve(this.client);
+          case "sequelize":
+            return this._getSequelizeConnectionManager().getConnection();
+          case "knex":
+            return this.client.client.acquireConnection();
+          case "typeorm":
+            return Promise.resolve(this.client.driver.master);
+          default:
+            return Promise.resolve(this.client);
+        }
+      }
+      _releaseConnection(conn) {
+        switch (this.clientType) {
+          case "pool":
+            return true;
+          case "sequelize":
+            return this._getSequelizeConnectionManager().releaseConnection(conn);
+          case "knex":
+            return this.client.client.releaseConnection(conn);
+          case "typeorm":
+            return true;
+          default:
+            return true;
+        }
+      }
+      _getSequelizeConnectionManager() {
+        let connectionManager;
+        let accessError;
+        try {
+          connectionManager = this.client.connectionManager;
+        } catch (err) {
+          accessError = err;
+        }
+        if (connectionManager) {
+          return connectionManager;
+        }
+        if (this.client.dialect && this.client.dialect.connectionManager) {
+          return this.client.dialect.connectionManager;
+        }
+        if (accessError) {
+          throw accessError;
+        }
+        throw new Error("Sequelize connection manager is not available");
+      }
+      /**
+       *
+       * @returns {Promise<any>}
+       * @private
+       */
+      _createTable() {
+        return new Promise((resolve, reject) => {
+          this._query({
+            text: this._getCreateTableStmt()
+          }).then(() => {
+            resolve();
+          }).catch((err) => {
+            if (err.code === "23505") {
+              resolve();
+            } else {
+              reject(err);
+            }
+          });
+        });
+      }
+      _getCreateTableStmt() {
+        return `CREATE TABLE IF NOT EXISTS ${this._getTableIdentifier()} (
+      key varchar(255) PRIMARY KEY,
+      points integer NOT NULL DEFAULT 0,
+      expire bigint
+    );`;
+      }
+      get clientType() {
+        return this._clientType;
+      }
+      set clientType(value) {
+        const constructorName = this.client.constructor.name;
+        if (typeof value === "undefined") {
+          if (constructorName === "Client") {
+            value = "client";
+          } else if (constructorName === "Pool" || constructorName === "BoundPool") {
+            value = "pool";
+          } else if (constructorName === "Sequelize") {
+            value = "sequelize";
+          } else {
+            throw new Error("storeType is not defined");
+          }
+        }
+        this._clientType = value.toLowerCase();
+      }
+      get tableName() {
+        return this._tableName;
+      }
+      set tableName(value) {
+        this._tableName = typeof value === "undefined" ? this.keyPrefix : value;
+      }
+      get schemaName() {
+        return this._schemaName;
+      }
+      set schemaName(value) {
+        this._schemaName = value;
+      }
+      get tableCreated() {
+        return this._tableCreated;
+      }
+      set tableCreated(value) {
+        this._tableCreated = typeof value === "undefined" ? false : !!value;
+      }
+      get clearExpiredByTimeout() {
+        return this._clearExpiredByTimeout;
+      }
+      set clearExpiredByTimeout(value) {
+        this._clearExpiredByTimeout = typeof value === "undefined" ? true : Boolean(value);
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        const row = result.rows[0];
+        res.isFirstInDuration = changedPoints === row.points;
+        res.consumedPoints = res.isFirstInDuration ? changedPoints : row.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = row.expire ? Math.max(row.expire - Date.now(), 0) : -1;
+        return res;
+      }
+      _query(q) {
+        const prefix = this.tableName.toLowerCase();
+        const queryObj = { text: q.text, values: q.values };
+        if (q.name) {
+          queryObj.name = `${prefix}:${q.name}`;
+        }
+        return new Promise((resolve, reject) => {
+          this._getConnection().then((conn) => {
+            conn.query(queryObj).then((res) => {
+              resolve(res);
+              this._releaseConnection(conn);
+            }).catch((err) => {
+              reject(err);
+              this._releaseConnection(conn);
+            });
+          }).catch((err) => {
+            reject(err);
+          });
+        });
+      }
+      _upsert(key, points, msDuration, forceExpire = false) {
+        if (!this.tableCreated) {
+          return Promise.reject(Error("Table is not created yet"));
+        }
+        const newExpire = msDuration > 0 ? Date.now() + msDuration : null;
+        const expireQ = forceExpire ? " $3 " : ` CASE
+             WHEN ${this._getTableIdentifier()}.expire <= $4 THEN $3
+             ELSE ${this._getTableIdentifier()}.expire
+            END `;
+        return this._query({
+          name: forceExpire ? "rlflx-upsert-force" : "rlflx-upsert",
+          text: `
+            INSERT INTO ${this._getTableIdentifier()} VALUES ($1, $2, $3)
+              ON CONFLICT(key) DO UPDATE SET
+                points = CASE
+                          WHEN (${this._getTableIdentifier()}.expire <= $4 OR 1=${forceExpire ? 1 : 0}) THEN $2
+                          ELSE ${this._getTableIdentifier()}.points + ($2)
+                         END,
+                expire = ${expireQ}
+            RETURNING points, expire;`,
+          values: [key, points, newExpire, Date.now()]
+        });
+      }
+      _get(rlKey) {
+        if (!this.tableCreated) {
+          return Promise.reject(Error("Table is not created yet"));
+        }
+        return new Promise((resolve, reject) => {
+          this._query({
+            name: "rlflx-get",
+            text: `
+            SELECT points, expire FROM ${this._getTableIdentifier()} WHERE key = $1 AND (expire > $2 OR expire IS NULL);`,
+            values: [rlKey, Date.now()]
+          }).then((res) => {
+            if (res.rowCount === 0) {
+              res = null;
+            }
+            resolve(res);
+          }).catch((err) => {
+            reject(err);
+          });
+        });
+      }
+      _delete(rlKey) {
+        if (!this.tableCreated) {
+          return Promise.reject(Error("Table is not created yet"));
+        }
+        return this._query({
+          name: "rlflx-delete",
+          text: `DELETE FROM ${this._getTableIdentifier()} WHERE key = $1`,
+          values: [rlKey]
+        }).then((res) => res.rowCount > 0);
+      }
+    };
+    module.exports = RateLimiterPostgres2;
+  }
+});
+
+// (disabled):cluster
+var require_cluster = __commonJS({
+  "(disabled):cluster"() {
+    "use strict";
+  }
+});
+
+// (disabled):crypto
+var require_crypto = __commonJS({
+  "(disabled):crypto"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/Record.js
+var require_Record = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/Record.js"(exports, module) {
+    "use strict";
+    module.exports = class Record {
+      /**
+       *
+       * @param value int
+       * @param expiresAt Number|Date
+       * @param timeoutId
+       */
+      constructor(value, expiresAt, timeoutId = null) {
+        this.value = value;
+        this.expiresAt = expiresAt;
+        this.timeoutId = timeoutId;
+      }
+      get value() {
+        return this._value;
+      }
+      set value(value) {
+        this._value = parseInt(value, 10);
+      }
+      get expiresAt() {
+        return this._expiresAt;
+      }
+      set expiresAt(value) {
+        if (value instanceof Date) {
+          this._expiresAt = value.getTime();
+        } else {
+          this._expiresAt = value;
+        }
+      }
+      get timeoutId() {
+        return this._timeoutId;
+      }
+      set timeoutId(value) {
+        this._timeoutId = value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/MemoryStorage.js
+var require_MemoryStorage = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/MemoryStorage.js"(exports, module) {
+    "use strict";
+    var Record = require_Record();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    module.exports = class MemoryStorage {
+      constructor() {
+        this._storage = /* @__PURE__ */ new Map();
+      }
+      incrby(key, value, durationSec) {
+        const record = this._storage.get(key);
+        if (record) {
+          const msBeforeExpires = record.expiresAt ? record.expiresAt - Date.now() : -1;
+          if (!record.expiresAt || msBeforeExpires > 0) {
+            record.value = record.value + value;
+            return new RateLimiterRes2(0, msBeforeExpires, record.value, false);
+          }
+          return this.set(key, value, durationSec);
+        }
+        return this.set(key, value, durationSec);
+      }
+      set(key, value, durationSec) {
+        const durationMs = durationSec * 1e3;
+        const existingRecord = this._storage.get(key);
+        if (existingRecord && existingRecord.timeoutId) {
+          clearTimeout(existingRecord.timeoutId);
+        }
+        const record = new Record(
+          value,
+          durationMs > 0 ? Date.now() + durationMs : null
+        );
+        this._storage.set(key, record);
+        if (durationMs > 0) {
+          record.timeoutId = setTimeout(() => {
+            this._storage.delete(key);
+          }, durationMs);
+          if (record.timeoutId.unref) {
+            record.timeoutId.unref();
+          }
+        }
+        return new RateLimiterRes2(0, durationMs === 0 ? -1 : durationMs, record.value, true);
+      }
+      /**
+       *
+       * @param key
+       * @returns {*}
+       */
+      get(key) {
+        const record = this._storage.get(key);
+        if (record) {
+          const msBeforeExpires = record.expiresAt ? record.expiresAt - Date.now() : -1;
+          return new RateLimiterRes2(0, msBeforeExpires, record.value, false);
+        }
+        return null;
+      }
+      /**
+       *
+       * @param key
+       * @returns {boolean}
+       */
+      delete(key) {
+        const record = this._storage.get(key);
+        if (record) {
+          if (record.timeoutId) {
+            clearTimeout(record.timeoutId);
+          }
+          this._storage.delete(key);
+          return true;
+        }
+        return false;
+      }
+      /**
+       * @internal
+       * @param key
+       * @param value
+       * @param expiresAt
+       */
+      _restoreRecord(key, value, expiresAt) {
+        const now = Date.now();
+        const hasExpiresAt = expiresAt !== null;
+        if (hasExpiresAt && !Number.isFinite(expiresAt)) {
+          return;
+        }
+        if (hasExpiresAt && expiresAt <= now) {
+          return;
+        }
+        const durationMs = hasExpiresAt ? expiresAt - now : 0;
+        const existingRecord = this._storage.get(key);
+        if (existingRecord && existingRecord.timeoutId) {
+          clearTimeout(existingRecord.timeoutId);
+        }
+        const record = new Record(
+          value,
+          expiresAt
+        );
+        this._storage.set(key, record);
+        if (durationMs > 0) {
+          record.timeoutId = setTimeout(() => {
+            this._storage.delete(key);
+          }, durationMs);
+          if (record.timeoutId.unref) {
+            record.timeoutId.unref();
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemory.js
+var require_RateLimiterMemory = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemory.js"(exports, module) {
+    "use strict";
+    var RateLimiterAbstract = require_RateLimiterAbstract();
+    var MemoryStorage = require_MemoryStorage();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterMemory2 = class extends RateLimiterAbstract {
+      constructor(opts = {}) {
+        super(opts);
+        this._memoryStorage = new MemoryStorage();
+      }
+      /**
+       *
+       * @param key
+       * @param pointsToConsume
+       * @param {Object} options
+       * @returns {Promise<RateLimiterRes>}
+       */
+      consume(key, pointsToConsume = 1, options = {}) {
+        return new Promise((resolve, reject) => {
+          const rlKey = this.getKey(key);
+          const secDuration = this._getKeySecDuration(options);
+          let res = this._memoryStorage.incrby(rlKey, pointsToConsume, secDuration);
+          res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+          if (res.consumedPoints > this.points) {
+            if (this.blockDuration > 0 && res.consumedPoints <= this.points + pointsToConsume) {
+              res = this._memoryStorage.set(rlKey, res.consumedPoints, this.blockDuration);
+            }
+            reject(res);
+          } else if (this.execEvenly && this.points > 0 && res.msBeforeNext > 0 && !res.isFirstInDuration) {
+            let delay = Math.ceil(res.msBeforeNext / (res.remainingPoints + 2));
+            if (delay < this.execEvenlyMinDelayMs) {
+              delay = res.consumedPoints * this.execEvenlyMinDelayMs;
+            }
+            res.msBeforeNext = Math.max(res.msBeforeNext - delay, 0);
+            setTimeout(resolve, delay, res);
+          } else {
+            resolve(res);
+          }
+        });
+      }
+      penalty(key, points = 1, options = {}) {
+        const rlKey = this.getKey(key);
+        return new Promise((resolve) => {
+          const secDuration = this._getKeySecDuration(options);
+          const res = this._memoryStorage.incrby(rlKey, points, secDuration);
+          res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+          resolve(res);
+        });
+      }
+      reward(key, points = 1, options = {}) {
+        const rlKey = this.getKey(key);
+        return new Promise((resolve) => {
+          const secDuration = this._getKeySecDuration(options);
+          const res = this._memoryStorage.incrby(rlKey, -points, secDuration);
+          res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+          resolve(res);
+        });
+      }
+      /**
+       * Block any key for secDuration seconds
+       *
+       * @param key
+       * @param secDuration
+       */
+      block(key, secDuration) {
+        const msDuration = secDuration * 1e3;
+        const initPoints = this.points + 1;
+        this._memoryStorage.set(this.getKey(key), initPoints, secDuration);
+        return Promise.resolve(
+          new RateLimiterRes2(0, msDuration === 0 ? -1 : msDuration, initPoints)
+        );
+      }
+      set(key, points, secDuration) {
+        const msDuration = (secDuration >= 0 ? secDuration : this.duration) * 1e3;
+        this._memoryStorage.set(this.getKey(key), points, secDuration);
+        return Promise.resolve(
+          new RateLimiterRes2(0, msDuration === 0 ? -1 : msDuration, points)
+        );
+      }
+      get(key) {
+        const res = this._memoryStorage.get(this.getKey(key));
+        if (res !== null) {
+          res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        }
+        return Promise.resolve(res);
+      }
+      delete(key) {
+        return Promise.resolve(this._memoryStorage.delete(this.getKey(key)));
+      }
+      dump() {
+        const storage = [];
+        for (const [key, record] of this._memoryStorage._storage) {
+          storage.push({
+            key: this.parseKey(key),
+            value: record.value,
+            expiresAt: record.expiresAt
+          });
+        }
+        return {
+          version: 1,
+          dumpedAt: Date.now(),
+          storage
+        };
+      }
+      /**
+       * Restores rate-limiter state from a previously dumped snapshot.
+       *
+       * Each entry is classified into one of three buckets:
+       *  - **invalid**  – the item is not an object or has a malformed schema (bad key, value or expiry type).
+       *  - **expired**  – the item has logically expired based on current timestamp.
+       *  - **restored** – the item was valid and successfully loaded into storage.
+       *
+       * @param {Object}  data            - Snapshot produced by {@link dump}.
+       * @param {boolean} [detailResponse=false] - When `true`, each bucket also
+       *   carries a `keys` array listing every affected key.
+       * @returns {{ invalid, expired, restored } | undefined} Summary counts (and
+       *   optionally keys).  Returns `undefined` when `data` fails schema checks.
+       */
+      restore(data, detailResponse = false) {
+        if (!data || typeof data !== "object" || data.version !== 1) {
+          return void 0;
+        }
+        const response = detailResponse ? {
+          invalid: { count: 0, keys: [] },
+          expired: { count: 0, keys: [] },
+          restored: { count: 0, keys: [] }
+        } : { invalid: 0, expired: 0, restored: 0 };
+        const record = (bucket, key) => {
+          if (detailResponse) {
+            response[bucket].count += 1;
+            response[bucket].keys.push(key);
+          } else {
+            response[bucket] += 1;
+          }
+        };
+        if (!Array.isArray(data.storage)) {
+          return response;
+        }
+        for (const item of data.storage) {
+          if (!item || typeof item !== "object") {
+            record("invalid", "N/A");
+            continue;
+          }
+          const isValidKey = typeof item.key === "string" || typeof item.key === "number";
+          const isValidValue = Number.isFinite(item.value);
+          const isValidExpiry = item.expiresAt === null || Number.isFinite(item.expiresAt);
+          if (!isValidKey || !isValidValue || !isValidExpiry) {
+            record("invalid", item.key);
+            continue;
+          }
+          if (item.expiresAt !== null && item.expiresAt <= Date.now()) {
+            record("expired", item.key);
+            continue;
+          }
+          this._memoryStorage._restoreRecord(this.getKey(item.key), item.value, item.expiresAt);
+          record("restored", item.key);
+        }
+        return response;
+      }
+    };
+    module.exports = RateLimiterMemory2;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterCluster.js
+var require_RateLimiterCluster = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterCluster.js"(exports, module) {
+    "use strict";
+    var cluster = require_cluster();
+    var crypto = require_crypto();
+    var RateLimiterAbstract = require_RateLimiterAbstract();
+    var RateLimiterMemory2 = require_RateLimiterMemory();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var channel = "rate_limiter_flexible";
+    var masterInstance = null;
+    var masterSendToWorker = function(worker, msg, type, res) {
+      let data;
+      if (res === null || res === true || res === false) {
+        data = res;
+      } else {
+        data = {
+          remainingPoints: res.remainingPoints,
+          msBeforeNext: res.msBeforeNext,
+          consumedPoints: res.consumedPoints,
+          isFirstInDuration: res.isFirstInDuration
+        };
+      }
+      worker.send({
+        channel,
+        keyPrefix: msg.keyPrefix,
+        // which rate limiter exactly
+        promiseId: msg.promiseId,
+        type,
+        data
+      });
+    };
+    var workerWaitInit = function(payload) {
+      setTimeout(() => {
+        if (this._initiated) {
+          process.send(payload);
+        } else if (typeof this._promises[payload.promiseId] !== "undefined") {
+          workerWaitInit.call(this, payload);
+        }
+      }, 30);
+    };
+    var workerSendToMaster = function(func, promiseId, key, arg, opts) {
+      const payload = {
+        channel,
+        keyPrefix: this.keyPrefix,
+        func,
+        promiseId,
+        data: {
+          key,
+          arg,
+          opts
+        }
+      };
+      if (!this._initiated) {
+        workerWaitInit.call(this, payload);
+      } else {
+        process.send(payload);
+      }
+    };
+    var masterProcessMsg = function(worker, msg) {
+      if (!msg || msg.channel !== channel || typeof this._rateLimiters[msg.keyPrefix] === "undefined") {
+        return false;
+      }
+      let promise;
+      switch (msg.func) {
+        case "consume":
+          promise = this._rateLimiters[msg.keyPrefix].consume(msg.data.key, msg.data.arg, msg.data.opts);
+          break;
+        case "penalty":
+          promise = this._rateLimiters[msg.keyPrefix].penalty(msg.data.key, msg.data.arg, msg.data.opts);
+          break;
+        case "reward":
+          promise = this._rateLimiters[msg.keyPrefix].reward(msg.data.key, msg.data.arg, msg.data.opts);
+          break;
+        case "block":
+          promise = this._rateLimiters[msg.keyPrefix].block(msg.data.key, msg.data.arg, msg.data.opts);
+          break;
+        case "get":
+          promise = this._rateLimiters[msg.keyPrefix].get(msg.data.key, msg.data.opts);
+          break;
+        case "delete":
+          promise = this._rateLimiters[msg.keyPrefix].delete(msg.data.key, msg.data.opts);
+          break;
+        default:
+          return false;
+      }
+      if (promise) {
+        promise.then((res) => {
+          masterSendToWorker(worker, msg, "resolve", res);
+        }).catch((rejRes) => {
+          masterSendToWorker(worker, msg, "reject", rejRes);
+        });
+      }
+    };
+    var workerProcessMsg = function(msg) {
+      if (!msg || msg.channel !== channel || msg.keyPrefix !== this.keyPrefix) {
+        return false;
+      }
+      if (this._promises[msg.promiseId]) {
+        clearTimeout(this._promises[msg.promiseId].timeoutId);
+        let res;
+        if (msg.data === null || msg.data === true || msg.data === false) {
+          res = msg.data;
+        } else {
+          res = new RateLimiterRes2(
+            msg.data.remainingPoints,
+            msg.data.msBeforeNext,
+            msg.data.consumedPoints,
+            msg.data.isFirstInDuration
+            // eslint-disable-line comma-dangle
+          );
+        }
+        switch (msg.type) {
+          case "resolve":
+            this._promises[msg.promiseId].resolve(res);
+            break;
+          case "reject":
+            this._promises[msg.promiseId].reject(res);
+            break;
+          default:
+            throw new Error(`RateLimiterCluster: no such message type '${msg.type}'`);
+        }
+        delete this._promises[msg.promiseId];
+      }
+    };
+    var getOpts = function() {
+      return {
+        points: this.points,
+        duration: this.duration,
+        blockDuration: this.blockDuration,
+        execEvenly: this.execEvenly,
+        execEvenlyMinDelayMs: this.execEvenlyMinDelayMs,
+        keyPrefix: this.keyPrefix
+      };
+    };
+    var savePromise = function(resolve, reject) {
+      const hrtime = process.hrtime();
+      let promiseId = hrtime[0].toString() + hrtime[1].toString();
+      if (typeof this._promises[promiseId] !== "undefined") {
+        promiseId += crypto.randomBytes(12).toString("base64");
+      }
+      this._promises[promiseId] = {
+        resolve,
+        reject,
+        timeoutId: setTimeout(() => {
+          delete this._promises[promiseId];
+          reject(new Error("RateLimiterCluster timeout: no answer from master in time"));
+        }, this.timeoutMs)
+      };
+      return promiseId;
+    };
+    var RateLimiterClusterMaster = class {
+      constructor() {
+        if (masterInstance) {
+          return masterInstance;
+        }
+        this._rateLimiters = {};
+        cluster.setMaxListeners(0);
+        cluster.on("message", (worker, msg) => {
+          if (msg && msg.channel === channel && msg.type === "init") {
+            if (typeof this._rateLimiters[msg.opts.keyPrefix] === "undefined") {
+              this._rateLimiters[msg.opts.keyPrefix] = new RateLimiterMemory2(msg.opts);
+            }
+            worker.send({
+              channel,
+              type: "init",
+              keyPrefix: msg.opts.keyPrefix
+            });
+          } else {
+            masterProcessMsg.call(this, worker, msg);
+          }
+        });
+        masterInstance = this;
+      }
+    };
+    var RateLimiterClusterMasterPM2 = class {
+      constructor(pm2) {
+        if (masterInstance) {
+          return masterInstance;
+        }
+        this._rateLimiters = {};
+        pm2.launchBus((err, pm2Bus) => {
+          pm2Bus.on("process:msg", (packet) => {
+            const msg = packet.raw;
+            if (msg && msg.channel === channel && msg.type === "init") {
+              if (typeof this._rateLimiters[msg.opts.keyPrefix] === "undefined") {
+                this._rateLimiters[msg.opts.keyPrefix] = new RateLimiterMemory2(msg.opts);
+              }
+              pm2.sendDataToProcessId(packet.process.pm_id, {
+                data: {},
+                topic: channel,
+                channel,
+                type: "init",
+                keyPrefix: msg.opts.keyPrefix
+              }, (sendErr, res) => {
+                if (sendErr) {
+                  console.log(sendErr, res);
+                }
+              });
+            } else {
+              const worker = {
+                send: (msgData) => {
+                  const pm2Message = msgData;
+                  pm2Message.topic = channel;
+                  if (typeof pm2Message.data === "undefined") {
+                    pm2Message.data = {};
+                  }
+                  pm2.sendDataToProcessId(packet.process.pm_id, pm2Message, (sendErr, res) => {
+                    if (sendErr) {
+                      console.log(sendErr, res);
+                    }
+                  });
+                }
+              };
+              masterProcessMsg.call(this, worker, msg);
+            }
+          });
+        });
+        masterInstance = this;
+      }
+    };
+    var RateLimiterClusterWorker = class extends RateLimiterAbstract {
+      get timeoutMs() {
+        return this._timeoutMs;
+      }
+      set timeoutMs(value) {
+        this._timeoutMs = typeof value === "undefined" ? 5e3 : Math.abs(parseInt(value));
+      }
+      constructor(opts = {}) {
+        super(opts);
+        process.setMaxListeners(0);
+        this.timeoutMs = opts.timeoutMs;
+        this._initiated = false;
+        process.on("message", (msg) => {
+          if (msg && msg.channel === channel && msg.type === "init" && msg.keyPrefix === this.keyPrefix) {
+            this._initiated = true;
+          } else {
+            workerProcessMsg.call(this, msg);
+          }
+        });
+        process.send({
+          channel,
+          type: "init",
+          opts: getOpts.call(this)
+        });
+        this._promises = {};
+      }
+      consume(key, pointsToConsume = 1, options = {}) {
+        return new Promise((resolve, reject) => {
+          const promiseId = savePromise.call(this, resolve, reject);
+          workerSendToMaster.call(this, "consume", promiseId, key, pointsToConsume, options);
+        });
+      }
+      penalty(key, points = 1, options = {}) {
+        return new Promise((resolve, reject) => {
+          const promiseId = savePromise.call(this, resolve, reject);
+          workerSendToMaster.call(this, "penalty", promiseId, key, points, options);
+        });
+      }
+      reward(key, points = 1, options = {}) {
+        return new Promise((resolve, reject) => {
+          const promiseId = savePromise.call(this, resolve, reject);
+          workerSendToMaster.call(this, "reward", promiseId, key, points, options);
+        });
+      }
+      block(key, secDuration, options = {}) {
+        return new Promise((resolve, reject) => {
+          const promiseId = savePromise.call(this, resolve, reject);
+          workerSendToMaster.call(this, "block", promiseId, key, secDuration, options);
+        });
+      }
+      get(key, options = {}) {
+        return new Promise((resolve, reject) => {
+          const promiseId = savePromise.call(this, resolve, reject);
+          workerSendToMaster.call(this, "get", promiseId, key, options);
+        });
+      }
+      delete(key, options = {}) {
+        return new Promise((resolve, reject) => {
+          const promiseId = savePromise.call(this, resolve, reject);
+          workerSendToMaster.call(this, "delete", promiseId, key, options);
+        });
+      }
+    };
+    module.exports = {
+      RateLimiterClusterMaster,
+      RateLimiterClusterMasterPM2,
+      RateLimiterCluster: RateLimiterClusterWorker
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemcache.js
+var require_RateLimiterMemcache = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemcache.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterMemcache = class extends RateLimiterStoreAbstract {
+      /**
+       *
+       * @param {Object} opts
+       * Defaults {
+       *   ... see other in RateLimiterStoreAbstract
+       *
+       *   storeClient: memcacheClient
+       * }
+       */
+      constructor(opts) {
+        super(opts);
+        this.client = opts.storeClient;
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        res.consumedPoints = parseInt(result.consumedPoints);
+        res.isFirstInDuration = result.consumedPoints === changedPoints;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = result.msBeforeNext;
+        return res;
+      }
+      _upsert(rlKey, points, msDuration, forceExpire = false, options = {}) {
+        return new Promise((resolve, reject) => {
+          const nowMs = Date.now();
+          const secDuration = Math.floor(msDuration / 1e3);
+          if (forceExpire) {
+            this.client.set(rlKey, points, secDuration, (err) => {
+              if (!err) {
+                this.client.set(
+                  `${rlKey}_expire`,
+                  secDuration > 0 ? nowMs + secDuration * 1e3 : -1,
+                  secDuration,
+                  () => {
+                    const res = {
+                      consumedPoints: points,
+                      msBeforeNext: secDuration > 0 ? secDuration * 1e3 : -1
+                    };
+                    resolve(res);
+                  }
+                );
+              } else {
+                reject(err);
+              }
+            });
+          } else {
+            this.client.incr(rlKey, points, (err, consumedPoints) => {
+              if (err || consumedPoints === false) {
+                this.client.add(rlKey, points, secDuration, (errAddKey, createdNew) => {
+                  if (errAddKey || !createdNew) {
+                    if (typeof options.attemptNumber === "undefined" || options.attemptNumber < 3) {
+                      const nextOptions = Object.assign({}, options);
+                      nextOptions.attemptNumber = nextOptions.attemptNumber ? nextOptions.attemptNumber + 1 : 1;
+                      this._upsert(rlKey, points, msDuration, forceExpire, nextOptions).then((resUpsert) => resolve(resUpsert)).catch((errUpsert) => reject(errUpsert));
+                    } else {
+                      reject(new Error("Can not add key"));
+                    }
+                  } else {
+                    this.client.add(
+                      `${rlKey}_expire`,
+                      secDuration > 0 ? nowMs + secDuration * 1e3 : -1,
+                      secDuration,
+                      () => {
+                        const res = {
+                          consumedPoints: points,
+                          msBeforeNext: secDuration > 0 ? secDuration * 1e3 : -1
+                        };
+                        resolve(res);
+                      }
+                    );
+                  }
+                });
+              } else {
+                this.client.get(`${rlKey}_expire`, (errGetExpire, resGetExpireMs) => {
+                  if (errGetExpire) {
+                    reject(errGetExpire);
+                  } else {
+                    const expireMs = resGetExpireMs === false ? 0 : resGetExpireMs;
+                    const res = {
+                      consumedPoints,
+                      msBeforeNext: expireMs >= 0 ? Math.max(expireMs - nowMs, 0) : -1
+                    };
+                    resolve(res);
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+      _get(rlKey) {
+        return new Promise((resolve, reject) => {
+          const nowMs = Date.now();
+          this.client.get(rlKey, (err, consumedPoints) => {
+            if (!consumedPoints) {
+              resolve(null);
+            } else {
+              this.client.get(`${rlKey}_expire`, (errGetExpire, resGetExpireMs) => {
+                if (errGetExpire) {
+                  reject(errGetExpire);
+                } else {
+                  const expireMs = resGetExpireMs === false ? 0 : resGetExpireMs;
+                  const res = {
+                    consumedPoints,
+                    msBeforeNext: expireMs >= 0 ? Math.max(expireMs - nowMs, 0) : -1
+                  };
+                  resolve(res);
+                }
+              });
+            }
+          });
+        });
+      }
+      _delete(rlKey) {
+        return new Promise((resolve, reject) => {
+          this.client.del(rlKey, (err, res) => {
+            if (err) {
+              reject(err);
+            } else if (res === false) {
+              resolve(res);
+            } else {
+              this.client.del(`${rlKey}_expire`, (errDelExpire) => {
+                if (errDelExpire) {
+                  reject(errDelExpire);
+                } else {
+                  resolve(res);
+                }
+              });
+            }
+          });
+        });
+      }
+    };
+    module.exports = RateLimiterMemcache;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RLWrapperBlackAndWhite.js
+var require_RLWrapperBlackAndWhite = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RLWrapperBlackAndWhite.js"(exports, module) {
+    "use strict";
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterCompatibleAbstract = require_RateLimiterCompatibleAbstract();
+    module.exports = class RLWrapperBlackAndWhite extends RateLimiterCompatibleAbstract {
+      constructor(opts = {}) {
+        super();
+        this.limiter = opts.limiter;
+        this.blackList = opts.blackList;
+        this.whiteList = opts.whiteList;
+        this.isBlackListed = opts.isBlackListed;
+        this.isWhiteListed = opts.isWhiteListed;
+        this.runActionAnyway = opts.runActionAnyway;
+      }
+      get limiter() {
+        return this._limiter;
+      }
+      set limiter(value) {
+        if (typeof value === "undefined") {
+          throw new Error("limiter is not set");
+        }
+        this._limiter = value;
+      }
+      get keyPrefix() {
+        return this.limiter.keyPrefix;
+      }
+      get blockDuration() {
+        return this.limiter.blockDuration;
+      }
+      set blockDuration(value) {
+        this.limiter.blockDuration = value;
+      }
+      get execEvenly() {
+        return this.limiter.execEvenly;
+      }
+      set execEvenly(value) {
+        this.limiter.execEvenly = value;
+      }
+      get runActionAnyway() {
+        return this._runActionAnyway;
+      }
+      set runActionAnyway(value) {
+        this._runActionAnyway = typeof value === "undefined" ? false : value;
+      }
+      get blackList() {
+        return this._blackList;
+      }
+      set blackList(value) {
+        this._blackList = Array.isArray(value) ? value : [];
+      }
+      get isBlackListed() {
+        return this._isBlackListed;
+      }
+      set isBlackListed(func) {
+        if (typeof func === "undefined") {
+          func = () => false;
+        }
+        if (typeof func !== "function") {
+          throw new Error("isBlackListed must be function");
+        }
+        this._isBlackListed = func;
+      }
+      get whiteList() {
+        return this._whiteList;
+      }
+      set whiteList(value) {
+        this._whiteList = Array.isArray(value) ? value : [];
+      }
+      get isWhiteListed() {
+        return this._isWhiteListed;
+      }
+      set isWhiteListed(func) {
+        if (typeof func === "undefined") {
+          func = () => false;
+        }
+        if (typeof func !== "function") {
+          throw new Error("isWhiteListed must be function");
+        }
+        this._isWhiteListed = func;
+      }
+      isBlackListedSomewhere(key) {
+        return this.blackList.indexOf(key) >= 0 || this.isBlackListed(key);
+      }
+      isWhiteListedSomewhere(key) {
+        return this.whiteList.indexOf(key) >= 0 || this.isWhiteListed(key);
+      }
+      getBlackRes() {
+        return new RateLimiterRes2(0, Number.MAX_SAFE_INTEGER, 0, false);
+      }
+      getWhiteRes() {
+        return new RateLimiterRes2(Number.MAX_SAFE_INTEGER, 0, 0, false);
+      }
+      rejectBlack() {
+        return Promise.reject(this.getBlackRes());
+      }
+      resolveBlack() {
+        return Promise.resolve(this.getBlackRes());
+      }
+      resolveWhite() {
+        return Promise.resolve(this.getWhiteRes());
+      }
+      _execAction(action, key, args, rejectOnBlack = false) {
+        let res;
+        if (this.isWhiteListedSomewhere(key)) {
+          res = this.resolveWhite();
+        } else if (this.isBlackListedSomewhere(key)) {
+          res = rejectOnBlack ? this.rejectBlack() : this.resolveBlack();
+        }
+        if (typeof res === "undefined") {
+          return this.limiter[action](key, ...args);
+        }
+        if (this.runActionAnyway) {
+          this.limiter[action](key, ...args).catch(() => {
+          });
+        }
+        return res;
+      }
+      consume(key, pointsToConsume = 1, options = {}) {
+        return this._execAction("consume", key, [pointsToConsume, options], true);
+      }
+      block(key, secDuration, options = {}) {
+        return this._execAction("block", key, [secDuration, options]);
+      }
+      penalty(key, points = 1, options = {}) {
+        return this._execAction("penalty", key, [points, options]);
+      }
+      reward(key, points = 1, options = {}) {
+        return this._execAction("reward", key, [points, options]);
+      }
+      get(key, options = {}) {
+        if (this.runActionAnyway) {
+          return this.limiter.get(key, options);
+        }
+        return this._execAction("get", key, [options]);
+      }
+      set(key, points, secDuration, options = {}) {
+        return this._execAction("set", key, [points, secDuration, options]);
+      }
+      delete(key, options = {}) {
+        return this.limiter.delete(key, options);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RLWrapperTimeouts.js
+var require_RLWrapperTimeouts = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RLWrapperTimeouts.js"(exports, module) {
+    "use strict";
+    var RateLimiterInsuredAbstract = require_RateLimiterInsuredAbstract();
+    var isRateLimiterCompatible = require_isRateLimiterCompatible();
+    module.exports = class RLWrapperTimeouts extends RateLimiterInsuredAbstract {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          points: 0,
+          duration: 0
+        });
+        this.limiter = opts.limiter;
+        this.timeoutMs = opts.timeoutMs || 0;
+      }
+      get limiter() {
+        return this._limiter;
+      }
+      set limiter(limiter) {
+        if (!isRateLimiterCompatible(limiter)) {
+          throw new TypeError("limiter must be an instance of RateLimiterAbstract or RateLimiterCompatibleAbstract");
+        }
+        this._limiter = limiter;
+        if (!this.insuranceLimiter && limiter instanceof RateLimiterInsuredAbstract) {
+          this.insuranceLimiter = limiter.insuranceLimiter;
+        }
+      }
+      get timeoutMs() {
+        return this._timeoutMs;
+      }
+      set timeoutMs(value) {
+        if (typeof value !== "number" || value < 0) {
+          throw new TypeError("timeoutMs must be a non-negative number");
+        }
+        this._timeoutMs = value;
+      }
+      _run(funcName, params) {
+        return new Promise(async (resolve, reject) => {
+          const timeout = setTimeout(() => {
+            return reject(new Error("Operation timed out"));
+          }, this.timeoutMs);
+          await this.limiter[funcName](...params).then((result) => {
+            clearTimeout(timeout);
+            resolve(result);
+          }).catch((err) => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+        });
+      }
+      _consume(key, pointsToConsume = 1, options = {}) {
+        return this._run("consume", [key, pointsToConsume, options]);
+      }
+      _penalty(key, points = 1, options = {}) {
+        return this._run("penalty", [key, points, options]);
+      }
+      _reward(key, points = 1, options = {}) {
+        return this._run("reward", [key, points, options]);
+      }
+      _get(key, options = {}) {
+        return this._run("get", [key, options]);
+      }
+      _set(key, points, secDuration, options = {}) {
+        return this._run("set", [key, points, secDuration, options]);
+      }
+      _block(key, secDuration, options = {}) {
+        return this._run("block", [key, secDuration, options]);
+      }
+      _delete(key, options = {}) {
+        return this._run("delete", [key, options]);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterUnion.js
+var require_RateLimiterUnion = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterUnion.js"(exports, module) {
+    "use strict";
+    var isRateLimiterCompatible = require_isRateLimiterCompatible();
+    module.exports = class RateLimiterUnion {
+      constructor(...limiters) {
+        if (limiters.length < 1) {
+          throw new Error("RateLimiterUnion: at least one limiter have to be passed");
+        }
+        limiters.forEach((limiter) => {
+          if (!isRateLimiterCompatible(limiter)) {
+            throw new Error("RateLimiterUnion: all limiters have to be instance of RateLimiterAbstract or RateLimiterCompatibleAbstract");
+          }
+        });
+        this._limiters = limiters;
+      }
+      consume(key, points = 1) {
+        return new Promise((resolve, reject) => {
+          const promises = [];
+          this._limiters.forEach((limiter) => {
+            promises.push(limiter.consume(key, points).catch((rej) => ({ rejected: true, rej })));
+          });
+          Promise.all(promises).then((res) => {
+            const resObj = {};
+            let rejected = false;
+            res.forEach((item) => {
+              if (item.rejected === true) {
+                rejected = true;
+              }
+            });
+            for (let i = 0; i < res.length; i++) {
+              if (rejected && res[i].rejected === true) {
+                resObj[this._limiters[i].keyPrefix] = res[i].rej;
+              } else if (!rejected) {
+                resObj[this._limiters[i].keyPrefix] = res[i];
+              }
+            }
+            if (rejected) {
+              reject(resObj);
+            } else {
+              resolve(resObj);
+            }
+          });
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterQueueError.js
+var require_RateLimiterQueueError = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterQueueError.js"(exports, module) {
+    "use strict";
+    module.exports = class RateLimiterQueueError extends Error {
+      constructor(message, extra) {
+        super();
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = "CustomError";
+        this.message = message;
+        if (extra) {
+          this.extra = extra;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterQueue.js
+var require_RateLimiterQueue = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterQueue.js"(exports, module) {
+    "use strict";
+    var RateLimiterQueueError = require_RateLimiterQueueError();
+    var MAX_QUEUE_SIZE = 4294967295;
+    var KEY_DEFAULT = "limiter";
+    module.exports = class RateLimiterQueue {
+      constructor(limiterFlexible, opts = {}) {
+        const maxQueueSize = opts.maxQueueSize !== void 0 ? opts.maxQueueSize : MAX_QUEUE_SIZE;
+        this._queueLimiters = {
+          KEY_DEFAULT: new RateLimiterQueueInternal(limiterFlexible, {
+            ...opts,
+            maxQueueSize,
+            key: KEY_DEFAULT
+          })
+        };
+        this._limiterFlexible = limiterFlexible;
+        this._maxQueueSize = maxQueueSize;
+      }
+      getTokensRemaining(key = KEY_DEFAULT) {
+        if (this._queueLimiters[key]) {
+          return this._queueLimiters[key].getTokensRemaining();
+        } else {
+          return Promise.resolve(this._limiterFlexible.points);
+        }
+      }
+      removeTokens(tokens, key = KEY_DEFAULT, expiresUnixAt = 0) {
+        if (!this._queueLimiters[key]) {
+          this._queueLimiters[key] = new RateLimiterQueueInternal(
+            this._limiterFlexible,
+            {
+              key,
+              maxQueueSize: this._maxQueueSize
+            }
+          );
+        }
+        return this._queueLimiters[key].removeTokens(tokens, expiresUnixAt);
+      }
+    };
+    var RateLimiterQueueInternal = class {
+      constructor(limiterFlexible, opts = {
+        maxQueueSize: MAX_QUEUE_SIZE,
+        key: KEY_DEFAULT
+      }) {
+        this._key = opts.key;
+        this._waitTimeout = null;
+        this._queue = [];
+        this._limiterFlexible = limiterFlexible;
+        this._hasExpiringRequests = false;
+        this._maxQueueSize = opts.maxQueueSize;
+      }
+      getTokensRemaining() {
+        return this._limiterFlexible.get(this._key).then((rlRes) => {
+          return rlRes !== null ? rlRes.remainingPoints : this._limiterFlexible.points;
+        });
+      }
+      removeTokens(tokens, expiresUnixAt = 0) {
+        const _this = this;
+        return new Promise((resolve, reject) => {
+          if (tokens > _this._limiterFlexible.points) {
+            reject(new RateLimiterQueueError(`Requested tokens ${tokens} exceeds maximum ${_this._limiterFlexible.points} tokens per interval`));
+            return;
+          }
+          if (_this._queue.length > 0) {
+            _this._queueRequest.call(_this, resolve, reject, tokens, expiresUnixAt);
+          } else {
+            _this._limiterFlexible.consume(_this._key, tokens).then((res) => {
+              resolve(res.remainingPoints);
+            }).catch((rej) => {
+              if (rej instanceof Error) {
+                reject(rej);
+              } else {
+                _this._queueRequest.call(_this, resolve, reject, tokens, expiresUnixAt);
+                if (_this._waitTimeout === null) {
+                  _this._waitTimeout = setTimeout(_this._processFIFO.bind(_this), rej.msBeforeNext);
+                }
+              }
+            });
+          }
+        });
+      }
+      _queueRequest(resolve, reject, tokens, expiresUnixAt = 0) {
+        const _this = this;
+        if (_this._queue.length < _this._maxQueueSize) {
+          _this._queue.push({ resolve, reject, tokens, expiresUnixAt });
+          if (expiresUnixAt > 0) {
+            _this._hasExpiringRequests = true;
+          }
+        } else {
+          reject(new RateLimiterQueueError(`Number of requests reached it's maximum ${_this._maxQueueSize}`));
+        }
+      }
+      _processFIFO() {
+        const _this = this;
+        if (_this._waitTimeout !== null) {
+          clearTimeout(_this._waitTimeout);
+          _this._waitTimeout = null;
+        }
+        if (_this._hasExpiringRequests) {
+          const nowSecs = Math.floor(Date.now() / 1e3);
+          _this._queue = _this._queue.filter((item2) => {
+            if (item2.expiresUnixAt > 0 && nowSecs >= item2.expiresUnixAt) {
+              item2.reject(new RateLimiterQueueError("The request to remove tokens expired before it could be fulfilled"));
+              return false;
+            }
+            return true;
+          });
+        }
+        if (_this._queue.length === 0) {
+          return;
+        }
+        const item = _this._queue.shift();
+        _this._limiterFlexible.consume(_this._key, item.tokens).then((res) => {
+          item.resolve(res.remainingPoints);
+          _this._processFIFO.call(_this);
+        }).catch((rej) => {
+          if (rej instanceof Error) {
+            item.reject(rej);
+            _this._processFIFO.call(_this);
+          } else {
+            _this._queue.unshift(item);
+            if (_this._waitTimeout === null) {
+              _this._waitTimeout = setTimeout(_this._processFIFO.bind(_this), rej.msBeforeNext);
+            }
+          }
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/BurstyRateLimiter.js
+var require_BurstyRateLimiter = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/BurstyRateLimiter.js"(exports, module) {
+    "use strict";
+    var RateLimiterRes2 = require_RateLimiterRes();
+    module.exports = class BurstyRateLimiter {
+      constructor(rateLimiter, burstLimiter) {
+        this._rateLimiter = rateLimiter;
+        this._burstLimiter = burstLimiter;
+      }
+      /**
+       * Merge rate limiter response objects. Responses can be null
+       *
+       * @param {RateLimiterRes} [rlRes] Rate limiter response
+       * @param {RateLimiterRes} [blRes] Bursty limiter response
+       */
+      _combineRes(rlRes, blRes) {
+        if (!rlRes) {
+          return null;
+        }
+        return new RateLimiterRes2(
+          rlRes.remainingPoints,
+          Math.min(rlRes.msBeforeNext, blRes ? blRes.msBeforeNext : 0),
+          rlRes.consumedPoints,
+          rlRes.isFirstInDuration
+        );
+      }
+      /**
+       * @param key
+       * @param pointsToConsume
+       * @param options
+       * @returns {Promise<any>}
+       */
+      consume(key, pointsToConsume = 1, options = {}) {
+        return this._rateLimiter.consume(key, pointsToConsume, options).catch((rlRej) => {
+          if (rlRej instanceof RateLimiterRes2) {
+            return this._burstLimiter.consume(key, pointsToConsume, options).then((blRes) => {
+              return Promise.resolve(this._combineRes(rlRej, blRes));
+            }).catch(
+              (blRej) => {
+                if (blRej instanceof RateLimiterRes2) {
+                  return Promise.reject(this._combineRes(rlRej, blRej));
+                } else {
+                  return Promise.reject(blRej);
+                }
+              }
+            );
+          } else {
+            return Promise.reject(rlRej);
+          }
+        });
+      }
+      /**
+       * It doesn't expose available points from burstLimiter
+       *
+       * @param key
+       * @returns {Promise<RateLimiterRes>}
+       */
+      get(key) {
+        return Promise.all([
+          this._rateLimiter.get(key),
+          this._burstLimiter.get(key)
+        ]).then(([rlRes, blRes]) => {
+          return this._combineRes(rlRes, blRes);
+        });
+      }
+      get points() {
+        return this._rateLimiter.points;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterDynamo.js
+var require_RateLimiterDynamo = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterDynamo.js"(exports, module) {
+    "use strict";
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var DynamoItem = class {
+      /**
+       * Create a DynamoItem.
+       * @param {string} rlKey - The key for the rate limiter.
+       * @param {number} points - The number of points.
+       * @param {number} expire - The expiration time in seconds.
+       */
+      constructor(rlKey, points, expire) {
+        this.key = rlKey;
+        this.points = points;
+        this.expire = expire;
+      }
+    };
+    var DEFAULT_READ_CAPACITY_UNITS = 25;
+    var DEFAULT_WRITE_CAPACITY_UNITS = 25;
+    var RateLimiterDynamo = class extends RateLimiterStoreAbstract {
+      /**
+       * Constructs a new instance of the class.
+       * The storeClient MUST be an instance of AWS.DynamoDB NOT of AWS.DynamoDBClient.
+       *
+       * @param {Object} opts - The options for the constructor.
+       * @param {function} cb - The callback function (optional).
+       * @return {void}
+       */
+      constructor(opts, cb = null) {
+        super(opts);
+        this.client = opts.storeClient;
+        this.tableName = opts.tableName;
+        this.tableCreated = opts.tableCreated;
+        this.ttlManuallySet = opts.ttlSet;
+        if (!this.tableCreated) {
+          this._createTable(opts.dynamoTableOpts).then((data) => {
+            this.tableCreated = true;
+            this._setTTL().finally(() => {
+              if (typeof cb === "function") {
+                cb();
+              }
+            });
+          }).catch((err) => {
+            if (typeof cb === "function") {
+              cb(err);
+            } else {
+              throw err;
+            }
+          });
+        } else {
+          this._setTTL().finally(() => {
+            if (typeof cb === "function") {
+              cb();
+            }
+          });
+        }
+      }
+      get tableName() {
+        return this._tableName;
+      }
+      set tableName(value) {
+        this._tableName = typeof value === "undefined" ? "node-rate-limiter-flexible" : value;
+      }
+      get tableCreated() {
+        return this._tableCreated;
+      }
+      set tableCreated(value) {
+        this._tableCreated = typeof value === "undefined" ? false : !!value;
+      }
+      /**
+       * Creates a table in the database. Return null if the table already exists.
+       * 
+       * @param {{readCapacityUnits: number, writeCapacityUnits: number}} tableOpts
+       * @return {Promise} A promise that resolves with the result of creating the table.
+       */
+      async _createTable(tableOpts) {
+        const params = {
+          TableName: this.tableName,
+          AttributeDefinitions: [
+            {
+              AttributeName: "key",
+              AttributeType: "S"
+            }
+          ],
+          KeySchema: [
+            {
+              AttributeName: "key",
+              KeyType: "HASH"
+            }
+          ],
+          ProvisionedThroughput: {
+            ReadCapacityUnits: tableOpts && tableOpts.readCapacityUnits ? tableOpts.readCapacityUnits : DEFAULT_READ_CAPACITY_UNITS,
+            WriteCapacityUnits: tableOpts && tableOpts.writeCapacityUnits ? tableOpts.writeCapacityUnits : DEFAULT_WRITE_CAPACITY_UNITS
+          }
+        };
+        try {
+          const data = await this.client.createTable(params);
+          return data;
+        } catch (err) {
+          if (err.__type && err.__type.includes("ResourceInUseException")) {
+            return null;
+          } else {
+            throw err;
+          }
+        }
+      }
+      /**
+       * Retrieves an item from the table based on the provided key.
+       *
+       * @param {string} rlKey - The key used to retrieve the item.
+       * @throws {Error} Throws an error if the table is not created yet.
+       * @return {DynamoItem|null} - The retrieved item, or null if it doesn't exist.
+       */
+      async _get(rlKey) {
+        if (!this.tableCreated) {
+          throw new Error("Table is not created yet");
+        }
+        const params = {
+          TableName: this.tableName,
+          Key: {
+            key: { S: rlKey }
+          }
+        };
+        const data = await this.client.getItem(params);
+        if (!data.Item) {
+          return null;
+        }
+        const item = new DynamoItem(
+          data.Item.key.S,
+          Number(data.Item.points.N),
+          Number(data.Item.expire.N)
+        );
+        const dateNowSec = Date.now() / 1e3;
+        if (item.expire !== -1 && item.expire <= dateNowSec) {
+          return null;
+        }
+        return item;
+      }
+      /**
+       * Deletes an item from the table based on the given rlKey.
+       *
+       * @param {string} rlKey - The rlKey of the item to delete.
+       * @throws {Error} Throws an error if the table is not created yet.
+       * @return {boolean} Returns true if the item was successfully deleted, otherwise false.
+       */
+      async _delete(rlKey) {
+        if (!this.tableCreated) {
+          throw new Error("Table is not created yet");
+        }
+        const params = {
+          TableName: this.tableName,
+          Key: {
+            key: { S: rlKey }
+          },
+          ConditionExpression: "attribute_exists(#k)",
+          ExpressionAttributeNames: {
+            "#k": "key"
+          }
+        };
+        try {
+          const data = await this._client.deleteItem(params);
+          return data.$metadata.httpStatusCode === 200;
+        } catch (err) {
+          if (err.__type && err.__type.includes("ConditionalCheckFailedException")) {
+            return false;
+          } else {
+            throw err;
+          }
+        }
+      }
+      /**
+       * Implemented with DynamoDB Atomic Counters. 3 calls are made to DynamoDB but each call is atomic.
+       * From the documentation: "UpdateItem calls are naturally serialized within DynamoDB,
+       * so there are no race condition concerns with making multiple simultaneous calls."
+       * See: https://aws.amazon.com/it/blogs/database/implement-resource-counters-with-amazon-dynamodb/
+       * @param {*} rlKey 
+       * @param {*} points 
+       * @param {*} msDuration 
+       * @param {*} forceExpire 
+       * @param {*} options 
+       * @returns
+       */
+      async _upsert(rlKey, points, msDuration, forceExpire = false, options = {}) {
+        if (!this.tableCreated) {
+          throw new Error("Table is not created yet");
+        }
+        const dateNow = Date.now();
+        const dateNowSec = dateNow / 1e3;
+        const newExpireSec = msDuration > 0 ? (dateNow + msDuration) / 1e3 : -1;
+        if (forceExpire) {
+          return await this._baseUpsert({
+            TableName: this.tableName,
+            Key: { key: { S: rlKey } },
+            UpdateExpression: "SET points = :points, expire = :expire",
+            ExpressionAttributeValues: {
+              ":points": { N: points.toString() },
+              ":expire": { N: newExpireSec.toString() }
+            },
+            ReturnValues: "ALL_NEW"
+          });
+        }
+        try {
+          return await this._baseUpsert({
+            TableName: this.tableName,
+            Key: { key: { S: rlKey } },
+            UpdateExpression: "SET points = :new_points, expire = :new_expire",
+            ExpressionAttributeValues: {
+              ":new_points": { N: points.toString() },
+              ":new_expire": { N: newExpireSec.toString() },
+              ":where_expire": { N: dateNowSec.toString() }
+            },
+            ConditionExpression: "expire <= :where_expire OR attribute_not_exists(points)",
+            ReturnValues: "ALL_NEW"
+          });
+        } catch (err) {
+          return await this._baseUpsert({
+            TableName: this.tableName,
+            Key: { key: { S: rlKey } },
+            UpdateExpression: "SET points = points + :new_points",
+            ExpressionAttributeValues: {
+              ":new_points": { N: points.toString() },
+              ":where_expire": { N: dateNowSec.toString() }
+            },
+            ConditionExpression: "expire > :where_expire",
+            ReturnValues: "ALL_NEW"
+          });
+        }
+      }
+      /**
+       * Asynchronously upserts data into the table. params is a DynamoDB params object.
+       *
+       * @param {Object} params - The parameters for the upsert operation.
+       * @throws {Error} Throws an error if the table is not created yet.
+       * @return {DynamoItem} Returns a DynamoItem object with the updated data.
+       */
+      async _baseUpsert(params) {
+        if (!this.tableCreated) {
+          throw new Error("Table is not created yet");
+        }
+        try {
+          const data = await this.client.updateItem(params);
+          return new DynamoItem(
+            data.Attributes.key.S,
+            Number(data.Attributes.points.N),
+            Number(data.Attributes.expire.N)
+          );
+        } catch (err) {
+          throw err;
+        }
+      }
+      /**
+       * Sets the Time-to-Live (TTL) for the table. TTL use the expire field in the table.
+       * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html
+       *
+       * @return {Promise} A promise that resolves when the TTL is successfully set.
+       * @throws {Error} Throws an error if the table is not created yet.
+       * @returns {Promise}
+       */
+      async _setTTL() {
+        if (!this.tableCreated) {
+          throw new Error("Table is not created yet");
+        }
+        try {
+          const isTTLSet = await this._isTTLSet();
+          if (isTTLSet) {
+            return;
+          }
+          const params = {
+            TableName: this.tableName,
+            TimeToLiveSpecification: {
+              AttributeName: "expire",
+              Enabled: true
+            }
+          };
+          const res = await this.client.updateTimeToLive(params);
+          return res;
+        } catch (err) {
+          throw err;
+        }
+      }
+      /**
+       * Checks if the Time To Live (TTL) feature is set for the DynamoDB table.
+       *
+       * @return {boolean} Returns true if the TTL feature is enabled for the table, otherwise false.
+       * @throws {Error} Throws an error if the table is not created yet or if there is an error while checking the TTL status.
+       */
+      async _isTTLSet() {
+        if (!this.tableCreated) {
+          throw new Error("Table is not created yet");
+        }
+        if (this.ttlManuallySet) {
+          return true;
+        }
+        try {
+          const res = await this.client.describeTimeToLive({ TableName: this.tableName });
+          return res.$metadata.httpStatusCode == 200 && res.TimeToLiveDescription.TimeToLiveStatus === "ENABLED" && res.TimeToLiveDescription.AttributeName === "expire";
+        } catch (err) {
+          throw err;
+        }
+      }
+      /**
+       * Generate a RateLimiterRes object based on the provided parameters.
+       *
+       * @param {string} rlKey - The key for the rate limiter.
+       * @param {number} changedPoints - The number of points that have changed.
+       * @param {DynamoItem} result - The result object of _get() method.
+       * @returns {RateLimiterRes} - The generated RateLimiterRes object.
+       */
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        res.isFirstInDuration = changedPoints === result.points;
+        res.consumedPoints = res.isFirstInDuration ? changedPoints : result.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = result.expire != -1 ? Math.max(result.expire * 1e3 - Date.now(), 0) : -1;
+        return res;
+      }
+    };
+    module.exports = RateLimiterDynamo;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterPrisma.js
+var require_RateLimiterPrisma = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterPrisma.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterPrisma = class extends RateLimiterStoreAbstract {
+      /**
+       * Constructor for the rate limiter
+       * @param {Object} opts - Options for the rate limiter
+       */
+      constructor(opts) {
+        super(opts);
+        this.modelName = opts.tableName || "RateLimiterFlexible";
+        this.prismaClient = opts.storeClient;
+        this.clearExpiredByTimeout = opts.clearExpiredByTimeout || true;
+        if (!this.prismaClient) {
+          throw new Error("Prisma client is not provided");
+        }
+        if (this.clearExpiredByTimeout) {
+          this._clearExpiredHourAgo();
+        }
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        let doc = result;
+        res.isFirstInDuration = doc.points === changedPoints;
+        res.consumedPoints = doc.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = doc.expire !== null ? Math.max(new Date(doc.expire).getTime() - Date.now(), 0) : -1;
+        return res;
+      }
+      _upsert(key, points, msDuration, forceExpire = false) {
+        if (!this.prismaClient) {
+          return Promise.reject(new Error("Prisma client is not established"));
+        }
+        const now = /* @__PURE__ */ new Date();
+        const newExpire = msDuration > 0 ? new Date(now.getTime() + msDuration) : null;
+        return this.prismaClient.$transaction(async (prisma) => {
+          const existingRecord = await prisma[this.modelName].findFirst({
+            where: { key }
+          });
+          if (existingRecord) {
+            const shouldUpdateExpire = forceExpire || !existingRecord.expire || existingRecord.expire <= now || newExpire === null;
+            return prisma[this.modelName].update({
+              where: { key },
+              data: {
+                points: !shouldUpdateExpire ? existingRecord.points + points : points,
+                ...shouldUpdateExpire && { expire: newExpire }
+              }
+            });
+          } else {
+            return prisma[this.modelName].create({
+              data: {
+                key,
+                points,
+                expire: newExpire
+              }
+            });
+          }
+        });
+      }
+      _get(rlKey) {
+        if (!this.prismaClient) {
+          return Promise.reject(new Error("Prisma client is not established"));
+        }
+        return this.prismaClient[this.modelName].findFirst({
+          where: {
+            AND: [
+              { key: rlKey },
+              {
+                OR: [
+                  { expire: { gt: /* @__PURE__ */ new Date() } },
+                  { expire: null }
+                ]
+              }
+            ]
+          }
+        });
+      }
+      _delete(rlKey) {
+        if (!this.prismaClient) {
+          return Promise.reject(new Error("Prisma client is not established"));
+        }
+        return this.prismaClient[this.modelName].deleteMany({
+          where: {
+            key: rlKey
+          }
+        }).then((res) => res.count > 0);
+      }
+      _clearExpiredHourAgo() {
+        if (this._clearExpiredTimeoutId) {
+          clearTimeout(this._clearExpiredTimeoutId);
+        }
+        this._clearExpiredTimeoutId = setTimeout(async () => {
+          await this.prismaClient[this.modelName].deleteMany({
+            where: {
+              expire: {
+                lt: new Date(Date.now() - 36e5)
+              }
+            }
+          });
+          this._clearExpiredHourAgo();
+        }, 3e5);
+        this._clearExpiredTimeoutId.unref();
+      }
+    };
+    module.exports = RateLimiterPrisma;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzle.js
+var require_RateLimiterDrizzle = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzle.js"(exports, module) {
+    "use strict";
+    var drizzleOperators = null;
+    var CLEANUP_INTERVAL_MS = 3e5;
+    var EXPIRED_THRESHOLD_MS = 36e5;
+    var RateLimiterDrizzleError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "RateLimiterDrizzleError";
+      }
+    };
+    async function loadDrizzleOperators() {
+      if (drizzleOperators) return drizzleOperators;
+      const requiredOperators = ["and", "or", "gt", "lt", "eq", "isNull", "sql"];
+      function getPackageName() {
+        return ["drizzle", "orm"].join("-");
+      }
+      const collectModuleLayers = (mod) => {
+        const layers = [];
+        const seen = /* @__PURE__ */ new Set();
+        let current = mod;
+        while (current && (typeof current === "object" || typeof current === "function") && !seen.has(current)) {
+          layers.push(current);
+          seen.add(current);
+          current = current.default;
+        }
+        return layers;
+      };
+      const importModule = async (specifier, { optional = false } = {}) => {
+        try {
+          return await import(
+            /* @vite-ignore */
+            specifier
+          );
+        } catch (error) {
+          if (optional) {
+            return null;
+          }
+          throw new RateLimiterDrizzleError(
+            error.message || "Failed to import drizzle-orm package."
+          );
+        }
+      };
+      const mainModule = await importModule(`${getPackageName()}`);
+      const sqlModule = await importModule(`${getPackageName()}/sql`, { optional: true });
+      const mainCandidates = collectModuleLayers(mainModule);
+      const sqlCandidates = sqlModule ? collectModuleLayers(sqlModule) : [];
+      const resolvedOperators = {};
+      const missingOperators = [];
+      for (const operatorName of requiredOperators) {
+        const candidates = operatorName === "sql" ? [...sqlCandidates, ...mainCandidates] : mainCandidates;
+        const operator = candidates.map((candidate) => candidate?.[operatorName]).find((value) => typeof value === "function");
+        if (!operator) {
+          missingOperators.push(operatorName);
+          continue;
+        }
+        resolvedOperators[operatorName] = operator;
+      }
+      if (missingOperators.length > 0) {
+        throw new RateLimiterDrizzleError(
+          `Failed to load drizzle-orm operators: missing ${missingOperators.join(", ")}`
+        );
+      }
+      drizzleOperators = resolvedOperators;
+      return drizzleOperators;
+    }
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterDrizzle = class extends RateLimiterStoreAbstract {
+      constructor(opts) {
+        super(opts);
+        if (!opts?.schema) {
+          throw new RateLimiterDrizzleError("Drizzle schema is required");
+        }
+        if (!opts?.storeClient) {
+          throw new RateLimiterDrizzleError("Drizzle client is required");
+        }
+        this.schema = opts.schema;
+        this.drizzleClient = opts.storeClient;
+        this.clearExpiredByTimeout = opts.clearExpiredByTimeout ?? true;
+        if (this.clearExpiredByTimeout) {
+          this._clearExpiredHourAgo();
+        }
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        let doc = result;
+        res.isFirstInDuration = doc.points === changedPoints;
+        res.consumedPoints = doc.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = doc.expire !== null ? Math.max(new Date(doc.expire).getTime() - Date.now(), 0) : -1;
+        return res;
+      }
+      async _upsert(key, points, msDuration, forceExpire = false) {
+        if (!this.drizzleClient) {
+          return Promise.reject(new RateLimiterDrizzleError("Drizzle client is not established"));
+        }
+        const { eq, sql } = await loadDrizzleOperators();
+        const now = /* @__PURE__ */ new Date();
+        const newExpire = msDuration > 0 ? new Date(now.getTime() + msDuration) : null;
+        const query = await this.drizzleClient.transaction(async (tx) => {
+          const [existingRecord] = await tx.select().from(this.schema).where(eq(this.schema.key, key)).limit(1);
+          const shouldUpdateExpire = forceExpire || !existingRecord?.expire || existingRecord?.expire <= now || newExpire === null;
+          const [data] = await tx.insert(this.schema).values({
+            key,
+            points,
+            expire: newExpire
+          }).onConflictDoUpdate({
+            target: this.schema.key,
+            set: {
+              points: !shouldUpdateExpire ? sql`${this.schema.points} + ${points}` : points,
+              ...shouldUpdateExpire && { expire: newExpire }
+            }
+          }).returning();
+          return data;
+        });
+        return query;
+      }
+      async _get(rlKey) {
+        if (!this.drizzleClient) {
+          return Promise.reject(new RateLimiterDrizzleError("Drizzle client is not established"));
+        }
+        const { and, or, gt, eq, isNull } = await loadDrizzleOperators();
+        const [response] = await this.drizzleClient.select().from(this.schema).where(
+          and(
+            eq(this.schema.key, rlKey),
+            or(gt(this.schema.expire, /* @__PURE__ */ new Date()), isNull(this.schema.expire))
+          )
+        ).limit(1);
+        return response || null;
+      }
+      async _delete(rlKey) {
+        if (!this.drizzleClient) {
+          return Promise.reject(new RateLimiterDrizzleError("Drizzle client is not established"));
+        }
+        const { eq } = await loadDrizzleOperators();
+        const [result] = await this.drizzleClient.delete(this.schema).where(eq(this.schema.key, rlKey)).returning({ key: this.schema.key });
+        return !!result?.key;
+      }
+      _clearExpiredHourAgo() {
+        if (this._clearExpiredTimeoutId) {
+          clearTimeout(this._clearExpiredTimeoutId);
+        }
+        this._clearExpiredTimeoutId = setTimeout(async () => {
+          try {
+            const { lt } = await loadDrizzleOperators();
+            await this.drizzleClient.delete(this.schema).where(lt(this.schema.expire, new Date(Date.now() - EXPIRED_THRESHOLD_MS)));
+          } catch (error) {
+            console.warn("Failed to clear expired records:", error);
+          }
+          this._clearExpiredHourAgo();
+        }, CLEANUP_INTERVAL_MS);
+        this._clearExpiredTimeoutId.unref();
+      }
+    };
+    module.exports = RateLimiterDrizzle;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzleNonAtomic.js
+var require_RateLimiterDrizzleNonAtomic = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzleNonAtomic.js"(exports, module) {
+    "use strict";
+    var drizzleOperators = null;
+    var CLEANUP_INTERVAL_MS = 3e5;
+    var EXPIRED_THRESHOLD_MS = 36e5;
+    var RateLimiterDrizzleError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "RateLimiterDrizzleError";
+      }
+    };
+    async function getDrizzleOperators() {
+      if (drizzleOperators) return drizzleOperators;
+      try {
+        let getPackageName2 = function() {
+          return ["drizzle", "orm"].join("-");
+        };
+        var getPackageName = getPackageName2;
+        const drizzleOrm = await import(`${getPackageName2()}`);
+        const { and, or, gt, lt, eq, isNull, sql } = drizzleOrm.default || drizzleOrm;
+        drizzleOperators = { and, or, gt, lt, eq, isNull, sql };
+        return drizzleOperators;
+      } catch (error) {
+        throw new RateLimiterDrizzleError(
+          "drizzle-orm is not installed. Please install drizzle-orm to use RateLimiterDrizzleNonAtomic."
+        );
+      }
+    }
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterDrizzleNonAtomic = class extends RateLimiterStoreAbstract {
+      constructor(opts) {
+        super(opts);
+        if (!opts?.schema) {
+          throw new RateLimiterDrizzleError("Drizzle schema is required");
+        }
+        if (!opts?.storeClient) {
+          throw new RateLimiterDrizzleError("Drizzle client is required");
+        }
+        this.schema = opts.schema;
+        this.drizzleClient = opts.storeClient;
+        this.clearExpiredByTimeout = opts.clearExpiredByTimeout ?? true;
+        if (this.clearExpiredByTimeout) {
+          this._clearExpiredHourAgo();
+        }
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        let doc = result;
+        res.isFirstInDuration = doc.points === changedPoints;
+        res.consumedPoints = doc.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = doc.expire !== null ? Math.max(new Date(doc.expire).getTime() - Date.now(), 0) : -1;
+        return res;
+      }
+      async _upsert(key, points, msDuration, forceExpire = false) {
+        if (!this.drizzleClient) {
+          return Promise.reject(new RateLimiterDrizzleError("Drizzle client is not established"));
+        }
+        const { eq } = await getDrizzleOperators();
+        const now = /* @__PURE__ */ new Date();
+        const newExpire = msDuration > 0 ? new Date(now.getTime() + msDuration) : null;
+        const [existingRecord] = await this.drizzleClient.select().from(this.schema).where(eq(this.schema.key, key)).limit(1);
+        const shouldUpdateExpire = forceExpire || !existingRecord || !existingRecord.expire || existingRecord.expire <= now || newExpire === null;
+        let newPoints;
+        if (existingRecord && !shouldUpdateExpire) {
+          newPoints = existingRecord.points + points;
+        } else {
+          newPoints = points;
+        }
+        const [data] = await this.drizzleClient.insert(this.schema).values({
+          key,
+          points: newPoints,
+          expire: newExpire
+        }).onConflictDoUpdate({
+          target: this.schema.key,
+          set: {
+            points: newPoints,
+            ...shouldUpdateExpire && { expire: newExpire }
+          }
+        }).returning();
+        return data;
+      }
+      async _get(rlKey) {
+        if (!this.drizzleClient) {
+          return Promise.reject(new RateLimiterDrizzleError("Drizzle client is not established"));
+        }
+        const { and, or, gt, eq, isNull } = await getDrizzleOperators();
+        const [response] = await this.drizzleClient.select().from(this.schema).where(
+          and(
+            eq(this.schema.key, rlKey),
+            or(gt(this.schema.expire, /* @__PURE__ */ new Date()), isNull(this.schema.expire))
+          )
+        ).limit(1);
+        return response || null;
+      }
+      async _delete(rlKey) {
+        if (!this.drizzleClient) {
+          return Promise.reject(new RateLimiterDrizzleError("Drizzle client is not established"));
+        }
+        const { eq } = await getDrizzleOperators();
+        const [result] = await this.drizzleClient.delete(this.schema).where(eq(this.schema.key, rlKey)).returning({ key: this.schema.key });
+        return !!(result && result.key);
+      }
+      _clearExpiredHourAgo() {
+        if (this._clearExpiredTimeoutId) {
+          clearTimeout(this._clearExpiredTimeoutId);
+        }
+        this._clearExpiredTimeoutId = setTimeout(async () => {
+          try {
+            const { lt } = await getDrizzleOperators();
+            await this.drizzleClient.delete(this.schema).where(lt(this.schema.expire, new Date(Date.now() - EXPIRED_THRESHOLD_MS)));
+          } catch (error) {
+            console.warn("Failed to clear expired records:", error);
+          }
+          this._clearExpiredHourAgo();
+        }, CLEANUP_INTERVAL_MS);
+        this._clearExpiredTimeoutId.unref();
+      }
+    };
+    module.exports = RateLimiterDrizzleNonAtomic;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkey.js
+var require_RateLimiterValkey = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkey.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var incrTtlLuaScript = `
+server.call('set', KEYS[1], 0, 'EX', ARGV[2], 'NX')
+local consumed = server.call('incrby', KEYS[1], ARGV[1])
+local ttl = server.call('pttl', KEYS[1])
+return {consumed, ttl}
+`;
+    var RateLimiterValkey = class extends RateLimiterStoreAbstract {
+      /**
+       *
+       * @param {Object} opts
+       * Defaults {
+       *   ... see other in RateLimiterStoreAbstract
+       *
+       *   storeClient: ValkeyClient
+       *   rejectIfValkeyNotReady: boolean = false - reject / invoke insuranceLimiter immediately when valkey connection is not "ready"
+       * }
+       */
+      constructor(opts) {
+        super(opts);
+        this.client = opts.storeClient;
+        this._rejectIfValkeyNotReady = !!opts.rejectIfValkeyNotReady;
+        this._incrTtlLuaScript = opts.customIncrTtlLuaScript || incrTtlLuaScript;
+        this.client.defineCommand("rlflxIncr", {
+          numberOfKeys: 1,
+          lua: this._incrTtlLuaScript
+        });
+      }
+      /**
+       * Prevent actual valkey call if valkey connection is not ready
+       * @return {boolean}
+       * @private
+       */
+      _isValkeyReady() {
+        if (!this._rejectIfValkeyNotReady) {
+          return true;
+        }
+        return this.client.status === "ready";
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        let consumed;
+        let resTtlMs;
+        if (Array.isArray(result[0])) {
+          [[, consumed], [, resTtlMs]] = result;
+        } else {
+          [consumed, resTtlMs] = result;
+        }
+        const res = new RateLimiterRes2();
+        res.consumedPoints = +consumed;
+        res.isFirstInDuration = res.consumedPoints === changedPoints;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = resTtlMs;
+        return res;
+      }
+      _upsert(rlKey, points, msDuration, forceExpire = false) {
+        if (!this._isValkeyReady()) {
+          throw new Error("Valkey connection is not ready");
+        }
+        const secDuration = Math.floor(msDuration / 1e3);
+        if (forceExpire) {
+          const multi = this.client.multi();
+          if (secDuration > 0) {
+            multi.set(rlKey, points, "EX", secDuration);
+          } else {
+            multi.set(rlKey, points);
+          }
+          return multi.pttl(rlKey).exec();
+        }
+        if (secDuration > 0) {
+          return this.client.rlflxIncr([rlKey, String(points), String(secDuration), String(this.points), String(this.duration)]);
+        }
+        return this.client.multi().incrby(rlKey, points).pttl(rlKey).exec();
+      }
+      _get(rlKey) {
+        if (!this._isValkeyReady()) {
+          throw new Error("Valkey connection is not ready");
+        }
+        return this.client.multi().get(rlKey).pttl(rlKey).exec().then((result) => {
+          const [[, points]] = result;
+          if (points === null) return null;
+          return result;
+        });
+      }
+      _delete(rlKey) {
+        return this.client.del(rlKey).then((result) => result > 0);
+      }
+    };
+    module.exports = RateLimiterValkey;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkeyGlide.js
+var require_RateLimiterValkeyGlide = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkeyGlide.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var DEFAULT_LIBRARY_NAME = "ratelimiterflexible";
+    var DEFAULT_VALKEY_SCRIPT = `local key = KEYS[1]
+local pointsToConsume = tonumber(ARGV[1])
+if tonumber(ARGV[2]) > 0 then
+  server.call('set', key, "0", 'EX', ARGV[2], 'NX')
+  local consumed = server.call('incrby', key, pointsToConsume)
+  local pttl = server.call('pttl', key)
+  return {consumed, pttl}
+end
+local consumed = server.call('incrby', key, pointsToConsume)
+local pttl = server.call('pttl', key)
+return {consumed, pttl}`;
+    var GET_VALKEY_SCRIPT = `local key = KEYS[1]
+local value = server.call('get', key)
+if value == nil then
+  return value
+end
+local pttl = server.call('pttl', key)
+return {tonumber(value), pttl}`;
+    var RateLimiterValkeyGlide = class extends RateLimiterStoreAbstract {
+      /**
+       * Constructor for RateLimiterValkeyGlide
+       *
+       * @param {Object} opts - Configuration options
+       * @param {GlideClient|GlideClusterClient} opts.storeClient - Valkey Glide client instance (required)
+       * @param {number} opts.points - Maximum number of points that can be consumed over duration (required)
+       * @param {number} opts.duration - Duration in seconds before points are reset (required, 0 = never expires)
+       * @param {number} [opts.blockDuration=0] - Duration in seconds that a key will be blocked for if consumed more than points
+       * @param {boolean} [opts.rejectIfValkeyNotReady=false] - Whether to reject requests if Valkey is not ready
+       * @param {boolean} [opts.execEvenly=false] - Delay actions to distribute them evenly over duration
+       * @param {number} [opts.execEvenlyMinDelayMs] - Minimum delay between actions when execEvenly is true
+       * @param {string} [opts.customFunction] - Custom Lua script for rate limiting logic
+       * @param {number} [opts.inMemoryBlockOnConsumed] - Points threshold for in-memory blocking
+       * @param {number} [opts.inMemoryBlockDuration] - Duration in seconds for in-memory blocking
+       * @param {string} [opts.customFunctionLibName] - Custom name for the function library, defaults to 'ratelimiter'.
+       * The name is used to identify the library of the lua function. An custom name should be used only if you
+       * you want to use different libraries for different rate limiters, otherwise it is not needed.
+       * @param {RateLimiterAbstract} [opts.insuranceLimiter] - Backup limiter to use when the primary client fails
+       *
+       * @example
+       * const rateLimiter = new RateLimiterValkeyGlide({
+       *   storeClient: glideClient,
+       *   points: 5,
+       *   duration: 1
+       * });
+       *
+       * @example <caption>With custom Lua function</caption>
+       * const customScript = `local key = KEYS[1]
+       * local pointsToConsume = tonumber(ARGV[1]) or 0
+       * local secDuration = tonumber(ARGV[2]) or 0
+       *
+       * -- Custom implementation
+       * -- ...
+       *
+       * -- Must return exactly two values: [consumed_points, ttl_in_ms]
+       * return {consumed, ttl}`
+       *
+       * const rateLimiter = new RateLimiterValkeyGlide({
+       *   storeClient: glideClient,
+       *   points: 5,
+       *   customFunction: customScript
+       * });
+       *
+       * @example <caption>With insurance limiter</caption>
+       * const rateLimiter = new RateLimiterValkeyGlide({
+       *   storeClient: primaryGlideClient,
+       *   points: 5,
+       *   duration: 2,
+       *   insuranceLimiter: new RateLimiterMemory({
+       *     points: 5,
+       *     duration: 2
+       *   })
+       * });
+       *
+       * @description
+       * When providing a custom Lua script via `opts.customFunction`, it must:
+       *
+       * 1. Accept parameters:
+       *    - KEYS[1]: The key being rate limited
+       *    - ARGV[1]: Points to consume (as string, use tonumber() to convert)
+       *    - ARGV[2]: Duration in seconds (as string, use tonumber() to convert)
+       *
+       * 2. Return an array with exactly two elements:
+       *    - [0]: Consumed points (number)
+       *    - [1]: TTL in milliseconds (number)
+       *
+       * 3. Handle scenarios:
+       *    - New key creation: Initialize with expiry for fixed windows
+       *    - Key updates: Increment existing counters
+       */
+      constructor(opts) {
+        super(opts);
+        this.client = opts.storeClient;
+        this._scriptLoaded = false;
+        this._getScriptLoaded = false;
+        this._rejectIfValkeyNotReady = !!opts.rejectIfValkeyNotReady;
+        this._luaScript = opts.customFunction || DEFAULT_VALKEY_SCRIPT;
+        this._libraryName = opts.customFunctionLibName || DEFAULT_LIBRARY_NAME;
+      }
+      /**
+       * Ensure scripts are loaded in the Valkey server
+       * @returns {Promise<boolean>} True if scripts are loaded
+       * @private
+       */
+      async _loadScripts() {
+        if (this._scriptLoaded && this._getScriptLoaded) {
+          return true;
+        }
+        if (!this.client) {
+          throw new Error("Valkey client is not set");
+        }
+        const promises = [];
+        if (!this._scriptLoaded) {
+          const script = Buffer.from(`#!lua name=${this._libraryName}
+        local function consume(KEYS, ARGV)
+          ${this._luaScript.trim()}
+        end
+        server.register_function('consume', consume)`);
+          promises.push(this.client.functionLoad(script, { replace: true }));
+        } else promises.push(Promise.resolve(this._libraryName));
+        if (!this._getScriptLoaded) {
+          const script = Buffer.from(`#!lua name=ratelimiter_get
+        local function getValue(KEYS, ARGV)
+          ${GET_VALKEY_SCRIPT.trim()}
+        end
+        server.register_function('getValue', getValue)`);
+          promises.push(this.client.functionLoad(script, { replace: true }));
+        } else promises.push(Promise.resolve("ratelimiter_get"));
+        const results = await Promise.all(promises);
+        this._scriptLoaded = results[0] === this._libraryName;
+        this._getScriptLoaded = results[1] === "ratelimiter_get";
+        if (!this._scriptLoaded || !this._getScriptLoaded) {
+          throw new Error("Valkey connection is not ready, scripts not loaded");
+        }
+        return true;
+      }
+      /**
+       * Update or insert the rate limiter record
+       *
+       * @param {string} rlKey - The rate limiter key
+       * @param {number} pointsToConsume - Points to be consumed
+       * @param {number} msDuration - Duration in milliseconds
+       * @param {boolean} [forceExpire=false] - Whether to force expiration
+       * @param {Object} [options={}] - Additional options
+       * @returns {Promise<Array>} Array containing consumed points and TTL
+       * @private
+       */
+      async _upsert(rlKey, pointsToConsume, msDuration, forceExpire = false, options = {}) {
+        await this._loadScripts();
+        const secDuration = Math.floor(msDuration / 1e3);
+        if (forceExpire) {
+          if (secDuration > 0) {
+            await this.client.set(
+              rlKey,
+              String(pointsToConsume),
+              { expiry: { type: "EX", count: secDuration } }
+            );
+            return [pointsToConsume, secDuration * 1e3];
+          }
+          await this.client.set(rlKey, String(pointsToConsume));
+          return [pointsToConsume, -1];
+        }
+        const result = await this.client.fcall(
+          "consume",
+          [rlKey],
+          [String(pointsToConsume), String(secDuration)]
+        );
+        return result;
+      }
+      /**
+       * Get the rate limiter record
+       *
+       * @param {string} rlKey - The rate limiter key
+       * @param {Object} [options={}] - Additional options
+       * @returns {Promise<Array|null>} Array containing consumed points and TTL, or null if not found
+       * @private
+       */
+      async _get(rlKey, options = {}) {
+        await this._loadScripts();
+        const res = await this.client.fcall("getValue", [rlKey], []);
+        return res.length > 0 ? res : null;
+      }
+      /**
+       * Delete the rate limiter record
+       *
+       * @param {string} rlKey - The rate limiter key
+       * @param {Object} [options={}] - Additional options
+       * @returns {Promise<boolean>} True if successful, false otherwise
+       * @private
+       */
+      async _delete(rlKey, options = {}) {
+        const result = await this.client.del([rlKey]);
+        return result > 0;
+      }
+      /**
+       * Convert raw result to RateLimiterRes object
+       *
+       * @param {string} rlKey - The rate limiter key
+       * @param {number} changedPoints - Points changed in this operation
+       * @param {Array|null} result - Result from Valkey operation
+       * @returns {RateLimiterRes|null} RateLimiterRes object or null if result is null
+       * @private
+       */
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        if (result === null) {
+          return null;
+        }
+        const res = new RateLimiterRes2();
+        const [consumedPointsStr, pttl] = result;
+        const consumedPoints = Number(consumedPointsStr);
+        res.isFirstInDuration = consumedPoints === changedPoints;
+        res.consumedPoints = consumedPoints;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = pttl;
+        return res;
+      }
+      /**
+       * Close the rate limiter and release resources
+       * Note: The method won't going to close the Valkey client, as it may be shared with other instances.
+       * @returns {Promise<void>} Promise that resolves when the rate limiter is closed
+       */
+      async close() {
+        if (this._scriptLoaded) {
+          await this.client.functionDelete(this._libraryName);
+          this._scriptLoaded = false;
+        }
+        if (this._getScriptLoaded) {
+          await this.client.functionDelete("ratelimiter_get");
+          this._getScriptLoaded = false;
+        }
+        if (this.insuranceLimiter) {
+          try {
+            await this.insuranceLimiter.close();
+          } catch (e) {
+          }
+        }
+        this.client = null;
+        this._scriptLoaded = false;
+        this._getScriptLoaded = false;
+        this._rejectIfValkeyNotReady = false;
+        this._luaScript = null;
+        this._libraryName = null;
+        this.insuranceLimiter = null;
+      }
+    };
+    module.exports = RateLimiterValkeyGlide;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterSQLite.js
+var require_RateLimiterSQLite = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterSQLite.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterSQLite = class extends RateLimiterStoreAbstract {
+      /**
+       * @callback callback
+       * @param {Object} err
+       *
+       * @param {Object} opts
+       * @param {callback} cb
+       * Defaults {
+       *   ... see other in RateLimiterStoreAbstract
+       *   storeClient: sqliteClient, // SQLite database instance (sqlite3, better-sqlite3, or knex instance)
+       *   storeType: 'sqlite3' | 'better-sqlite3' | 'knex', // Optional, defaults to 'sqlite3'
+       *   tableName: 'string',
+       *   tableCreated: boolean,
+       *   clearExpiredByTimeout: boolean,
+       * }
+       */
+      constructor(opts, cb = null) {
+        super(opts);
+        /**
+         * Internal store type used to determine the SQLite client in use.
+         * It can be one of the following:
+         * - `"sqlite3".
+         * - `"better-sqlite3".
+         *
+         * @type {("sqlite3" | "better-sqlite3" | null)}
+         * @private
+         */
+        __publicField(this, "_internalStoreType", null);
+        this.client = opts.storeClient;
+        this.storeType = opts.storeType || "sqlite3";
+        this.tableName = opts.tableName;
+        this.tableCreated = opts.tableCreated || false;
+        this.clearExpiredByTimeout = opts.clearExpiredByTimeout;
+        this._validateStoreTypes(cb);
+        this._validateStoreClient(cb);
+        this._setInternalStoreType(cb);
+        this._validateTableName(cb);
+        if (!this.tableCreated) {
+          this._createDbAndTable().then(() => {
+            this.tableCreated = true;
+            if (this.clearExpiredByTimeout) this._clearExpiredHourAgo();
+            if (typeof cb === "function") cb();
+          }).catch((err) => {
+            if (typeof cb === "function") cb(err);
+            else throw err;
+          });
+        } else {
+          if (this.clearExpiredByTimeout) this._clearExpiredHourAgo();
+          if (typeof cb === "function") cb();
+        }
+      }
+      _validateStoreTypes(cb) {
+        const validStoreTypes = ["sqlite3", "better-sqlite3", "knex"];
+        if (!validStoreTypes.includes(this.storeType)) {
+          const err = new Error(
+            `storeType must be one of: ${validStoreTypes.join(", ")}`
+          );
+          if (typeof cb === "function") return cb(err);
+          throw err;
+        }
+      }
+      _validateStoreClient(cb) {
+        if (this.storeType === "sqlite3") {
+          if (typeof this.client.run !== "function") {
+            const err = new Error(
+              "storeClient must be an instance of sqlite3.Database when storeType is 'sqlite3' or no storeType was provided"
+            );
+            if (typeof cb === "function") return cb(err);
+            throw err;
+          }
+        } else if (this.storeType === "better-sqlite3") {
+          if (typeof this.client.prepare !== "function" || typeof this.client.run !== "undefined") {
+            const err = new Error(
+              "storeClient must be an instance of better-sqlite3.Database when storeType is 'better-sqlite3'"
+            );
+            if (typeof cb === "function") return cb(err);
+            throw err;
+          }
+        } else if (this.storeType === "knex") {
+          if (typeof this.client.raw !== "function") {
+            const err = new Error(
+              "storeClient must be an instance of Knex when storeType is 'knex'"
+            );
+            if (typeof cb === "function") return cb(err);
+            throw err;
+          }
+        }
+      }
+      _setInternalStoreType(cb) {
+        if (this.storeType === "knex") {
+          const knexClientType = this.client.client.config.client;
+          if (knexClientType === "sqlite3") {
+            this._internalStoreType = "sqlite3";
+          } else if (knexClientType === "better-sqlite3") {
+            this._internalStoreType = "better-sqlite3";
+          } else {
+            const err = new Error(
+              "Knex must be configured with 'sqlite3' or 'better-sqlite3' for RateLimiterSQLite"
+            );
+            if (typeof cb === "function") return cb(err);
+            throw err;
+          }
+        } else {
+          this._internalStoreType = this.storeType;
+        }
+      }
+      _validateTableName(cb) {
+        if (!/^[A-Za-z0-9_]*$/.test(this.tableName)) {
+          const err = new Error("Table name must contain only letters and numbers");
+          if (typeof cb === "function") return cb(err);
+          throw err;
+        }
+      }
+      /**
+       * Acquires the database connection based on the storeType.
+       * @returns {Promise<Object>} The database client or connection
+       */
+      async _getConnection() {
+        if (this.storeType === "knex") {
+          return this.client.client.acquireConnection();
+        }
+        return this.client;
+      }
+      /**
+       * Releases the database connection if necessary.
+       * @param {Object} conn The database client or connection
+       */
+      _releaseConnection(conn) {
+        if (this.storeType === "knex") {
+          this.client.client.releaseConnection(conn);
+        }
+      }
+      async _createDbAndTable() {
+        const conn = await this._getConnection();
+        try {
+          switch (this._internalStoreType) {
+            case "sqlite3":
+              await new Promise((resolve, reject) => {
+                conn.run(
+                  this._getCreateTableSQL(),
+                  (err) => err ? reject(err) : resolve()
+                );
+              });
+              break;
+            case "better-sqlite3":
+              conn.prepare(this._getCreateTableSQL()).run();
+              break;
+            default:
+              throw new Error("Unsupported internalStoreType");
+          }
+        } finally {
+          this._releaseConnection(conn);
+        }
+      }
+      _getCreateTableSQL() {
+        return `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+      key TEXT PRIMARY KEY,
+      points INTEGER NOT NULL DEFAULT 0,
+      expire INTEGER
+    )`;
+      }
+      _clearExpiredHourAgo() {
+        if (this._clearExpiredTimeoutId) clearTimeout(this._clearExpiredTimeoutId);
+        this._clearExpiredTimeoutId = setTimeout(() => {
+          this.clearExpired(Date.now() - 36e5).then(() => this._clearExpiredHourAgo());
+        }, 3e5);
+        this._clearExpiredTimeoutId.unref();
+      }
+      async clearExpired(nowMs) {
+        const sql = `DELETE FROM ${this.tableName} WHERE expire < ?`;
+        const conn = await this._getConnection();
+        try {
+          switch (this._internalStoreType) {
+            case "sqlite3":
+              await new Promise((resolve, reject) => {
+                conn.run(sql, [nowMs], (err) => err ? reject(err) : resolve());
+              });
+              break;
+            case "better-sqlite3":
+              conn.prepare(sql).run(nowMs);
+              break;
+            default:
+              throw new Error("Unsupported internalStoreType");
+          }
+        } finally {
+          this._releaseConnection(conn);
+        }
+      }
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        res.isFirstInDuration = changedPoints === result.points;
+        res.consumedPoints = res.isFirstInDuration ? changedPoints : result.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = result.expire ? Math.max(result.expire - Date.now(), 0) : -1;
+        return res;
+      }
+      async _upsertTransactionSQLite3(conn, upsertQuery, upsertParams) {
+        return await new Promise((resolve, reject) => {
+          conn.serialize(() => {
+            conn.run("SAVEPOINT rate_limiter_trx;", (err) => {
+              if (err) return reject(err);
+              conn.get(upsertQuery, upsertParams, (err2, row) => {
+                if (err2) {
+                  conn.run(
+                    "ROLLBACK TO SAVEPOINT rate_limiter_trx;",
+                    () => reject(err2)
+                  );
+                  return;
+                }
+                conn.run("RELEASE SAVEPOINT rate_limiter_trx;", () => resolve(row));
+              });
+            });
+          });
+        });
+      }
+      async _upsertTransactionBetterSQLite3(conn, upsertQuery, upsertParams) {
+        return conn.transaction(
+          () => conn.prepare(upsertQuery).get(...upsertParams)
+        )();
+      }
+      async _upsertTransaction(rlKey, points, msDuration, forceExpire) {
+        const dateNow = Date.now();
+        const newExpire = msDuration > 0 ? dateNow + msDuration : null;
+        const upsertQuery = forceExpire ? `INSERT OR REPLACE INTO ${this.tableName} (key, points, expire) VALUES (?, ?, ?) RETURNING points, expire` : `INSERT INTO ${this.tableName} (key, points, expire)
+         VALUES (?, ?, ?)
+         ON CONFLICT(key) DO UPDATE SET
+           points = CASE WHEN expire IS NULL OR expire > ? THEN points + excluded.points ELSE excluded.points END,
+           expire = CASE WHEN expire IS NULL OR expire > ? THEN expire ELSE excluded.expire END
+         RETURNING points, expire`;
+        const upsertParams = forceExpire ? [rlKey, points, newExpire] : [rlKey, points, newExpire, dateNow, dateNow];
+        const conn = await this._getConnection();
+        try {
+          switch (this._internalStoreType) {
+            case "sqlite3":
+              return this._upsertTransactionSQLite3(
+                conn,
+                upsertQuery,
+                upsertParams
+              );
+            case "better-sqlite3":
+              return this._upsertTransactionBetterSQLite3(
+                conn,
+                upsertQuery,
+                upsertParams
+              );
+            default:
+              throw new Error("Unsupported internalStoreType");
+          }
+        } finally {
+          this._releaseConnection(conn);
+        }
+      }
+      _upsert(rlKey, points, msDuration, forceExpire = false) {
+        if (!this.tableCreated) {
+          return Promise.reject(new Error("Table is not created yet"));
+        }
+        return this._upsertTransaction(rlKey, points, msDuration, forceExpire);
+      }
+      async _get(rlKey) {
+        const sql = `SELECT points, expire FROM ${this.tableName} WHERE key = ? AND (expire > ? OR expire IS NULL)`;
+        const now = Date.now();
+        const conn = await this._getConnection();
+        try {
+          switch (this._internalStoreType) {
+            case "sqlite3":
+              return await new Promise((resolve, reject) => {
+                conn.get(
+                  sql,
+                  [rlKey, now],
+                  (err, row) => err ? reject(err) : resolve(row || null)
+                );
+              });
+            case "better-sqlite3":
+              return conn.prepare(sql).get(rlKey, now) || null;
+            default:
+              throw new Error("Unsupported internalStoreType");
+          }
+        } finally {
+          this._releaseConnection(conn);
+        }
+      }
+      async _delete(rlKey) {
+        if (!this.tableCreated) {
+          return Promise.reject(new Error("Table is not created yet"));
+        }
+        const sql = `DELETE FROM ${this.tableName} WHERE key = ?`;
+        const conn = await this._getConnection();
+        try {
+          switch (this._internalStoreType) {
+            case "sqlite3":
+              return await new Promise((resolve, reject) => {
+                conn.run(sql, [rlKey], function(err) {
+                  if (err) reject(err);
+                  else resolve(this.changes > 0);
+                });
+              });
+            case "better-sqlite3":
+              const result = conn.prepare(sql).run(rlKey);
+              return result.changes > 0;
+            default:
+              throw new Error("Unsupported internalStoreType");
+          }
+        } finally {
+          this._releaseConnection(conn);
+        }
+      }
+    };
+    module.exports = RateLimiterSQLite;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterEtcdTransactionFailedError.js
+var require_RateLimiterEtcdTransactionFailedError = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterEtcdTransactionFailedError.js"(exports, module) {
+    "use strict";
+    module.exports = class RateLimiterEtcdTransactionFailedError extends Error {
+      constructor(message) {
+        super();
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = "RateLimiterEtcdTransactionFailedError";
+        this.message = message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterSetupError.js
+var require_RateLimiterSetupError = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterSetupError.js"(exports, module) {
+    "use strict";
+    module.exports = class RateLimiterSetupError extends Error {
+      constructor(message) {
+        super();
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = "RateLimiterSetupError";
+        this.message = message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcdNonAtomic.js
+var require_RateLimiterEtcdNonAtomic = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcdNonAtomic.js"(exports, module) {
+    "use strict";
+    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterSetupError = require_RateLimiterSetupError();
+    var RateLimiterEtcdNonAtomic = class extends RateLimiterStoreAbstract {
+      /**
+       * @param {Object} opts
+       */
+      constructor(opts) {
+        super(opts);
+        if (!opts.storeClient) {
+          throw new RateLimiterSetupError('You need to set the option "storeClient" to an instance of class "Etcd3".');
+        }
+        this.client = opts.storeClient;
+      }
+      /**
+       * Get RateLimiterRes object filled depending on storeResult, which specific for exact store.
+       */
+      _getRateLimiterRes(rlKey, changedPoints, result) {
+        const res = new RateLimiterRes2();
+        res.isFirstInDuration = changedPoints === result.points;
+        res.consumedPoints = res.isFirstInDuration ? changedPoints : result.points;
+        res.remainingPoints = Math.max(this.points - res.consumedPoints, 0);
+        res.msBeforeNext = result.expire ? Math.max(result.expire - Date.now(), 0) : -1;
+        return res;
+      }
+      /**
+       * Resolve with object used for {@link _getRateLimiterRes} to generate {@link RateLimiterRes}.
+       */
+      async _upsert(rlKey, points, msDuration, forceExpire = false) {
+        const expire = msDuration > 0 ? Date.now() + msDuration : null;
+        let newValue = { points, expire };
+        if (forceExpire) {
+          await this.client.put(rlKey).value(JSON.stringify(newValue));
+        } else {
+          const oldValue = await this._get(rlKey);
+          newValue = { points: (oldValue !== null ? oldValue.points : 0) + points, expire };
+          await this.client.put(rlKey).value(JSON.stringify(newValue));
+        }
+        return newValue;
+      }
+      /**
+       * Resolve with raw result from Store OR null if rlKey is not set
+       * or Reject with error
+       */
+      async _get(rlKey) {
+        return this.client.get(rlKey).string().then((result) => result !== null ? JSON.parse(result) : null);
+      }
+      /**
+       * Resolve with true OR false if rlKey doesn't exist.
+       * or Reject with error.
+       */
+      async _delete(rlKey) {
+        return this.client.delete().key(rlKey).then((result) => result.deleted === "1");
+      }
+    };
+    module.exports = RateLimiterEtcdNonAtomic;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcd.js
+var require_RateLimiterEtcd = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcd.js"(exports, module) {
+    "use strict";
+    var RateLimiterEtcdTransactionFailedError = require_RateLimiterEtcdTransactionFailedError();
+    var RateLimiterEtcdNonAtomic = require_RateLimiterEtcdNonAtomic();
+    var MAX_TRANSACTION_TRIES = 5;
+    var RateLimiterEtcd = class extends RateLimiterEtcdNonAtomic {
+      /**
+       * Resolve with object used for {@link _getRateLimiterRes} to generate {@link RateLimiterRes}.
+       */
+      async _upsert(rlKey, points, msDuration, forceExpire = false) {
+        const expire = msDuration > 0 ? Date.now() + msDuration : null;
+        let newValue = { points, expire };
+        let oldValue;
+        if (forceExpire) {
+          await this.client.put(rlKey).value(JSON.stringify(newValue));
+        } else {
+          const added = await this.client.if(rlKey, "Version", "===", "0").then(this.client.put(rlKey).value(JSON.stringify(newValue))).commit().then((result) => !!result.succeeded);
+          if (!added) {
+            let success = false;
+            for (let i = 0; i < MAX_TRANSACTION_TRIES; i++) {
+              oldValue = await this._get(rlKey);
+              newValue = { points: oldValue.points + points, expire };
+              success = await this.client.if(rlKey, "Value", "===", JSON.stringify(oldValue)).then(this.client.put(rlKey).value(JSON.stringify(newValue))).commit().then((result) => !!result.succeeded);
+              if (success) {
+                break;
+              }
+            }
+            if (!success) {
+              throw new RateLimiterEtcdTransactionFailedError("Could not set new value in a transaction.");
+            }
+          }
+        }
+        return newValue;
+      }
+    };
+    module.exports = RateLimiterEtcd;
+  }
+});
+
+// ../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/index.js
+var require_rate_limiter_flexible = __commonJS({
+  "../../node_modules/.pnpm/rate-limiter-flexible@11.2.1/node_modules/rate-limiter-flexible/index.js"(exports, module) {
+    "use strict";
+    var RateLimiterRedis = require_RateLimiterRedis();
+    var RateLimiterRedisNonAtomic = require_RateLimiterRedisNonAtomic();
+    var RateLimiterMongo = require_RateLimiterMongo();
+    var RateLimiterMySQL = require_RateLimiterMySQL();
+    var RateLimiterPostgres2 = require_RateLimiterPostgres();
+    var { RateLimiterClusterMaster, RateLimiterClusterMasterPM2, RateLimiterCluster } = require_RateLimiterCluster();
+    var RateLimiterMemory2 = require_RateLimiterMemory();
+    var RateLimiterMemcache = require_RateLimiterMemcache();
+    var RLWrapperBlackAndWhite = require_RLWrapperBlackAndWhite();
+    var RLWrapperTimeouts = require_RLWrapperTimeouts();
+    var RateLimiterUnion = require_RateLimiterUnion();
+    var RateLimiterQueue = require_RateLimiterQueue();
+    var BurstyRateLimiter = require_BurstyRateLimiter();
+    var RateLimiterRes2 = require_RateLimiterRes();
+    var RateLimiterCompatibleAbstract = require_RateLimiterCompatibleAbstract();
+    var RateLimiterDynamo = require_RateLimiterDynamo();
+    var RateLimiterPrisma = require_RateLimiterPrisma();
+    var RateLimiterDrizzle = require_RateLimiterDrizzle();
+    var RateLimiterDrizzleNonAtomic = require_RateLimiterDrizzleNonAtomic();
+    var RateLimiterValkey = require_RateLimiterValkey();
+    var RateLimiterValkeyGlide = require_RateLimiterValkeyGlide();
+    var RateLimiterSQLite = require_RateLimiterSQLite();
+    var RateLimiterEtcd = require_RateLimiterEtcd();
+    var RateLimiterEtcdNonAtomic = require_RateLimiterEtcdNonAtomic();
+    var RateLimiterQueueError = require_RateLimiterQueueError();
+    var RateLimiterEtcdTransactionFailedError = require_RateLimiterEtcdTransactionFailedError();
+    module.exports = {
+      RateLimiterRedis,
+      RateLimiterRedisNonAtomic,
+      RateLimiterMongo,
+      RateLimiterMySQL,
+      RateLimiterPostgres: RateLimiterPostgres2,
+      RateLimiterMemory: RateLimiterMemory2,
+      RateLimiterMemcache,
+      RateLimiterClusterMaster,
+      RateLimiterClusterMasterPM2,
+      RateLimiterCluster,
+      RLWrapperBlackAndWhite,
+      RLWrapperTimeouts,
+      RateLimiterUnion,
+      RateLimiterQueue,
+      BurstyRateLimiter,
+      RateLimiterRes: RateLimiterRes2,
+      RateLimiterCompatibleAbstract,
+      RateLimiterDynamo,
+      RateLimiterPrisma,
+      RateLimiterValkey,
+      RateLimiterValkeyGlide,
+      RateLimiterSQLite,
+      RateLimiterEtcd,
+      RateLimiterDrizzle,
+      RateLimiterDrizzleNonAtomic,
+      RateLimiterEtcdNonAtomic,
+      RateLimiterQueueError,
+      RateLimiterEtcdTransactionFailedError
+    };
+  }
+});
+
+// src/rate-limit.ts
+var import_rate_limiter_flexible = __toESM(require_rate_limiter_flexible(), 1);
+
+// src/errors.ts
+var ApiError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+};
+function errorResponse(error) {
+  const body = { error: { code: error.code, message: error.message } };
+  if (error.details !== void 0) body.error.details = error.details;
+  return new Response(JSON.stringify(body), {
+    status: error.status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+
+// src/middleware.ts
+function withHeaders(response, set) {
+  try {
+    set(response.headers);
+    return response;
+  } catch {
+    const copy = new Response(response.body, response);
+    set(copy.headers);
+    return copy;
+  }
+}
+
+// src/rate-limit.ts
+function memoryRateLimitStore() {
+  return storeOf(async (limit, windowSeconds) => new import_rate_limiter_flexible.RateLimiterMemory({ points: limit, duration: windowSeconds }));
+}
+function postgresRateLimitStore(client, options = {}) {
+  const { table = "rate_limits", schema, createTable = true } = options;
+  const storeClient = { query: (q) => client.query(q.text, q.values) };
+  let hits = 0;
+  return storeOf(
+    (limit, windowSeconds) => new Promise((resolve, reject) => {
+      const limiter = new import_rate_limiter_flexible.RateLimiterPostgres(
+        {
+          storeClient,
+          storeType: "pool",
+          tableName: table,
+          schemaName: schema,
+          tableCreated: !createTable,
+          clearExpiredByTimeout: false,
+          points: limit,
+          duration: windowSeconds,
+          insuranceLimiter: new import_rate_limiter_flexible.RateLimiterMemory({ points: limit, duration: windowSeconds })
+        },
+        // Called inside the constructor when the table exists already: resolve once it returned.
+        (error) => error ? reject(error) : queueMicrotask(() => resolve(limiter))
+      );
+    }),
+    (limiter) => {
+      const sweep = limiter;
+      if (++hits % 1e3 === 0) void sweep.clearExpired(Date.now() - 36e5).catch(() => {
+      });
+    }
+  );
+}
+function storeOf(make, onHit) {
+  const limiters = /* @__PURE__ */ new Map();
+  return {
+    async hit(key, limit, windowSeconds) {
+      const id = `${limit}/${windowSeconds}`;
+      let pending = limiters.get(id);
+      if (!pending) {
+        limiters.set(id, pending = make(limit, windowSeconds));
+        pending.catch(() => limiters.delete(id));
+      }
+      const limiter = await pending;
+      onHit?.(limiter);
+      try {
+        const res = await limiter.consume(key);
+        return { allowed: true, remaining: res.remainingPoints, resetMs: res.msBeforeNext };
+      } catch (thrown) {
+        if (thrown instanceof import_rate_limiter_flexible.RateLimiterRes) return { allowed: false, remaining: 0, resetMs: thrown.msBeforeNext };
+        throw thrown;
+      }
+    }
+  };
+}
+var ADDRESSES = /* @__PURE__ */ Symbol.for("fluixi.clientAddress");
+var sharedMemory = memoryRateLimitStore();
+var created = 0;
+function clientAddressOf(request) {
+  return globalThis[ADDRESSES]?.get(request);
+}
+function rateLimit(options) {
+  const { match, methods, limit, window, key = clientAddressOf, store = sharedMemory } = options;
+  const applies = matcher(match);
+  const methodSet = methods && new Set(methods.map((m) => m.toUpperCase()));
+  const bucket = options.name ?? `limit${++created}`;
+  return async (request, next) => {
+    if (methodSet && !methodSet.has(request.method)) return next();
+    if (!applies(request)) return next();
+    const who = await key(request);
+    if (!who) return next();
+    const { allowed, remaining, resetMs } = await store.hit(`${bucket}:${who}`, limit, window);
+    const reset = String(Math.ceil(resetMs / 1e3));
+    const set = (headers) => {
+      headers.set("ratelimit-limit", String(limit));
+      headers.set("ratelimit-remaining", String(remaining));
+      headers.set("ratelimit-reset", reset);
+    };
+    if (!allowed) {
+      const refused = errorResponse(new ApiError(429, "rate_limited", "Too many requests. Try again later."));
+      refused.headers.set("retry-after", reset);
+      set(refused.headers);
+      return refused;
+    }
+    return withHeaders(await next(), set);
+  };
+}
+function matcher(match) {
+  if (!match) return () => true;
+  if (typeof match === "function") return match;
+  const exact = new Set(match.filter((p) => !p.endsWith("/*")));
+  const prefixes = match.filter((p) => p.endsWith("/*")).map((p) => p.slice(0, -1));
+  return (request) => {
+    const { pathname } = new URL(request.url);
+    return exact.has(pathname) || prefixes.some((p) => pathname.startsWith(p));
+  };
+}
+export {
+  clientAddressOf,
+  memoryRateLimitStore,
+  postgresRateLimitStore,
+  rateLimit
+};