es5.js

/**
  * This file contains the full Bottleneck library (MIT) compiled to ES5.
  * https://github.com/SGrondin/bottleneck
  * It also contains the regenerator-runtime (MIT), necessary for Babel-generated ES5 code to execute promise and async/await code.
  * See the following link for Copyright and License information:
  * https://github.com/facebook/regenerator/blob/master/packages/regenerator-runtime/runtime.js
  */
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.Bottleneck = factory());
}(this, (function () { 'use strict';

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	function getCjsExportFromNamespace (n) {
		return n && n['default'] || n;
	}

	var runtime = createCommonjsModule(function (module) {
	/**
	 * Copyright (c) 2014-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	!(function(global) {

	  var Op = Object.prototype;
	  var hasOwn = Op.hasOwnProperty;
	  var undefined; // More compressible than void 0.
	  var $Symbol = typeof Symbol === "function" ? Symbol : {};
	  var iteratorSymbol = $Symbol.iterator || "@@iterator";
	  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
	  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
	  var runtime = global.regeneratorRuntime;
	  if (runtime) {
	    {
	      // If regeneratorRuntime is defined globally and we're in a module,
	      // make the exports object identical to regeneratorRuntime.
	      module.exports = runtime;
	    }
	    // Don't bother evaluating the rest of this file if the runtime was
	    // already defined globally.
	    return;
	  }

	  // Define the runtime globally (as expected by generated code) as either
	  // module.exports (if we're in a module) or a new, empty object.
	  runtime = global.regeneratorRuntime = module.exports;

	  function wrap(innerFn, outerFn, self, tryLocsList) {
	    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
	    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
	    var generator = Object.create(protoGenerator.prototype);
	    var context = new Context(tryLocsList || []);

	    // The ._invoke method unifies the implementations of the .next,
	    // .throw, and .return methods.
	    generator._invoke = makeInvokeMethod(innerFn, self, context);

	    return generator;
	  }
	  runtime.wrap = wrap;

	  // Try/catch helper to minimize deoptimizations. Returns a completion
	  // record like context.tryEntries[i].completion. This interface could
	  // have been (and was previously) designed to take a closure to be
	  // invoked without arguments, but in all the cases we care about we
	  // already have an existing method we want to call, so there's no need
	  // to create a new function object. We can even get away with assuming
	  // the method takes exactly one argument, since that happens to be true
	  // in every case, so we don't have to touch the arguments object. The
	  // only additional allocation required is the completion record, which
	  // has a stable shape and so hopefully should be cheap to allocate.
	  function tryCatch(fn, obj, arg) {
	    try {
	      return { type: "normal", arg: fn.call(obj, arg) };
	    } catch (err) {
	      return { type: "throw", arg: err };
	    }
	  }

	  var GenStateSuspendedStart = "suspendedStart";
	  var GenStateSuspendedYield = "suspendedYield";
	  var GenStateExecuting = "executing";
	  var GenStateCompleted = "completed";

	  // Returning this object from the innerFn has the same effect as
	  // breaking out of the dispatch switch statement.
	  var ContinueSentinel = {};

	  // Dummy constructor functions that we use as the .constructor and
	  // .constructor.prototype properties for functions that return Generator
	  // objects. For full spec compliance, you may wish to configure your
	  // minifier not to mangle the names of these two functions.
	  function Generator() {}
	  function GeneratorFunction() {}
	  function GeneratorFunctionPrototype() {}

	  // This is a polyfill for %IteratorPrototype% for environments that
	  // don't natively support it.
	  var IteratorPrototype = {};
	  IteratorPrototype[iteratorSymbol] = function () {
	    return this;
	  };

	  var getProto = Object.getPrototypeOf;
	  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
	  if (NativeIteratorPrototype &&
	      NativeIteratorPrototype !== Op &&
	      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
	    // This environment has a native %IteratorPrototype%; use it instead
	    // of the polyfill.
	    IteratorPrototype = NativeIteratorPrototype;
	  }

	  var Gp = GeneratorFunctionPrototype.prototype =
	    Generator.prototype = Object.create(IteratorPrototype);
	  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
	  GeneratorFunctionPrototype.constructor = GeneratorFunction;
	  GeneratorFunctionPrototype[toStringTagSymbol] =
	    GeneratorFunction.displayName = "GeneratorFunction";

	  // Helper for defining the .next, .throw, and .return methods of the
	  // Iterator interface in terms of a single ._invoke method.
	  function defineIteratorMethods(prototype) {
	    ["next", "throw", "return"].forEach(function(method) {
	      prototype[method] = function(arg) {
	        return this._invoke(method, arg);
	      };
	    });
	  }

	  runtime.isGeneratorFunction = function(genFun) {
	    var ctor = typeof genFun === "function" && genFun.constructor;
	    return ctor
	      ? ctor === GeneratorFunction ||
	        // For the native GeneratorFunction constructor, the best we can
	        // do is to check its .name property.
	        (ctor.displayName || ctor.name) === "GeneratorFunction"
	      : false;
	  };

	  runtime.mark = function(genFun) {
	    if (Object.setPrototypeOf) {
	      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
	    } else {
	      genFun.__proto__ = GeneratorFunctionPrototype;
	      if (!(toStringTagSymbol in genFun)) {
	        genFun[toStringTagSymbol] = "GeneratorFunction";
	      }
	    }
	    genFun.prototype = Object.create(Gp);
	    return genFun;
	  };

	  // Within the body of any async function, `await x` is transformed to
	  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
	  // `hasOwn.call(value, "__await")` to determine if the yielded value is
	  // meant to be awaited.
	  runtime.awrap = function(arg) {
	    return { __await: arg };
	  };

	  function AsyncIterator(generator) {
	    function invoke(method, arg, resolve, reject) {
	      var record = tryCatch(generator[method], generator, arg);
	      if (record.type === "throw") {
	        reject(record.arg);
	      } else {
	        var result = record.arg;
	        var value = result.value;
	        if (value &&
	            typeof value === "object" &&
	            hasOwn.call(value, "__await")) {
	          return Promise.resolve(value.__await).then(function(value) {
	            invoke("next", value, resolve, reject);
	          }, function(err) {
	            invoke("throw", err, resolve, reject);
	          });
	        }

	        return Promise.resolve(value).then(function(unwrapped) {
	          // When a yielded Promise is resolved, its final value becomes
	          // the .value of the Promise<{value,done}> result for the
	          // current iteration.
	          result.value = unwrapped;
	          resolve(result);
	        }, function(error) {
	          // If a rejected Promise was yielded, throw the rejection back
	          // into the async generator function so it can be handled there.
	          return invoke("throw", error, resolve, reject);
	        });
	      }
	    }

	    var previousPromise;

	    function enqueue(method, arg) {
	      function callInvokeWithMethodAndArg() {
	        return new Promise(function(resolve, reject) {
	          invoke(method, arg, resolve, reject);
	        });
	      }

	      return previousPromise =
	        // If enqueue has been called before, then we want to wait until
	        // all previous Promises have been resolved before calling invoke,
	        // so that results are always delivered in the correct order. If
	        // enqueue has not been called before, then it is important to
	        // call invoke immediately, without waiting on a callback to fire,
	        // so that the async generator function has the opportunity to do
	        // any necessary setup in a predictable way. This predictability
	        // is why the Promise constructor synchronously invokes its
	        // executor callback, and why async functions synchronously
	        // execute code before the first await. Since we implement simple
	        // async functions in terms of async generators, it is especially
	        // important to get this right, even though it requires care.
	        previousPromise ? previousPromise.then(
	          callInvokeWithMethodAndArg,
	          // Avoid propagating failures to Promises returned by later
	          // invocations of the iterator.
	          callInvokeWithMethodAndArg
	        ) : callInvokeWithMethodAndArg();
	    }

	    // Define the unified helper method that is used to implement .next,
	    // .throw, and .return (see defineIteratorMethods).
	    this._invoke = enqueue;
	  }

	  defineIteratorMethods(AsyncIterator.prototype);
	  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
	    return this;
	  };
	  runtime.AsyncIterator = AsyncIterator;

	  // Note that simple async functions are implemented on top of
	  // AsyncIterator objects; they just return a Promise for the value of
	  // the final result produced by the iterator.
	  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
	    var iter = new AsyncIterator(
	      wrap(innerFn, outerFn, self, tryLocsList)
	    );

	    return runtime.isGeneratorFunction(outerFn)
	      ? iter // If outerFn is a generator, return the full iterator.
	      : iter.next().then(function(result) {
	          return result.done ? result.value : iter.next();
	        });
	  };

	  function makeInvokeMethod(innerFn, self, context) {
	    var state = GenStateSuspendedStart;

	    return function invoke(method, arg) {
	      if (state === GenStateExecuting) {
	        throw new Error("Generator is already running");
	      }

	      if (state === GenStateCompleted) {
	        if (method === "throw") {
	          throw arg;
	        }

	        // Be forgiving, per 25.3.3.3.3 of the spec:
	        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
	        return doneResult();
	      }

	      context.method = method;
	      context.arg = arg;

	      while (true) {
	        var delegate = context.delegate;
	        if (delegate) {
	          var delegateResult = maybeInvokeDelegate(delegate, context);
	          if (delegateResult) {
	            if (delegateResult === ContinueSentinel) continue;
	            return delegateResult;
	          }
	        }

	        if (context.method === "next") {
	          // Setting context._sent for legacy support of Babel's
	          // function.sent implementation.
	          context.sent = context._sent = context.arg;

	        } else if (context.method === "throw") {
	          if (state === GenStateSuspendedStart) {
	            state = GenStateCompleted;
	            throw context.arg;
	          }

	          context.dispatchException(context.arg);

	        } else if (context.method === "return") {
	          context.abrupt("return", context.arg);
	        }

	        state = GenStateExecuting;

	        var record = tryCatch(innerFn, self, context);
	        if (record.type === "normal") {
	          // If an exception is thrown from innerFn, we leave state ===
	          // GenStateExecuting and loop back for another invocation.
	          state = context.done
	            ? GenStateCompleted
	            : GenStateSuspendedYield;

	          if (record.arg === ContinueSentinel) {
	            continue;
	          }

	          return {
	            value: record.arg,
	            done: context.done
	          };

	        } else if (record.type === "throw") {
	          state = GenStateCompleted;
	          // Dispatch the exception by looping back around to the
	          // context.dispatchException(context.arg) call above.
	          context.method = "throw";
	          context.arg = record.arg;
	        }
	      }
	    };
	  }

	  // Call delegate.iterator[context.method](context.arg) and handle the
	  // result, either by returning a { value, done } result from the
	  // delegate iterator, or by modifying context.method and context.arg,
	  // setting context.delegate to null, and returning the ContinueSentinel.
	  function maybeInvokeDelegate(delegate, context) {
	    var method = delegate.iterator[context.method];
	    if (method === undefined) {
	      // A .throw or .return when the delegate iterator has no .throw
	      // method always terminates the yield* loop.
	      context.delegate = null;

	      if (context.method === "throw") {
	        if (delegate.iterator.return) {
	          // If the delegate iterator has a return method, give it a
	          // chance to clean up.
	          context.method = "return";
	          context.arg = undefined;
	          maybeInvokeDelegate(delegate, context);

	          if (context.method === "throw") {
	            // If maybeInvokeDelegate(context) changed context.method from
	            // "return" to "throw", let that override the TypeError below.
	            return ContinueSentinel;
	          }
	        }

	        context.method = "throw";
	        context.arg = new TypeError(
	          "The iterator does not provide a 'throw' method");
	      }

	      return ContinueSentinel;
	    }

	    var record = tryCatch(method, delegate.iterator, context.arg);

	    if (record.type === "throw") {
	      context.method = "throw";
	      context.arg = record.arg;
	      context.delegate = null;
	      return ContinueSentinel;
	    }

	    var info = record.arg;

	    if (! info) {
	      context.method = "throw";
	      context.arg = new TypeError("iterator result is not an object");
	      context.delegate = null;
	      return ContinueSentinel;
	    }

	    if (info.done) {
	      // Assign the result of the finished delegate to the temporary
	      // variable specified by delegate.resultName (see delegateYield).
	      context[delegate.resultName] = info.value;

	      // Resume execution at the desired location (see delegateYield).
	      context.next = delegate.nextLoc;

	      // If context.method was "throw" but the delegate handled the
	      // exception, let the outer generator proceed normally. If
	      // context.method was "next", forget context.arg since it has been
	      // "consumed" by the delegate iterator. If context.method was
	      // "return", allow the original .return call to continue in the
	      // outer generator.
	      if (context.method !== "return") {
	        context.method = "next";
	        context.arg = undefined;
	      }

	    } else {
	      // Re-yield the result returned by the delegate method.
	      return info;
	    }

	    // The delegate iterator is finished, so forget it and continue with
	    // the outer generator.
	    context.delegate = null;
	    return ContinueSentinel;
	  }

	  // Define Generator.prototype.{next,throw,return} in terms of the
	  // unified ._invoke helper method.
	  defineIteratorMethods(Gp);

	  Gp[toStringTagSymbol] = "Generator";

	  // A Generator should always return itself as the iterator object when the
	  // @@iterator function is called on it. Some browsers' implementations of the
	  // iterator prototype chain incorrectly implement this, causing the Generator
	  // object to not be returned from this call. This ensures that doesn't happen.
	  // See https://github.com/facebook/regenerator/issues/274 for more details.
	  Gp[iteratorSymbol] = function() {
	    return this;
	  };

	  Gp.toString = function() {
	    return "[object Generator]";
	  };

	  function pushTryEntry(locs) {
	    var entry = { tryLoc: locs[0] };

	    if (1 in locs) {
	      entry.catchLoc = locs[1];
	    }

	    if (2 in locs) {
	      entry.finallyLoc = locs[2];
	      entry.afterLoc = locs[3];
	    }

	    this.tryEntries.push(entry);
	  }

	  function resetTryEntry(entry) {
	    var record = entry.completion || {};
	    record.type = "normal";
	    delete record.arg;
	    entry.completion = record;
	  }

	  function Context(tryLocsList) {
	    // The root entry object (effectively a try statement without a catch
	    // or a finally block) gives us a place to store values thrown from
	    // locations where there is no enclosing try statement.
	    this.tryEntries = [{ tryLoc: "root" }];
	    tryLocsList.forEach(pushTryEntry, this);
	    this.reset(true);
	  }

	  runtime.keys = function(object) {
	    var keys = [];
	    for (var key in object) {
	      keys.push(key);
	    }
	    keys.reverse();

	    // Rather than returning an object with a next method, we keep
	    // things simple and return the next function itself.
	    return function next() {
	      while (keys.length) {
	        var key = keys.pop();
	        if (key in object) {
	          next.value = key;
	          next.done = false;
	          return next;
	        }
	      }

	      // To avoid creating an additional object, we just hang the .value
	      // and .done properties off the next function object itself. This
	      // also ensures that the minifier will not anonymize the function.
	      next.done = true;
	      return next;
	    };
	  };

	  function values(iterable) {
	    if (iterable) {
	      var iteratorMethod = iterable[iteratorSymbol];
	      if (iteratorMethod) {
	        return iteratorMethod.call(iterable);
	      }

	      if (typeof iterable.next === "function") {
	        return iterable;
	      }

	      if (!isNaN(iterable.length)) {
	        var i = -1, next = function next() {
	          while (++i < iterable.length) {
	            if (hasOwn.call(iterable, i)) {
	              next.value = iterable[i];
	              next.done = false;
	              return next;
	            }
	          }

	          next.value = undefined;
	          next.done = true;

	          return next;
	        };

	        return next.next = next;
	      }
	    }

	    // Return an iterator with no values.
	    return { next: doneResult };
	  }
	  runtime.values = values;

	  function doneResult() {
	    return { value: undefined, done: true };
	  }

	  Context.prototype = {
	    constructor: Context,

	    reset: function(skipTempReset) {
	      this.prev = 0;
	      this.next = 0;
	      // Resetting context._sent for legacy support of Babel's
	      // function.sent implementation.
	      this.sent = this._sent = undefined;
	      this.done = false;
	      this.delegate = null;

	      this.method = "next";
	      this.arg = undefined;

	      this.tryEntries.forEach(resetTryEntry);

	      if (!skipTempReset) {
	        for (var name in this) {
	          // Not sure about the optimal order of these conditions:
	          if (name.charAt(0) === "t" &&
	              hasOwn.call(this, name) &&
	              !isNaN(+name.slice(1))) {
	            this[name] = undefined;
	          }
	        }
	      }
	    },

	    stop: function() {
	      this.done = true;

	      var rootEntry = this.tryEntries[0];
	      var rootRecord = rootEntry.completion;
	      if (rootRecord.type === "throw") {
	        throw rootRecord.arg;
	      }

	      return this.rval;
	    },

	    dispatchException: function(exception) {
	      if (this.done) {
	        throw exception;
	      }

	      var context = this;
	      function handle(loc, caught) {
	        record.type = "throw";
	        record.arg = exception;
	        context.next = loc;

	        if (caught) {
	          // If the dispatched exception was caught by a catch block,
	          // then let that catch block handle the exception normally.
	          context.method = "next";
	          context.arg = undefined;
	        }

	        return !! caught;
	      }

	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        var record = entry.completion;

	        if (entry.tryLoc === "root") {
	          // Exception thrown outside of any try block that could handle
	          // it, so set the completion value of the entire function to
	          // throw the exception.
	          return handle("end");
	        }

	        if (entry.tryLoc <= this.prev) {
	          var hasCatch = hasOwn.call(entry, "catchLoc");
	          var hasFinally = hasOwn.call(entry, "finallyLoc");

	          if (hasCatch && hasFinally) {
	            if (this.prev < entry.catchLoc) {
	              return handle(entry.catchLoc, true);
	            } else if (this.prev < entry.finallyLoc) {
	              return handle(entry.finallyLoc);
	            }

	          } else if (hasCatch) {
	            if (this.prev < entry.catchLoc) {
	              return handle(entry.catchLoc, true);
	            }

	          } else if (hasFinally) {
	            if (this.prev < entry.finallyLoc) {
	              return handle(entry.finallyLoc);
	            }

	          } else {
	            throw new Error("try statement without catch or finally");
	          }
	        }
	      }
	    },

	    abrupt: function(type, arg) {
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        if (entry.tryLoc <= this.prev &&
	            hasOwn.call(entry, "finallyLoc") &&
	            this.prev < entry.finallyLoc) {
	          var finallyEntry = entry;
	          break;
	        }
	      }

	      if (finallyEntry &&
	          (type === "break" ||
	           type === "continue") &&
	          finallyEntry.tryLoc <= arg &&
	          arg <= finallyEntry.finallyLoc) {
	        // Ignore the finally entry if control is not jumping to a
	        // location outside the try/catch block.
	        finallyEntry = null;
	      }

	      var record = finallyEntry ? finallyEntry.completion : {};
	      record.type = type;
	      record.arg = arg;

	      if (finallyEntry) {
	        this.method = "next";
	        this.next = finallyEntry.finallyLoc;
	        return ContinueSentinel;
	      }

	      return this.complete(record);
	    },

	    complete: function(record, afterLoc) {
	      if (record.type === "throw") {
	        throw record.arg;
	      }

	      if (record.type === "break" ||
	          record.type === "continue") {
	        this.next = record.arg;
	      } else if (record.type === "return") {
	        this.rval = this.arg = record.arg;
	        this.method = "return";
	        this.next = "end";
	      } else if (record.type === "normal" && afterLoc) {
	        this.next = afterLoc;
	      }

	      return ContinueSentinel;
	    },

	    finish: function(finallyLoc) {
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        if (entry.finallyLoc === finallyLoc) {
	          this.complete(entry.completion, entry.afterLoc);
	          resetTryEntry(entry);
	          return ContinueSentinel;
	        }
	      }
	    },

	    "catch": function(tryLoc) {
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        if (entry.tryLoc === tryLoc) {
	          var record = entry.completion;
	          if (record.type === "throw") {
	            var thrown = record.arg;
	            resetTryEntry(entry);
	          }
	          return thrown;
	        }
	      }

	      // The context.catch method must only be called with a location
	      // argument that corresponds to a known catch block.
	      throw new Error("illegal catch attempt");
	    },

	    delegateYield: function(iterable, resultName, nextLoc) {
	      this.delegate = {
	        iterator: values(iterable),
	        resultName: resultName,
	        nextLoc: nextLoc
	      };

	      if (this.method === "next") {
	        // Deliberately forget the last sent value so that we don't
	        // accidentally pass it on to the delegate.
	        this.arg = undefined;
	      }

	      return ContinueSentinel;
	    }
	  };
	})(
	  // In sloppy mode, unbound `this` refers to the global object, fallback to
	  // Function constructor if we're in global strict mode. That is sadly a form
	  // of indirect eval which violates Content Security Policy.
	  (function() {
	    return this || (typeof self === "object" && self);
	  })() || Function("return this")()
	);
	});

	function _typeof(obj) {
	  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
	    _typeof = function (obj) {
	      return typeof obj;
	    };
	  } else {
	    _typeof = function (obj) {
	      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
	    };
	  }

	  return _typeof(obj);
	}

	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
	  try {
	    var info = gen[key](arg);
	    var value = info.value;
	  } catch (error) {
	    reject(error);
	    return;
	  }

	  if (info.done) {
	    resolve(value);
	  } else {
	    Promise.resolve(value).then(_next, _throw);
	  }
	}

	function _asyncToGenerator(fn) {
	  return function () {
	    var self = this,
	        args = arguments;
	    return new Promise(function (resolve, reject) {
	      var gen = fn.apply(self, args);

	      function _next(value) {
	        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
	      }

	      function _throw(err) {
	        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
	      }

	      _next(undefined);
	    });
	  };
	}

	function _classCallCheck(instance, Constructor) {
	  if (!(instance instanceof Constructor)) {
	    throw new TypeError("Cannot call a class as a function");
	  }
	}

	function _defineProperties(target, props) {
	  for (var i = 0; i < props.length; i++) {
	    var descriptor = props[i];
	    descriptor.enumerable = descriptor.enumerable || false;
	    descriptor.configurable = true;
	    if ("value" in descriptor) descriptor.writable = true;
	    Object.defineProperty(target, descriptor.key, descriptor);
	  }
	}

	function _createClass(Constructor, protoProps, staticProps) {
	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
	  if (staticProps) _defineProperties(Constructor, staticProps);
	  return Constructor;
	}

	function _inherits(subClass, superClass) {
	  if (typeof superClass !== "function" && superClass !== null) {
	    throw new TypeError("Super expression must either be null or a function");
	  }

	  subClass.prototype = Object.create(superClass && superClass.prototype, {
	    constructor: {
	      value: subClass,
	      writable: true,
	      configurable: true
	    }
	  });
	  if (superClass) _setPrototypeOf(subClass, superClass);
	}

	function _getPrototypeOf(o) {
	  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
	    return o.__proto__ || Object.getPrototypeOf(o);
	  };
	  return _getPrototypeOf(o);
	}

	function _setPrototypeOf(o, p) {
	  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
	    o.__proto__ = p;
	    return o;
	  };

	  return _setPrototypeOf(o, p);
	}

	function isNativeReflectConstruct() {
	  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
	  if (Reflect.construct.sham) return false;
	  if (typeof Proxy === "function") return true;

	  try {
	    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
	    return true;
	  } catch (e) {
	    return false;
	  }
	}

	function _construct(Parent, args, Class) {
	  if (isNativeReflectConstruct()) {
	    _construct = Reflect.construct;
	  } else {
	    _construct = function _construct(Parent, args, Class) {
	      var a = [null];
	      a.push.apply(a, args);
	      var Constructor = Function.bind.apply(Parent, a);
	      var instance = new Constructor();
	      if (Class) _setPrototypeOf(instance, Class.prototype);
	      return instance;
	    };
	  }

	  return _construct.apply(null, arguments);
	}

	function _isNativeFunction(fn) {
	  return Function.toString.call(fn).indexOf("[native code]") !== -1;
	}

	function _wrapNativeSuper(Class) {
	  var _cache = typeof Map === "function" ? new Map() : undefined;

	  _wrapNativeSuper = function _wrapNativeSuper(Class) {
	    if (Class === null || !_isNativeFunction(Class)) return Class;

	    if (typeof Class !== "function") {
	      throw new TypeError("Super expression must either be null or a function");
	    }

	    if (typeof _cache !== "undefined") {
	      if (_cache.has(Class)) return _cache.get(Class);

	      _cache.set(Class, Wrapper);
	    }

	    function Wrapper() {
	      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
	    }

	    Wrapper.prototype = Object.create(Class.prototype, {
	      constructor: {
	        value: Wrapper,
	        enumerable: false,
	        writable: true,
	        configurable: true
	      }
	    });
	    return _setPrototypeOf(Wrapper, Class);
	  };

	  return _wrapNativeSuper(Class);
	}

	function _assertThisInitialized(self) {
	  if (self === void 0) {
	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	  }

	  return self;
	}

	function _possibleConstructorReturn(self, call) {
	  if (call && (typeof call === "object" || typeof call === "function")) {
	    return call;
	  }

	  return _assertThisInitialized(self);
	}

	function _slicedToArray(arr, i) {
	  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
	}

	function _toArray(arr) {
	  return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();
	}

	function _toConsumableArray(arr) {
	  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
	}

	function _arrayWithoutHoles(arr) {
	  if (Array.isArray(arr)) {
	    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

	    return arr2;
	  }
	}

	function _arrayWithHoles(arr) {
	  if (Array.isArray(arr)) return arr;
	}

	function _iterableToArray(iter) {
	  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
	}

	function _iterableToArrayLimit(arr, i) {
	  var _arr = [];
	  var _n = true;
	  var _d = false;
	  var _e = undefined;

	  try {
	    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
	      _arr.push(_s.value);

	      if (i && _arr.length === i) break;
	    }
	  } catch (err) {
	    _d = true;
	    _e = err;
	  } finally {
	    try {
	      if (!_n && _i["return"] != null) _i["return"]();
	    } finally {
	      if (_d) throw _e;
	    }
	  }

	  return _arr;
	}

	function _nonIterableSpread() {
	  throw new TypeError("Invalid attempt to spread non-iterable instance");
	}

	function _nonIterableRest() {
	  throw new TypeError("Invalid attempt to destructure non-iterable instance");
	}

	var load = function load(received, defaults) {
	  var onto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	  var k, ref, v;

	  for (k in defaults) {
	    v = defaults[k];
	    onto[k] = (ref = received[k]) != null ? ref : v;
	  }

	  return onto;
	};

	var overwrite = function overwrite(received, defaults) {
	  var onto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	  var k, v;

	  for (k in received) {
	    v = received[k];

	    if (defaults[k] !== void 0) {
	      onto[k] = v;
	    }
	  }

	  return onto;
	};

	var parser = {
	  load: load,
	  overwrite: overwrite
	};

	var DLList;

	DLList =
	/*#__PURE__*/
	function () {
	  function DLList(incr, decr) {
	    _classCallCheck(this, DLList);

	    this.incr = incr;
	    this.decr = decr;
	    this._first = null;
	    this._last = null;
	    this.length = 0;
	  }

	  _createClass(DLList, [{
	    key: "push",
	    value: function push(value) {
	      var node;
	      this.length++;

	      if (typeof this.incr === "function") {
	        this.incr();
	      }

	      node = {
	        value: value,
	        prev: this._last,
	        next: null
	      };

	      if (this._last != null) {
	        this._last.next = node;
	        this._last = node;
	      } else {
	        this._first = this._last = node;
	      }

	      return void 0;
	    }
	  }, {
	    key: "shift",
	    value: function shift() {
	      var value;

	      if (this._first == null) {
	        return;
	      } else {
	        this.length--;

	        if (typeof this.decr === "function") {
	          this.decr();
	        }
	      }

	      value = this._first.value;

	      if ((this._first = this._first.next) != null) {
	        this._first.prev = null;
	      } else {
	        this._last = null;
	      }

	      return value;
	    }
	  }, {
	    key: "first",
	    value: function first() {
	      if (this._first != null) {
	        return this._first.value;
	      }
	    }
	  }, {
	    key: "getArray",
	    value: function getArray() {
	      var node, ref, results;
	      node = this._first;
	      results = [];

	      while (node != null) {
	        results.push((ref = node, node = node.next, ref.value));
	      }

	      return results;
	    }
	  }, {
	    key: "forEachShift",
	    value: function forEachShift(cb) {
	      var node;
	      node = this.shift();

	      while (node != null) {
	        cb(node), node = this.shift();
	      }

	      return void 0;
	    }
	  }, {
	    key: "debug",
	    value: function debug() {
	      var node, ref, ref1, ref2, results;
	      node = this._first;
	      results = [];

	      while (node != null) {
	        results.push((ref = node, node = node.next, {
	          value: ref.value,
	          prev: (ref1 = ref.prev) != null ? ref1.value : void 0,
	          next: (ref2 = ref.next) != null ? ref2.value : void 0
	        }));
	      }

	      return results;
	    }
	  }]);

	  return DLList;
	}();

	var DLList_1 = DLList;

	var Events;

	Events =
	/*#__PURE__*/
	function () {
	  function Events(instance) {
	    var _this = this;

	    _classCallCheck(this, Events);

	    this.instance = instance;
	    this._events = {};

	    if (this.instance.on != null || this.instance.once != null || this.instance.removeAllListeners != null) {
	      throw new Error("An Emitter already exists for this object");
	    }

	    this.instance.on = function (name, cb) {
	      return _this._addListener(name, "many", cb);
	    };

	    this.instance.once = function (name, cb) {
	      return _this._addListener(name, "once", cb);
	    };

	    this.instance.removeAllListeners = function () {
	      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

	      if (name != null) {
	        return delete _this._events[name];
	      } else {
	        return _this._events = {};
	      }
	    };
	  }

	  _createClass(Events, [{
	    key: "_addListener",
	    value: function _addListener(name, status, cb) {
	      var base;

	      if ((base = this._events)[name] == null) {
	        base[name] = [];
	      }

	      this._events[name].push({
	        cb: cb,
	        status: status
	      });

	      return this.instance;
	    }
	  }, {
	    key: "listenerCount",
	    value: function listenerCount(name) {
	      if (this._events[name] != null) {
	        return this._events[name].length;
	      } else {
	        return 0;
	      }
	    }
	  }, {
	    key: "trigger",
	    value: function () {
	      var _trigger = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee2(name) {
	        var _this2 = this;

	        var _len,
	            args,
	            _key,
	            e,
	            promises,
	            _args2 = arguments;

	        return regeneratorRuntime.wrap(function _callee2$(_context2) {
	          while (1) {
	            switch (_context2.prev = _context2.next) {
	              case 0:
	                for (_len = _args2.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	                  args[_key - 1] = _args2[_key];
	                }

	                _context2.prev = 1;

	                if (name !== "debug") {
	                  this.trigger("debug", "Event triggered: ".concat(name), args);
	                }

	                if (!(this._events[name] == null)) {
	                  _context2.next = 5;
	                  break;
	                }

	                return _context2.abrupt("return");

	              case 5:
	                this._events[name] = this._events[name].filter(function (listener) {
	                  return listener.status !== "none";
	                });
	                promises = this._events[name].map(
	                /*#__PURE__*/
	                function () {
	                  var _ref = _asyncToGenerator(
	                  /*#__PURE__*/
	                  regeneratorRuntime.mark(function _callee(listener) {
	                    var e, returned;
	                    return regeneratorRuntime.wrap(function _callee$(_context) {
	                      while (1) {
	                        switch (_context.prev = _context.next) {
	                          case 0:
	                            if (!(listener.status === "none")) {
	                              _context.next = 2;
	                              break;
	                            }

	                            return _context.abrupt("return");

	                          case 2:
	                            if (listener.status === "once") {
	                              listener.status = "none";
	                            }

	                            _context.prev = 3;
	                            returned = typeof listener.cb === "function" ? listener.cb.apply(listener, args) : void 0;

	                            if (!(typeof (returned != null ? returned.then : void 0) === "function")) {
	                              _context.next = 11;
	                              break;
	                            }

	                            _context.next = 8;
	                            return returned;

	                          case 8:
	                            return _context.abrupt("return", _context.sent);

	                          case 11:
	                            return _context.abrupt("return", returned);

	                          case 12:
	                            _context.next = 19;
	                            break;

	                          case 14:
	                            _context.prev = 14;
	                            _context.t0 = _context["catch"](3);
	                            e = _context.t0;

	                            {
	                              _this2.trigger("error", e);
	                            }

	                            return _context.abrupt("return", null);

	                          case 19:
	                          case "end":
	                            return _context.stop();
	                        }
	                      }
	                    }, _callee, null, [[3, 14]]);
	                  }));

	                  return function (_x2) {
	                    return _ref.apply(this, arguments);
	                  };
	                }());
	                _context2.next = 9;
	                return Promise.all(promises);

	              case 9:
	                _context2.t0 = function (x) {
	                  return x != null;
	                };

	                return _context2.abrupt("return", _context2.sent.find(_context2.t0));

	              case 13:
	                _context2.prev = 13;
	                _context2.t1 = _context2["catch"](1);
	                e = _context2.t1;

	                {
	                  this.trigger("error", e);
	                }

	                return _context2.abrupt("return", null);

	              case 18:
	              case "end":
	                return _context2.stop();
	            }
	          }
	        }, _callee2, this, [[1, 13]]);
	      }));

	      function trigger(_x) {
	        return _trigger.apply(this, arguments);
	      }

	      return trigger;
	    }()
	  }]);

	  return Events;
	}();

	var Events_1 = Events;

	var DLList$1, Events$1, Queues;
	DLList$1 = DLList_1;
	Events$1 = Events_1;

	Queues =
	/*#__PURE__*/
	function () {
	  function Queues(num_priorities) {
	    _classCallCheck(this, Queues);

	    var i;
	    this.Events = new Events$1(this);
	    this._length = 0;

	    this._lists = function () {
	      var _this = this;

	      var j, ref, results;
	      results = [];

	      for (i = j = 1, ref = num_priorities; 1 <= ref ? j <= ref : j >= ref; i = 1 <= ref ? ++j : --j) {
	        results.push(new DLList$1(function () {
	          return _this.incr();
	        }, function () {
	          return _this.decr();
	        }));
	      }

	      return results;
	    }.call(this);
	  }

	  _createClass(Queues, [{
	    key: "incr",
	    value: function incr() {
	      if (this._length++ === 0) {
	        return this.Events.trigger("leftzero");
	      }
	    }
	  }, {
	    key: "decr",
	    value: function decr() {
	      if (--this._length === 0) {
	        return this.Events.trigger("zero");
	      }
	    }
	  }, {
	    key: "push",
	    value: function push(job) {
	      return this._lists[job.options.priority].push(job);
	    }
	  }, {
	    key: "queued",
	    value: function queued(priority) {
	      if (priority != null) {
	        return this._lists[priority].length;
	      } else {
	        return this._length;
	      }
	    }
	  }, {
	    key: "shiftAll",
	    value: function shiftAll(fn) {
	      return this._lists.forEach(function (list) {
	        return list.forEachShift(fn);
	      });
	    }
	  }, {
	    key: "getFirst",
	    value: function getFirst() {
	      var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._lists;
	      var j, len, list;

	      for (j = 0, len = arr.length; j < len; j++) {
	        list = arr[j];

	        if (list.length > 0) {
	          return list;
	        }
	      }

	      return [];
	    }
	  }, {
	    key: "shiftLastFrom",
	    value: function shiftLastFrom(priority) {
	      return this.getFirst(this._lists.slice(priority).reverse()).shift();
	    }
	  }]);

	  return Queues;
	}();

	var Queues_1 = Queues;

	var BottleneckError;

	BottleneckError =
	/*#__PURE__*/
	function (_Error) {
	  _inherits(BottleneckError, _Error);

	  function BottleneckError() {
	    _classCallCheck(this, BottleneckError);

	    return _possibleConstructorReturn(this, _getPrototypeOf(BottleneckError).apply(this, arguments));
	  }

	  return BottleneckError;
	}(_wrapNativeSuper(Error));

	var BottleneckError_1 = BottleneckError;

	var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1;
	NUM_PRIORITIES = 10;
	DEFAULT_PRIORITY = 5;
	parser$1 = parser;
	BottleneckError$1 = BottleneckError_1;

	Job =
	/*#__PURE__*/
	function () {
	  function Job(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) {
	    var _this = this;

	    _classCallCheck(this, Job);

	    this.task = task;
	    this.args = args;
	    this.rejectOnDrop = rejectOnDrop;
	    this.Events = Events;
	    this._states = _states;
	    this.Promise = Promise;
	    this.options = parser$1.load(options, jobDefaults);
	    this.options.priority = this._sanitizePriority(this.options.priority);

	    if (this.options.id === jobDefaults.id) {
	      this.options.id = "".concat(this.options.id, "-").concat(this._randomIndex());
	    }

	    this.promise = new this.Promise(function (_resolve, _reject) {
	      _this._resolve = _resolve;
	      _this._reject = _reject;
	    });
	    this.retryCount = 0;
	  }

	  _createClass(Job, [{
	    key: "_sanitizePriority",
	    value: function _sanitizePriority(priority) {
	      var sProperty;
	      sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority;

	      if (sProperty < 0) {
	        return 0;
	      } else if (sProperty > NUM_PRIORITIES - 1) {
	        return NUM_PRIORITIES - 1;
	      } else {
	        return sProperty;
	      }
	    }
	  }, {
	    key: "_randomIndex",
	    value: function _randomIndex() {
	      return Math.random().toString(36).slice(2);
	    }
	  }, {
	    key: "doDrop",
	    value: function doDrop() {
	      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
	          error = _ref.error,
	          _ref$message = _ref.message,
	          message = _ref$message === void 0 ? "This job has been dropped by Bottleneck" : _ref$message;

	      if (this._states.remove(this.options.id)) {
	        if (this.rejectOnDrop) {
	          this._reject(error != null ? error : new BottleneckError$1(message));
	        }

	        this.Events.trigger("dropped", {
	          args: this.args,
	          options: this.options,
	          task: this.task,
	          promise: this.promise
	        });
	        return true;
	      } else {
	        return false;
	      }
	    }
	  }, {
	    key: "_assertStatus",
	    value: function _assertStatus(expected) {
	      var status;
	      status = this._states.jobStatus(this.options.id);

	      if (!(status === expected || expected === "DONE" && status === null)) {
	        throw new BottleneckError$1("Invalid job status ".concat(status, ", expected ").concat(expected, ". Please open an issue at https://github.com/SGrondin/bottleneck/issues"));
	      }
	    }
	  }, {
	    key: "doReceive",
	    value: function doReceive() {
	      this._states.start(this.options.id);

	      return this.Events.trigger("received", {
	        args: this.args,
	        options: this.options
	      });
	    }
	  }, {
	    key: "doQueue",
	    value: function doQueue(reachedHWM, blocked) {
	      this._assertStatus("RECEIVED");

	      this._states.next(this.options.id);

	      return this.Events.trigger("queued", {
	        args: this.args,
	        options: this.options,
	        reachedHWM: reachedHWM,
	        blocked: blocked
	      });
	    }
	  }, {
	    key: "doRun",
	    value: function doRun() {
	      if (this.retryCount === 0) {
	        this._assertStatus("QUEUED");

	        this._states.next(this.options.id);
	      } else {
	        this._assertStatus("EXECUTING");
	      }

	      return this.Events.trigger("scheduled", {
	        args: this.args,
	        options: this.options
	      });
	    }
	  }, {
	    key: "doExecute",
	    value: function () {
	      var _doExecute = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee(chained, clearGlobalState, run, free) {
	        var error, eventInfo, passed;
	        return regeneratorRuntime.wrap(function _callee$(_context) {
	          while (1) {
	            switch (_context.prev = _context.next) {
	              case 0:
	                if (this.retryCount === 0) {
	                  this._assertStatus("RUNNING");

	                  this._states.next(this.options.id);
	                } else {
	                  this._assertStatus("EXECUTING");
	                }

	                eventInfo = {
	                  args: this.args,
	                  options: this.options,
	                  retryCount: this.retryCount
	                };
	                this.Events.trigger("executing", eventInfo);
	                _context.prev = 3;
	                _context.next = 6;
	                return chained != null ? chained.schedule.apply(chained, [this.options, this.task].concat(_toConsumableArray(this.args))) : this.task.apply(this, _toConsumableArray(this.args));

	              case 6:
	                passed = _context.sent;

	                if (!clearGlobalState()) {
	                  _context.next = 13;
	                  break;
	                }

	                this.doDone(eventInfo);
	                _context.next = 11;
	                return free(this.options, eventInfo);

	              case 11:
	                this._assertStatus("DONE");

	                return _context.abrupt("return", this._resolve(passed));

	              case 13:
	                _context.next = 19;
	                break;

	              case 15:
	                _context.prev = 15;
	                _context.t0 = _context["catch"](3);
	                error = _context.t0;
	                return _context.abrupt("return", this._onFailure(error, eventInfo, clearGlobalState, run, free));

	              case 19:
	              case "end":
	                return _context.stop();
	            }
	          }
	        }, _callee, this, [[3, 15]]);
	      }));

	      function doExecute(_x, _x2, _x3, _x4) {
	        return _doExecute.apply(this, arguments);
	      }

	      return doExecute;
	    }()
	  }, {
	    key: "doExpire",
	    value: function doExpire(clearGlobalState, run, free) {
	      var error, eventInfo;

	      if (this._states.jobStatus(this.options.id === "RUNNING")) {
	        this._states.next(this.options.id);
	      }

	      this._assertStatus("EXECUTING");

	      eventInfo = {
	        args: this.args,
	        options: this.options,
	        retryCount: this.retryCount
	      };
	      error = new BottleneckError$1("This job timed out after ".concat(this.options.expiration, " ms."));
	      return this._onFailure(error, eventInfo, clearGlobalState, run, free);
	    }
	  }, {
	    key: "_onFailure",
	    value: function () {
	      var _onFailure2 = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee2(error, eventInfo, clearGlobalState, run, free) {
	        var retry, retryAfter;
	        return regeneratorRuntime.wrap(function _callee2$(_context2) {
	          while (1) {
	            switch (_context2.prev = _context2.next) {
	              case 0:
	                if (!clearGlobalState()) {
	                  _context2.next = 16;
	                  break;
	                }

	                _context2.next = 3;
	                return this.Events.trigger("failed", error, eventInfo);

	              case 3:
	                retry = _context2.sent;

	                if (!(retry != null)) {
	                  _context2.next = 11;
	                  break;
	                }

	                retryAfter = ~~retry;
	                this.Events.trigger("retry", "Retrying ".concat(this.options.id, " after ").concat(retryAfter, " ms"), eventInfo);
	                this.retryCount++;
	                return _context2.abrupt("return", run(retryAfter));

	              case 11:
	                this.doDone(eventInfo);
	                _context2.next = 14;
	                return free(this.options, eventInfo);

	              case 14:
	                this._assertStatus("DONE");

	                return _context2.abrupt("return", this._reject(error));

	              case 16:
	              case "end":
	                return _context2.stop();
	            }
	          }
	        }, _callee2, this);
	      }));

	      function _onFailure(_x5, _x6, _x7, _x8, _x9) {
	        return _onFailure2.apply(this, arguments);
	      }

	      return _onFailure;
	    }()
	  }, {
	    key: "doDone",
	    value: function doDone(eventInfo) {
	      this._assertStatus("EXECUTING");

	      this._states.next(this.options.id);

	      return this.Events.trigger("done", eventInfo);
	    }
	  }]);

	  return Job;
	}();

	var Job_1 = Job;

	var BottleneckError$2, LocalDatastore, parser$2;
	parser$2 = parser;
	BottleneckError$2 = BottleneckError_1;

	LocalDatastore =
	/*#__PURE__*/
	function () {
	  function LocalDatastore(instance, storeOptions, storeInstanceOptions) {
	    _classCallCheck(this, LocalDatastore);

	    this.instance = instance;
	    this.storeOptions = storeOptions;
	    this.clientId = this.instance._randomIndex();
	    parser$2.load(storeInstanceOptions, storeInstanceOptions, this);
	    this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now();
	    this._running = 0;
	    this._done = 0;
	    this._unblockTime = 0;
	    this.ready = this.Promise.resolve();
	    this.clients = {};

	    this._startHeartbeat();
	  }

	  _createClass(LocalDatastore, [{
	    key: "_startHeartbeat",
	    value: function _startHeartbeat() {
	      var _this = this;

	      var base;

	      if (this.heartbeat == null && (this.storeOptions.reservoirRefreshInterval != null && this.storeOptions.reservoirRefreshAmount != null || this.storeOptions.reservoirIncreaseInterval != null && this.storeOptions.reservoirIncreaseAmount != null)) {
	        return typeof (base = this.heartbeat = setInterval(function () {
	          var amount, incr, maximum, now, reservoir;
	          now = Date.now();

	          if (_this.storeOptions.reservoirRefreshInterval != null && now >= _this._lastReservoirRefresh + _this.storeOptions.reservoirRefreshInterval) {
	            _this._lastReservoirRefresh = now;
	            _this.storeOptions.reservoir = _this.storeOptions.reservoirRefreshAmount;

	            _this.instance._drainAll(_this.computeCapacity());
	          }

	          if (_this.storeOptions.reservoirIncreaseInterval != null && now >= _this._lastReservoirIncrease + _this.storeOptions.reservoirIncreaseInterval) {
	            var _this$storeOptions = _this.storeOptions;
	            amount = _this$storeOptions.reservoirIncreaseAmount;
	            maximum = _this$storeOptions.reservoirIncreaseMaximum;
	            reservoir = _this$storeOptions.reservoir;
	            _this._lastReservoirIncrease = now;
	            incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount;

	            if (incr > 0) {
	              _this.storeOptions.reservoir += incr;
	              return _this.instance._drainAll(_this.computeCapacity());
	            }
	          }
	        }, this.heartbeatInterval)).unref === "function" ? base.unref() : void 0;
	      } else {
	        return clearInterval(this.heartbeat);
	      }
	    }
	  }, {
	    key: "__publish__",
	    value: function () {
	      var _publish__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee(message) {
	        return regeneratorRuntime.wrap(function _callee$(_context) {
	          while (1) {
	            switch (_context.prev = _context.next) {
	              case 0:
	                _context.next = 2;
	                return this.yieldLoop();

	              case 2:
	                return _context.abrupt("return", this.instance.Events.trigger("message", message.toString()));

	              case 3:
	              case "end":
	                return _context.stop();
	            }
	          }
	        }, _callee, this);
	      }));

	      function __publish__(_x) {
	        return _publish__.apply(this, arguments);
	      }

	      return __publish__;
	    }()
	  }, {
	    key: "__disconnect__",
	    value: function () {
	      var _disconnect__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee2(flush) {
	        return regeneratorRuntime.wrap(function _callee2$(_context2) {
	          while (1) {
	            switch (_context2.prev = _context2.next) {
	              case 0:
	                _context2.next = 2;
	                return this.yieldLoop();

	              case 2:
	                clearInterval(this.heartbeat);
	                return _context2.abrupt("return", this.Promise.resolve());

	              case 4:
	              case "end":
	                return _context2.stop();
	            }
	          }
	        }, _callee2, this);
	      }));

	      function __disconnect__(_x2) {
	        return _disconnect__.apply(this, arguments);
	      }

	      return __disconnect__;
	    }()
	  }, {
	    key: "yieldLoop",
	    value: function yieldLoop() {
	      var t = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
	      return new this.Promise(function (resolve, reject) {
	        return setTimeout(resolve, t);
	      });
	    }
	  }, {
	    key: "computePenalty",
	    value: function computePenalty() {
	      var ref;
	      return (ref = this.storeOptions.penalty) != null ? ref : 15 * this.storeOptions.minTime || 5000;
	    }
	  }, {
	    key: "__updateSettings__",
	    value: function () {
	      var _updateSettings__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee3(options) {
	        return regeneratorRuntime.wrap(function _callee3$(_context3) {
	          while (1) {
	            switch (_context3.prev = _context3.next) {
	              case 0:
	                _context3.next = 2;
	                return this.yieldLoop();

	              case 2:
	                parser$2.overwrite(options, options, this.storeOptions);

	                this._startHeartbeat();

	                this.instance._drainAll(this.computeCapacity());

	                return _context3.abrupt("return", true);

	              case 6:
	              case "end":
	                return _context3.stop();
	            }
	          }
	        }, _callee3, this);
	      }));

	      function __updateSettings__(_x3) {
	        return _updateSettings__.apply(this, arguments);
	      }

	      return __updateSettings__;
	    }()
	  }, {
	    key: "__running__",
	    value: function () {
	      var _running__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee4() {
	        return regeneratorRuntime.wrap(function _callee4$(_context4) {
	          while (1) {
	            switch (_context4.prev = _context4.next) {
	              case 0:
	                _context4.next = 2;
	                return this.yieldLoop();

	              case 2:
	                return _context4.abrupt("return", this._running);

	              case 3:
	              case "end":
	                return _context4.stop();
	            }
	          }
	        }, _callee4, this);
	      }));

	      function __running__() {
	        return _running__.apply(this, arguments);
	      }

	      return __running__;
	    }()
	  }, {
	    key: "__queued__",
	    value: function () {
	      var _queued__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee5() {
	        return regeneratorRuntime.wrap(function _callee5$(_context5) {
	          while (1) {
	            switch (_context5.prev = _context5.next) {
	              case 0:
	                _context5.next = 2;
	                return this.yieldLoop();

	              case 2:
	                return _context5.abrupt("return", this.instance.queued());

	              case 3:
	              case "end":
	                return _context5.stop();
	            }
	          }
	        }, _callee5, this);
	      }));

	      function __queued__() {
	        return _queued__.apply(this, arguments);
	      }

	      return __queued__;
	    }()
	  }, {
	    key: "__done__",
	    value: function () {
	      var _done__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee6() {
	        return regeneratorRuntime.wrap(function _callee6$(_context6) {
	          while (1) {
	            switch (_context6.prev = _context6.next) {
	              case 0:
	                _context6.next = 2;
	                return this.yieldLoop();

	              case 2:
	                return _context6.abrupt("return", this._done);

	              case 3:
	              case "end":
	                return _context6.stop();
	            }
	          }
	        }, _callee6, this);
	      }));

	      function __done__() {
	        return _done__.apply(this, arguments);
	      }

	      return __done__;
	    }()
	  }, {
	    key: "__groupCheck__",
	    value: function () {
	      var _groupCheck__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee7(time) {
	        return regeneratorRuntime.wrap(function _callee7$(_context7) {
	          while (1) {
	            switch (_context7.prev = _context7.next) {
	              case 0:
	                _context7.next = 2;
	                return this.yieldLoop();

	              case 2:
	                return _context7.abrupt("return", this._nextRequest + this.timeout < time);

	              case 3:
	              case "end":
	                return _context7.stop();
	            }
	          }
	        }, _callee7, this);
	      }));

	      function __groupCheck__(_x4) {
	        return _groupCheck__.apply(this, arguments);
	      }

	      return __groupCheck__;
	    }()
	  }, {
	    key: "computeCapacity",
	    value: function computeCapacity() {
	      var maxConcurrent, reservoir;
	      var _this$storeOptions2 = this.storeOptions;
	      maxConcurrent = _this$storeOptions2.maxConcurrent;
	      reservoir = _this$storeOptions2.reservoir;

	      if (maxConcurrent != null && reservoir != null) {
	        return Math.min(maxConcurrent - this._running, reservoir);
	      } else if (maxConcurrent != null) {
	        return maxConcurrent - this._running;
	      } else if (reservoir != null) {
	        return reservoir;
	      } else {
	        return null;
	      }
	    }
	  }, {
	    key: "conditionsCheck",
	    value: function conditionsCheck(weight) {
	      var capacity;
	      capacity = this.computeCapacity();
	      return capacity == null || weight <= capacity;
	    }
	  }, {
	    key: "__incrementReservoir__",
	    value: function () {
	      var _incrementReservoir__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee8(incr) {
	        var reservoir;
	        return regeneratorRuntime.wrap(function _callee8$(_context8) {
	          while (1) {
	            switch (_context8.prev = _context8.next) {
	              case 0:
	                _context8.next = 2;
	                return this.yieldLoop();

	              case 2:
	                reservoir = this.storeOptions.reservoir += incr;

	                this.instance._drainAll(this.computeCapacity());

	                return _context8.abrupt("return", reservoir);

	              case 5:
	              case "end":
	                return _context8.stop();
	            }
	          }
	        }, _callee8, this);
	      }));

	      function __incrementReservoir__(_x5) {
	        return _incrementReservoir__.apply(this, arguments);
	      }

	      return __incrementReservoir__;
	    }()
	  }, {
	    key: "__currentReservoir__",
	    value: function () {
	      var _currentReservoir__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee9() {
	        return regeneratorRuntime.wrap(function _callee9$(_context9) {
	          while (1) {
	            switch (_context9.prev = _context9.next) {
	              case 0:
	                _context9.next = 2;
	                return this.yieldLoop();

	              case 2:
	                return _context9.abrupt("return", this.storeOptions.reservoir);

	              case 3:
	              case "end":
	                return _context9.stop();
	            }
	          }
	        }, _callee9, this);
	      }));

	      function __currentReservoir__() {
	        return _currentReservoir__.apply(this, arguments);
	      }

	      return __currentReservoir__;
	    }()
	  }, {
	    key: "isBlocked",
	    value: function isBlocked(now) {
	      return this._unblockTime >= now;
	    }
	  }, {
	    key: "check",
	    value: function check(weight, now) {
	      return this.conditionsCheck(weight) && this._nextRequest - now <= 0;
	    }
	  }, {
	    key: "__check__",
	    value: function () {
	      var _check__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee10(weight) {
	        var now;
	        return regeneratorRuntime.wrap(function _callee10$(_context10) {
	          while (1) {
	            switch (_context10.prev = _context10.next) {
	              case 0:
	                _context10.next = 2;
	                return this.yieldLoop();

	              case 2:
	                now = Date.now();
	                return _context10.abrupt("return", this.check(weight, now));

	              case 4:
	              case "end":
	                return _context10.stop();
	            }
	          }
	        }, _callee10, this);
	      }));

	      function __check__(_x6) {
	        return _check__.apply(this, arguments);
	      }

	      return __check__;
	    }()
	  }, {
	    key: "__register__",
	    value: function () {
	      var _register__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee11(index, weight, expiration) {
	        var now, wait;
	        return regeneratorRuntime.wrap(function _callee11$(_context11) {
	          while (1) {
	            switch (_context11.prev = _context11.next) {
	              case 0:
	                _context11.next = 2;
	                return this.yieldLoop();

	              case 2:
	                now = Date.now();

	                if (!this.conditionsCheck(weight)) {
	                  _context11.next = 11;
	                  break;
	                }

	                this._running += weight;

	                if (this.storeOptions.reservoir != null) {
	                  this.storeOptions.reservoir -= weight;
	                }

	                wait = Math.max(this._nextRequest - now, 0);
	                this._nextRequest = now + wait + this.storeOptions.minTime;
	                return _context11.abrupt("return", {
	                  success: true,
	                  wait: wait,
	                  reservoir: this.storeOptions.reservoir
	                });

	              case 11:
	                return _context11.abrupt("return", {
	                  success: false
	                });

	              case 12:
	              case "end":
	                return _context11.stop();
	            }
	          }
	        }, _callee11, this);
	      }));

	      function __register__(_x7, _x8, _x9) {
	        return _register__.apply(this, arguments);
	      }

	      return __register__;
	    }()
	  }, {
	    key: "strategyIsBlock",
	    value: function strategyIsBlock() {
	      return this.storeOptions.strategy === 3;
	    }
	  }, {
	    key: "__submit__",
	    value: function () {
	      var _submit__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee12(queueLength, weight) {
	        var blocked, now, reachedHWM;
	        return regeneratorRuntime.wrap(function _callee12$(_context12) {
	          while (1) {
	            switch (_context12.prev = _context12.next) {
	              case 0:
	                _context12.next = 2;
	                return this.yieldLoop();

	              case 2:
	                if (!(this.storeOptions.maxConcurrent != null && weight > this.storeOptions.maxConcurrent)) {
	                  _context12.next = 4;
	                  break;
	                }

	                throw new BottleneckError$2("Impossible to add a job having a weight of ".concat(weight, " to a limiter having a maxConcurrent setting of ").concat(this.storeOptions.maxConcurrent));

	              case 4:
	                now = Date.now();
	                reachedHWM = this.storeOptions.highWater != null && queueLength === this.storeOptions.highWater && !this.check(weight, now);
	                blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now));

	                if (blocked) {
	                  this._unblockTime = now + this.computePenalty();
	                  this._nextRequest = this._unblockTime + this.storeOptions.minTime;

	                  this.instance._dropAllQueued();
	                }

	                return _context12.abrupt("return", {
	                  reachedHWM: reachedHWM,
	                  blocked: blocked,
	                  strategy: this.storeOptions.strategy
	                });

	              case 9:
	              case "end":
	                return _context12.stop();
	            }
	          }
	        }, _callee12, this);
	      }));

	      function __submit__(_x10, _x11) {
	        return _submit__.apply(this, arguments);
	      }

	      return __submit__;
	    }()
	  }, {
	    key: "__free__",
	    value: function () {
	      var _free__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee13(index, weight) {
	        return regeneratorRuntime.wrap(function _callee13$(_context13) {
	          while (1) {
	            switch (_context13.prev = _context13.next) {
	              case 0:
	                _context13.next = 2;
	                return this.yieldLoop();

	              case 2:
	                this._running -= weight;
	                this._done += weight;

	                this.instance._drainAll(this.computeCapacity());

	                return _context13.abrupt("return", {
	                  running: this._running
	                });

	              case 6:
	              case "end":
	                return _context13.stop();
	            }
	          }
	        }, _callee13, this);
	      }));

	      function __free__(_x12, _x13) {
	        return _free__.apply(this, arguments);
	      }

	      return __free__;
	    }()
	  }]);

	  return LocalDatastore;
	}();

	var LocalDatastore_1 = LocalDatastore;

	var lua = {
		"blacklist_client.lua": "local blacklist = ARGV[num_static_argv + 1]\n\nif redis.call('zscore', client_last_seen_key, blacklist) then\n  redis.call('zadd', client_last_seen_key, 0, blacklist)\nend\n\n\nreturn {}\n",
		"check.lua": "local weight = tonumber(ARGV[num_static_argv + 1])\n\nlocal capacity = process_tick(now, false)['capacity']\nlocal nextRequest = tonumber(redis.call('hget', settings_key, 'nextRequest'))\n\nreturn conditions_check(capacity, weight) and nextRequest - now <= 0\n",
		"conditions_check.lua": "local conditions_check = function (capacity, weight)\n  return capacity == nil or weight <= capacity\nend\n",
		"current_reservoir.lua": "return process_tick(now, false)['reservoir']\n",
		"done.lua": "process_tick(now, false)\n\nreturn tonumber(redis.call('hget', settings_key, 'done'))\n",
		"free.lua": "local index = ARGV[num_static_argv + 1]\n\nredis.call('zadd', job_expirations_key, 0, index)\n\nreturn process_tick(now, false)['running']\n",
		"get_time.lua": "redis.replicate_commands()\n\nlocal get_time = function ()\n  local time = redis.call('time')\n\n  return tonumber(time[1]..string.sub(time[2], 1, 3))\nend\n",
		"group_check.lua": "return not (redis.call('exists', settings_key) == 1)\n",
		"heartbeat.lua": "process_tick(now, true)\n",
		"increment_reservoir.lua": "local incr = tonumber(ARGV[num_static_argv + 1])\n\nredis.call('hincrby', settings_key, 'reservoir', incr)\n\nlocal reservoir = process_tick(now, true)['reservoir']\n\nlocal groupTimeout = tonumber(redis.call('hget', settings_key, 'groupTimeout'))\nrefresh_expiration(0, 0, groupTimeout)\n\nreturn reservoir\n",
		"init.lua": "local clear = tonumber(ARGV[num_static_argv + 1])\nlocal limiter_version = ARGV[num_static_argv + 2]\nlocal num_local_argv = num_static_argv + 2\n\nif clear == 1 then\n  redis.call('del', unpack(KEYS))\nend\n\nif redis.call('exists', settings_key) == 0 then\n  -- Create\n  local args = {'hmset', settings_key}\n\n  for i = num_local_argv + 1, #ARGV do\n    table.insert(args, ARGV[i])\n  end\n\n  redis.call(unpack(args))\n  redis.call('hmset', settings_key,\n    'nextRequest', now,\n    'lastReservoirRefresh', now,\n    'lastReservoirIncrease', now,\n    'running', 0,\n    'done', 0,\n    'unblockTime', 0,\n    'capacityPriorityCounter', 0\n  )\n\nelse\n  -- Apply migrations\n  local settings = redis.call('hmget', settings_key,\n    'id',\n    'version'\n  )\n  local id = settings[1]\n  local current_version = settings[2]\n\n  if current_version ~= limiter_version then\n    local version_digits = {}\n    for k, v in string.gmatch(current_version, \"([^.]+)\") do\n      table.insert(version_digits, tonumber(k))\n    end\n\n    -- 2.10.0\n    if version_digits[2] < 10 then\n      redis.call('hsetnx', settings_key, 'reservoirRefreshInterval', '')\n      redis.call('hsetnx', settings_key, 'reservoirRefreshAmount', '')\n      redis.call('hsetnx', settings_key, 'lastReservoirRefresh', '')\n      redis.call('hsetnx', settings_key, 'done', 0)\n      redis.call('hset', settings_key, 'version', '2.10.0')\n    end\n\n    -- 2.11.1\n    if version_digits[2] < 11 or (version_digits[2] == 11 and version_digits[3] < 1) then\n      if redis.call('hstrlen', settings_key, 'lastReservoirRefresh') == 0 then\n        redis.call('hmset', settings_key,\n          'lastReservoirRefresh', now,\n          'version', '2.11.1'\n        )\n      end\n    end\n\n    -- 2.14.0\n    if version_digits[2] < 14 then\n      local old_running_key = 'b_'..id..'_running'\n      local old_executing_key = 'b_'..id..'_executing'\n\n      if redis.call('exists', old_running_key) == 1 then\n        redis.call('rename', old_running_key, job_weights_key)\n      end\n      if redis.call('exists', old_executing_key) == 1 then\n        redis.call('rename', old_executing_key, job_expirations_key)\n      end\n      redis.call('hset', settings_key, 'version', '2.14.0')\n    end\n\n    -- 2.15.2\n    if version_digits[2] < 15 or (version_digits[2] == 15 and version_digits[3] < 2) then\n      redis.call('hsetnx', settings_key, 'capacityPriorityCounter', 0)\n      redis.call('hset', settings_key, 'version', '2.15.2')\n    end\n\n    -- 2.17.0\n    if version_digits[2] < 17 then\n      redis.call('hsetnx', settings_key, 'clientTimeout', 10000)\n      redis.call('hset', settings_key, 'version', '2.17.0')\n    end\n\n    -- 2.18.0\n    if version_digits[2] < 18 then\n      redis.call('hsetnx', settings_key, 'reservoirIncreaseInterval', '')\n      redis.call('hsetnx', settings_key, 'reservoirIncreaseAmount', '')\n      redis.call('hsetnx', settings_key, 'reservoirIncreaseMaximum', '')\n      redis.call('hsetnx', settings_key, 'lastReservoirIncrease', now)\n      redis.call('hset', settings_key, 'version', '2.18.0')\n    end\n\n  end\n\n  process_tick(now, false)\nend\n\nlocal groupTimeout = tonumber(redis.call('hget', settings_key, 'groupTimeout'))\nrefresh_expiration(0, 0, groupTimeout)\n\nreturn {}\n",
		"process_tick.lua": "local process_tick = function (now, always_publish)\n\n  local compute_capacity = function (maxConcurrent, running, reservoir)\n    if maxConcurrent ~= nil and reservoir ~= nil then\n      return math.min((maxConcurrent - running), reservoir)\n    elseif maxConcurrent ~= nil then\n      return maxConcurrent - running\n    elseif reservoir ~= nil then\n      return reservoir\n    else\n      return nil\n    end\n  end\n\n  local settings = redis.call('hmget', settings_key,\n    'id',\n    'maxConcurrent',\n    'running',\n    'reservoir',\n    'reservoirRefreshInterval',\n    'reservoirRefreshAmount',\n    'lastReservoirRefresh',\n    'reservoirIncreaseInterval',\n    'reservoirIncreaseAmount',\n    'reservoirIncreaseMaximum',\n    'lastReservoirIncrease',\n    'capacityPriorityCounter',\n    'clientTimeout'\n  )\n  local id = settings[1]\n  local maxConcurrent = tonumber(settings[2])\n  local running = tonumber(settings[3])\n  local reservoir = tonumber(settings[4])\n  local reservoirRefreshInterval = tonumber(settings[5])\n  local reservoirRefreshAmount = tonumber(settings[6])\n  local lastReservoirRefresh = tonumber(settings[7])\n  local reservoirIncreaseInterval = tonumber(settings[8])\n  local reservoirIncreaseAmount = tonumber(settings[9])\n  local reservoirIncreaseMaximum = tonumber(settings[10])\n  local lastReservoirIncrease = tonumber(settings[11])\n  local capacityPriorityCounter = tonumber(settings[12])\n  local clientTimeout = tonumber(settings[13])\n\n  local initial_capacity = compute_capacity(maxConcurrent, running, reservoir)\n\n  --\n  -- Process 'running' changes\n  --\n  local expired = redis.call('zrangebyscore', job_expirations_key, '-inf', '('..now)\n\n  if #expired > 0 then\n    redis.call('zremrangebyscore', job_expirations_key, '-inf', '('..now)\n\n    local flush_batch = function (batch, acc)\n      local weights = redis.call('hmget', job_weights_key, unpack(batch))\n                      redis.call('hdel',  job_weights_key, unpack(batch))\n      local clients = redis.call('hmget', job_clients_key, unpack(batch))\n                      redis.call('hdel',  job_clients_key, unpack(batch))\n\n      -- Calculate sum of removed weights\n      for i = 1, #weights do\n        acc['total'] = acc['total'] + (tonumber(weights[i]) or 0)\n      end\n\n      -- Calculate sum of removed weights by client\n      local client_weights = {}\n      for i = 1, #clients do\n        local removed = tonumber(weights[i]) or 0\n        if removed > 0 then\n          acc['client_weights'][clients[i]] = (acc['client_weights'][clients[i]] or 0) + removed\n        end\n      end\n    end\n\n    local acc = {\n      ['total'] = 0,\n      ['client_weights'] = {}\n    }\n    local batch_size = 1000\n\n    -- Compute changes to Zsets and apply changes to Hashes\n    for i = 1, #expired, batch_size do\n      local batch = {}\n      for j = i, math.min(i + batch_size - 1, #expired) do\n        table.insert(batch, expired[j])\n      end\n\n      flush_batch(batch, acc)\n    end\n\n    -- Apply changes to Zsets\n    if acc['total'] > 0 then\n      redis.call('hincrby', settings_key, 'done', acc['total'])\n      running = tonumber(redis.call('hincrby', settings_key, 'running', -acc['total']))\n    end\n\n    for client, weight in pairs(acc['client_weights']) do\n      redis.call('zincrby', client_running_key, -weight, client)\n    end\n  end\n\n  --\n  -- Process 'reservoir' changes\n  --\n  local reservoirRefreshActive = reservoirRefreshInterval ~= nil and reservoirRefreshAmount ~= nil\n  if reservoirRefreshActive and now >= lastReservoirRefresh + reservoirRefreshInterval then\n    reservoir = reservoirRefreshAmount\n    redis.call('hmset', settings_key,\n      'reservoir', reservoir,\n      'lastReservoirRefresh', now\n    )\n  end\n\n  local reservoirIncreaseActive = reservoirIncreaseInterval ~= nil and reservoirIncreaseAmount ~= nil\n  if reservoirIncreaseActive and now >= lastReservoirIncrease + reservoirIncreaseInterval then\n    local num_intervals = math.floor((now - lastReservoirIncrease) / reservoirIncreaseInterval)\n    local incr = reservoirIncreaseAmount * num_intervals\n    if reservoirIncreaseMaximum ~= nil then\n      incr = math.min(incr, reservoirIncreaseMaximum - (reservoir or 0))\n    end\n    if incr > 0 then\n      reservoir = (reservoir or 0) + incr\n    end\n    redis.call('hmset', settings_key,\n      'reservoir', reservoir,\n      'lastReservoirIncrease', lastReservoirIncrease + (num_intervals * reservoirIncreaseInterval)\n    )\n  end\n\n  --\n  -- Clear unresponsive clients\n  --\n  local unresponsive = redis.call('zrangebyscore', client_last_seen_key, '-inf', (now - clientTimeout))\n  local unresponsive_lookup = {}\n  local terminated_clients = {}\n  for i = 1, #unresponsive do\n    unresponsive_lookup[unresponsive[i]] = true\n    if tonumber(redis.call('zscore', client_running_key, unresponsive[i])) == 0 then\n      table.insert(terminated_clients, unresponsive[i])\n    end\n  end\n  if #terminated_clients > 0 then\n    redis.call('zrem', client_running_key,         unpack(terminated_clients))\n    redis.call('hdel', client_num_queued_key,      unpack(terminated_clients))\n    redis.call('zrem', client_last_registered_key, unpack(terminated_clients))\n    redis.call('zrem', client_last_seen_key,       unpack(terminated_clients))\n  end\n\n  --\n  -- Broadcast capacity changes\n  --\n  local final_capacity = compute_capacity(maxConcurrent, running, reservoir)\n\n  if always_publish or (initial_capacity ~= nil and final_capacity == nil) then\n    -- always_publish or was not unlimited, now unlimited\n    redis.call('publish', 'b_'..id, 'capacity:'..(final_capacity or ''))\n\n  elseif initial_capacity ~= nil and final_capacity ~= nil and final_capacity > initial_capacity then\n    -- capacity was increased\n    -- send the capacity message to the limiter having the lowest number of running jobs\n    -- the tiebreaker is the limiter having not registered a job in the longest time\n\n    local lowest_concurrency_value = nil\n    local lowest_concurrency_clients = {}\n    local lowest_concurrency_last_registered = {}\n    local client_concurrencies = redis.call('zrange', client_running_key, 0, -1, 'withscores')\n\n    for i = 1, #client_concurrencies, 2 do\n      local client = client_concurrencies[i]\n      local concurrency = tonumber(client_concurrencies[i+1])\n\n      if (\n        lowest_concurrency_value == nil or lowest_concurrency_value == concurrency\n      ) and (\n        not unresponsive_lookup[client]\n      ) and (\n        tonumber(redis.call('hget', client_num_queued_key, client)) > 0\n      ) then\n        lowest_concurrency_value = concurrency\n        table.insert(lowest_concurrency_clients, client)\n        local last_registered = tonumber(redis.call('zscore', client_last_registered_key, client))\n        table.insert(lowest_concurrency_last_registered, last_registered)\n      end\n    end\n\n    if #lowest_concurrency_clients > 0 then\n      local position = 1\n      local earliest = lowest_concurrency_last_registered[1]\n\n      for i,v in ipairs(lowest_concurrency_last_registered) do\n        if v < earliest then\n          position = i\n          earliest = v\n        end\n      end\n\n      local next_client = lowest_concurrency_clients[position]\n      redis.call('publish', 'b_'..id,\n        'capacity-priority:'..(final_capacity or '')..\n        ':'..next_client..\n        ':'..capacityPriorityCounter\n      )\n      redis.call('hincrby', settings_key, 'capacityPriorityCounter', '1')\n    else\n      redis.call('publish', 'b_'..id, 'capacity:'..(final_capacity or ''))\n    end\n  end\n\n  return {\n    ['capacity'] = final_capacity,\n    ['running'] = running,\n    ['reservoir'] = reservoir\n  }\nend\n",
		"queued.lua": "local clientTimeout = tonumber(redis.call('hget', settings_key, 'clientTimeout'))\nlocal valid_clients = redis.call('zrangebyscore', client_last_seen_key, (now - clientTimeout), 'inf')\nlocal client_queued = redis.call('hmget', client_num_queued_key, unpack(valid_clients))\n\nlocal sum = 0\nfor i = 1, #client_queued do\n  sum = sum + tonumber(client_queued[i])\nend\n\nreturn sum\n",
		"refresh_expiration.lua": "local refresh_expiration = function (now, nextRequest, groupTimeout)\n\n  if groupTimeout ~= nil then\n    local ttl = (nextRequest + groupTimeout) - now\n\n    for i = 1, #KEYS do\n      redis.call('pexpire', KEYS[i], ttl)\n    end\n  end\n\nend\n",
		"refs.lua": "local settings_key = KEYS[1]\nlocal job_weights_key = KEYS[2]\nlocal job_expirations_key = KEYS[3]\nlocal job_clients_key = KEYS[4]\nlocal client_running_key = KEYS[5]\nlocal client_num_queued_key = KEYS[6]\nlocal client_last_registered_key = KEYS[7]\nlocal client_last_seen_key = KEYS[8]\n\nlocal now = tonumber(ARGV[1])\nlocal client = ARGV[2]\n\nlocal num_static_argv = 2\n",
		"register.lua": "local index = ARGV[num_static_argv + 1]\nlocal weight = tonumber(ARGV[num_static_argv + 2])\nlocal expiration = tonumber(ARGV[num_static_argv + 3])\n\nlocal state = process_tick(now, false)\nlocal capacity = state['capacity']\nlocal reservoir = state['reservoir']\n\nlocal settings = redis.call('hmget', settings_key,\n  'nextRequest',\n  'minTime',\n  'groupTimeout'\n)\nlocal nextRequest = tonumber(settings[1])\nlocal minTime = tonumber(settings[2])\nlocal groupTimeout = tonumber(settings[3])\n\nif conditions_check(capacity, weight) then\n\n  redis.call('hincrby', settings_key, 'running', weight)\n  redis.call('hset', job_weights_key, index, weight)\n  if expiration ~= nil then\n    redis.call('zadd', job_expirations_key, now + expiration, index)\n  end\n  redis.call('hset', job_clients_key, index, client)\n  redis.call('zincrby', client_running_key, weight, client)\n  redis.call('hincrby', client_num_queued_key, client, -1)\n  redis.call('zadd', client_last_registered_key, now, client)\n\n  local wait = math.max(nextRequest - now, 0)\n  local newNextRequest = now + wait + minTime\n\n  if reservoir == nil then\n    redis.call('hset', settings_key,\n      'nextRequest', newNextRequest\n    )\n  else\n    reservoir = reservoir - weight\n    redis.call('hmset', settings_key,\n      'reservoir', reservoir,\n      'nextRequest', newNextRequest\n    )\n  end\n\n  refresh_expiration(now, newNextRequest, groupTimeout)\n\n  return {true, wait, reservoir}\n\nelse\n  return {false}\nend\n",
		"register_client.lua": "local queued = tonumber(ARGV[num_static_argv + 1])\n\n-- Could have been re-registered concurrently\nif not redis.call('zscore', client_last_seen_key, client) then\n  redis.call('zadd', client_running_key, 0, client)\n  redis.call('hset', client_num_queued_key, client, queued)\n  redis.call('zadd', client_last_registered_key, 0, client)\nend\n\nredis.call('zadd', client_last_seen_key, now, client)\n\nreturn {}\n",
		"running.lua": "return process_tick(now, false)['running']\n",
		"submit.lua": "local queueLength = tonumber(ARGV[num_static_argv + 1])\nlocal weight = tonumber(ARGV[num_static_argv + 2])\n\nlocal capacity = process_tick(now, false)['capacity']\n\nlocal settings = redis.call('hmget', settings_key,\n  'id',\n  'maxConcurrent',\n  'highWater',\n  'nextRequest',\n  'strategy',\n  'unblockTime',\n  'penalty',\n  'minTime',\n  'groupTimeout'\n)\nlocal id = settings[1]\nlocal maxConcurrent = tonumber(settings[2])\nlocal highWater = tonumber(settings[3])\nlocal nextRequest = tonumber(settings[4])\nlocal strategy = tonumber(settings[5])\nlocal unblockTime = tonumber(settings[6])\nlocal penalty = tonumber(settings[7])\nlocal minTime = tonumber(settings[8])\nlocal groupTimeout = tonumber(settings[9])\n\nif maxConcurrent ~= nil and weight > maxConcurrent then\n  return redis.error_reply('OVERWEIGHT:'..weight..':'..maxConcurrent)\nend\n\nlocal reachedHWM = (highWater ~= nil and queueLength == highWater\n  and not (\n    conditions_check(capacity, weight)\n    and nextRequest - now <= 0\n  )\n)\n\nlocal blocked = strategy == 3 and (reachedHWM or unblockTime >= now)\n\nif blocked then\n  local computedPenalty = penalty\n  if computedPenalty == nil then\n    if minTime == 0 then\n      computedPenalty = 5000\n    else\n      computedPenalty = 15 * minTime\n    end\n  end\n\n  local newNextRequest = now + computedPenalty + minTime\n\n  redis.call('hmset', settings_key,\n    'unblockTime', now + computedPenalty,\n    'nextRequest', newNextRequest\n  )\n\n  local clients_queued_reset = redis.call('hkeys', client_num_queued_key)\n  local queued_reset = {}\n  for i = 1, #clients_queued_reset do\n    table.insert(queued_reset, clients_queued_reset[i])\n    table.insert(queued_reset, 0)\n  end\n  redis.call('hmset', client_num_queued_key, unpack(queued_reset))\n\n  redis.call('publish', 'b_'..id, 'blocked:')\n\n  refresh_expiration(now, newNextRequest, groupTimeout)\nend\n\nif not blocked and not reachedHWM then\n  redis.call('hincrby', client_num_queued_key, client, 1)\nend\n\nreturn {reachedHWM, blocked, strategy}\n",
		"update_settings.lua": "local args = {'hmset', settings_key}\n\nfor i = num_static_argv + 1, #ARGV do\n  table.insert(args, ARGV[i])\nend\n\nredis.call(unpack(args))\n\nprocess_tick(now, true)\n\nlocal groupTimeout = tonumber(redis.call('hget', settings_key, 'groupTimeout'))\nrefresh_expiration(0, 0, groupTimeout)\n\nreturn {}\n",
		"validate_client.lua": "if not redis.call('zscore', client_last_seen_key, client) then\n  return redis.error_reply('UNKNOWN_CLIENT')\nend\n\nredis.call('zadd', client_last_seen_key, now, client)\n",
		"validate_keys.lua": "if not (redis.call('exists', settings_key) == 1) then\n  return redis.error_reply('SETTINGS_KEY_NOT_FOUND')\nend\n"
	};

	var lua$1 = /*#__PURE__*/Object.freeze({
		default: lua
	});

	var require$$0 = getCjsExportFromNamespace(lua$1);

	var Scripts = createCommonjsModule(function (module, exports) {
	  var headers, lua, templates;
	  lua = require$$0;
	  headers = {
	    refs: lua["refs.lua"],
	    validate_keys: lua["validate_keys.lua"],
	    validate_client: lua["validate_client.lua"],
	    refresh_expiration: lua["refresh_expiration.lua"],
	    process_tick: lua["process_tick.lua"],
	    conditions_check: lua["conditions_check.lua"],
	    get_time: lua["get_time.lua"]
	  };

	  exports.allKeys = function (id) {
	    return [
	    /*
	    HASH
	    */
	    "b_".concat(id, "_settings"),
	    /*
	    HASH
	    job index -> weight
	    */
	    "b_".concat(id, "_job_weights"),
	    /*
	    ZSET
	    job index -> expiration
	    */
	    "b_".concat(id, "_job_expirations"),
	    /*
	    HASH
	    job index -> client
	    */
	    "b_".concat(id, "_job_clients"),
	    /*
	    ZSET
	    client -> sum running
	    */
	    "b_".concat(id, "_client_running"),
	    /*
	    HASH
	    client -> num queued
	    */
	    "b_".concat(id, "_client_num_queued"),
	    /*
	    ZSET
	    client -> last job registered
	    */
	    "b_".concat(id, "_client_last_registered"),
	    /*
	    ZSET
	    client -> last seen
	    */
	    "b_".concat(id, "_client_last_seen")];
	  };

	  templates = {
	    init: {
	      keys: exports.allKeys,
	      headers: ["process_tick"],
	      refresh_expiration: true,
	      code: lua["init.lua"]
	    },
	    group_check: {
	      keys: exports.allKeys,
	      headers: [],
	      refresh_expiration: false,
	      code: lua["group_check.lua"]
	    },
	    register_client: {
	      keys: exports.allKeys,
	      headers: ["validate_keys"],
	      refresh_expiration: false,
	      code: lua["register_client.lua"]
	    },
	    blacklist_client: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client"],
	      refresh_expiration: false,
	      code: lua["blacklist_client.lua"]
	    },
	    heartbeat: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: false,
	      code: lua["heartbeat.lua"]
	    },
	    update_settings: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: true,
	      code: lua["update_settings.lua"]
	    },
	    running: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: false,
	      code: lua["running.lua"]
	    },
	    queued: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client"],
	      refresh_expiration: false,
	      code: lua["queued.lua"]
	    },
	    done: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: false,
	      code: lua["done.lua"]
	    },
	    check: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick", "conditions_check"],
	      refresh_expiration: false,
	      code: lua["check.lua"]
	    },
	    submit: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick", "conditions_check"],
	      refresh_expiration: true,
	      code: lua["submit.lua"]
	    },
	    register: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick", "conditions_check"],
	      refresh_expiration: true,
	      code: lua["register.lua"]
	    },
	    free: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: true,
	      code: lua["free.lua"]
	    },
	    current_reservoir: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: false,
	      code: lua["current_reservoir.lua"]
	    },
	    increment_reservoir: {
	      keys: exports.allKeys,
	      headers: ["validate_keys", "validate_client", "process_tick"],
	      refresh_expiration: true,
	      code: lua["increment_reservoir.lua"]
	    }
	  };
	  exports.names = Object.keys(templates);

	  exports.keys = function (name, id) {
	    return templates[name].keys(id);
	  };

	  exports.payload = function (name) {
	    var template;
	    template = templates[name];
	    return Array.prototype.concat(headers.refs, template.headers.map(function (h) {
	      return headers[h];
	    }), template.refresh_expiration ? headers.refresh_expiration : "", template.code).join("\n");
	  };
	});
	var Scripts_1 = Scripts.allKeys;
	var Scripts_2 = Scripts.names;
	var Scripts_3 = Scripts.keys;
	var Scripts_4 = Scripts.payload;

	var Events$2, RedisConnection, Scripts$1, parser$3;
	parser$3 = parser;
	Events$2 = Events_1;
	Scripts$1 = Scripts;

	RedisConnection = function () {
	  var RedisConnection =
	  /*#__PURE__*/
	  function () {
	    function RedisConnection() {
	      var _this = this;

	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	      _classCallCheck(this, RedisConnection);

	      parser$3.load(options, this.defaults, this);

	      if (this.Redis == null) {
	        this.Redis = eval("require")("redis"); // Obfuscated or else Webpack/Angular will try to inline the optional redis module. To override this behavior: pass the redis module to Bottleneck as the 'Redis' option.
	      }

	      if (this.Events == null) {
	        this.Events = new Events$2(this);
	      }

	      this.terminated = false;

	      if (this.client == null) {
	        this.client = this.Redis.createClient(this.clientOptions);
	      }

	      this.subscriber = this.client.duplicate();
	      this.limiters = {};
	      this.shas = {};
	      this.ready = this.Promise.all([this._setup(this.client, false), this._setup(this.subscriber, true)]).then(function () {
	        return _this._loadScripts();
	      }).then(function () {
	        return {
	          client: _this.client,
	          subscriber: _this.subscriber
	        };
	      });
	    }

	    _createClass(RedisConnection, [{
	      key: "_setup",
	      value: function _setup(client, sub) {
	        var _this2 = this;

	        client.setMaxListeners(0);
	        return new this.Promise(function (resolve, reject) {
	          client.on("error", function (e) {
	            return _this2.Events.trigger("error", e);
	          });

	          if (sub) {
	            client.on("message", function (channel, message) {
	              var ref;
	              return (ref = _this2.limiters[channel]) != null ? ref._store.onMessage(channel, message) : void 0;
	            });
	          }

	          if (client.ready) {
	            return resolve();
	          } else {
	            return client.once("ready", resolve);
	          }
	        });
	      }
	    }, {
	      key: "_loadScript",
	      value: function _loadScript(name) {
	        var _this3 = this;

	        return new this.Promise(function (resolve, reject) {
	          var payload;
	          payload = Scripts$1.payload(name);
	          return _this3.client.multi([["script", "load", payload]]).exec(function (err, replies) {
	            if (err != null) {
	              return reject(err);
	            }

	            _this3.shas[name] = replies[0];
	            return resolve(replies[0]);
	          });
	        });
	      }
	    }, {
	      key: "_loadScripts",
	      value: function _loadScripts() {
	        var _this4 = this;

	        return this.Promise.all(Scripts$1.names.map(function (k) {
	          return _this4._loadScript(k);
	        }));
	      }
	    }, {
	      key: "__runCommand__",
	      value: function () {
	        var _runCommand__ = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee(cmd) {
	          var _this5 = this;

	          return regeneratorRuntime.wrap(function _callee$(_context) {
	            while (1) {
	              switch (_context.prev = _context.next) {
	                case 0:
	                  _context.next = 2;
	                  return this.ready;

	                case 2:
	                  return _context.abrupt("return", new this.Promise(function (resolve, reject) {
	                    return _this5.client.multi([cmd]).exec_atomic(function (err, replies) {
	                      if (err != null) {
	                        return reject(err);
	                      } else {
	                        return resolve(replies[0]);
	                      }
	                    });
	                  }));

	                case 3:
	                case "end":
	                  return _context.stop();
	              }
	            }
	          }, _callee, this);
	        }));

	        function __runCommand__(_x) {
	          return _runCommand__.apply(this, arguments);
	        }

	        return __runCommand__;
	      }()
	    }, {
	      key: "__addLimiter__",
	      value: function __addLimiter__(instance) {
	        var _this6 = this;

	        return this.Promise.all([instance.channel(), instance.channel_client()].map(function (channel) {
	          return new _this6.Promise(function (resolve, reject) {
	            var _handler;

	            _handler = function handler(chan) {
	              if (chan === channel) {
	                _this6.subscriber.removeListener("subscribe", _handler);

	                _this6.limiters[channel] = instance;
	                return resolve();
	              }
	            };

	            _this6.subscriber.on("subscribe", _handler);

	            return _this6.subscriber.subscribe(channel);
	          });
	        }));
	      }
	    }, {
	      key: "__removeLimiter__",
	      value: function __removeLimiter__(instance) {
	        var _this7 = this;

	        return this.Promise.all([instance.channel(), instance.channel_client()].map(
	        /*#__PURE__*/
	        function () {
	          var _ref = _asyncToGenerator(
	          /*#__PURE__*/
	          regeneratorRuntime.mark(function _callee2(channel) {
	            return regeneratorRuntime.wrap(function _callee2$(_context2) {
	              while (1) {
	                switch (_context2.prev = _context2.next) {
	                  case 0:
	                    if (_this7.terminated) {
	                      _context2.next = 3;
	                      break;
	                    }

	                    _context2.next = 3;
	                    return new _this7.Promise(function (resolve, reject) {
	                      return _this7.subscriber.unsubscribe(channel, function (err, chan) {
	                        if (err != null) {
	                          return reject(err);
	                        }

	                        if (chan === channel) {
	                          return resolve();
	                        }
	                      });
	                    });

	                  case 3:
	                    return _context2.abrupt("return", delete _this7.limiters[channel]);

	                  case 4:
	                  case "end":
	                    return _context2.stop();
	                }
	              }
	            }, _callee2);
	          }));

	          return function (_x2) {
	            return _ref.apply(this, arguments);
	          };
	        }()));
	      }
	    }, {
	      key: "__scriptArgs__",
	      value: function __scriptArgs__(name, id, args, cb) {
	        var keys;
	        keys = Scripts$1.keys(name, id);
	        return [this.shas[name], keys.length].concat(keys, args, cb);
	      }
	    }, {
	      key: "__scriptFn__",
	      value: function __scriptFn__(name) {
	        return this.client.evalsha.bind(this.client);
	      }
	    }, {
	      key: "disconnect",
	      value: function disconnect() {
	        var flush = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	        var i, k, len, ref;
	        ref = Object.keys(this.limiters);

	        for (i = 0, len = ref.length; i < len; i++) {
	          k = ref[i];
	          clearInterval(this.limiters[k]._store.heartbeat);
	        }

	        this.limiters = {};
	        this.terminated = true;
	        this.client.end(flush);
	        this.subscriber.end(flush);
	        return this.Promise.resolve();
	      }
	    }]);

	    return RedisConnection;
	  }();
	  RedisConnection.prototype.datastore = "redis";
	  RedisConnection.prototype.defaults = {
	    Redis: null,
	    clientOptions: {},
	    client: null,
	    Promise: Promise,
	    Events: null
	  };
	  return RedisConnection;
	}.call(commonjsGlobal);

	var RedisConnection_1 = RedisConnection;

	var Events$3, IORedisConnection, Scripts$2, parser$4;
	parser$4 = parser;
	Events$3 = Events_1;
	Scripts$2 = Scripts;

	IORedisConnection = function () {
	  var IORedisConnection =
	  /*#__PURE__*/
	  function () {
	    function IORedisConnection() {
	      var _this = this;

	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	      _classCallCheck(this, IORedisConnection);

	      parser$4.load(options, this.defaults, this);

	      if (this.Redis == null) {
	        this.Redis = eval("require")("ioredis"); // Obfuscated or else Webpack/Angular will try to inline the optional ioredis module. To override this behavior: pass the ioredis module to Bottleneck as the 'Redis' option.
	      }

	      if (this.Events == null) {
	        this.Events = new Events$3(this);
	      }

	      this.terminated = false;

	      if (this.clusterNodes != null) {
	        this.client = new this.Redis.Cluster(this.clusterNodes, this.clientOptions);
	        this.subscriber = new this.Redis.Cluster(this.clusterNodes, this.clientOptions);
	      } else if (this.client != null && this.client.duplicate == null) {
	        this.subscriber = new this.Redis.Cluster(this.client.startupNodes, this.client.options);
	      } else {
	        if (this.client == null) {
	          this.client = new this.Redis(this.clientOptions);
	        }

	        this.subscriber = this.client.duplicate();
	      }

	      this.limiters = {};
	      this.ready = this.Promise.all([this._setup(this.client, false), this._setup(this.subscriber, true)]).then(function () {
	        _this._loadScripts();

	        return {
	          client: _this.client,
	          subscriber: _this.subscriber
	        };
	      });
	    }

	    _createClass(IORedisConnection, [{
	      key: "_setup",
	      value: function _setup(client, sub) {
	        var _this2 = this;

	        client.setMaxListeners(0);
	        return new this.Promise(function (resolve, reject) {
	          client.on("error", function (e) {
	            return _this2.Events.trigger("error", e);
	          });

	          if (sub) {
	            client.on("message", function (channel, message) {
	              var ref;
	              return (ref = _this2.limiters[channel]) != null ? ref._store.onMessage(channel, message) : void 0;
	            });
	          }

	          if (client.status === "ready") {
	            return resolve();
	          } else {
	            return client.once("ready", resolve);
	          }
	        });
	      }
	    }, {
	      key: "_loadScripts",
	      value: function _loadScripts() {
	        var _this3 = this;

	        return Scripts$2.names.forEach(function (name) {
	          return _this3.client.defineCommand(name, {
	            lua: Scripts$2.payload(name)
	          });
	        });
	      }
	    }, {
	      key: "__runCommand__",
	      value: function () {
	        var _runCommand__ = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee(cmd) {
	          var _, deleted, _ref, _ref2, _ref2$;

	          return regeneratorRuntime.wrap(function _callee$(_context) {
	            while (1) {
	              switch (_context.prev = _context.next) {
	                case 0:
	                  _context.next = 2;
	                  return this.ready;

	                case 2:
	                  _context.next = 4;
	                  return this.client.pipeline([cmd]).exec();

	                case 4:
	                  _ref = _context.sent;
	                  _ref2 = _slicedToArray(_ref, 1);
	                  _ref2$ = _slicedToArray(_ref2[0], 2);
	                  _ = _ref2$[0];
	                  deleted = _ref2$[1];
	                  return _context.abrupt("return", deleted);

	                case 10:
	                case "end":
	                  return _context.stop();
	              }
	            }
	          }, _callee, this);
	        }));

	        function __runCommand__(_x) {
	          return _runCommand__.apply(this, arguments);
	        }

	        return __runCommand__;
	      }()
	    }, {
	      key: "__addLimiter__",
	      value: function __addLimiter__(instance) {
	        var _this4 = this;

	        return this.Promise.all([instance.channel(), instance.channel_client()].map(function (channel) {
	          return new _this4.Promise(function (resolve, reject) {
	            return _this4.subscriber.subscribe(channel, function () {
	              _this4.limiters[channel] = instance;
	              return resolve();
	            });
	          });
	        }));
	      }
	    }, {
	      key: "__removeLimiter__",
	      value: function __removeLimiter__(instance) {
	        var _this5 = this;

	        return [instance.channel(), instance.channel_client()].forEach(
	        /*#__PURE__*/
	        function () {
	          var _ref3 = _asyncToGenerator(
	          /*#__PURE__*/
	          regeneratorRuntime.mark(function _callee2(channel) {
	            return regeneratorRuntime.wrap(function _callee2$(_context2) {
	              while (1) {
	                switch (_context2.prev = _context2.next) {
	                  case 0:
	                    if (_this5.terminated) {
	                      _context2.next = 3;
	                      break;
	                    }

	                    _context2.next = 3;
	                    return _this5.subscriber.unsubscribe(channel);

	                  case 3:
	                    return _context2.abrupt("return", delete _this5.limiters[channel]);

	                  case 4:
	                  case "end":
	                    return _context2.stop();
	                }
	              }
	            }, _callee2);
	          }));

	          return function (_x2) {
	            return _ref3.apply(this, arguments);
	          };
	        }());
	      }
	    }, {
	      key: "__scriptArgs__",
	      value: function __scriptArgs__(name, id, args, cb) {
	        var keys;
	        keys = Scripts$2.keys(name, id);
	        return [keys.length].concat(keys, args, cb);
	      }
	    }, {
	      key: "__scriptFn__",
	      value: function __scriptFn__(name) {
	        return this.client[name].bind(this.client);
	      }
	    }, {
	      key: "disconnect",
	      value: function disconnect() {
	        var flush = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	        var i, k, len, ref;
	        ref = Object.keys(this.limiters);

	        for (i = 0, len = ref.length; i < len; i++) {
	          k = ref[i];
	          clearInterval(this.limiters[k]._store.heartbeat);
	        }

	        this.limiters = {};
	        this.terminated = true;

	        if (flush) {
	          return this.Promise.all([this.client.quit(), this.subscriber.quit()]);
	        } else {
	          this.client.disconnect();
	          this.subscriber.disconnect();
	          return this.Promise.resolve();
	        }
	      }
	    }]);

	    return IORedisConnection;
	  }();
	  IORedisConnection.prototype.datastore = "ioredis";
	  IORedisConnection.prototype.defaults = {
	    Redis: null,
	    clientOptions: {},
	    clusterNodes: null,
	    client: null,
	    Promise: Promise,
	    Events: null
	  };
	  return IORedisConnection;
	}.call(commonjsGlobal);

	var IORedisConnection_1 = IORedisConnection;

	var BottleneckError$3, IORedisConnection$1, RedisConnection$1, RedisDatastore, parser$5;
	parser$5 = parser;
	BottleneckError$3 = BottleneckError_1;
	RedisConnection$1 = RedisConnection_1;
	IORedisConnection$1 = IORedisConnection_1;

	RedisDatastore =
	/*#__PURE__*/
	function () {
	  function RedisDatastore(instance, storeOptions, storeInstanceOptions) {
	    var _this = this;

	    _classCallCheck(this, RedisDatastore);

	    this.instance = instance;
	    this.storeOptions = storeOptions;
	    this.originalId = this.instance.id;
	    this.clientId = this.instance._randomIndex();
	    parser$5.load(storeInstanceOptions, storeInstanceOptions, this);
	    this.clients = {};
	    this.capacityPriorityCounters = {};
	    this.sharedConnection = this.connection != null;

	    if (this.connection == null) {
	      this.connection = this.instance.datastore === "redis" ? new RedisConnection$1({
	        Redis: this.Redis,
	        clientOptions: this.clientOptions,
	        Promise: this.Promise,
	        Events: this.instance.Events
	      }) : this.instance.datastore === "ioredis" ? new IORedisConnection$1({
	        Redis: this.Redis,
	        clientOptions: this.clientOptions,
	        clusterNodes: this.clusterNodes,
	        Promise: this.Promise,
	        Events: this.instance.Events
	      }) : void 0;
	    }

	    this.instance.connection = this.connection;
	    this.instance.datastore = this.connection.datastore;
	    this.ready = this.connection.ready.then(function (clients) {
	      _this.clients = clients;
	      return _this.runScript("init", _this.prepareInitSettings(_this.clearDatastore));
	    }).then(function () {
	      return _this.connection.__addLimiter__(_this.instance);
	    }).then(function () {
	      return _this.runScript("register_client", [_this.instance.queued()]);
	    }).then(function () {
	      var base;

	      if (typeof (base = _this.heartbeat = setInterval(function () {
	        return _this.runScript("heartbeat", [])["catch"](function (e) {
	          return _this.instance.Events.trigger("error", e);
	        });
	      }, _this.heartbeatInterval)).unref === "function") {
	        base.unref();
	      }

	      return _this.clients;
	    });
	  }

	  _createClass(RedisDatastore, [{
	    key: "__publish__",
	    value: function () {
	      var _publish__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee(message) {
	        var client, _ref;

	        return regeneratorRuntime.wrap(function _callee$(_context) {
	          while (1) {
	            switch (_context.prev = _context.next) {
	              case 0:
	                _context.next = 2;
	                return this.ready;

	              case 2:
	                _ref = _context.sent;
	                client = _ref.client;
	                return _context.abrupt("return", client.publish(this.instance.channel(), "message:".concat(message.toString())));

	              case 5:
	              case "end":
	                return _context.stop();
	            }
	          }
	        }, _callee, this);
	      }));

	      function __publish__(_x) {
	        return _publish__.apply(this, arguments);
	      }

	      return __publish__;
	    }()
	  }, {
	    key: "onMessage",
	    value: function () {
	      var _onMessage = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee3(channel, message) {
	        var _this2 = this;

	        var capacity, counter, data, drained, e, newCapacity, pos, priorityClient, rawCapacity, type, _ref2, _data$split, _data$split2;

	        return regeneratorRuntime.wrap(function _callee3$(_context3) {
	          while (1) {
	            switch (_context3.prev = _context3.next) {
	              case 0:
	                _context3.prev = 0;
	                pos = message.indexOf(":");
	                _ref2 = [message.slice(0, pos), message.slice(pos + 1)];
	                type = _ref2[0];
	                data = _ref2[1];

	                if (!(type === "capacity")) {
	                  _context3.next = 11;
	                  break;
	                }

	                _context3.next = 8;
	                return this.instance._drainAll(data.length > 0 ? ~~data : void 0);

	              case 8:
	                return _context3.abrupt("return", _context3.sent);

	              case 11:
	                if (!(type === "capacity-priority")) {
	                  _context3.next = 37;
	                  break;
	                }

	                _data$split = data.split(":");
	                _data$split2 = _slicedToArray(_data$split, 3);
	                rawCapacity = _data$split2[0];
	                priorityClient = _data$split2[1];
	                counter = _data$split2[2];
	                capacity = rawCapacity.length > 0 ? ~~rawCapacity : void 0;

	                if (!(priorityClient === this.clientId)) {
	                  _context3.next = 28;
	                  break;
	                }

	                _context3.next = 21;
	                return this.instance._drainAll(capacity);

	              case 21:
	                drained = _context3.sent;
	                newCapacity = capacity != null ? capacity - (drained || 0) : "";
	                _context3.next = 25;
	                return this.clients.client.publish(this.instance.channel(), "capacity-priority:".concat(newCapacity, "::").concat(counter));

	              case 25:
	                return _context3.abrupt("return", _context3.sent);

	              case 28:
	                if (!(priorityClient === "")) {
	                  _context3.next = 34;
	                  break;
	                }

	                clearTimeout(this.capacityPriorityCounters[counter]);
	                delete this.capacityPriorityCounters[counter];
	                return _context3.abrupt("return", this.instance._drainAll(capacity));

	              case 34:
	                return _context3.abrupt("return", this.capacityPriorityCounters[counter] = setTimeout(
	                /*#__PURE__*/
	                _asyncToGenerator(
	                /*#__PURE__*/
	                regeneratorRuntime.mark(function _callee2() {
	                  var e;
	                  return regeneratorRuntime.wrap(function _callee2$(_context2) {
	                    while (1) {
	                      switch (_context2.prev = _context2.next) {
	                        case 0:
	                          _context2.prev = 0;
	                          delete _this2.capacityPriorityCounters[counter];
	                          _context2.next = 4;
	                          return _this2.runScript("blacklist_client", [priorityClient]);

	                        case 4:
	                          _context2.next = 6;
	                          return _this2.instance._drainAll(capacity);

	                        case 6:
	                          return _context2.abrupt("return", _context2.sent);

	                        case 9:
	                          _context2.prev = 9;
	                          _context2.t0 = _context2["catch"](0);
	                          e = _context2.t0;
	                          return _context2.abrupt("return", _this2.instance.Events.trigger("error", e));

	                        case 13:
	                        case "end":
	                          return _context2.stop();
	                      }
	                    }
	                  }, _callee2, null, [[0, 9]]);
	                })), 1000));

	              case 35:
	                _context3.next = 45;
	                break;

	              case 37:
	                if (!(type === "message")) {
	                  _context3.next = 41;
	                  break;
	                }

	                return _context3.abrupt("return", this.instance.Events.trigger("message", data));

	              case 41:
	                if (!(type === "blocked")) {
	                  _context3.next = 45;
	                  break;
	                }

	                _context3.next = 44;
	                return this.instance._dropAllQueued();

	              case 44:
	                return _context3.abrupt("return", _context3.sent);

	              case 45:
	                _context3.next = 51;
	                break;

	              case 47:
	                _context3.prev = 47;
	                _context3.t0 = _context3["catch"](0);
	                e = _context3.t0;
	                return _context3.abrupt("return", this.instance.Events.trigger("error", e));

	              case 51:
	              case "end":
	                return _context3.stop();
	            }
	          }
	        }, _callee3, this, [[0, 47]]);
	      }));

	      function onMessage(_x2, _x3) {
	        return _onMessage.apply(this, arguments);
	      }

	      return onMessage;
	    }()
	  }, {
	    key: "__disconnect__",
	    value: function __disconnect__(flush) {
	      clearInterval(this.heartbeat);

	      if (this.sharedConnection) {
	        return this.connection.__removeLimiter__(this.instance);
	      } else {
	        return this.connection.disconnect(flush);
	      }
	    }
	  }, {
	    key: "runScript",
	    value: function () {
	      var _runScript = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee4(name, args) {
	        var _this3 = this;

	        return regeneratorRuntime.wrap(function _callee4$(_context4) {
	          while (1) {
	            switch (_context4.prev = _context4.next) {
	              case 0:
	                if (name === "init" || name === "register_client") {
	                  _context4.next = 3;
	                  break;
	                }

	                _context4.next = 3;
	                return this.ready;

	              case 3:
	                return _context4.abrupt("return", new this.Promise(function (resolve, reject) {
	                  var all_args, arr;
	                  all_args = [Date.now(), _this3.clientId].concat(args);

	                  _this3.instance.Events.trigger("debug", "Calling Redis script: ".concat(name, ".lua"), all_args);

	                  arr = _this3.connection.__scriptArgs__(name, _this3.originalId, all_args, function (err, replies) {
	                    if (err != null) {
	                      return reject(err);
	                    }

	                    return resolve(replies);
	                  });
	                  return _this3.connection.__scriptFn__(name).apply(void 0, _toConsumableArray(arr));
	                })["catch"](function (e) {
	                  if (e.message === "SETTINGS_KEY_NOT_FOUND") {
	                    if (name === "heartbeat") {
	                      return _this3.Promise.resolve();
	                    } else {
	                      return _this3.runScript("init", _this3.prepareInitSettings(false)).then(function () {
	                        return _this3.runScript(name, args);
	                      });
	                    }
	                  } else if (e.message === "UNKNOWN_CLIENT") {
	                    return _this3.runScript("register_client", [_this3.instance.queued()]).then(function () {
	                      return _this3.runScript(name, args);
	                    });
	                  } else {
	                    return _this3.Promise.reject(e);
	                  }
	                }));

	              case 4:
	              case "end":
	                return _context4.stop();
	            }
	          }
	        }, _callee4, this);
	      }));

	      function runScript(_x4, _x5) {
	        return _runScript.apply(this, arguments);
	      }

	      return runScript;
	    }()
	  }, {
	    key: "prepareArray",
	    value: function prepareArray(arr) {
	      var i, len, results, x;
	      results = [];

	      for (i = 0, len = arr.length; i < len; i++) {
	        x = arr[i];
	        results.push(x != null ? x.toString() : "");
	      }

	      return results;
	    }
	  }, {
	    key: "prepareObject",
	    value: function prepareObject(obj) {
	      var arr, k, v;
	      arr = [];

	      for (k in obj) {
	        v = obj[k];
	        arr.push(k, v != null ? v.toString() : "");
	      }

	      return arr;
	    }
	  }, {
	    key: "prepareInitSettings",
	    value: function prepareInitSettings(clear) {
	      var args;
	      args = this.prepareObject(Object.assign({}, this.storeOptions, {
	        id: this.originalId,
	        version: this.instance.version,
	        groupTimeout: this.timeout,
	        clientTimeout: this.clientTimeout
	      }));
	      args.unshift(clear ? 1 : 0, this.instance.version);
	      return args;
	    }
	  }, {
	    key: "convertBool",
	    value: function convertBool(b) {
	      return !!b;
	    }
	  }, {
	    key: "__updateSettings__",
	    value: function () {
	      var _updateSettings__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee5(options) {
	        return regeneratorRuntime.wrap(function _callee5$(_context5) {
	          while (1) {
	            switch (_context5.prev = _context5.next) {
	              case 0:
	                _context5.next = 2;
	                return this.runScript("update_settings", this.prepareObject(options));

	              case 2:
	                return _context5.abrupt("return", parser$5.overwrite(options, options, this.storeOptions));

	              case 3:
	              case "end":
	                return _context5.stop();
	            }
	          }
	        }, _callee5, this);
	      }));

	      function __updateSettings__(_x6) {
	        return _updateSettings__.apply(this, arguments);
	      }

	      return __updateSettings__;
	    }()
	  }, {
	    key: "__running__",
	    value: function __running__() {
	      return this.runScript("running", []);
	    }
	  }, {
	    key: "__queued__",
	    value: function __queued__() {
	      return this.runScript("queued", []);
	    }
	  }, {
	    key: "__done__",
	    value: function __done__() {
	      return this.runScript("done", []);
	    }
	  }, {
	    key: "__groupCheck__",
	    value: function () {
	      var _groupCheck__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee6() {
	        return regeneratorRuntime.wrap(function _callee6$(_context6) {
	          while (1) {
	            switch (_context6.prev = _context6.next) {
	              case 0:
	                _context6.t0 = this;
	                _context6.next = 3;
	                return this.runScript("group_check", []);

	              case 3:
	                _context6.t1 = _context6.sent;
	                return _context6.abrupt("return", _context6.t0.convertBool.call(_context6.t0, _context6.t1));

	              case 5:
	              case "end":
	                return _context6.stop();
	            }
	          }
	        }, _callee6, this);
	      }));

	      function __groupCheck__() {
	        return _groupCheck__.apply(this, arguments);
	      }

	      return __groupCheck__;
	    }()
	  }, {
	    key: "__incrementReservoir__",
	    value: function __incrementReservoir__(incr) {
	      return this.runScript("increment_reservoir", [incr]);
	    }
	  }, {
	    key: "__currentReservoir__",
	    value: function __currentReservoir__() {
	      return this.runScript("current_reservoir", []);
	    }
	  }, {
	    key: "__check__",
	    value: function () {
	      var _check__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee7(weight) {
	        return regeneratorRuntime.wrap(function _callee7$(_context7) {
	          while (1) {
	            switch (_context7.prev = _context7.next) {
	              case 0:
	                _context7.t0 = this;
	                _context7.next = 3;
	                return this.runScript("check", this.prepareArray([weight]));

	              case 3:
	                _context7.t1 = _context7.sent;
	                return _context7.abrupt("return", _context7.t0.convertBool.call(_context7.t0, _context7.t1));

	              case 5:
	              case "end":
	                return _context7.stop();
	            }
	          }
	        }, _callee7, this);
	      }));

	      function __check__(_x7) {
	        return _check__.apply(this, arguments);
	      }

	      return __check__;
	    }()
	  }, {
	    key: "__register__",
	    value: function () {
	      var _register__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee8(index, weight, expiration) {
	        var reservoir, success, wait, _ref4, _ref5;

	        return regeneratorRuntime.wrap(function _callee8$(_context8) {
	          while (1) {
	            switch (_context8.prev = _context8.next) {
	              case 0:
	                _context8.next = 2;
	                return this.runScript("register", this.prepareArray([index, weight, expiration]));

	              case 2:
	                _ref4 = _context8.sent;
	                _ref5 = _slicedToArray(_ref4, 3);
	                success = _ref5[0];
	                wait = _ref5[1];
	                reservoir = _ref5[2];
	                return _context8.abrupt("return", {
	                  success: this.convertBool(success),
	                  wait: wait,
	                  reservoir: reservoir
	                });

	              case 8:
	              case "end":
	                return _context8.stop();
	            }
	          }
	        }, _callee8, this);
	      }));

	      function __register__(_x8, _x9, _x10) {
	        return _register__.apply(this, arguments);
	      }

	      return __register__;
	    }()
	  }, {
	    key: "__submit__",
	    value: function () {
	      var _submit__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee9(queueLength, weight) {
	        var blocked, e, maxConcurrent, overweight, reachedHWM, strategy, _ref6, _ref7, _e$message$split, _e$message$split2;

	        return regeneratorRuntime.wrap(function _callee9$(_context9) {
	          while (1) {
	            switch (_context9.prev = _context9.next) {
	              case 0:
	                _context9.prev = 0;
	                _context9.next = 3;
	                return this.runScript("submit", this.prepareArray([queueLength, weight]));

	              case 3:
	                _ref6 = _context9.sent;
	                _ref7 = _slicedToArray(_ref6, 3);
	                reachedHWM = _ref7[0];
	                blocked = _ref7[1];
	                strategy = _ref7[2];
	                return _context9.abrupt("return", {
	                  reachedHWM: this.convertBool(reachedHWM),
	                  blocked: this.convertBool(blocked),
	                  strategy: strategy
	                });

	              case 11:
	                _context9.prev = 11;
	                _context9.t0 = _context9["catch"](0);
	                e = _context9.t0;

	                if (!(e.message.indexOf("OVERWEIGHT") === 0)) {
	                  _context9.next = 23;
	                  break;
	                }

	                _e$message$split = e.message.split(":");
	                _e$message$split2 = _slicedToArray(_e$message$split, 3);
	                overweight = _e$message$split2[0];
	                weight = _e$message$split2[1];
	                maxConcurrent = _e$message$split2[2];
	                throw new BottleneckError$3("Impossible to add a job having a weight of ".concat(weight, " to a limiter having a maxConcurrent setting of ").concat(maxConcurrent));

	              case 23:
	                throw e;

	              case 24:
	              case "end":
	                return _context9.stop();
	            }
	          }
	        }, _callee9, this, [[0, 11]]);
	      }));

	      function __submit__(_x11, _x12) {
	        return _submit__.apply(this, arguments);
	      }

	      return __submit__;
	    }()
	  }, {
	    key: "__free__",
	    value: function () {
	      var _free__ = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee10(index, weight) {
	        var running;
	        return regeneratorRuntime.wrap(function _callee10$(_context10) {
	          while (1) {
	            switch (_context10.prev = _context10.next) {
	              case 0:
	                _context10.next = 2;
	                return this.runScript("free", this.prepareArray([index]));

	              case 2:
	                running = _context10.sent;
	                return _context10.abrupt("return", {
	                  running: running
	                });

	              case 4:
	              case "end":
	                return _context10.stop();
	            }
	          }
	        }, _callee10, this);
	      }));

	      function __free__(_x13, _x14) {
	        return _free__.apply(this, arguments);
	      }

	      return __free__;
	    }()
	  }]);

	  return RedisDatastore;
	}();

	var RedisDatastore_1 = RedisDatastore;

	var BottleneckError$4, States;
	BottleneckError$4 = BottleneckError_1;

	States =
	/*#__PURE__*/
	function () {
	  function States(status1) {
	    _classCallCheck(this, States);

	    this.status = status1;
	    this._jobs = {};
	    this.counts = this.status.map(function () {
	      return 0;
	    });
	  }

	  _createClass(States, [{
	    key: "next",
	    value: function next(id) {
	      var current, next;
	      current = this._jobs[id];
	      next = current + 1;

	      if (current != null && next < this.status.length) {
	        this.counts[current]--;
	        this.counts[next]++;
	        return this._jobs[id]++;
	      } else if (current != null) {
	        this.counts[current]--;
	        return delete this._jobs[id];
	      }
	    }
	  }, {
	    key: "start",
	    value: function start(id) {
	      var initial;
	      initial = 0;
	      this._jobs[id] = initial;
	      return this.counts[initial]++;
	    }
	  }, {
	    key: "remove",
	    value: function remove(id) {
	      var current;
	      current = this._jobs[id];

	      if (current != null) {
	        this.counts[current]--;
	        delete this._jobs[id];
	      }

	      return current != null;
	    }
	  }, {
	    key: "jobStatus",
	    value: function jobStatus(id) {
	      var ref;
	      return (ref = this.status[this._jobs[id]]) != null ? ref : null;
	    }
	  }, {
	    key: "statusJobs",
	    value: function statusJobs(status) {
	      var k, pos, ref, results, v;

	      if (status != null) {
	        pos = this.status.indexOf(status);

	        if (pos < 0) {
	          throw new BottleneckError$4("status must be one of ".concat(this.status.join(', ')));
	        }

	        ref = this._jobs;
	        results = [];

	        for (k in ref) {
	          v = ref[k];

	          if (v === pos) {
	            results.push(k);
	          }
	        }

	        return results;
	      } else {
	        return Object.keys(this._jobs);
	      }
	    }
	  }, {
	    key: "statusCounts",
	    value: function statusCounts() {
	      var _this = this;

	      return this.counts.reduce(function (acc, v, i) {
	        acc[_this.status[i]] = v;
	        return acc;
	      }, {});
	    }
	  }]);

	  return States;
	}();

	var States_1 = States;

	var DLList$2, Sync;
	DLList$2 = DLList_1;

	Sync =
	/*#__PURE__*/
	function () {
	  function Sync(name, Promise) {
	    _classCallCheck(this, Sync);

	    this.schedule = this.schedule.bind(this);
	    this.name = name;
	    this.Promise = Promise;
	    this._running = 0;
	    this._queue = new DLList$2();
	  }

	  _createClass(Sync, [{
	    key: "isEmpty",
	    value: function isEmpty() {
	      return this._queue.length === 0;
	    }
	  }, {
	    key: "_tryToRun",
	    value: function () {
	      var _tryToRun2 = _asyncToGenerator(
	      /*#__PURE__*/
	      regeneratorRuntime.mark(function _callee2() {
	        var args, cb, error, reject, resolve, returned, task, _this$_queue$shift;

	        return regeneratorRuntime.wrap(function _callee2$(_context2) {
	          while (1) {
	            switch (_context2.prev = _context2.next) {
	              case 0:
	                if (!(this._running < 1 && this._queue.length > 0)) {
	                  _context2.next = 13;
	                  break;
	                }

	                this._running++;
	                _this$_queue$shift = this._queue.shift();
	                task = _this$_queue$shift.task;
	                args = _this$_queue$shift.args;
	                resolve = _this$_queue$shift.resolve;
	                reject = _this$_queue$shift.reject;
	                _context2.next = 9;
	                return _asyncToGenerator(
	                /*#__PURE__*/
	                regeneratorRuntime.mark(function _callee() {
	                  return regeneratorRuntime.wrap(function _callee$(_context) {
	                    while (1) {
	                      switch (_context.prev = _context.next) {
	                        case 0:
	                          _context.prev = 0;
	                          _context.next = 3;
	                          return task.apply(void 0, _toConsumableArray(args));

	                        case 3:
	                          returned = _context.sent;
	                          return _context.abrupt("return", function () {
	                            return resolve(returned);
	                          });

	                        case 7:
	                          _context.prev = 7;
	                          _context.t0 = _context["catch"](0);
	                          error = _context.t0;
	                          return _context.abrupt("return", function () {
	                            return reject(error);
	                          });

	                        case 11:
	                        case "end":
	                          return _context.stop();
	                      }
	                    }
	                  }, _callee, null, [[0, 7]]);
	                }))();

	              case 9:
	                cb = _context2.sent;
	                this._running--;

	                this._tryToRun();

	                return _context2.abrupt("return", cb());

	              case 13:
	              case "end":
	                return _context2.stop();
	            }
	          }
	        }, _callee2, this);
	      }));

	      function _tryToRun() {
	        return _tryToRun2.apply(this, arguments);
	      }

	      return _tryToRun;
	    }()
	  }, {
	    key: "schedule",
	    value: function schedule(task) {
	      var promise, reject, resolve;
	      resolve = reject = null;
	      promise = new this.Promise(function (_resolve, _reject) {
	        resolve = _resolve;
	        return reject = _reject;
	      });

	      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	        args[_key - 1] = arguments[_key];
	      }

	      this._queue.push({
	        task: task,
	        args: args,
	        resolve: resolve,
	        reject: reject
	      });

	      this._tryToRun();

	      return promise;
	    }
	  }]);

	  return Sync;
	}();

	var Sync_1 = Sync;

	var version = "2.19.5";
	var version$1 = {
		version: version
	};

	var version$2 = /*#__PURE__*/Object.freeze({
		version: version,
		default: version$1
	});

	var Events$4, Group, IORedisConnection$2, RedisConnection$2, Scripts$3, parser$6;
	parser$6 = parser;
	Events$4 = Events_1;
	RedisConnection$2 = RedisConnection_1;
	IORedisConnection$2 = IORedisConnection_1;
	Scripts$3 = Scripts;

	Group = function () {
	  var Group =
	  /*#__PURE__*/
	  function () {
	    function Group() {
	      var limiterOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	      _classCallCheck(this, Group);

	      this.deleteKey = this.deleteKey.bind(this);
	      this.limiterOptions = limiterOptions;
	      parser$6.load(this.limiterOptions, this.defaults, this);
	      this.Events = new Events$4(this);
	      this.instances = {};
	      this.Bottleneck = Bottleneck_1;

	      this._startAutoCleanup();

	      this.sharedConnection = this.connection != null;

	      if (this.connection == null) {
	        if (this.limiterOptions.datastore === "redis") {
	          this.connection = new RedisConnection$2(Object.assign({}, this.limiterOptions, {
	            Events: this.Events
	          }));
	        } else if (this.limiterOptions.datastore === "ioredis") {
	          this.connection = new IORedisConnection$2(Object.assign({}, this.limiterOptions, {
	            Events: this.Events
	          }));
	        }
	      }
	    }

	    _createClass(Group, [{
	      key: "key",
	      value: function key() {
	        var _this = this;

	        var _key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";

	        var ref;
	        return (ref = this.instances[_key]) != null ? ref : function () {
	          var limiter;
	          limiter = _this.instances[_key] = new _this.Bottleneck(Object.assign(_this.limiterOptions, {
	            id: "".concat(_this.id, "-").concat(_key),
	            timeout: _this.timeout,
	            connection: _this.connection
	          }));

	          _this.Events.trigger("created", limiter, _key);

	          return limiter;
	        }();
	      }
	    }, {
	      key: "deleteKey",
	      value: function () {
	        var _deleteKey = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee() {
	          var key,
	              deleted,
	              instance,
	              _args = arguments;
	          return regeneratorRuntime.wrap(function _callee$(_context) {
	            while (1) {
	              switch (_context.prev = _context.next) {
	                case 0:
	                  key = _args.length > 0 && _args[0] !== undefined ? _args[0] : "";
	                  instance = this.instances[key];

	                  if (!this.connection) {
	                    _context.next = 6;
	                    break;
	                  }

	                  _context.next = 5;
	                  return this.connection.__runCommand__(['del'].concat(_toConsumableArray(Scripts$3.allKeys("".concat(this.id, "-").concat(key)))));

	                case 5:
	                  deleted = _context.sent;

	                case 6:
	                  if (!(instance != null)) {
	                    _context.next = 10;
	                    break;
	                  }

	                  delete this.instances[key];
	                  _context.next = 10;
	                  return instance.disconnect();

	                case 10:
	                  return _context.abrupt("return", instance != null || deleted > 0);

	                case 11:
	                case "end":
	                  return _context.stop();
	              }
	            }
	          }, _callee, this);
	        }));

	        function deleteKey() {
	          return _deleteKey.apply(this, arguments);
	        }

	        return deleteKey;
	      }()
	    }, {
	      key: "limiters",
	      value: function limiters() {
	        var k, ref, results, v;
	        ref = this.instances;
	        results = [];

	        for (k in ref) {
	          v = ref[k];
	          results.push({
	            key: k,
	            limiter: v
	          });
	        }

	        return results;
	      }
	    }, {
	      key: "keys",
	      value: function keys() {
	        return Object.keys(this.instances);
	      }
	    }, {
	      key: "clusterKeys",
	      value: function () {
	        var _clusterKeys = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee2() {
	          var cursor, end, found, i, k, keys, len, next, start, _ref, _ref2;

	          return regeneratorRuntime.wrap(function _callee2$(_context2) {
	            while (1) {
	              switch (_context2.prev = _context2.next) {
	                case 0:
	                  if (!(this.connection == null)) {
	                    _context2.next = 2;
	                    break;
	                  }

	                  return _context2.abrupt("return", this.Promise.resolve(this.keys()));

	                case 2:
	                  keys = [];
	                  cursor = null;
	                  start = "b_".concat(this.id, "-").length;
	                  end = "_settings".length;

	                case 6:
	                  if (!(cursor !== 0)) {
	                    _context2.next = 17;
	                    break;
	                  }

	                  _context2.next = 9;
	                  return this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", "b_".concat(this.id, "-*_settings"), "count", 10000]);

	                case 9:
	                  _ref = _context2.sent;
	                  _ref2 = _slicedToArray(_ref, 2);
	                  next = _ref2[0];
	                  found = _ref2[1];
	                  cursor = ~~next;

	                  for (i = 0, len = found.length; i < len; i++) {
	                    k = found[i];
	                    keys.push(k.slice(start, -end));
	                  }

	                  _context2.next = 6;
	                  break;

	                case 17:
	                  return _context2.abrupt("return", keys);

	                case 18:
	                case "end":
	                  return _context2.stop();
	              }
	            }
	          }, _callee2, this);
	        }));

	        function clusterKeys() {
	          return _clusterKeys.apply(this, arguments);
	        }

	        return clusterKeys;
	      }()
	    }, {
	      key: "_startAutoCleanup",
	      value: function _startAutoCleanup() {
	        var _this2 = this;

	        var base;
	        clearInterval(this.interval);
	        return typeof (base = this.interval = setInterval(
	        /*#__PURE__*/
	        _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee3() {
	          var e, k, ref, results, time, v;
	          return regeneratorRuntime.wrap(function _callee3$(_context3) {
	            while (1) {
	              switch (_context3.prev = _context3.next) {
	                case 0:
	                  time = Date.now();
	                  ref = _this2.instances;
	                  results = [];
	                  _context3.t0 = regeneratorRuntime.keys(ref);

	                case 4:
	                  if ((_context3.t1 = _context3.t0()).done) {
	                    _context3.next = 23;
	                    break;
	                  }

	                  k = _context3.t1.value;
	                  v = ref[k];
	                  _context3.prev = 7;
	                  _context3.next = 10;
	                  return v._store.__groupCheck__(time);

	                case 10:
	                  if (!_context3.sent) {
	                    _context3.next = 14;
	                    break;
	                  }

	                  results.push(_this2.deleteKey(k));
	                  _context3.next = 15;
	                  break;

	                case 14:
	                  results.push(void 0);

	                case 15:
	                  _context3.next = 21;
	                  break;

	                case 17:
	                  _context3.prev = 17;
	                  _context3.t2 = _context3["catch"](7);
	                  e = _context3.t2;
	                  results.push(v.Events.trigger("error", e));

	                case 21:
	                  _context3.next = 4;
	                  break;

	                case 23:
	                  return _context3.abrupt("return", results);

	                case 24:
	                case "end":
	                  return _context3.stop();
	              }
	            }
	          }, _callee3, null, [[7, 17]]);
	        })), this.timeout / 2)).unref === "function" ? base.unref() : void 0;
	      }
	    }, {
	      key: "updateSettings",
	      value: function updateSettings() {
	        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	        parser$6.overwrite(options, this.defaults, this);
	        parser$6.overwrite(options, options, this.limiterOptions);

	        if (options.timeout != null) {
	          return this._startAutoCleanup();
	        }
	      }
	    }, {
	      key: "disconnect",
	      value: function disconnect() {
	        var flush = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	        var ref;

	        if (!this.sharedConnection) {
	          return (ref = this.connection) != null ? ref.disconnect(flush) : void 0;
	        }
	      }
	    }]);

	    return Group;
	  }();
	  Group.prototype.defaults = {
	    timeout: 1000 * 60 * 5,
	    connection: null,
	    Promise: Promise,
	    id: "group-key"
	  };
	  return Group;
	}.call(commonjsGlobal);

	var Group_1 = Group;

	var Batcher, Events$5, parser$7;
	parser$7 = parser;
	Events$5 = Events_1;

	Batcher = function () {
	  var Batcher =
	  /*#__PURE__*/
	  function () {
	    function Batcher() {
	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	      _classCallCheck(this, Batcher);

	      this.options = options;
	      parser$7.load(this.options, this.defaults, this);
	      this.Events = new Events$5(this);
	      this._arr = [];

	      this._resetPromise();

	      this._lastFlush = Date.now();
	    }

	    _createClass(Batcher, [{
	      key: "_resetPromise",
	      value: function _resetPromise() {
	        var _this = this;

	        return this._promise = new this.Promise(function (res, rej) {
	          return _this._resolve = res;
	        });
	      }
	    }, {
	      key: "_flush",
	      value: function _flush() {
	        clearTimeout(this._timeout);
	        this._lastFlush = Date.now();

	        this._resolve();

	        this.Events.trigger("batch", this._arr);
	        this._arr = [];
	        return this._resetPromise();
	      }
	    }, {
	      key: "add",
	      value: function add(data) {
	        var _this2 = this;

	        var ret;

	        this._arr.push(data);

	        ret = this._promise;

	        if (this._arr.length === this.maxSize) {
	          this._flush();
	        } else if (this.maxTime != null && this._arr.length === 1) {
	          this._timeout = setTimeout(function () {
	            return _this2._flush();
	          }, this.maxTime);
	        }

	        return ret;
	      }
	    }]);

	    return Batcher;
	  }();
	  Batcher.prototype.defaults = {
	    maxTime: null,
	    maxSize: null,
	    Promise: Promise
	  };
	  return Batcher;
	}.call(commonjsGlobal);

	var Batcher_1 = Batcher;

	var require$$8 = getCjsExportFromNamespace(version$2);

	var Bottleneck,
	    DEFAULT_PRIORITY$1,
	    Events$6,
	    Job$1,
	    LocalDatastore$1,
	    NUM_PRIORITIES$1,
	    Queues$1,
	    RedisDatastore$1,
	    States$1,
	    Sync$1,
	    parser$8,
	    splice = [].splice;
	NUM_PRIORITIES$1 = 10;
	DEFAULT_PRIORITY$1 = 5;
	parser$8 = parser;
	Queues$1 = Queues_1;
	Job$1 = Job_1;
	LocalDatastore$1 = LocalDatastore_1;
	RedisDatastore$1 = RedisDatastore_1;
	Events$6 = Events_1;
	States$1 = States_1;
	Sync$1 = Sync_1;

	Bottleneck = function () {
	  var Bottleneck =
	  /*#__PURE__*/
	  function () {
	    function Bottleneck() {
	      var _this = this;

	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	      _classCallCheck(this, Bottleneck);

	      var storeInstanceOptions, storeOptions;
	      this._addToQueue = this._addToQueue.bind(this);

	      for (var _len = arguments.length, invalid = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	        invalid[_key - 1] = arguments[_key];
	      }

	      this._validateOptions(options, invalid);

	      parser$8.load(options, this.instanceDefaults, this);
	      this._queues = new Queues$1(NUM_PRIORITIES$1);
	      this._scheduled = {};
	      this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : []));
	      this._limiter = null;
	      this.Events = new Events$6(this);
	      this._submitLock = new Sync$1("submit", this.Promise);
	      this._registerLock = new Sync$1("register", this.Promise);
	      storeOptions = parser$8.load(options, this.storeDefaults, {});

	      this._store = function () {
	        if (this.datastore === "redis" || this.datastore === "ioredis" || this.connection != null) {
	          storeInstanceOptions = parser$8.load(options, this.redisStoreDefaults, {});
	          return new RedisDatastore$1(this, storeOptions, storeInstanceOptions);
	        } else if (this.datastore === "local") {
	          storeInstanceOptions = parser$8.load(options, this.localStoreDefaults, {});
	          return new LocalDatastore$1(this, storeOptions, storeInstanceOptions);
	        } else {
	          throw new Bottleneck.prototype.BottleneckError("Invalid datastore type: ".concat(this.datastore));
	        }
	      }.call(this);

	      this._queues.on("leftzero", function () {
	        var ref;
	        return (ref = _this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0;
	      });

	      this._queues.on("zero", function () {
	        var ref;
	        return (ref = _this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0;
	      });
	    }

	    _createClass(Bottleneck, [{
	      key: "_validateOptions",
	      value: function _validateOptions(options, invalid) {
	        if (!(options != null && _typeof(options) === "object" && invalid.length === 0)) {
	          throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1.");
	        }
	      }
	    }, {
	      key: "ready",
	      value: function ready() {
	        return this._store.ready;
	      }
	    }, {
	      key: "clients",
	      value: function clients() {
	        return this._store.clients;
	      }
	    }, {
	      key: "channel",
	      value: function channel() {
	        return "b_".concat(this.id);
	      }
	    }, {
	      key: "channel_client",
	      value: function channel_client() {
	        return "b_".concat(this.id, "_").concat(this._store.clientId);
	      }
	    }, {
	      key: "publish",
	      value: function publish(message) {
	        return this._store.__publish__(message);
	      }
	    }, {
	      key: "disconnect",
	      value: function disconnect() {
	        var flush = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	        return this._store.__disconnect__(flush);
	      }
	    }, {
	      key: "chain",
	      value: function chain(_limiter) {
	        this._limiter = _limiter;
	        return this;
	      }
	    }, {
	      key: "queued",
	      value: function queued(priority) {
	        return this._queues.queued(priority);
	      }
	    }, {
	      key: "clusterQueued",
	      value: function clusterQueued() {
	        return this._store.__queued__();
	      }
	    }, {
	      key: "empty",
	      value: function empty() {
	        return this.queued() === 0 && this._submitLock.isEmpty();
	      }
	    }, {
	      key: "running",
	      value: function running() {
	        return this._store.__running__();
	      }
	    }, {
	      key: "done",
	      value: function done() {
	        return this._store.__done__();
	      }
	    }, {
	      key: "jobStatus",
	      value: function jobStatus(id) {
	        return this._states.jobStatus(id);
	      }
	    }, {
	      key: "jobs",
	      value: function jobs(status) {
	        return this._states.statusJobs(status);
	      }
	    }, {
	      key: "counts",
	      value: function counts() {
	        return this._states.statusCounts();
	      }
	    }, {
	      key: "_randomIndex",
	      value: function _randomIndex() {
	        return Math.random().toString(36).slice(2);
	      }
	    }, {
	      key: "check",
	      value: function check() {
	        var weight = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
	        return this._store.__check__(weight);
	      }
	    }, {
	      key: "_clearGlobalState",
	      value: function _clearGlobalState(index) {
	        if (this._scheduled[index] != null) {
	          clearTimeout(this._scheduled[index].expiration);
	          delete this._scheduled[index];
	          return true;
	        } else {
	          return false;
	        }
	      }
	    }, {
	      key: "_free",
	      value: function () {
	        var _free2 = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee(index, job, options, eventInfo) {
	          var e, running, _ref;

	          return regeneratorRuntime.wrap(function _callee$(_context) {
	            while (1) {
	              switch (_context.prev = _context.next) {
	                case 0:
	                  _context.prev = 0;
	                  _context.next = 3;
	                  return this._store.__free__(index, options.weight);

	                case 3:
	                  _ref = _context.sent;
	                  running = _ref.running;
	                  this.Events.trigger("debug", "Freed ".concat(options.id), eventInfo);

	                  if (!(running === 0 && this.empty())) {
	                    _context.next = 8;
	                    break;
	                  }

	                  return _context.abrupt("return", this.Events.trigger("idle"));

	                case 8:
	                  _context.next = 14;
	                  break;

	                case 10:
	                  _context.prev = 10;
	                  _context.t0 = _context["catch"](0);
	                  e = _context.t0;
	                  return _context.abrupt("return", this.Events.trigger("error", e));

	                case 14:
	                case "end":
	                  return _context.stop();
	              }
	            }
	          }, _callee, this, [[0, 10]]);
	        }));

	        function _free(_x, _x2, _x3, _x4) {
	          return _free2.apply(this, arguments);
	        }

	        return _free;
	      }()
	    }, {
	      key: "_run",
	      value: function _run(index, job, wait) {
	        var _this2 = this;

	        var clearGlobalState, free, run;
	        job.doRun();
	        clearGlobalState = this._clearGlobalState.bind(this, index);
	        run = this._run.bind(this, index, job);
	        free = this._free.bind(this, index, job);
	        return this._scheduled[index] = {
	          timeout: setTimeout(function () {
	            return job.doExecute(_this2._limiter, clearGlobalState, run, free);
	          }, wait),
	          expiration: job.options.expiration != null ? setTimeout(function () {
	            return job.doExpire(clearGlobalState, run, free);
	          }, wait + job.options.expiration) : void 0,
	          job: job
	        };
	      }
	    }, {
	      key: "_drainOne",
	      value: function _drainOne(capacity) {
	        var _this3 = this;

	        return this._registerLock.schedule(function () {
	          var args, index, next, options, queue;

	          if (_this3.queued() === 0) {
	            return _this3.Promise.resolve(null);
	          }

	          queue = _this3._queues.getFirst();

	          var _next = next = queue.first();

	          options = _next.options;
	          args = _next.args;

	          if (capacity != null && options.weight > capacity) {
	            return _this3.Promise.resolve(null);
	          }

	          _this3.Events.trigger("debug", "Draining ".concat(options.id), {
	            args: args,
	            options: options
	          });

	          index = _this3._randomIndex();
	          return _this3._store.__register__(index, options.weight, options.expiration).then(function (_ref2) {
	            var success = _ref2.success,
	                wait = _ref2.wait,
	                reservoir = _ref2.reservoir;
	            var empty;

	            _this3.Events.trigger("debug", "Drained ".concat(options.id), {
	              success: success,
	              args: args,
	              options: options
	            });

	            if (success) {
	              queue.shift();
	              empty = _this3.empty();

	              if (empty) {
	                _this3.Events.trigger("empty");
	              }

	              if (reservoir === 0) {
	                _this3.Events.trigger("depleted", empty);
	              }

	              _this3._run(index, next, wait);

	              return _this3.Promise.resolve(options.weight);
	            } else {
	              return _this3.Promise.resolve(null);
	            }
	          });
	        });
	      }
	    }, {
	      key: "_drainAll",
	      value: function _drainAll(capacity) {
	        var _this4 = this;

	        var total = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	        return this._drainOne(capacity).then(function (drained) {
	          var newCapacity;

	          if (drained != null) {
	            newCapacity = capacity != null ? capacity - drained : capacity;
	            return _this4._drainAll(newCapacity, total + drained);
	          } else {
	            return _this4.Promise.resolve(total);
	          }
	        })["catch"](function (e) {
	          return _this4.Events.trigger("error", e);
	        });
	      }
	    }, {
	      key: "_dropAllQueued",
	      value: function _dropAllQueued(message) {
	        return this._queues.shiftAll(function (job) {
	          return job.doDrop({
	            message: message
	          });
	        });
	      }
	    }, {
	      key: "stop",
	      value: function stop() {
	        var _this5 = this;

	        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	        var done, waitForExecuting;
	        options = parser$8.load(options, this.stopDefaults);

	        waitForExecuting = function waitForExecuting(at) {
	          var finished;

	          finished = function finished() {
	            var counts;
	            counts = _this5._states.counts;
	            return counts[0] + counts[1] + counts[2] + counts[3] === at;
	          };

	          return new _this5.Promise(function (resolve, reject) {
	            if (finished()) {
	              return resolve();
	            } else {
	              return _this5.on("done", function () {
	                if (finished()) {
	                  _this5.removeAllListeners("done");

	                  return resolve();
	                }
	              });
	            }
	          });
	        };

	        done = options.dropWaitingJobs ? (this._run = function (index, next) {
	          return next.doDrop({
	            message: options.dropErrorMessage
	          });
	        }, this._drainOne = function () {
	          return _this5.Promise.resolve(null);
	        }, this._registerLock.schedule(function () {
	          return _this5._submitLock.schedule(function () {
	            var k, ref, v;
	            ref = _this5._scheduled;

	            for (k in ref) {
	              v = ref[k];

	              if (_this5.jobStatus(v.job.options.id) === "RUNNING") {
	                clearTimeout(v.timeout);
	                clearTimeout(v.expiration);
	                v.job.doDrop({
	                  message: options.dropErrorMessage
	                });
	              }
	            }

	            _this5._dropAllQueued(options.dropErrorMessage);

	            return waitForExecuting(0);
	          });
	        })) : this.schedule({
	          priority: NUM_PRIORITIES$1 - 1,
	          weight: 0
	        }, function () {
	          return waitForExecuting(1);
	        });

	        this._receive = function (job) {
	          return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage));
	        };

	        this.stop = function () {
	          return _this5.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called"));
	        };

	        return done;
	      }
	    }, {
	      key: "_addToQueue",
	      value: function () {
	        var _addToQueue2 = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee2(job) {
	          var args, blocked, error, options, reachedHWM, shifted, strategy, _ref3;

	          return regeneratorRuntime.wrap(function _callee2$(_context2) {
	            while (1) {
	              switch (_context2.prev = _context2.next) {
	                case 0:
	                  args = job.args;
	                  options = job.options;
	                  _context2.prev = 2;
	                  _context2.next = 5;
	                  return this._store.__submit__(this.queued(), options.weight);

	                case 5:
	                  _ref3 = _context2.sent;
	                  reachedHWM = _ref3.reachedHWM;
	                  blocked = _ref3.blocked;
	                  strategy = _ref3.strategy;
	                  _context2.next = 17;
	                  break;

	                case 11:
	                  _context2.prev = 11;
	                  _context2.t0 = _context2["catch"](2);
	                  error = _context2.t0;
	                  this.Events.trigger("debug", "Could not queue ".concat(options.id), {
	                    args: args,
	                    options: options,
	                    error: error
	                  });
	                  job.doDrop({
	                    error: error
	                  });
	                  return _context2.abrupt("return", false);

	                case 17:
	                  if (!blocked) {
	                    _context2.next = 22;
	                    break;
	                  }

	                  job.doDrop();
	                  return _context2.abrupt("return", true);

	                case 22:
	                  if (!reachedHWM) {
	                    _context2.next = 28;
	                    break;
	                  }

	                  shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0;

	                  if (shifted != null) {
	                    shifted.doDrop();
	                  }

	                  if (!(shifted == null || strategy === Bottleneck.prototype.strategy.OVERFLOW)) {
	                    _context2.next = 28;
	                    break;
	                  }

	                  if (shifted == null) {
	                    job.doDrop();
	                  }

	                  return _context2.abrupt("return", reachedHWM);

	                case 28:
	                  job.doQueue(reachedHWM, blocked);

	                  this._queues.push(job);

	                  _context2.next = 32;
	                  return this._drainAll();

	                case 32:
	                  return _context2.abrupt("return", reachedHWM);

	                case 33:
	                case "end":
	                  return _context2.stop();
	              }
	            }
	          }, _callee2, this, [[2, 11]]);
	        }));

	        function _addToQueue(_x5) {
	          return _addToQueue2.apply(this, arguments);
	        }

	        return _addToQueue;
	      }()
	    }, {
	      key: "_receive",
	      value: function _receive(job) {
	        if (this._states.jobStatus(job.options.id) != null) {
	          job._reject(new Bottleneck.prototype.BottleneckError("A job with the same id already exists (id=".concat(job.options.id, ")")));

	          return false;
	        } else {
	          job.doReceive();
	          return this._submitLock.schedule(this._addToQueue, job);
	        }
	      }
	    }, {
	      key: "submit",
	      value: function submit() {
	        var _this6 = this;

	        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	          args[_key2] = arguments[_key2];
	        }

	        var cb, fn, job, options, ref, ref1, task;

	        if (typeof args[0] === "function") {
	          var _ref4, _ref5, _splice$call, _splice$call2;

	          ref = args, (_ref4 = ref, _ref5 = _toArray(_ref4), fn = _ref5[0], args = _ref5.slice(1), _ref4), (_splice$call = splice.call(args, -1), _splice$call2 = _slicedToArray(_splice$call, 1), cb = _splice$call2[0], _splice$call);
	          options = parser$8.load({}, this.jobDefaults);
	        } else {
	          var _ref6, _ref7, _splice$call3, _splice$call4;

	          ref1 = args, (_ref6 = ref1, _ref7 = _toArray(_ref6), options = _ref7[0], fn = _ref7[1], args = _ref7.slice(2), _ref6), (_splice$call3 = splice.call(args, -1), _splice$call4 = _slicedToArray(_splice$call3, 1), cb = _splice$call4[0], _splice$call3);
	          options = parser$8.load(options, this.jobDefaults);
	        }

	        task = function task() {
	          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
	            args[_key3] = arguments[_key3];
	          }

	          return new _this6.Promise(function (resolve, reject) {
	            return fn.apply(void 0, args.concat([function () {
	              for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
	                args[_key4] = arguments[_key4];
	              }

	              return (args[0] != null ? reject : resolve)(args);
	            }]));
	          });
	        };

	        job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise);
	        job.promise.then(function (args) {
	          return typeof cb === "function" ? cb.apply(void 0, _toConsumableArray(args)) : void 0;
	        })["catch"](function (args) {
	          if (Array.isArray(args)) {
	            return typeof cb === "function" ? cb.apply(void 0, _toConsumableArray(args)) : void 0;
	          } else {
	            return typeof cb === "function" ? cb(args) : void 0;
	          }
	        });
	        return this._receive(job);
	      }
	    }, {
	      key: "schedule",
	      value: function schedule() {
	        for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
	          args[_key5] = arguments[_key5];
	        }

	        var job, options, task;

	        if (typeof args[0] === "function") {
	          var _args3 = args;

	          var _args4 = _toArray(_args3);

	          task = _args4[0];
	          args = _args4.slice(1);
	          options = {};
	        } else {
	          var _args5 = args;

	          var _args6 = _toArray(_args5);

	          options = _args6[0];
	          task = _args6[1];
	          args = _args6.slice(2);
	        }

	        job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise);

	        this._receive(job);

	        return job.promise;
	      }
	    }, {
	      key: "wrap",
	      value: function wrap(fn) {
	        var schedule, wrapped;
	        schedule = this.schedule.bind(this);

	        wrapped = function wrapped() {
	          for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
	            args[_key6] = arguments[_key6];
	          }

	          return schedule.apply(void 0, [fn.bind(this)].concat(args));
	        };

	        wrapped.withOptions = function (options) {
	          for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
	            args[_key7 - 1] = arguments[_key7];
	          }

	          return schedule.apply(void 0, [options, fn].concat(args));
	        };

	        return wrapped;
	      }
	    }, {
	      key: "updateSettings",
	      value: function () {
	        var _updateSettings = _asyncToGenerator(
	        /*#__PURE__*/
	        regeneratorRuntime.mark(function _callee3() {
	          var options,
	              _args7 = arguments;
	          return regeneratorRuntime.wrap(function _callee3$(_context3) {
	            while (1) {
	              switch (_context3.prev = _context3.next) {
	                case 0:
	                  options = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : {};
	                  _context3.next = 3;
	                  return this._store.__updateSettings__(parser$8.overwrite(options, this.storeDefaults));

	                case 3:
	                  parser$8.overwrite(options, this.instanceDefaults, this);
	                  return _context3.abrupt("return", this);

	                case 5:
	                case "end":
	                  return _context3.stop();
	              }
	            }
	          }, _callee3, this);
	        }));

	        function updateSettings() {
	          return _updateSettings.apply(this, arguments);
	        }

	        return updateSettings;
	      }()
	    }, {
	      key: "currentReservoir",
	      value: function currentReservoir() {
	        return this._store.__currentReservoir__();
	      }
	    }, {
	      key: "incrementReservoir",
	      value: function incrementReservoir() {
	        var incr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
	        return this._store.__incrementReservoir__(incr);
	      }
	    }]);

	    return Bottleneck;
	  }();
	  Bottleneck["default"] = Bottleneck;
	  Bottleneck.Events = Events$6;
	  Bottleneck.version = Bottleneck.prototype.version = require$$8.version;
	  Bottleneck.strategy = Bottleneck.prototype.strategy = {
	    LEAK: 1,
	    OVERFLOW: 2,
	    OVERFLOW_PRIORITY: 4,
	    BLOCK: 3
	  };
	  Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1;
	  Bottleneck.Group = Bottleneck.prototype.Group = Group_1;
	  Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = RedisConnection_1;
	  Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = IORedisConnection_1;
	  Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1;
	  Bottleneck.prototype.jobDefaults = {
	    priority: DEFAULT_PRIORITY$1,
	    weight: 1,
	    expiration: null,
	    id: "<no-id>"
	  };
	  Bottleneck.prototype.storeDefaults = {
	    maxConcurrent: null,
	    minTime: 0,
	    highWater: null,
	    strategy: Bottleneck.prototype.strategy.LEAK,
	    penalty: null,
	    reservoir: null,
	    reservoirRefreshInterval: null,
	    reservoirRefreshAmount: null,
	    reservoirIncreaseInterval: null,
	    reservoirIncreaseAmount: null,
	    reservoirIncreaseMaximum: null
	  };
	  Bottleneck.prototype.localStoreDefaults = {
	    Promise: Promise,
	    timeout: null,
	    heartbeatInterval: 250
	  };
	  Bottleneck.prototype.redisStoreDefaults = {
	    Promise: Promise,
	    timeout: null,
	    heartbeatInterval: 5000,
	    clientTimeout: 10000,
	    Redis: null,
	    clientOptions: {},
	    clusterNodes: null,
	    clearDatastore: false,
	    connection: null
	  };
	  Bottleneck.prototype.instanceDefaults = {
	    datastore: "local",
	    connection: null,
	    id: "<no-id>",
	    rejectOnDrop: true,
	    trackDoneStatus: false,
	    Promise: Promise
	  };
	  Bottleneck.prototype.stopDefaults = {
	    enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.",
	    dropWaitingJobs: true,
	    dropErrorMessage: "This limiter has been stopped."
	  };
	  return Bottleneck;
	}.call(commonjsGlobal);

	var Bottleneck_1 = Bottleneck;

	var es5 = Bottleneck_1;

	return es5;

})));