bullmq 5.1.0 → 5.1.1

package/dist/esm/commands/includes/trimEvents.lua

@@ -2,8 +2,11 @@
   Function to trim events, default 10000.
 ]]
 
+-- Includes
+--- @include "getOrSetMaxEvents"
+
 local function trimEvents(metaKey, eventStreamKey)
-  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  local maxEvents = getOrSetMaxEvents(metaKey)
   if maxEvents ~= false then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else

package/dist/esm/commands/includes/updateExistingJobsParent.lua

@@ -1,11 +1,13 @@
---- @include "updateParentDepsIfNeeded"
-
 --[[
     This function is used to update the parent's dependencies if the job
     is already completed and about to be ignored. The parent must get its
     dependencies updated to avoid the parent job being stuck forever in 
     the waiting-children state.
 ]]
+
+-- Includes
+--- @include "updateParentDepsIfNeeded"
+
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)

package/dist/esm/commands/moveJobsToWait-6.lua

@@ -26,6 +26,7 @@ local rcall = redis.call;
 
 -- Includes
 --- @include "includes/batches"
+--- @include "includes/getOrSetMaxEvents"
 --- @include "includes/getTargetQueueList"
 
 local metaKey = KEYS[6]
@@ -46,7 +47,7 @@ if (#jobs > 0) then
         end
     end
 
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(metaKey)
 
     for i, key in ipairs(jobs) do
         -- Emit waiting event

package/dist/esm/commands/moveToDelayed-7.lua

@@ -30,6 +30,7 @@ local rcall = redis.call
 
 -- Includes
 --- @include "includes/addDelayMarkerIfNeeded"
+--- @include "includes/getOrSetMaxEvents"
 --- @include "includes/isQueuePaused"
 
 local jobKey = KEYS[5]
@@ -58,7 +59,7 @@ if rcall("EXISTS", jobKey) == 1 then
     
     rcall("HSET", jobKey, "delay", ARGV[6])
 
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(metaKey)
 
     rcall("ZADD", delayedKey, score, jobId)
     rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "delayed",

package/dist/esm/commands/removeJob-1.lua

@@ -16,6 +16,7 @@ local rcall = redis.call
 
 -- Includes
 --- @include "includes/destructureJobKey"
+--- @include "includes/getOrSetMaxEvents"
 --- @include "includes/isLocked"
 --- @include "includes/removeJobFromAnyState"
 --- @include "includes/removeParentDependencyKey"
@@ -54,7 +55,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
     local prev = removeJobFromAnyState(prefix, jobId)
 
     if rcall("DEL", jobKey, jobKey .. ":logs", jobKey .. ":dependencies", jobKey .. ":processed") > 0 then
-        local maxEvents = rcall("HGET", prefix .. "meta", "opts.maxLenEvents") or 10000
+        local maxEvents = getOrSetMaxEvents(prefix .. "meta")
         rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",
             "jobId", jobId, "prev", prev)
     end

package/dist/esm/commands/retryJob-10.lua

@@ -31,6 +31,7 @@ local rcall = redis.call
 
 -- Includes
 --- @include "includes/addJobWithPriority"
+--- @include "includes/getOrSetMaxEvents"
 --- @include "includes/getTargetQueueList"
 --- @include "includes/promoteDelayedJobs"
 
@@ -65,7 +66,7 @@ if rcall("EXISTS", KEYS[4]) == 1 then
 
   rcall("HINCRBY", KEYS[4], "atm", 1)
 
-  local maxEvents = rcall("HGET", KEYS[5], "opts.maxLenEvents") or 10000
+  local maxEvents = getOrSetMaxEvents(KEYS[5])
 
   -- Emit waiting event
   rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "waiting",

package/dist/esm/commands/updateProgress-3.lua

@@ -18,8 +18,11 @@
 ]]
 local rcall = redis.call
 
+-- Includes
+--- @include "includes/getOrSetMaxEvents"
+
 if rcall("EXISTS", KEYS[1]) == 1 then -- // Make sure job exists
