@fefade/common 1.0.4 → 1.0.6

package/dist/index.js

@@ -1,4568 +1,21 @@
 "use strict";
-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 __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterAbstract.js
-var require_RateLimiterAbstract = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterAbstract.js"(exports2, module2) {
-    "use strict";
-    module2.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;
-      }
-      set execEvenlyMinDelayMs(value) {
-        this._execEvenlyMinDelayMs = typeof value === "undefined" ? Math.ceil(this.msDuration / this.points) : value;
-      }
-      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 rlKey.substring(this.keyPrefix.length);
-      }
-      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@10.0.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/BlockedKeys.js
-var require_BlockedKeys = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/BlockedKeys.js"(exports2, module2) {
-    "use strict";
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/index.js
-var require_BlockedKeys2 = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/BlockedKeys/index.js"(exports2, module2) {
-    "use strict";
-    var BlockedKeys = require_BlockedKeys();
-    module2.exports = BlockedKeys;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterRes.js
-var require_RateLimiterRes = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterRes.js"(exports2, module2) {
-    "use strict";
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterInsuredAbstract.js
-var require_RateLimiterInsuredAbstract = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterInsuredAbstract.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterAbstract = require_RateLimiterAbstract();
-    var RateLimiterRes2 = require_RateLimiterRes();
-    module2.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" && !(value instanceof RateLimiterAbstract)) {
-          throw new Error("insuranceLimiter must be instance of RateLimiterAbstract");
-        }
-        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 (!(this.insuranceLimiter instanceof RateLimiterAbstract)) {
-          reject(err);
-        } else {
-          this.insuranceLimiter[funcName](...params).then((res) => {
-            resolve(res);
-          }).catch((res) => {
-            reject(res);
-          });
-        }
-      }
-      _operation(funcName, params) {
-        const promise2 = this[funcName](...params);
-        return new Promise((resolve, reject) => {
-          return promise2.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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterStoreAbstract.js
-var require_RateLimiterStoreAbstract = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterStoreAbstract.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterAbstract = require_RateLimiterAbstract();
-    var BlockedKeys = require_BlockedKeys2();
-    var RateLimiterRes2 = require_RateLimiterRes();
-    var RateLimiterInsuredAbstract = require_RateLimiterInsuredAbstract();
-    module2.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 && res.msBeforeNext > 0 && !res.isFirstInDuration) {
-          let delay = Math.ceil(res.msBeforeNext / (res.remainingPoints + 2));
-          if (delay < this.execEvenlyMinDelayMs) {
-            delay = res.consumedPoints * this.execEvenlyMinDelayMs;
-          }
-          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._block(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]);
-          });
-        });
-      }
-      /**
-       * 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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedis.js
-var require_RateLimiterRedis = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedis.js"(exports2, module2) {
-    "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 (error48) {
-            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);
-      }
-    };
-    module2.exports = RateLimiterRedis;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedisNonAtomic.js
-var require_RateLimiterRedisNonAtomic = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterRedisNonAtomic.js"(exports2, module2) {
-    "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 (error48) {
-            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);
-      }
-    };
-    module2.exports = RateLimiterRedisNonAtomic;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMongo.js
-var require_RateLimiterMongo = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMongo.js"(exports2, module2) {
-    "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);
-      }
-    };
-    module2.exports = RateLimiterMongo;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMySQL.js
-var require_RateLimiterMySQL = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMySQL.js"(exports2, module2) {
-    "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);
-          });
-        });
-      }
-    };
-    module2.exports = RateLimiterMySQL;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterPostgres.js
-var require_RateLimiterPostgres = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterPostgres.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
-    var RateLimiterRes2 = require_RateLimiterRes();
-    var RateLimiterPostgres = 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 = { name: `${prefix}:${q.name}`, text: q.text, values: q.values };
-        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);
-      }
-    };
-    module2.exports = RateLimiterPostgres;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/Record.js
-var require_Record = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/Record.js"(exports2, module2) {
-    "use strict";
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/MemoryStorage.js
-var require_MemoryStorage = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/MemoryStorage/MemoryStorage.js"(exports2, module2) {
-    "use strict";
-    var Record = require_Record();
-    var RateLimiterRes2 = require_RateLimiterRes();
-    module2.exports = class MemoryStorage {
-      constructor() {
-        this._storage = /* @__PURE__ */ new Map();
-      }
-      incrby(key, value, durationSec) {
-        const record2 = this._storage.get(key);
-        if (record2) {
-          const msBeforeExpires = record2.expiresAt ? record2.expiresAt - Date.now() : -1;
-          if (!record2.expiresAt || msBeforeExpires > 0) {
-            record2.value = record2.value + value;
-            return new RateLimiterRes2(0, msBeforeExpires, record2.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 record2 = new Record(
-          value,
-          durationMs > 0 ? Date.now() + durationMs : null
-        );
-        this._storage.set(key, record2);
-        if (durationMs > 0) {
-          record2.timeoutId = setTimeout(() => {
-            this._storage.delete(key);
-          }, durationMs);
-          if (record2.timeoutId.unref) {
-            record2.timeoutId.unref();
-          }
-        }
-        return new RateLimiterRes2(0, durationMs === 0 ? -1 : durationMs, record2.value, true);
-      }
-      /**
-       *
-       * @param key
-       * @returns {*}
-       */
-      get(key) {
-        const record2 = this._storage.get(key);
-        if (record2) {
-          const msBeforeExpires = record2.expiresAt ? record2.expiresAt - Date.now() : -1;
-          return new RateLimiterRes2(0, msBeforeExpires, record2.value, false);
-        }
-        return null;
-      }
-      /**
-       *
-       * @param key
-       * @returns {boolean}
-       */
-      delete(key) {
-        const record2 = this._storage.get(key);
-        if (record2) {
-          if (record2.timeoutId) {
-            clearTimeout(record2.timeoutId);
-          }
-          this._storage.delete(key);
-          return true;
-        }
-        return false;
-      }
-    };
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemory.js
-var require_RateLimiterMemory = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemory.js"(exports2, module2) {
-    "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 && res.msBeforeNext > 0 && !res.isFirstInDuration) {
-            let delay = Math.ceil(res.msBeforeNext / (res.remainingPoints + 2));
-            if (delay < this.execEvenlyMinDelayMs) {
-              delay = res.consumedPoints * this.execEvenlyMinDelayMs;
-            }
-            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)));
-      }
-    };
-    module2.exports = RateLimiterMemory2;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterCluster.js
-var require_RateLimiterCluster = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterCluster.js"(exports2, module2) {
-    "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 promise2;
-      switch (msg.func) {
-        case "consume":
-          promise2 = this._rateLimiters[msg.keyPrefix].consume(msg.data.key, msg.data.arg, msg.data.opts);
-          break;
-        case "penalty":
-          promise2 = this._rateLimiters[msg.keyPrefix].penalty(msg.data.key, msg.data.arg, msg.data.opts);
-          break;
-        case "reward":
-          promise2 = this._rateLimiters[msg.keyPrefix].reward(msg.data.key, msg.data.arg, msg.data.opts);
-          break;
-        case "block":
-          promise2 = this._rateLimiters[msg.keyPrefix].block(msg.data.key, msg.data.arg, msg.data.opts);
-          break;
-        case "get":
-          promise2 = this._rateLimiters[msg.keyPrefix].get(msg.data.key, msg.data.opts);
-          break;
-        case "delete":
-          promise2 = this._rateLimiters[msg.keyPrefix].delete(msg.data.key, msg.data.opts);
-          break;
-        default:
-          return false;
-      }
-      if (promise2) {
-        promise2.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);
-        });
-      }
-    };
-    module2.exports = {
-      RateLimiterClusterMaster,
-      RateLimiterClusterMasterPM2,
-      RateLimiterCluster: RateLimiterClusterWorker
-    };
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemcache.js
-var require_RateLimiterMemcache = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterMemcache.js"(exports2, module2) {
-    "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);
-                }
-              });
-            }
-          });
-        });
-      }
-    };
-    module2.exports = RateLimiterMemcache;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RLWrapperBlackAndWhite.js
-var require_RLWrapperBlackAndWhite = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RLWrapperBlackAndWhite.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterRes2 = require_RateLimiterRes();
-    module2.exports = class RLWrapperBlackAndWhite {
-      constructor(opts = {}) {
-        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 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());
-      }
-      consume(key, pointsToConsume = 1) {
-        let res;
-        if (this.isWhiteListedSomewhere(key)) {
-          res = this.resolveWhite();
-        } else if (this.isBlackListedSomewhere(key)) {
-          res = this.rejectBlack();
-        }
-        if (typeof res === "undefined") {
-          return this.limiter.consume(key, pointsToConsume);
-        }
-        if (this.runActionAnyway) {
-          this.limiter.consume(key, pointsToConsume).catch(() => {
-          });
-        }
-        return res;
-      }
-      block(key, secDuration) {
-        let res;
-        if (this.isWhiteListedSomewhere(key)) {
-          res = this.resolveWhite();
-        } else if (this.isBlackListedSomewhere(key)) {
-          res = this.resolveBlack();
-        }
-        if (typeof res === "undefined") {
-          return this.limiter.block(key, secDuration);
-        }
-        if (this.runActionAnyway) {
-          this.limiter.block(key, secDuration).catch(() => {
-          });
-        }
-        return res;
-      }
-      penalty(key, points) {
-        let res;
-        if (this.isWhiteListedSomewhere(key)) {
-          res = this.resolveWhite();
-        } else if (this.isBlackListedSomewhere(key)) {
-          res = this.resolveBlack();
-        }
-        if (typeof res === "undefined") {
-          return this.limiter.penalty(key, points);
-        }
-        if (this.runActionAnyway) {
-          this.limiter.penalty(key, points).catch(() => {
-          });
-        }
-        return res;
-      }
-      reward(key, points) {
-        let res;
-        if (this.isWhiteListedSomewhere(key)) {
-          res = this.resolveWhite();
-        } else if (this.isBlackListedSomewhere(key)) {
-          res = this.resolveBlack();
-        }
-        if (typeof res === "undefined") {
-          return this.limiter.reward(key, points);
-        }
-        if (this.runActionAnyway) {
-          this.limiter.reward(key, points).catch(() => {
-          });
-        }
-        return res;
-      }
-      get(key) {
-        let res;
-        if (this.isWhiteListedSomewhere(key)) {
-          res = this.resolveWhite();
-        } else if (this.isBlackListedSomewhere(key)) {
-          res = this.resolveBlack();
-        }
-        if (typeof res === "undefined" || this.runActionAnyway) {
-          return this.limiter.get(key);
-        }
-        return res;
-      }
-      delete(key) {
-        return this.limiter.delete(key);
-      }
-    };
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RLWrapperTimeouts.js
-var require_RLWrapperTimeouts = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RLWrapperTimeouts.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterAbstract = require_RateLimiterAbstract();
-    var RateLimiterInsuredAbstract = require_RateLimiterInsuredAbstract();
-    module2.exports = class RLWrapperTimeouts extends RateLimiterInsuredAbstract {
-      constructor(opts = {}) {
-        super(opts);
-        this.limiter = opts.limiter;
-        this.timeoutMs = opts.timeoutMs || 0;
-      }
-      get limiter() {
-        return this._limiter;
-      }
-      set limiter(limiter) {
-        if (!(limiter instanceof RateLimiterAbstract)) {
-          throw new TypeError("limiter must be an instance of RateLimiterAbstract");
-        }
-        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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterUnion.js
-var require_RateLimiterUnion = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterUnion.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterAbstract = require_RateLimiterAbstract();
-    module2.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 (!(limiter instanceof RateLimiterAbstract)) {
-            throw new Error("RateLimiterUnion: all limiters have to be instance of RateLimiterAbstract");
-          }
-        });
-        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@10.0.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterQueueError.js
-var require_RateLimiterQueueError = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterQueueError.js"(exports2, module2) {
-    "use strict";
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterQueue.js
-var require_RateLimiterQueue = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterQueue.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterQueueError = require_RateLimiterQueueError();
-    var MAX_QUEUE_SIZE = 4294967295;
-    var KEY_DEFAULT = "limiter";
-    module2.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) {
-        if (!this._queueLimiters[key]) {
-          this._queueLimiters[key] = new RateLimiterQueueInternal(
-            this._limiterFlexible,
-            {
-              key,
-              maxQueueSize: this._maxQueueSize
-            }
-          );
-        }
-        return this._queueLimiters[key].removeTokens(tokens);
-      }
-    };
-    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._maxQueueSize = opts.maxQueueSize;
-      }
-      getTokensRemaining() {
-        return this._limiterFlexible.get(this._key).then((rlRes) => {
-          return rlRes !== null ? rlRes.remainingPoints : this._limiterFlexible.points;
-        });
-      }
-      removeTokens(tokens) {
-        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);
-          } 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);
-                if (_this._waitTimeout === null) {
-                  _this._waitTimeout = setTimeout(_this._processFIFO.bind(_this), rej.msBeforeNext);
-                }
-              }
-            });
-          }
-        });
-      }
-      _queueRequest(resolve, reject, tokens) {
-        const _this = this;
-        if (_this._queue.length < _this._maxQueueSize) {
-          _this._queue.push({ resolve, reject, tokens });
-        } 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._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@10.0.1/node_modules/rate-limiter-flexible/lib/BurstyRateLimiter.js
-var require_BurstyRateLimiter = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/BurstyRateLimiter.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterRes2 = require_RateLimiterRes();
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterDynamo.js
-var require_RateLimiterDynamo = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterDynamo.js"(exports2, module2) {
-    "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;
-      }
-    };
-    module2.exports = RateLimiterDynamo;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterPrisma.js
-var require_RateLimiterPrisma = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterPrisma.js"(exports2, module2) {
-    "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();
-      }
-    };
-    module2.exports = RateLimiterPrisma;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzle.js
-var require_RateLimiterDrizzle = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzle.js"(exports2, module2) {
-    "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 (error48) {
-        throw new RateLimiterDrizzleError(
-          "drizzle-orm is not installed. Please install drizzle-orm to use RateLimiterDrizzle."
-        );
-      }
-    }
-    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 getDrizzleOperators();
-        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 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?.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 (error48) {
-            console.warn("Failed to clear expired records:", error48);
-          }
-          this._clearExpiredHourAgo();
-        }, CLEANUP_INTERVAL_MS);
-        this._clearExpiredTimeoutId.unref();
-      }
-    };
-    module2.exports = RateLimiterDrizzle;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzleNonAtomic.js
-var require_RateLimiterDrizzleNonAtomic = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterDrizzleNonAtomic.js"(exports2, module2) {
-    "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 (error48) {
-        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 (error48) {
-            console.warn("Failed to clear expired records:", error48);
-          }
-          this._clearExpiredHourAgo();
-        }, CLEANUP_INTERVAL_MS);
-        this._clearExpiredTimeoutId.unref();
-      }
-    };
-    module2.exports = RateLimiterDrizzleNonAtomic;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkey.js
-var require_RateLimiterValkey = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkey.js"(exports2, module2) {
-    "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);
-      }
-    };
-    module2.exports = RateLimiterValkey;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkeyGlide.js
-var require_RateLimiterValkeyGlide = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterValkeyGlide.js"(exports2, module2) {
-    "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;
-      }
-    };
-    module2.exports = RateLimiterValkeyGlide;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterSQLite.js
-var require_RateLimiterSQLite = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterSQLite.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterStoreAbstract = require_RateLimiterStoreAbstract();
-    var RateLimiterRes2 = require_RateLimiterRes();
-    var RateLimiterSQLite = class extends RateLimiterStoreAbstract {
-      /**
-       * 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
-       */
-      _internalStoreType = null;
-      /**
-       * @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);
-        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);
-        }
-      }
-    };
-    module2.exports = RateLimiterSQLite;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterEtcdTransactionFailedError.js
-var require_RateLimiterEtcdTransactionFailedError = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterEtcdTransactionFailedError.js"(exports2, module2) {
-    "use strict";
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterSetupError.js
-var require_RateLimiterSetupError = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/component/RateLimiterSetupError.js"(exports2, module2) {
-    "use strict";
-    module2.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@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcdNonAtomic.js
-var require_RateLimiterEtcdNonAtomic = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcdNonAtomic.js"(exports2, module2) {
-    "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");
-      }
-    };
-    module2.exports = RateLimiterEtcdNonAtomic;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcd.js
-var require_RateLimiterEtcd = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/lib/RateLimiterEtcd.js"(exports2, module2) {
-    "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 success2 = false;
-            for (let i = 0; i < MAX_TRANSACTION_TRIES; i++) {
-              oldValue = await this._get(rlKey);
-              newValue = { points: oldValue.points + points, expire };
-              success2 = await this.client.if(rlKey, "Value", "===", JSON.stringify(oldValue)).then(this.client.put(rlKey).value(JSON.stringify(newValue))).commit().then((result) => !!result.succeeded);
-              if (success2) {
-                break;
-              }
-            }
-            if (!success2) {
-              throw new RateLimiterEtcdTransactionFailedError("Could not set new value in a transaction.");
-            }
-          }
-        }
-        return newValue;
-      }
-    };
-    module2.exports = RateLimiterEtcd;
-  }
-});
-
-// node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/index.js
-var require_rate_limiter_flexible = __commonJS({
-  "node_modules/.pnpm/rate-limiter-flexible@10.0.1/node_modules/rate-limiter-flexible/index.js"(exports2, module2) {
-    "use strict";
-    var RateLimiterRedis = require_RateLimiterRedis();
-    var RateLimiterRedisNonAtomic = require_RateLimiterRedisNonAtomic();
-    var RateLimiterMongo = require_RateLimiterMongo();
-    var RateLimiterMySQL = require_RateLimiterMySQL();
-    var RateLimiterPostgres = 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 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();
-    module2.exports = {
-      RateLimiterRedis,
-      RateLimiterRedisNonAtomic,
-      RateLimiterMongo,
-      RateLimiterMySQL,
-      RateLimiterPostgres,
-      RateLimiterMemory: RateLimiterMemory2,
-      RateLimiterMemcache,
-      RateLimiterClusterMaster,
-      RateLimiterClusterMasterPM2,
-      RateLimiterCluster,
-      RLWrapperBlackAndWhite,
-      RLWrapperTimeouts,
-      RateLimiterUnion,
-      RateLimiterQueue,
-      BurstyRateLimiter,
-      RateLimiterRes: RateLimiterRes2,
-      RateLimiterDynamo,
-      RateLimiterPrisma,
-      RateLimiterValkey,
-      RateLimiterValkeyGlide,
-      RateLimiterSQLite,
-      RateLimiterEtcd,
-      RateLimiterDrizzle,
-      RateLimiterDrizzleNonAtomic,
-      RateLimiterEtcdNonAtomic,
-      RateLimiterQueueError,
-      RateLimiterEtcdTransactionFailedError
-    };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
@@ -18557,9 +14010,9 @@ function handleError_default(err) {
   if (err instanceof external_exports.ZodError) {
     return new Errors(err.issues[0].message, "VALIDATION_ERROR", 400);
   }
-  const parsedError = firebaseError(err);
-  if (parsedError instanceof Errors) {
-    return parsedError;
+  const fbError = firebaseError(err);
+  if (fbError instanceof Errors) {
+    return fbError;
   }
   return new Errors("Internal server error", "INTERNAL_SERVER_ERROR", 500);
 }
@@ -18582,39 +14035,33 @@ function pathWithParams_default(path, params) {
   return queryString ? `${basePath}?${queryString}` : basePath;
 }
 
-// src/withRateLimit.ts
-var import_rate_limiter_flexible = __toESM(require_rate_limiter_flexible());
-
 // src/getIp.ts
 function getIp_default(request) {
   return request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || request.headers.get("CF-Connecting-IP") || request.headers.get("X-Forwarded-For") || "unknown";
 }
 
 // src/withRateLimit.ts
+function isRateLimiterRes(err) {
+  return err && typeof err === "object" && "msBeforeNext" in err && "remainingPoints" in err;
+}
 function withRateLimit_default(handler, limiter) {
   return async (event) => {
     const ip = getIp_default(event.request);
     try {
       await limiter.consume(ip);
     } catch (err) {
-      if (err instanceof import_rate_limiter_flexible.RateLimiterRes) {
-        Response.json(
-          { error: "Too many requests" },
-          {
-            status: 429,
-            headers: {
-              "Retry-After": "1800",
-              "Content-Type": "application/json"
-            }
+      if (isRateLimiterRes(err)) {
+        new Response(JSON.stringify({ error: "Too many requests" }), {
+          status: 429,
+          headers: {
+            "Retry-After": "1800",
+            "Content-Type": "application/json"
           }
-        );
+        });
       }
-      return Response.json(
-        { error: "Internal server error" },
-        {
-          status: 500
-        }
-      );
+      return new Response(JSON.stringify({ error: "Internal server error" }), {
+        status: 500
+      });
     }
     return handler({ ...event, ip });
   };
@@ -18623,11 +14070,14 @@ function withRateLimit_default(handler, limiter) {
 // src/validateTurnstile.ts
 function validateTurnstile_default(handler, secretKey) {
   return async (event) => {
+    if (!secretKey) {
+      return new Response(JSON.stringify({ error: "Invalid secret key" }));
+    }
     const body = await event.request.json();
     const token = body["cf-turnstile-response"];
     const ip = getIp_default(event.request);
     if (!token) {
-      return Response.json({ error: "Captcha not sent" });
+      return new Response(JSON.stringify({ error: "Captcha not sent" }));
     }
     const response = await fetch(
       "https://challenges.cloudflare.com/turnstile/v0/siteverify",
@@ -18644,7 +14094,9 @@ function validateTurnstile_default(handler, secretKey) {
       }
     );
     if (!response.ok) {
-      return Response.json({ error: "Invalid verification" }, { status: 400 });
+      return new Response(JSON.stringify({ error: "Invalid verification" }), {
+        status: 400
+      });
     }
     return handler({ ...event, ip });
   };
@@ -18659,7 +14111,6 @@ __export(constants_exports, {
   LANG_STRATEGY: () => LANG_STRATEGY,
   ORG_NAME: () => ORG_NAME,
   PROTOCOL: () => PROTOCOL,
-  RATE_LIMIT_DEFAULT_OPTIONS: () => RATE_LIMIT_DEFAULT_OPTIONS,
   SUPPORT_EMAIL: () => SUPPORT_EMAIL,
   URLS: () => URLS
 });
@@ -18684,11 +14135,6 @@ var LANG_STRATEGY = [
   "baseLocale",
   "globalVariable"
 ];
-var RATE_LIMIT_DEFAULT_OPTIONS = {
-  points: 3,
-  duration: 60 * 60,
-  blockDuration: 30 * 60
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Constants,