bullmq 5.66.5 → 5.66.7

package/dist/cjs/commands/includes/moveChildFromDependenciesIfNeeded.lua

@@ -6,28 +6,21 @@
 --- @include "moveParentToWaitIfNoPendingDependencies"
 --- @include "moveParentToWaitIfNeeded"
 --- @include "moveParentToWait"
---- @include "removeJobsOnFail"
 
-local moveParentToFailedIfNeeded = function (parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
+local handleChildFailureAndMoveParentToWait = function (parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
   if rcall("EXISTS", parentKey) == 1 then
     local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
     local parentDelayedKey = parentQueueKey .. ":delayed"
-    local parentPrioritizedKey = parentQueueKey .. ":prioritized"
     local parentWaitingChildrenOrDelayedKey
-    local prevState
     if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then
       parentWaitingChildrenOrDelayedKey = parentWaitingChildrenKey
-      prevState = "waiting-children"
     elseif rcall("ZSCORE", parentDelayedKey, parentId) then
       parentWaitingChildrenOrDelayedKey = parentDelayedKey
-      prevState = "delayed"
       rcall("HSET", parentKey, "delay", 0)
     end
 
     if parentWaitingChildrenOrDelayedKey then
       rcall("ZREM", parentWaitingChildrenOrDelayedKey, parentId)
-      local parentQueuePrefix = parentQueueKey .. ":"
-      local parentFailedKey = parentQueueKey .. ":failed"
       local deferredFailure = "child " .. jobIdKey .. " failed"
       rcall("HSET", parentKey, "defa", deferredFailure)
       moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
@@ -47,9 +40,9 @@ local moveChildFromDependenciesIfNeeded = function (rawParentData, childKey, fai
     local parentDependenciesChildrenKey = parentKey .. ":dependencies"
     if parentData['fpof'] then
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
-        local parentUnsuccesssfulChildrenKey = parentKey .. ":unsuccessful"
-        rcall("ZADD", parentUnsuccesssfulChildrenKey, timestamp, childKey)
-        moveParentToFailedIfNeeded(
+        local parentUnsuccessfulChildrenKey = parentKey .. ":unsuccessful"
+        rcall("ZADD", parentUnsuccessfulChildrenKey, timestamp, childKey)
+        handleChildFailureAndMoveParentToWait(
           parentData['queueKey'],
           parentKey,
           parentData['id'],

package/dist/cjs/commands/includes/removeJobsByMaxAge.lua

@@ -5,10 +5,9 @@
 -- Includes
 --- @include "removeJob"
 
-local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix,
-  shouldRemoveDebounceKey)
+local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix, maxLimit)
   local start = timestamp - maxAge * 1000
-  local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf")
+  local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf", "LIMIT", 0, maxLimit)
   for i, jobId in ipairs(jobIds) do
     removeJob(jobId, false, prefix, false --[[remove debounce key]])
   end

package/dist/cjs/commands/moveToFinished-14.lua

@@ -107,6 +107,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
     local maxMetricsSize = opts['maxMetricsSize']
     local maxCount = opts['keepJobs']['count']
     local maxAge = opts['keepJobs']['age']
+    local maxLimit = opts['keepJobs']['limit'] or 1000
 
     local jobAttributes = rcall("HMGET", jobIdKey, "parentKey", "parent", "deid")
     local parentKey = jobAttributes[1] or ""
@@ -175,7 +176,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
 
         -- Remove old jobs?
         if maxAge ~= nil then
-            removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
+            removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix, maxLimit)
         end
 
         if maxCount ~= nil and maxCount > 0 then

package/dist/cjs/interfaces/index.js

@@ -10,7 +10,6 @@ tslib_1.__exportStar(require("./flow-job"), exports);
 tslib_1.__exportStar(require("./ioredis-events"), exports);
 tslib_1.__exportStar(require("./job-json"), exports);
 tslib_1.__exportStar(require("./job-scheduler-json"), exports);
-tslib_1.__exportStar(require("./keep-jobs"), exports);
 tslib_1.__exportStar(require("./lock-manager-worker-context"), exports);
 tslib_1.__exportStar(require("./metrics-options"), exports);
 tslib_1.__exportStar(require("./metrics"), exports);

package/dist/cjs/interfaces/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,0DAAgC;AAChC,uDAA6B;AAC7B,qDAA2B;AAC3B,2DAAiC;AACjC,qDAA2B;AAC3B,+DAAqC;AACrC,sDAA4B;AAC5B,wEAA8C;AAC9C,4DAAkC;AAClC,oDAA0B;AAC1B,wDAA8B;AAC9B,0DAAgC;AAChC,2DAAiC;AACjC,mDAAyB;AACzB,2DAAiC;AACjC,uDAA6B;AAC7B,0DAAgC;AAChC,iEAAuC;AACvC,0DAAgC;AAChC,0DAAgC;AAChC,2DAAiC;AACjC,+DAAqC;AACrC,2DAAiC;AACjC,0DAAgC;AAChC,iEAAuC;AACvC,oEAA0C;AAC1C,0DAAgC;AAChC,8DAAoC;AACpC,2DAAiC;AACjC,sDAA4B;AAC5B,qDAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,0DAAgC;AAChC,uDAA6B;AAC7B,qDAA2B;AAC3B,2DAAiC;AACjC,qDAA2B;AAC3B,+DAAqC;AACrC,wEAA8C;AAC9C,4DAAkC;AAClC,oDAA0B;AAC1B,wDAA8B;AAC9B,0DAAgC;AAChC,2DAAiC;AACjC,mDAAyB;AACzB,2DAAiC;AACjC,uDAA6B;AAC7B,0DAAgC;AAChC,iEAAuC;AACvC,0DAAgC;AAChC,0DAAgC;AAChC,2DAAiC;AACjC,+DAAqC;AACrC,2DAAiC;AACjC,0DAAgC;AAChC,iEAAuC;AACvC,oEAA0C;AAC1C,0DAAgC;AAChC,8DAAoC;AACpC,2DAAiC;AACjC,sDAA4B;AAC5B,qDAA2B"}

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

@@ -292,200 +292,19 @@ local function moveParentToWaitIfNoPendingDependencies(parentQueueKey, parentDep
     moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
   end
 end
---[[
-  Functions to remove jobs when removeOnFail option is provided.
-]]
--- Includes
---[[
-  Function to remove job.
-]]
--- Includes
---[[
-  Function to remove deduplication key if needed
-  when a job is being removed.
-]]
-local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
-  jobId, deduplicationId)
-  if deduplicationId then
-    local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    local currentJobId = rcall('GET', deduplicationKey)
-    if currentJobId and currentJobId == jobId then
-      return rcall("DEL", deduplicationKey)
-    end
-  end
-end
---[[
-  Function to remove job keys.
-]]
-local function removeJobKeys(jobKey)
-  return rcall("DEL", jobKey, jobKey .. ':logs', jobKey .. ':dependencies',
-    jobKey .. ':processed', jobKey .. ':failed', jobKey .. ':unsuccessful')
-end
---[[
-  Check if this job has a parent. If so we will just remove it from
-  the parent child list, but if it is the last child we should move the parent to "wait/paused"
-  which requires code from "moveToFinished"
-]]
--- Includes
---[[
-  Functions to destructure job key.
-  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
-]]
-local getJobIdFromKey = function (jobKey)
-  return string.match(jobKey, ".*:(.*)")
-end
-local getJobKeyPrefix = function (jobKey, jobId)
-  return string.sub(jobKey, 0, #jobKey - #jobId)
-end
-local function _moveParentToWait(parentPrefix, parentId, emitEvent)
-  local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
-    parentPrefix .. "wait", parentPrefix .. "paused")
-  addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
-  if emitEvent then
-    local parentEventStream = parentPrefix .. "events"
-    rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
-  end
-end
-local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
-  if parentKey then
-    local parentDependenciesKey = parentKey .. ":dependencies"
-    local result = rcall("SREM", parentDependenciesKey, jobKey)
-    if result > 0 then
-      local pendingDependencies = rcall("SCARD", parentDependenciesKey)
-      if pendingDependencies == 0 then
-        local parentId = getJobIdFromKey(parentKey)
-        local parentPrefix = getJobKeyPrefix(parentKey, parentId)
-        local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
-        if numRemovedElements == 1 then
-          if hard then -- remove parent in same queue
-            if parentPrefix == baseKey then
-              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
-              removeJobKeys(parentKey)
-              if debounceId then
-                rcall("DEL", parentPrefix .. "de:" .. debounceId)
-              end
-            else
-              _moveParentToWait(parentPrefix, parentId)
-            end
-          else
-            _moveParentToWait(parentPrefix, parentId, true)
-          end
-        end
-      end
-      return true
-    end
-  else
-    local parentAttributes = rcall("HMGET", jobKey, "parentKey", "deid")
-    local missedParentKey = parentAttributes[1]
-    if( (type(missedParentKey) == "string") and missedParentKey ~= ""
-      and (rcall("EXISTS", missedParentKey) == 1)) then
-      local parentDependenciesKey = missedParentKey .. ":dependencies"
-      local result = rcall("SREM", parentDependenciesKey, jobKey)
-      if result > 0 then
-        local pendingDependencies = rcall("SCARD", parentDependenciesKey)
-        if pendingDependencies == 0 then
-          local parentId = getJobIdFromKey(missedParentKey)
-          local parentPrefix = getJobKeyPrefix(missedParentKey, parentId)
-          local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
-          if numRemovedElements == 1 then
-            if hard then
-              if parentPrefix == baseKey then
-                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
-                removeJobKeys(missedParentKey)
-                if parentAttributes[2] then
-                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
-                end
-              else
-                _moveParentToWait(parentPrefix, parentId)
-              end
-            else
-              _moveParentToWait(parentPrefix, parentId, true)
-            end
-          end
-        end
-        return true
-      end
-    end
-  end
-  return false
-end
-local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
-  local jobKey = baseKey .. jobId
-  removeParentDependencyKey(jobKey, hard, nil, baseKey)
-  if shouldRemoveDeduplicationKey then
-    local deduplicationId = rcall("HGET", jobKey, "deid")
-    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobId, deduplicationId)
-  end
-  removeJobKeys(jobKey)
-end
---[[
-  Functions to remove jobs by max age.
-]]
--- Includes
-local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix,
-  shouldRemoveDebounceKey)
-  local start = timestamp - maxAge * 1000
-  local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf")
-  for i, jobId in ipairs(jobIds) do
-    removeJob(jobId, false, prefix, false --[[remove debounce key]])
-  end
-  rcall("ZREMRANGEBYSCORE", targetSet, "-inf", start)
-end
---[[
-  Functions to remove jobs by max count.
-]]
--- Includes
-local function removeJobsByMaxCount(maxCount, targetSet, prefix)
-  local start = maxCount
-  local jobIds = rcall("ZREVRANGE", targetSet, start, -1)
-  for i, jobId in ipairs(jobIds) do
-    removeJob(jobId, false, prefix, false --[[remove debounce key]])
-  end
-  rcall("ZREMRANGEBYRANK", targetSet, 0, -(maxCount + 1))
-end
-local function removeJobsOnFail(queueKeyPrefix, failedKey, jobId, opts, timestamp)
-  local removeOnFailType = type(opts["removeOnFail"])
-  if removeOnFailType == "number" then
-    removeJobsByMaxCount(opts["removeOnFail"],
-                        failedKey, queueKeyPrefix)
-  elseif removeOnFailType == "boolean" then
-    if opts["removeOnFail"] then
-      removeJob(jobId, false, queueKeyPrefix,
-                false --[[remove debounce key]])
-      rcall("ZREM", failedKey, jobId)
-    end
-  elseif removeOnFailType ~= "nil" then
-    local maxAge = opts["removeOnFail"]["age"]
-    local maxCount = opts["removeOnFail"]["count"]
-    if maxAge ~= nil then
-      removeJobsByMaxAge(timestamp, maxAge,
-                        failedKey, queueKeyPrefix)
-    end
-    if maxCount ~= nil and maxCount > 0 then
-      removeJobsByMaxCount(maxCount, failedKey,
-                            queueKeyPrefix)
-    end
-  end 
-end
-local moveParentToFailedIfNeeded = function (parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
+local handleChildFailureAndMoveParentToWait = function (parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
   if rcall("EXISTS", parentKey) == 1 then
     local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
     local parentDelayedKey = parentQueueKey .. ":delayed"
-    local parentPrioritizedKey = parentQueueKey .. ":prioritized"
     local parentWaitingChildrenOrDelayedKey
-    local prevState
     if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then
       parentWaitingChildrenOrDelayedKey = parentWaitingChildrenKey
-      prevState = "waiting-children"
     elseif rcall("ZSCORE", parentDelayedKey, parentId) then
       parentWaitingChildrenOrDelayedKey = parentDelayedKey
-      prevState = "delayed"
       rcall("HSET", parentKey, "delay", 0)
     end
     if parentWaitingChildrenOrDelayedKey then
       rcall("ZREM", parentWaitingChildrenOrDelayedKey, parentId)
-      local parentQueuePrefix = parentQueueKey .. ":"
-      local parentFailedKey = parentQueueKey .. ":failed"
       local deferredFailure = "child " .. jobIdKey .. " failed"
       rcall("HSET", parentKey, "defa", deferredFailure)
       moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
@@ -504,9 +323,9 @@ local moveChildFromDependenciesIfNeeded = function (rawParentData, childKey, fai
     local parentDependenciesChildrenKey = parentKey .. ":dependencies"
     if parentData['fpof'] then
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
-        local parentUnsuccesssfulChildrenKey = parentKey .. ":unsuccessful"
-        rcall("ZADD", parentUnsuccesssfulChildrenKey, timestamp, childKey)
-        moveParentToFailedIfNeeded(
+        local parentUnsuccessfulChildrenKey = parentKey .. ":unsuccessful"
+        rcall("ZADD", parentUnsuccessfulChildrenKey, timestamp, childKey)
+        handleChildFailureAndMoveParentToWait(
           parentData['queueKey'],
           parentKey,
           parentData['id'],
@@ -622,6 +441,152 @@ local function removeDeduplicationKeyIfNeededOnFinalization(prefixKey,
     end
   end
 end
+--[[
+  Function to remove job keys.
+]]
+local function removeJobKeys(jobKey)
+  return rcall("DEL", jobKey, jobKey .. ':logs', jobKey .. ':dependencies',
+    jobKey .. ':processed', jobKey .. ':failed', jobKey .. ':unsuccessful')
+end
+--[[
+  Functions to remove jobs by max age.
+]]
+-- Includes
+--[[
+  Function to remove job.
+]]
+-- Includes
+--[[
+  Function to remove deduplication key if needed
+  when a job is being removed.
+]]
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobId, deduplicationId)
+  if deduplicationId then
+    local deduplicationKey = prefixKey .. "de:" .. deduplicationId
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
+  end
+end
+--[[
+  Check if this job has a parent. If so we will just remove it from
+  the parent child list, but if it is the last child we should move the parent to "wait/paused"
+  which requires code from "moveToFinished"
+]]
+-- Includes
+--[[
+  Functions to destructure job key.
+  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
+]]
+local getJobIdFromKey = function (jobKey)
+  return string.match(jobKey, ".*:(.*)")
+end
+local getJobKeyPrefix = function (jobKey, jobId)
+  return string.sub(jobKey, 0, #jobKey - #jobId)
+end
+local function _moveParentToWait(parentPrefix, parentId, emitEvent)
+  local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
+    parentPrefix .. "wait", parentPrefix .. "paused")
+  addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
+  if emitEvent then
+    local parentEventStream = parentPrefix .. "events"
+    rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
+  end
+end
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
+  if parentKey then
+    local parentDependenciesKey = parentKey .. ":dependencies"
+    local result = rcall("SREM", parentDependenciesKey, jobKey)
+    if result > 0 then
+      local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+      if pendingDependencies == 0 then
+        local parentId = getJobIdFromKey(parentKey)
+        local parentPrefix = getJobKeyPrefix(parentKey, parentId)
+        local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+        if numRemovedElements == 1 then
+          if hard then -- remove parent in same queue
+            if parentPrefix == baseKey then
+              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
+              removeJobKeys(parentKey)
+              if debounceId then
+                rcall("DEL", parentPrefix .. "de:" .. debounceId)
+              end
+            else
+              _moveParentToWait(parentPrefix, parentId)
+            end
+          else
+            _moveParentToWait(parentPrefix, parentId, true)
+          end
+        end
+      end
+      return true
+    end
+  else
+    local parentAttributes = rcall("HMGET", jobKey, "parentKey", "deid")
+    local missedParentKey = parentAttributes[1]
+    if( (type(missedParentKey) == "string") and missedParentKey ~= ""
+      and (rcall("EXISTS", missedParentKey) == 1)) then
+      local parentDependenciesKey = missedParentKey .. ":dependencies"
+      local result = rcall("SREM", parentDependenciesKey, jobKey)
+      if result > 0 then
+        local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+        if pendingDependencies == 0 then
+          local parentId = getJobIdFromKey(missedParentKey)
+          local parentPrefix = getJobKeyPrefix(missedParentKey, parentId)
+          local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+          if numRemovedElements == 1 then
+            if hard then
+              if parentPrefix == baseKey then
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
+                removeJobKeys(missedParentKey)
+                if parentAttributes[2] then
+                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
+                end
+              else
+                _moveParentToWait(parentPrefix, parentId)
+              end
+            else
+              _moveParentToWait(parentPrefix, parentId, true)
+            end
+          end
+        end
+        return true
+      end
+    end
+  end
+  return false
+end
+local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
+  local jobKey = baseKey .. jobId
+  removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  if shouldRemoveDeduplicationKey then
+    local deduplicationId = rcall("HGET", jobKey, "deid")
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobId, deduplicationId)
+  end
+  removeJobKeys(jobKey)
+end
+local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix, maxLimit)
+  local start = timestamp - maxAge * 1000
+  local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf", "LIMIT", 0, maxLimit)
+  for i, jobId in ipairs(jobIds) do
+    removeJob(jobId, false, prefix, false --[[remove debounce key]])
+  end
+  rcall("ZREMRANGEBYSCORE", targetSet, "-inf", start)
+end
+--[[
+  Functions to remove jobs by max count.
+]]
+-- Includes
+local function removeJobsByMaxCount(maxCount, targetSet, prefix)
+  local start = maxCount
+  local jobIds = rcall("ZREVRANGE", targetSet, start, -1)
+  for i, jobId in ipairs(jobIds) do
+    removeJob(jobId, false, prefix, false --[[remove debounce key]])
+  end
+  rcall("ZREMRANGEBYRANK", targetSet, 0, -(maxCount + 1))
+end
 local function removeLock(jobKey, stalledKey, token, jobId)
   if token ~= "0" then
     local lockKey = jobKey .. ':lock'
@@ -708,6 +673,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
     local maxMetricsSize = opts['maxMetricsSize']
     local maxCount = opts['keepJobs']['count']
     local maxAge = opts['keepJobs']['age']
+    local maxLimit = opts['keepJobs']['limit'] or 1000
     local jobAttributes = rcall("HMGET", jobIdKey, "parentKey", "parent", "deid")
     local parentKey = jobAttributes[1] or ""
     local parentId = ""
@@ -763,7 +729,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
         end
         -- Remove old jobs?
         if maxAge ~= nil then
-            removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
+            removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix, maxLimit)
         end
         if maxCount ~= nil and maxCount > 0 then
             removeJobsByMaxCount(maxCount, targetSet, prefix)

package/dist/cjs/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAo1Bf,CAAC;AACW,QAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkzBf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}