@upstash/ratelimit 2.0.2 → 2.0.4

package/dist/index.js

@@ -49,10 +49,10 @@ var Analytics = class {
    * @returns
    */
   extractGeo(req) {
-    if (typeof req.geo !== "undefined") {
+    if (req.geo !== void 0) {
       return req.geo;
     }
-    if (typeof req.cf !== "undefined") {
+    if (req.cf !== void 0) {
       return req.cf;
     }
     return {};
@@ -141,54 +141,203 @@ function ms(d) {
   const time = Number.parseInt(match[1]);
   const unit = match[2];
   switch (unit) {
-    case "ms":
+    case "ms": {
       return time;
-    case "s":
+    }
+    case "s": {
       return time * 1e3;
-    case "m":
+    }
+    case "m": {
       return time * 1e3 * 60;
-    case "h":
+    }
+    case "h": {
       return time * 1e3 * 60 * 60;
-    case "d":
+    }
+    case "d": {
       return time * 1e3 * 60 * 60 * 24;
-    default:
+    }
+    default: {
       throw new Error(`Unable to parse window size: ${d}`);
+    }
   }
 }
 
 // src/hash.ts
-var setHash = async (ctx, script, kind) => {
-  const regionContexts = "redis" in ctx ? [ctx] : ctx.regionContexts;
-  const hashSample = regionContexts[0].scriptHashes[kind];
-  if (!hashSample) {
-    await Promise.all(regionContexts.map(async (context) => {
-      context.scriptHashes[kind] = await context.redis.scriptLoad(script);
-    }));
-  }
-  ;
-};
-var safeEval = async (ctx, script, kind, keys, args) => {
-  if (!ctx.cacheScripts) {
-    return await ctx.redis.eval(script, keys, args);
-  }
-  ;
-  await setHash(ctx, script, kind);
+var safeEval = async (ctx, script, keys, args) => {
   try {
-    return await ctx.redis.evalsha(ctx.scriptHashes[kind], keys, args);
+    return await ctx.redis.evalsha(script.hash, keys, args);
   } catch (error) {
     if (`${error}`.includes("NOSCRIPT")) {
-      console.log("Script with the expected hash was not found in redis db. It is probably flushed. Will load another scipt before continuing.");
-      ctx.scriptHashes[kind] = void 0;
-      await setHash(ctx, script, kind);
-      console.log("  New script successfully loaded.");
-      return await ctx.redis.evalsha(ctx.scriptHashes[kind], keys, args);
+      const hash = await ctx.redis.scriptLoad(script.script);
+      if (hash !== script.hash) {
+        console.warn(
+          "Upstash Ratelimit: Expected hash and the hash received from Redis are different. Ratelimit will work as usual but performance will be reduced."
+        );
+      }
+      return await ctx.redis.evalsha(hash, keys, args);
     }
     throw error;
   }
 };
 
-// src/lua-scripts/multi.ts
+// src/lua-scripts/single.ts
 var fixedWindowLimitScript = `
+  local key           = KEYS[1]
+  local window        = ARGV[1]
+  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
+
+  local r = redis.call("INCRBY", key, incrementBy)
+  if r == tonumber(incrementBy) then
+  -- The first time this key is set, the value will be equal to incrementBy.
+  -- So we only need the expire command once
+  redis.call("PEXPIRE", key, window)
+  end
+
+  return r
+`;
+var fixedWindowRemainingTokensScript = `
+      local key = KEYS[1]
+      local tokens = 0
+
+      local value = redis.call('GET', key)
+      if value then
+          tokens = value
+      end
+      return tokens
+    `;
+var slidingWindowLimitScript = `
+  local currentKey  = KEYS[1]           -- identifier including prefixes
+  local previousKey = KEYS[2]           -- key of the previous bucket
+  local tokens      = tonumber(ARGV[1]) -- tokens per window
+  local now         = ARGV[2]           -- current timestamp in milliseconds
+  local window      = ARGV[3]           -- interval in milliseconds
+  local incrementBy = ARGV[4]           -- increment rate per request at a given value, default is 1
+
+  local requestsInCurrentWindow = redis.call("GET", currentKey)
+  if requestsInCurrentWindow == false then
+    requestsInCurrentWindow = 0
+  end
+
+  local requestsInPreviousWindow = redis.call("GET", previousKey)
+  if requestsInPreviousWindow == false then
+    requestsInPreviousWindow = 0
+  end
+  local percentageInCurrent = ( now % window ) / window
+  -- weighted requests to consider from the previous window
+  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+  if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
+    return -1
+  end
+
+  local newValue = redis.call("INCRBY", currentKey, incrementBy)
+  if newValue == tonumber(incrementBy) then
+    -- The first time this key is set, the value will be equal to incrementBy.
+    -- So we only need the expire command once
+    redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
+  end
+  return tokens - ( newValue + requestsInPreviousWindow )
+`;
+var slidingWindowRemainingTokensScript = `
+  local currentKey  = KEYS[1]           -- identifier including prefixes
+  local previousKey = KEYS[2]           -- key of the previous bucket
+  local now         = ARGV[1]           -- current timestamp in milliseconds
+  local window      = ARGV[2]           -- interval in milliseconds
+
+  local requestsInCurrentWindow = redis.call("GET", currentKey)
+  if requestsInCurrentWindow == false then
+    requestsInCurrentWindow = 0
+  end
+
+  local requestsInPreviousWindow = redis.call("GET", previousKey)
+  if requestsInPreviousWindow == false then
+    requestsInPreviousWindow = 0
+  end
+
+  local percentageInCurrent = ( now % window ) / window
+  -- weighted requests to consider from the previous window
+  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
+
+  return requestsInPreviousWindow + requestsInCurrentWindow
+`;
+var tokenBucketLimitScript = `
+  local key         = KEYS[1]           -- identifier including prefixes
+  local maxTokens   = tonumber(ARGV[1]) -- maximum number of tokens
+  local interval    = tonumber(ARGV[2]) -- size of the window in milliseconds
+  local refillRate  = tonumber(ARGV[3]) -- how many tokens are refilled after each interval
+  local now         = tonumber(ARGV[4]) -- current timestamp in milliseconds
+  local incrementBy = tonumber(ARGV[5]) -- how many tokens to consume, default is 1
+        
+  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
+        
+  local refilledAt
+  local tokens
+
+  if bucket[1] == false then
+    refilledAt = now
+    tokens = maxTokens
+  else
+    refilledAt = tonumber(bucket[1])
+    tokens = tonumber(bucket[2])
+  end
+        
+  if now >= refilledAt + interval then
+    local numRefills = math.floor((now - refilledAt) / interval)
+    tokens = math.min(maxTokens, tokens + numRefills * refillRate)
+
+    refilledAt = refilledAt + numRefills * interval
+  end
+
+  if tokens == 0 then
+    return {-1, refilledAt + interval}
+  end
+
+  local remaining = tokens - incrementBy
+  local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
+        
+  redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
+  redis.call("PEXPIRE", key, expireAt)
+  return {remaining, refilledAt + interval}
+`;
+var tokenBucketIdentifierNotFound = -1;
+var tokenBucketRemainingTokensScript = `
+  local key         = KEYS[1]
+  local maxTokens   = tonumber(ARGV[1])
+        
+  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
+
+  if bucket[1] == false then
+    return {maxTokens, ${tokenBucketIdentifierNotFound}}
+  end
+        
+  return {tonumber(bucket[2]), tonumber(bucket[1])}
+`;
+var cachedFixedWindowLimitScript = `
+  local key     = KEYS[1]
+  local window  = ARGV[1]
+  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
+
+  local r = redis.call("INCRBY", key, incrementBy)
+  if r == incrementBy then
+  -- The first time this key is set, the value will be equal to incrementBy.
+  -- So we only need the expire command once
+  redis.call("PEXPIRE", key, window)
+  end
+      
+  return r
+`;
+var cachedFixedWindowRemainingTokenScript = `
+  local key = KEYS[1]
+  local tokens = 0
+
+  local value = redis.call('GET', key)
+  if value then
+      tokens = value
+  end
+  return tokens
+`;
+
+// src/lua-scripts/multi.ts
+var fixedWindowLimitScript2 = `
 	local key           = KEYS[1]
 	local id            = ARGV[1]
 	local window        = ARGV[2]
@@ -204,7 +353,7 @@ var fixedWindowLimitScript = `
 
 	return fields
 `;
-var fixedWindowRemainingTokensScript = `
+var fixedWindowRemainingTokensScript2 = `
       local key = KEYS[1]
       local tokens = 0
 
@@ -212,7 +361,7 @@ var fixedWindowRemainingTokensScript = `
 
       return fields
     `;
-var slidingWindowLimitScript = `
+var slidingWindowLimitScript2 = `
 	local currentKey    = KEYS[1]           -- identifier including prefixes
 	local previousKey   = KEYS[2]           -- key of the previous bucket
 	local tokens        = tonumber(ARGV[1]) -- tokens per window
@@ -247,7 +396,7 @@ var slidingWindowLimitScript = `
 	end
 	return {currentFields, previousFields, true}
 `;
-var slidingWindowRemainingTokensScript = `
+var slidingWindowRemainingTokensScript2 = `
 	local currentKey    = KEYS[1]           -- identifier including prefixes
 	local previousKey   = KEYS[2]           -- key of the previous bucket
 	local now         	= ARGV[1]           -- current timestamp in milliseconds
@@ -296,6 +445,78 @@ var resetScript = `
       until cursor == "0"
     `;
 
+// src/lua-scripts/hash.ts
+var SCRIPTS = {
+  singleRegion: {
+    fixedWindow: {
+      limit: {
+        script: fixedWindowLimitScript,
+        hash: "b13943e359636db027ad280f1def143f02158c13"
+      },
+      getRemaining: {
+        script: fixedWindowRemainingTokensScript,
+        hash: "8c4c341934502aee132643ffbe58ead3450e5208"
+      }
+    },
+    slidingWindow: {
+      limit: {
+        script: slidingWindowLimitScript,
+        hash: "e1391e429b699c780eb0480350cd5b7280fd9213"
+      },
+      getRemaining: {
+        script: slidingWindowRemainingTokensScript,
+        hash: "65a73ac5a05bf9712903bc304b77268980c1c417"
+      }
+    },
+    tokenBucket: {
+      limit: {
+        script: tokenBucketLimitScript,
+        hash: "5bece90aeef8189a8cfd28995b479529e270b3c6"
+      },
+      getRemaining: {
+        script: tokenBucketRemainingTokensScript,
+        hash: "a15be2bb1db2a15f7c82db06146f9d08983900d0"
+      }
+    },
+    cachedFixedWindow: {
+      limit: {
+        script: cachedFixedWindowLimitScript,
+        hash: "c26b12703dd137939b9a69a3a9b18e906a2d940f"
+      },
+      getRemaining: {
+        script: cachedFixedWindowRemainingTokenScript,
+        hash: "8e8f222ccae68b595ee6e3f3bf2199629a62b91a"
+      }
+    }
+  },
+  multiRegion: {
+    fixedWindow: {
+      limit: {
+        script: fixedWindowLimitScript2,
+        hash: "a8c14f3835aa87bd70e5e2116081b81664abcf5c"
+      },
+      getRemaining: {
+        script: fixedWindowRemainingTokensScript2,
+        hash: "8ab8322d0ed5fe5ac8eb08f0c2e4557f1b4816fd"
+      }
+    },
+    slidingWindow: {
+      limit: {
+        script: slidingWindowLimitScript2,
+        hash: "cb4fdc2575056df7c6d422764df0de3a08d6753b"
+      },
+      getRemaining: {
+        script: slidingWindowRemainingTokensScript2,
+        hash: "558c9306b7ec54abb50747fe0b17e5d44bd24868"
+      }
+    }
+  }
+};
+var RESET_SCRIPT = {
+  script: resetScript,
+  hash: "54bd274ddc59fb3be0f42deee2f64322a10e2b50"
+};
+
 // src/types.ts
 var DenyListExtension = "denyList";
 var IpDenyListKey = "ipDenyList";
@@ -379,7 +600,7 @@ var updateIpDenyList = async (redis, prefix, threshold, ttl) => {
   const transaction = redis.multi();
   transaction.sdiffstore(allDenyLists, allDenyLists, ipDenyList);
   transaction.del(ipDenyList);
-  transaction.sadd(ipDenyList, ...allIps);
+  transaction.sadd(ipDenyList, allIps.at(0), ...allIps.slice(1));
   transaction.sdiffstore(ipDenyList, ipDenyList, allDenyLists);
   transaction.sunionstore(allDenyLists, allDenyLists, ipDenyList);
   transaction.set(statusKey, "valid", { px: ttl ?? getIpListTTL() });
@@ -481,7 +702,7 @@ var Ratelimit = class {
     }) : void 0;
     if (config.ephemeralCache instanceof Map) {
       this.ctx.cache = new Cache(config.ephemeralCache);
-    } else if (typeof config.ephemeralCache === "undefined") {
+    } else if (config.ephemeralCache === void 0) {
       this.ctx.cache = new Cache(/* @__PURE__ */ new Map());
     }
   }
@@ -612,15 +833,10 @@ var Ratelimit = class {
     const key = this.getKey(identifier);
     const definedMembers = this.getDefinedMembers(identifier, req);
     const deniedValue = checkDenyListCache(definedMembers);
-    let result;
-    if (deniedValue) {
-      result = [defaultDeniedResponse(deniedValue), { deniedValue, invalidIpDenyList: false }];
-    } else {
-      result = await Promise.all([
-        this.limiter().limit(this.ctx, key, req?.rate),
-        this.enableProtection ? checkDenyList(this.primaryRedis, this.prefix, definedMembers) : { deniedValue: void 0, invalidIpDenyList: false }
-      ]);
-    }
+    const result = deniedValue ? [defaultDeniedResponse(deniedValue), { deniedValue, invalidIpDenyList: false }] : await Promise.all([
+      this.limiter().limit(this.ctx, key, req?.rate),
+      this.enableProtection ? checkDenyList(this.primaryRedis, this.prefix, definedMembers) : { deniedValue: void 0, invalidIpDenyList: false }
+    ]);
     return resolveLimitPayload(this.primaryRedis, this.prefix, result, this.denyListThreshold);
   };
   /**
@@ -670,9 +886,9 @@ var Ratelimit = class {
           time: Date.now(),
           success: ratelimitResponse.reason === "denyList" ? "denied" : ratelimitResponse.success,
           ...geo
-        }).catch((err) => {
+        }).catch((error) => {
           let errorMessage = "Failed to record analytics";
-          if (`${err}`.includes("WRONGTYPE")) {
+          if (`${error}`.includes("WRONGTYPE")) {
             errorMessage = `
     Failed to record analytics. See the information below:
 
@@ -685,11 +901,11 @@ var Ratelimit = class {
 
     `;
           }
-          console.warn(errorMessage, err);
+          console.warn(errorMessage, error);
         });
         ratelimitResponse.pending = Promise.all([ratelimitResponse.pending, analyticsP]);
-      } catch (err) {
-        console.warn("Failed to record analytics", err);
+      } catch (error) {
+        console.warn("Failed to record analytics", error);
       }
       ;
     }
@@ -735,9 +951,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
       analytics: config.analytics,
       ctx: {
         regionContexts: config.redis.map((redis) => ({
-          redis,
-          scriptHashes: {},
-          cacheScripts: config.cacheScripts ?? true
+          redis
         })),
         cache: config.ephemeralCache ? new Cache(config.ephemeralCache) : void 0
       }
@@ -786,8 +1000,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            fixedWindowLimitScript,
-            "limitHash",
+            SCRIPTS.multiRegion.fixedWindow.limit,
             [key],
             [requestId, windowDuration, incrementBy]
           )
@@ -803,18 +1016,17 @@ var MultiRegionRatelimit = class extends Ratelimit {
         const remaining = tokens - usedTokens;
         async function sync() {
           const individualIDs = await Promise.all(dbs.map((s) => s.request));
-          const allIDs = Array.from(
-            new Set(
-              individualIDs.flatMap((_) => _).reduce((acc, curr, index) => {
-                if (index % 2 === 0) {
-                  acc.push(curr);
-                }
-                return acc;
-              }, [])
-            ).values()
-          );
+          const allIDs = [...new Set(
+            individualIDs.flat().reduce((acc, curr, index) => {
+              if (index % 2 === 0) {
+                acc.push(curr);
+              }
+              return acc;
+            }, [])
+          ).values()];
           for (const db of dbs) {
-            const usedDbTokens = (await db.request).reduce(
+            const usedDbTokensRequest = await db.request;
+            const usedDbTokens = usedDbTokensRequest.reduce(
               (accTokens, usedToken, index) => {
                 let parsedToken = 0;
                 if (index % 2) {
@@ -824,7 +1036,8 @@ var MultiRegionRatelimit = class extends Ratelimit {
               },
               0
             );
-            const dbIds = (await db.request).reduce((ids, currentId, index) => {
+            const dbIdsRequest = await db.request;
+            const dbIds = dbIdsRequest.reduce((ids, currentId, index) => {
               if (index % 2 === 0) {
                 ids.push(currentId);
               }
@@ -862,8 +1075,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            fixedWindowRemainingTokensScript,
-            "getRemainingHash",
+            SCRIPTS.multiRegion.fixedWindow.getRemaining,
             [key],
             [null]
           )
@@ -889,8 +1101,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
         await Promise.all(ctx.regionContexts.map((regionContext) => {
           safeEval(
             regionContext,
-            resetScript,
-            "resetHash",
+            RESET_SCRIPT,
             [pattern],
             [null]
           );
@@ -943,8 +1154,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            slidingWindowLimitScript,
-            "limitHash",
+            SCRIPTS.multiRegion.slidingWindow.limit,
             [currentKey, previousKey],
             [tokens, now, windowDuration, requestId, incrementBy]
             // lua seems to return `1` for true and `null` for false
@@ -974,16 +1184,14 @@ var MultiRegionRatelimit = class extends Ratelimit {
         const remaining = tokens - usedTokens;
         async function sync() {
           const res = await Promise.all(dbs.map((s) => s.request));
-          const allCurrentIds = Array.from(
-            new Set(
-              res.flatMap(([current2]) => current2).reduce((acc, curr, index) => {
-                if (index % 2 === 0) {
-                  acc.push(curr);
-                }
-                return acc;
-              }, [])
-            ).values()
-          );
+          const allCurrentIds = [...new Set(
+            res.flatMap(([current2]) => current2).reduce((acc, curr, index) => {
+              if (index % 2 === 0) {
+                acc.push(curr);
+              }
+              return acc;
+            }, [])
+          ).values()];
           for (const db of dbs) {
             const [current2, _previous, _success] = await db.request;
             const dbIds = current2.reduce((ids, currentId, index) => {
@@ -1033,8 +1241,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
           redis: regionContext.redis,
           request: safeEval(
             regionContext,
-            slidingWindowRemainingTokensScript,
-            "getRemainingHash",
+            SCRIPTS.multiRegion.slidingWindow.getRemaining,
             [currentKey, previousKey],
             [now, windowSize]
             // lua seems to return `1` for true and `null` for false
@@ -1054,8 +1261,7 @@ var MultiRegionRatelimit = class extends Ratelimit {
         await Promise.all(ctx.regionContexts.map((regionContext) => {
           safeEval(
             regionContext,
-            resetScript,
-            "resetHash",
+            RESET_SCRIPT,
             [pattern],
             [null]
           );
@@ -1065,162 +1271,6 @@ var MultiRegionRatelimit = class extends Ratelimit {
   }
 };
 
-// src/lua-scripts/single.ts
-var fixedWindowLimitScript2 = `
-  local key           = KEYS[1]
-  local window        = ARGV[1]
-  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
-
-  local r = redis.call("INCRBY", key, incrementBy)
-  if r == tonumber(incrementBy) then
-  -- The first time this key is set, the value will be equal to incrementBy.
-  -- So we only need the expire command once
-  redis.call("PEXPIRE", key, window)
-  end
-
-  return r
-`;
-var fixedWindowRemainingTokensScript2 = `
-      local key = KEYS[1]
-      local tokens = 0
-
-      local value = redis.call('GET', key)
-      if value then
-          tokens = value
-      end
-      return tokens
-    `;
-var slidingWindowLimitScript2 = `
-  local currentKey  = KEYS[1]           -- identifier including prefixes
-  local previousKey = KEYS[2]           -- key of the previous bucket
-  local tokens      = tonumber(ARGV[1]) -- tokens per window
-  local now         = ARGV[2]           -- current timestamp in milliseconds
-  local window      = ARGV[3]           -- interval in milliseconds
-  local incrementBy = ARGV[4]           -- increment rate per request at a given value, default is 1
-
-  local requestsInCurrentWindow = redis.call("GET", currentKey)
-  if requestsInCurrentWindow == false then
-    requestsInCurrentWindow = 0
-  end
-
-  local requestsInPreviousWindow = redis.call("GET", previousKey)
-  if requestsInPreviousWindow == false then
-    requestsInPreviousWindow = 0
-  end
-  local percentageInCurrent = ( now % window ) / window
-  -- weighted requests to consider from the previous window
-  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
-  if requestsInPreviousWindow + requestsInCurrentWindow >= tokens then
-    return -1
-  end
-
-  local newValue = redis.call("INCRBY", currentKey, incrementBy)
-  if newValue == tonumber(incrementBy) then
-    -- The first time this key is set, the value will be equal to incrementBy.
-    -- So we only need the expire command once
-    redis.call("PEXPIRE", currentKey, window * 2 + 1000) -- Enough time to overlap with a new window + 1 second
-  end
-  return tokens - ( newValue + requestsInPreviousWindow )
-`;
-var slidingWindowRemainingTokensScript2 = `
-  local currentKey  = KEYS[1]           -- identifier including prefixes
-  local previousKey = KEYS[2]           -- key of the previous bucket
-  local now         = ARGV[1]           -- current timestamp in milliseconds
-  local window      = ARGV[2]           -- interval in milliseconds
-
-  local requestsInCurrentWindow = redis.call("GET", currentKey)
-  if requestsInCurrentWindow == false then
-    requestsInCurrentWindow = 0
-  end
-
-  local requestsInPreviousWindow = redis.call("GET", previousKey)
-  if requestsInPreviousWindow == false then
-    requestsInPreviousWindow = 0
-  end
-
-  local percentageInCurrent = ( now % window ) / window
-  -- weighted requests to consider from the previous window
-  requestsInPreviousWindow = math.floor(( 1 - percentageInCurrent ) * requestsInPreviousWindow)
-
-  return requestsInPreviousWindow + requestsInCurrentWindow
-`;
-var tokenBucketLimitScript = `
-  local key         = KEYS[1]           -- identifier including prefixes
-  local maxTokens   = tonumber(ARGV[1]) -- maximum number of tokens
-  local interval    = tonumber(ARGV[2]) -- size of the window in milliseconds
-  local refillRate  = tonumber(ARGV[3]) -- how many tokens are refilled after each interval
-  local now         = tonumber(ARGV[4]) -- current timestamp in milliseconds
-  local incrementBy = tonumber(ARGV[5]) -- how many tokens to consume, default is 1
-        
-  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
-        
-  local refilledAt
-  local tokens
-
-  if bucket[1] == false then
-    refilledAt = now
-    tokens = maxTokens
-  else
-    refilledAt = tonumber(bucket[1])
-    tokens = tonumber(bucket[2])
-  end
-        
-  if now >= refilledAt + interval then
-    local numRefills = math.floor((now - refilledAt) / interval)
-    tokens = math.min(maxTokens, tokens + numRefills * refillRate)
-
-    refilledAt = refilledAt + numRefills * interval
-  end
-
-  if tokens == 0 then
-    return {-1, refilledAt + interval}
-  end
-
-  local remaining = tokens - incrementBy
-  local expireAt = math.ceil(((maxTokens - remaining) / refillRate)) * interval
-        
-  redis.call("HSET", key, "refilledAt", refilledAt, "tokens", remaining)
-  redis.call("PEXPIRE", key, expireAt)
-  return {remaining, refilledAt + interval}
-`;
-var tokenBucketIdentifierNotFound = -1;
-var tokenBucketRemainingTokensScript = `
-  local key         = KEYS[1]
-  local maxTokens   = tonumber(ARGV[1])
-        
-  local bucket = redis.call("HMGET", key, "refilledAt", "tokens")
-
-  if bucket[1] == false then
-    return {maxTokens, ${tokenBucketIdentifierNotFound}}
-  end
-        
-  return {tonumber(bucket[2]), tonumber(bucket[1])}
-`;
-var cachedFixedWindowLimitScript = `
-  local key     = KEYS[1]
-  local window  = ARGV[1]
-  local incrementBy   = ARGV[2] -- increment rate per request at a given value, default is 1
-
-  local r = redis.call("INCRBY", key, incrementBy)
-  if r == incrementBy then
-  -- The first time this key is set, the value will be equal to incrementBy.
-  -- So we only need the expire command once
-  redis.call("PEXPIRE", key, window)
-  end
-      
-  return r
-`;
-var cachedFixedWindowRemainingTokenScript = `
-  local key = KEYS[1]
-  local tokens = 0
-
-  local value = redis.call('GET', key)
-  if value then
-      tokens = value
-  end
-  return tokens
-`;
-
 // src/single.ts
 var RegionRatelimit = class extends Ratelimit {
   /**
@@ -1233,9 +1283,7 @@ var RegionRatelimit = class extends Ratelimit {
       timeout: config.timeout,
       analytics: config.analytics,
       ctx: {
-        redis: config.redis,
-        scriptHashes: {},
-        cacheScripts: config.cacheScripts ?? true
+        redis: config.redis
       },
       ephemeralCache: config.ephemeralCache,
       enableProtection: config.enableProtection,
@@ -1282,8 +1330,7 @@ var RegionRatelimit = class extends Ratelimit {
         const incrementBy = rate ? Math.max(1, rate) : 1;
         const usedTokensAfterUpdate = await safeEval(
           ctx,
-          fixedWindowLimitScript2,
-          "limitHash",
+          SCRIPTS.singleRegion.fixedWindow.limit,
           [key],
           [windowDuration, incrementBy]
         );
@@ -1306,8 +1353,7 @@ var RegionRatelimit = class extends Ratelimit {
         const key = [identifier, bucket].join(":");
         const usedTokens = await safeEval(
           ctx,
-          fixedWindowRemainingTokensScript2,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.fixedWindow.getRemaining,
           [key],
           [null]
         );
@@ -1323,8 +1369,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );
@@ -1372,8 +1417,7 @@ var RegionRatelimit = class extends Ratelimit {
         const incrementBy = rate ? Math.max(1, rate) : 1;
         const remainingTokens = await safeEval(
           ctx,
-          slidingWindowLimitScript2,
-          "limitHash",
+          SCRIPTS.singleRegion.slidingWindow.limit,
           [currentKey, previousKey],
           [tokens, now, windowSize, incrementBy]
         );
@@ -1398,8 +1442,7 @@ var RegionRatelimit = class extends Ratelimit {
         const previousKey = [identifier, previousWindow].join(":");
         const usedTokens = await safeEval(
           ctx,
-          slidingWindowRemainingTokensScript2,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.slidingWindow.getRemaining,
           [currentKey, previousKey],
           [now, windowSize]
         );
@@ -1415,8 +1458,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );
@@ -1457,8 +1499,7 @@ var RegionRatelimit = class extends Ratelimit {
         const incrementBy = rate ? Math.max(1, rate) : 1;
         const [remaining, reset] = await safeEval(
           ctx,
-          tokenBucketLimitScript,
-          "limitHash",
+          SCRIPTS.singleRegion.tokenBucket.limit,
           [identifier],
           [maxTokens, intervalDuration, refillRate, now, incrementBy]
         );
@@ -1477,8 +1518,7 @@ var RegionRatelimit = class extends Ratelimit {
       async getRemaining(ctx, identifier) {
         const [remainingTokens, refilledAt] = await safeEval(
           ctx,
-          tokenBucketRemainingTokensScript,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.tokenBucket.getRemaining,
           [identifier],
           [maxTokens]
         );
@@ -1496,8 +1536,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );
@@ -1545,8 +1584,7 @@ var RegionRatelimit = class extends Ratelimit {
           const success = cachedTokensAfterUpdate < tokens;
           const pending = success ? safeEval(
             ctx,
-            cachedFixedWindowLimitScript,
-            "limitHash",
+            SCRIPTS.singleRegion.cachedFixedWindow.limit,
             [key],
             [windowDuration, incrementBy]
           ) : Promise.resolve();
@@ -1560,8 +1598,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         const usedTokensAfterUpdate = await safeEval(
           ctx,
-          cachedFixedWindowLimitScript,
-          "limitHash",
+          SCRIPTS.singleRegion.cachedFixedWindow.limit,
           [key],
           [windowDuration, incrementBy]
         );
@@ -1591,8 +1628,7 @@ var RegionRatelimit = class extends Ratelimit {
         }
         const usedTokens = await safeEval(
           ctx,
-          cachedFixedWindowRemainingTokenScript,
-          "getRemainingHash",
+          SCRIPTS.singleRegion.cachedFixedWindow.getRemaining,
           [key],
           [null]
         );
@@ -1611,8 +1647,7 @@ var RegionRatelimit = class extends Ratelimit {
         const pattern = [identifier, "*"].join(":");
         await safeEval(
           ctx,
-          resetScript,
-          "resetHash",
+          RESET_SCRIPT,
           [pattern],
           [null]
         );