-    local maxEvents = rcall("HGET", KEYS[3], "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(KEYS[3])
 
     rcall("HSET", KEYS[1], "progress", ARGV[2])
     rcall("XADD", KEYS[2], "MAXLEN", "~", maxEvents, "*", "event", "progress",

package/dist/esm/scripts/addDelayedJob-6.js

@@ -44,38 +44,13 @@ local repeatJobKey = args[9]
 local parent = args[8]
 local parentData
 -- Includes
---[[
-  Function to store a job
-]]
-local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
-                        parentKey, parentData, repeatJobKey)
-    local jsonOpts = cjson.encode(opts)
-    local delay = opts['delay'] or 0
-    local priority = opts['priority'] or 0
-    local optionalValues = {}
-    if parentKey ~= nil then
-        table.insert(optionalValues, "parentKey")
-        table.insert(optionalValues, parentKey)
-        table.insert(optionalValues, "parent")
-        table.insert(optionalValues, parentData)
-    end
-    if repeatJobKey ~= nil then
-        table.insert(optionalValues, "rjk")
-        table.insert(optionalValues, repeatJobKey)
-    end
-    rcall("HMSET", jobIdKey, "name", name, "data", data, "opts", jsonOpts,
-          "timestamp", timestamp, "delay", delay, "priority", priority,
-          unpack(optionalValues))
-    rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
-    return delay, priority
-end
 --[[
   Add delay marker if needed.
 ]] 
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -94,6 +69,17 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
         rcall("ZADD", markerKey, nextTimestamp, "0")
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
   (since an empty list and !EXISTS are not really the same).
@@ -101,6 +87,38 @@ end
 local function isQueuePaused(queueMetaKey)
     return rcall("HEXISTS", queueMetaKey, "paused") == 1
 end
+--[[
+  Function to store a job
+]]
+local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
+                        parentKey, parentData, repeatJobKey)
+    local jsonOpts = cjson.encode(opts)
+    local delay = opts['delay'] or 0
+    local priority = opts['priority'] or 0
+    local optionalValues = {}
+    if parentKey ~= nil then
+        table.insert(optionalValues, "parentKey")
+        table.insert(optionalValues, parentKey)
+        table.insert(optionalValues, "parent")
+        table.insert(optionalValues, parentData)
+    end
+    if repeatJobKey ~= nil then
+        table.insert(optionalValues, "rjk")
+        table.insert(optionalValues, repeatJobKey)
+    end
+    rcall("HMSET", jobIdKey, "name", name, "data", data, "opts", jsonOpts,
+          "timestamp", timestamp, "delay", delay, "priority", priority,
+          unpack(optionalValues))
+    rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
+    return delay, priority
+end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -176,12 +194,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -199,14 +211,6 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
-local function getOrSetMaxEvents(metaKey)
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
-    if not maxEvents then
-        maxEvents = 10000
-        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
-    end
-    return maxEvents
-end
 if parentKey ~= nil then
     if rcall("EXISTS", parentKey) ~= 1 then return -5 end
     parentData = cjson.encode(parent)

package/dist/esm/scripts/addDelayedJob-6.js.map

@@ -1 +1 @@
-{"version":3,"file":"addDelayedJob-6.js","sourceRoot":"","sources":["../../../src/scripts/addDelayedJob-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Pf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addDelayedJob-6.js","sourceRoot":"","sources":["../../../src/scripts/addDelayedJob-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkQf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/addParentJob-4.js

@@ -64,6 +64,13 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
     rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
     return delay, priority
 end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -78,7 +85,7 @@ end
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -171,12 +178,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -194,6 +195,9 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
 local function getOrSetMaxEvents(metaKey)
     local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
     if not maxEvents then

package/dist/esm/scripts/addParentJob-4.js.map

@@ -1 +1 @@
-{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Of,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmPf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/addPrioritizedJob-7.js

@@ -87,6 +87,13 @@ local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, pr
     rcall("ZADD", markerKey, 0, "0")
   end
 end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -101,7 +108,7 @@ end
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -176,12 +183,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -199,6 +200,9 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
 local function getOrSetMaxEvents(metaKey)
     local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
     if not maxEvents then

package/dist/esm/scripts/addPrioritizedJob-7.js.map

@@ -1 +1 @@
-{"version":3,"file":"addPrioritizedJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuPf,CAAC;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addPrioritizedJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Pf,CAAC;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/addStandardJob-7.js

@@ -73,6 +73,13 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
     rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
     return delay, priority
 end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -87,7 +94,7 @@ end
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -180,12 +187,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -203,6 +204,9 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
 local function getOrSetMaxEvents(metaKey)
     local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
     if not maxEvents then

package/dist/esm/scripts/addStandardJob-7.js.map

@@ -1 +1 @@
-{"version":3,"file":"addStandardJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addStandardJob-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgQf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addStandardJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addStandardJob-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoQf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/cleanJobsInSet-2.js

@@ -197,10 +197,12 @@ local function batches(n, batchSize)
     end
   end
 end
--- We use ZRANGEBYSCORE to make the case where we're deleting a limited number
--- of items in a sorted set only run a single iteration. If we simply used
--- ZRANGE, we may take a long time traversing through jobs that are within the
--- grace period.
+--[[
+  We use ZRANGEBYSCORE to make the case where we're deleting a limited number
+  of items in a sorted set only run a single iteration. If we simply used
+  ZRANGE, we may take a long time traversing through jobs that are within the
+  grace period.
+]]
 local function getJobsInZset(zsetKey, rangeEnd, limit)
   if limit > 0 then
     return rcall("ZRANGEBYSCORE", zsetKey, 0, rangeEnd, "LIMIT", 0, limit)

package/dist/esm/scripts/cleanJobsInSet-2.js.map

@@ -1 +1 @@
-{"version":3,"file":"cleanJobsInSet-2.js","sourceRoot":"","sources":["../../../src/scripts/cleanJobsInSet-2.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqQf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"cleanJobsInSet-2.js","sourceRoot":"","sources":["../../../src/scripts/cleanJobsInSet-2.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/moveJobsToWait-6.js

@@ -35,6 +35,17 @@ local function batches(n, batchSize)
     end
   end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
   (since an empty list and !EXISTS are not really the same).
@@ -61,7 +72,7 @@ if (#jobs > 0) then
             rcall("HDEL", jobKey, "finishedOn", "processedOn", "returnvalue")
         end
     end
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(metaKey)
     for i, key in ipairs(jobs) do
         -- Emit waiting event
         rcall("XADD", KEYS[2], "MAXLEN", "~", maxEvents, "*", "event",

package/dist/esm/scripts/moveJobsToWait-6.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveJobsToWait-6.js","sourceRoot":"","sources":["../../../src/scripts/moveJobsToWait-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Ef,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveJobsToWait-6.js","sourceRoot":"","sources":["../../../src/scripts/moveJobsToWait-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/moveStalledJobsToWait-8.js

@@ -177,8 +177,20 @@ end
 --[[
   Function to trim events, default 10000.
 ]]
+-- Includes
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 local function trimEvents(metaKey, eventStreamKey)
-  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  local maxEvents = getOrSetMaxEvents(metaKey)
   if maxEvents ~= false then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else

package/dist/esm/scripts/moveStalledJobsToWait-8.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveStalledJobsToWait-8.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwRf,CAAC;AACF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveStalledJobsToWait-8.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoSf,CAAC;AACF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/moveToActive-11.js

@@ -36,7 +36,7 @@ local opts = cmsgpack.unpack(ARGV[3])
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -47,6 +47,9 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
+--[[
+  Function to get current rate limit ttl.
+]]
 local function getRateLimitTTL(maxJobs, rateLimiterKey)
   if maxJobs and maxJobs <= tonumber(rcall("GET", rateLimiterKey) or 0) then
     local pttl = rcall("PTTL", rateLimiterKey)

package/dist/esm/scripts/moveToActive-11.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiOf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoOf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/esm/scripts/moveToDelayed-7.js

@@ -30,7 +30,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -49,6 +49,17 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
         rcall("ZADD", markerKey, nextTimestamp, "0")
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
   (since an empty list and !EXISTS are not really the same).
@@ -77,7 +88,7 @@ if rcall("EXISTS", jobKey) == 1 then
         rcall("HINCRBY", jobKey, "atm", 1)
     end
     rcall("HSET", jobKey, "delay", ARGV[6])
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(metaKey)
     rcall("ZADD", delayedKey, score, jobId)
     rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "delayed",
           "jobId", jobId, "delay", delayedTimestamp)

package/dist/esm/scripts/moveToDelayed-7.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToDelayed-7.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Ff,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveToDelayed-7.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/moveToFinished-14.js

@@ -102,7 +102,7 @@ local function collectMetrics(metaKey, dataPointsList, maxDataPoints,
 end
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -454,8 +454,20 @@ end
 --[[
   Function to trim events, default 10000.
 ]]
+-- Includes
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 local function trimEvents(metaKey, eventStreamKey)
-  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  local maxEvents = getOrSetMaxEvents(metaKey)
   if maxEvents ~= false then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else
@@ -472,6 +484,9 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
+--[[
+  Function to get current rate limit ttl.
+]]
 local function getRateLimitTTL(maxJobs, rateLimiterKey)
   if maxJobs and maxJobs <= tonumber(rcall("GET", rateLimiterKey) or 0) then
     local pttl = rcall("PTTL", rateLimiterKey)

package/dist/esm/scripts/moveToFinished-14.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToFinished-14.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-14.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAipBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToFinished-14.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-14.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgqBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/esm/scripts/pause-7.js

@@ -20,7 +20,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then

package/dist/esm/scripts/removeJob-1.js

@@ -20,6 +20,17 @@ end
 local getJobKeyPrefix = function (jobKey, jobId)
   return string.sub(jobKey, 0, #jobKey - #jobId)
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 --[[
   Function to recursively check if there are no locks
   on the jobs to be removed.
@@ -188,7 +199,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
     end
     local prev = removeJobFromAnyState(prefix, jobId)
     if rcall("DEL", jobKey, jobKey .. ":logs", jobKey .. ":dependencies", jobKey .. ":processed") > 0 then
-        local maxEvents = rcall("HGET", prefix .. "meta", "opts.maxLenEvents") or 10000
+        local maxEvents = getOrSetMaxEvents(prefix .. "meta")
         rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",
             "jobId", jobId, "prev", prev)
     end

package/dist/esm/scripts/removeJob-1.js.map

@@ -1 +1 @@
-{"version":3,"file":"removeJob-1.js","sourceRoot":"","sources":["../../../src/scripts/removeJob-1.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyMf,CAAC;AACF,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"removeJob-1.js","sourceRoot":"","sources":["../../../src/scripts/removeJob-1.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoNf,CAAC;AACF,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}