enterprise-fetch 1.0.0 → 2.0.0

package/dist/client/enterprise-fetch.cjs.js

@@ -1,1300 +1,593 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('cross-fetch')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'cross-fetch'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['enterprise-fetch-legacy'] = {}, global.fetch));
-}(this, (function (exports, fetch) { 'use strict';
-
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
-
-  function _defineProperty(obj, key, value) {
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["enterprise-fetch-legacy"] = {}));
+})(this, (function (exports) { 'use strict';
+
+  function _typeof$1(o) {
+    "@babel/helpers - typeof";
 
-    return obj;
+    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof$1(o);
   }
 
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
+  function toPrimitive(t, r) {
+    if ("object" != _typeof$1(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != _typeof$1(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
   }
 
-  function _iterableToArrayLimit(arr, i) {
-    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _e = undefined;
+  function toPropertyKey(t) {
+    var i = toPrimitive(t, "string");
+    return "symbol" == _typeof$1(i) ? i : i + "";
+  }
 
-    try {
-      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-        _arr.push(_s.value);
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
 
-        if (i && _arr.length === i) break;
-      }
-    } catch (err) {
-      _d = true;
-      _e = err;
-    } finally {
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = true,
+        o = false;
       try {
-        if (!_n && _i["return"] != null) _i["return"]();
+        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = true, n = r;
       } finally {
-        if (_d) throw _e;
+        try {
+          if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
       }
+      return a;
     }
-
-    return _arr;
   }
 
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) {
-      arr2[i] = arr[i];
-    }
-
-    return arr2;
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
   }
 
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
   }
 
   function _nonIterableRest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
-  function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  function _slicedToArray(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
   }
 
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+      if (-1 !== e.indexOf(n)) continue;
+      t[n] = r[n];
     }
-
-    return target;
+    return t;
   }
 
-  function _objectWithoutProperties(source, excluded) {
-    if (source == null) return {};
-    var target = _objectWithoutPropertiesLoose(source, excluded);
-    var key, i;
-
+  function _objectWithoutProperties(e, t) {
+    if (null == e) return {};
+    var o,
+      r,
+      i = _objectWithoutPropertiesLoose(e, t);
     if (Object.getOwnPropertySymbols) {
-      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-      for (i = 0; i < sourceSymbolKeys.length; i++) {
-        key = sourceSymbolKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
-      }
+      var n = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
     }
-
-    return target;
+    return i;
   }
 
-  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  function asyncGeneratorStep(n, t, e, r, o, a, c) {
     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);
+      var i = n[a](c),
+        u = i.value;
+    } catch (n) {
+      return void e(n);
     }
+    i.done ? t(u) : Promise.resolve(u).then(r, o);
   }
-
-  function _asyncToGenerator(fn) {
+  function _asyncToGenerator(n) {
     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);
+      var t = this,
+        e = arguments;
+      return new Promise(function (r, o) {
+        var a = n.apply(t, e);
+        function _next(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
         }
-
-        function _throw(err) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+        function _throw(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
         }
-
-        _next(undefined);
+        _next(void 0);
       });
     };
   }
 
-  function createCommonjsModule(fn) {
-    var module = { exports: {} };
-  	return fn(module, module.exports), module.exports;
+  function getDefaultExportFromCjs (x) {
+  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
   }
 
-  /**
-   * 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.
-   */
-
-  var runtime_1 = createCommonjsModule(function (module) {
-  var runtime = (function (exports) {
-
-    var Op = Object.prototype;
-    var hasOwn = Op.hasOwnProperty;
-    var undefined$1; // 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";
-
-    function define(obj, key, value) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-      return obj[key];
-    }
-    try {
-      // IE 8 has a broken Object.defineProperty that only works on DOM objects.
-      define({}, "");
-    } catch (err) {
-      define = function(obj, key, value) {
-        return obj[key] = value;
-      };
-    }
-
-    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;
-    }
-    exports.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;
-    GeneratorFunction.displayName = define(
-      GeneratorFunctionPrototype,
-      toStringTagSymbol,
-      "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) {
-        define(prototype, method, function(arg) {
-          return this._invoke(method, arg);
-        });
-      });
-    }
-
-    exports.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;
-    };
-
-    exports.mark = function(genFun) {
-      if (Object.setPrototypeOf) {
-        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-      } else {
-        genFun.__proto__ = GeneratorFunctionPrototype;
-        define(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.
-    exports.awrap = function(arg) {
-      return { __await: arg };
-    };
-
-    function AsyncIterator(generator, PromiseImpl) {
-      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 PromiseImpl.resolve(value.__await).then(function(value) {
-              invoke("next", value, resolve, reject);
-            }, function(err) {
-              invoke("throw", err, resolve, reject);
-            });
-          }
-
-          return PromiseImpl.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 PromiseImpl(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;
-    };
-    exports.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.
-    exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-      if (PromiseImpl === void 0) PromiseImpl = Promise;
-
-      var iter = new AsyncIterator(
-        wrap(innerFn, outerFn, self, tryLocsList),
-        PromiseImpl
-      );
-
-      return exports.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 regeneratorRuntime$1 = {exports: {}};
 
-          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;
-            }
+  var OverloadYield = {exports: {}};
 
-            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$1) {
-        // A .throw or .return when the delegate iterator has no .throw
-        // method always terminates the yield* loop.
-        context.delegate = null;
-
-        if (context.method === "throw") {
-          // Note: ["return"] must be used for ES3 parsing compatibility.
-          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$1;
-            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$1;
-        }
-
-      } 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);
-
-    define(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);
-    }
-
-    exports.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$1;
-            next.done = true;
-
-            return next;
-          };
-
-          return next.next = next;
-        }
-      }
-
-      // Return an iterator with no values.
-      return { next: doneResult };
-    }
-    exports.values = values;
-
-    function doneResult() {
-      return { value: undefined$1, 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$1;
-        this.done = false;
-        this.delegate = null;
-
-        this.method = "next";
-        this.arg = undefined$1;
-
-        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$1;
-            }
-          }
-        }
-      },
-
-      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$1;
-          }
-
-          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$1;
-        }
+  var hasRequiredOverloadYield;
 
-        return ContinueSentinel;
-      }
-    };
-
-    // Regardless of whether this script is executing as a CommonJS module
-    // or not, return the runtime object so that we can declare the variable
-    // regeneratorRuntime in the outer scope, which allows this module to be
-    // injected easily by `bin/regenerator --include-runtime script.js`.
-    return exports;
-
-  }(
-    // If this script is executing as a CommonJS module, use module.exports
-    // as the regeneratorRuntime namespace. Otherwise create a new empty
-    // object. Either way, the resulting object will be used to initialize
-    // the regeneratorRuntime variable at the top of this file.
-    module.exports 
-  ));
-
-  try {
-    regeneratorRuntime = runtime;
-  } catch (accidentalStrictMode) {
-    // This module should not be running in strict mode, so the above
-    // assignment should always work unless something is misconfigured. Just
-    // in case runtime.js accidentally runs in strict mode, we can escape
-    // strict mode using a global Function call. This could conceivably fail
-    // if a Content Security Policy forbids using Function, but in that case
-    // the proper solution is to fix the accidental strict mode problem. If
-    // you've misconfigured your bundler to force strict mode and applied a
-    // CSP to forbid Function, and you're not willing to fix either of those
-    // problems, please detail your unique predicament in a GitHub issue.
-    Function("r", "regeneratorRuntime = r")(runtime);
+  function requireOverloadYield () {
+  	if (hasRequiredOverloadYield) return OverloadYield.exports;
+  	hasRequiredOverloadYield = 1;
+  	(function (module) {
+  		function _OverloadYield(e, d) {
+  		  this.v = e, this.k = d;
+  		}
+  		module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (OverloadYield));
+  	return OverloadYield.exports;
   }
-  });
-
-  var regenerator = runtime_1;
 
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function _typeof(obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function _typeof(obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
+  var regenerator$1 = {exports: {}};
+
+  var regeneratorDefine = {exports: {}};
+
+  var hasRequiredRegeneratorDefine;
+
+  function requireRegeneratorDefine () {
+  	if (hasRequiredRegeneratorDefine) return regeneratorDefine.exports;
+  	hasRequiredRegeneratorDefine = 1;
+  	(function (module) {
+  		function _regeneratorDefine(e, r, n, t) {
+  		  var i = Object.defineProperty;
+  		  try {
+  		    i({}, "", {});
+  		  } catch (e) {
+  		    i = 0;
+  		  }
+  		  module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {
+  		    function o(r, n) {
+  		      _regeneratorDefine(e, r, function (e) {
+  		        return this._invoke(r, n, e);
+  		      });
+  		    }
+  		    r ? i ? i(e, r, {
+  		      value: n,
+  		      enumerable: !t,
+  		      configurable: !t,
+  		      writable: !t
+  		    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  		  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _regeneratorDefine(e, r, n, t);
+  		}
+  		module.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorDefine));
+  	return regeneratorDefine.exports;
   }
 
-  function assign(obj, props) {
-    for (var key in props) {
-      Object.defineProperty(obj, key, {
-        value: props[key],
-        enumerable: true,
-        configurable: true
-      });
-    }
-
-    return obj;
+  var hasRequiredRegenerator$1;
+
+  function requireRegenerator$1 () {
+  	if (hasRequiredRegenerator$1) return regenerator$1.exports;
+  	hasRequiredRegenerator$1 = 1;
+  	(function (module) {
+  		var regeneratorDefine = requireRegeneratorDefine();
+  		function _regenerator() {
+  		  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  		  var e,
+  		    t,
+  		    r = "function" == typeof Symbol ? Symbol : {},
+  		    n = r.iterator || "@@iterator",
+  		    o = r.toStringTag || "@@toStringTag";
+  		  function i(r, n, o, i) {
+  		    var c = n && n.prototype instanceof Generator ? n : Generator,
+  		      u = Object.create(c.prototype);
+  		    return regeneratorDefine(u, "_invoke", function (r, n, o) {
+  		      var i,
+  		        c,
+  		        u,
+  		        f = 0,
+  		        p = o || [],
+  		        y = false,
+  		        G = {
+  		          p: 0,
+  		          n: 0,
+  		          v: e,
+  		          a: d,
+  		          f: d.bind(e, 4),
+  		          d: function d(t, r) {
+  		            return i = t, c = 0, u = e, G.n = r, a;
+  		          }
+  		        };
+  		      function d(r, n) {
+  		        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+  		          var o,
+  		            i = p[t],
+  		            d = G.p,
+  		            l = i[2];
+  		          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+  		        }
+  		        if (o || r > 1) return a;
+  		        throw y = true, n;
+  		      }
+  		      return function (o, p, l) {
+  		        if (f > 1) throw TypeError("Generator is already running");
+  		        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+  		          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+  		          try {
+  		            if (f = 2, i) {
+  		              if (c || (o = "next"), t = i[o]) {
+  		                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+  		                if (!t.done) return t;
+  		                u = t.value, c < 2 && (c = 0);
+  		              } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+  		              i = e;
+  		            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+  		          } catch (t) {
+  		            i = e, c = 1, u = t;
+  		          } finally {
+  		            f = 1;
+  		          }
+  		        }
+  		        return {
+  		          value: t,
+  		          done: y
+  		        };
+  		      };
+  		    }(r, o, i), true), u;
+  		  }
+  		  var a = {};
+  		  function Generator() {}
+  		  function GeneratorFunction() {}
+  		  function GeneratorFunctionPrototype() {}
+  		  t = Object.getPrototypeOf;
+  		  var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function () {
+  		      return this;
+  		    }), t),
+  		    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  		  function f(e) {
+  		    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  		  }
+  		  return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), regeneratorDefine(u), regeneratorDefine(u, o, "Generator"), regeneratorDefine(u, n, function () {
+  		    return this;
+  		  }), regeneratorDefine(u, "toString", function () {
+  		    return "[object Generator]";
+  		  }), (module.exports = _regenerator = function _regenerator() {
+  		    return {
+  		      w: i,
+  		      m: f
+  		    };
+  		  }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+  		}
+  		module.exports = _regenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regenerator$1));
+  	return regenerator$1.exports;
   }
 
-  function createError(err, code, props) {
-    if (!err || typeof err === 'string') {
-      throw new TypeError('Please pass an Error to err-code');
-    }
-
-    if (!props) {
-      props = {};
-    }
-
-    if (_typeof(code) === 'object') {
-      props = code;
-      code = undefined;
-    }
-
-    if (code != null) {
-      props.code = code;
-    }
-
-    try {
-      return assign(err, props);
-    } catch (_) {
-      props.message = err.message;
-      props.stack = err.stack;
-
-      var ErrClass = function ErrClass() {};
-
-      ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
-      return assign(new ErrClass(), props);
-    }
+  var regeneratorAsync = {exports: {}};
+
+  var regeneratorAsyncGen = {exports: {}};
+
+  var regeneratorAsyncIterator = {exports: {}};
+
+  var hasRequiredRegeneratorAsyncIterator;
+
+  function requireRegeneratorAsyncIterator () {
+  	if (hasRequiredRegeneratorAsyncIterator) return regeneratorAsyncIterator.exports;
+  	hasRequiredRegeneratorAsyncIterator = 1;
+  	(function (module) {
+  		var OverloadYield = requireOverloadYield();
+  		var regeneratorDefine = requireRegeneratorDefine();
+  		function AsyncIterator(t, e) {
+  		  function n(r, o, i, f) {
+  		    try {
+  		      var c = t[r](o),
+  		        u = c.value;
+  		      return u instanceof OverloadYield ? e.resolve(u.v).then(function (t) {
+  		        n("next", t, i, f);
+  		      }, function (t) {
+  		        n("throw", t, i, f);
+  		      }) : e.resolve(u).then(function (t) {
+  		        c.value = t, i(c);
+  		      }, function (t) {
+  		        return n("throw", t, i, f);
+  		      });
+  		    } catch (t) {
+  		      f(t);
+  		    }
+  		  }
+  		  var r;
+  		  this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () {
+  		    return this;
+  		  })), regeneratorDefine(this, "_invoke", function (t, o, i) {
+  		    function f() {
+  		      return new e(function (e, r) {
+  		        n(t, i, e, r);
+  		      });
+  		    }
+  		    return r = r ? r.then(f, f) : f();
+  		  }, true);
+  		}
+  		module.exports = AsyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorAsyncIterator));
+  	return regeneratorAsyncIterator.exports;
   }
 
-  var errCode = createError;
-
-  function RetryOperation(timeouts, options) {
-    // Compatibility for the old (timeouts, retryForever) signature
-    if (typeof options === 'boolean') {
-      options = { forever: options };
-    }
-
-    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-    this._timeouts = timeouts;
-    this._options = options || {};
-    this._maxRetryTime = options && options.maxRetryTime || Infinity;
-    this._fn = null;
-    this._errors = [];
-    this._attempts = 1;
-    this._operationTimeout = null;
-    this._operationTimeoutCb = null;
-    this._timeout = null;
-    this._operationStart = null;
-
-    if (this._options.forever) {
-      this._cachedTimeouts = this._timeouts.slice(0);
-    }
+  var hasRequiredRegeneratorAsyncGen;
+
+  function requireRegeneratorAsyncGen () {
+  	if (hasRequiredRegeneratorAsyncGen) return regeneratorAsyncGen.exports;
+  	hasRequiredRegeneratorAsyncGen = 1;
+  	(function (module) {
+  		var regenerator = requireRegenerator$1();
+  		var regeneratorAsyncIterator = requireRegeneratorAsyncIterator();
+  		function _regeneratorAsyncGen(r, e, t, o, n) {
+  		  return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise);
+  		}
+  		module.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorAsyncGen));
+  	return regeneratorAsyncGen.exports;
   }
-  var retry_operation = RetryOperation;
-
-  RetryOperation.prototype.reset = function() {
-    this._attempts = 1;
-    this._timeouts = this._originalTimeouts;
-  };
-
-  RetryOperation.prototype.stop = function() {
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-
-    this._timeouts       = [];
-    this._cachedTimeouts = null;
-  };
-
-  RetryOperation.prototype.retry = function(err) {
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-
-    if (!err) {
-      return false;
-    }
-    var currentTime = new Date().getTime();
-    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-      this._errors.unshift(new Error('RetryOperation timeout occurred'));
-      return false;
-    }
-
-    this._errors.push(err);
-
-    var timeout = this._timeouts.shift();
-    if (timeout === undefined) {
-      if (this._cachedTimeouts) {
-        // retry forever, only keep last error
-        this._errors.splice(this._errors.length - 1, this._errors.length);
-        this._timeouts = this._cachedTimeouts.slice(0);
-        timeout = this._timeouts.shift();
-      } else {
-        return false;
-      }
-    }
-
-    var self = this;
-    var timer = setTimeout(function() {
-      self._attempts++;
-
-      if (self._operationTimeoutCb) {
-        self._timeout = setTimeout(function() {
-          self._operationTimeoutCb(self._attempts);
-        }, self._operationTimeout);
-
-        if (self._options.unref) {
-            self._timeout.unref();
-        }
-      }
-
-      self._fn(self._attempts);
-    }, timeout);
-
-    if (this._options.unref) {
-        timer.unref();
-    }
-
-    return true;
-  };
-
-  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-    this._fn = fn;
-
-    if (timeoutOps) {
-      if (timeoutOps.timeout) {
-        this._operationTimeout = timeoutOps.timeout;
-      }
-      if (timeoutOps.cb) {
-        this._operationTimeoutCb = timeoutOps.cb;
-      }
-    }
-
-    var self = this;
-    if (this._operationTimeoutCb) {
-      this._timeout = setTimeout(function() {
-        self._operationTimeoutCb();
-      }, self._operationTimeout);
-    }
-
-    this._operationStart = new Date().getTime();
-
-    this._fn(this._attempts);
-  };
-
-  RetryOperation.prototype.try = function(fn) {
-    console.log('Using RetryOperation.try() is deprecated');
-    this.attempt(fn);
-  };
-
-  RetryOperation.prototype.start = function(fn) {
-    console.log('Using RetryOperation.start() is deprecated');
-    this.attempt(fn);
-  };
-
-  RetryOperation.prototype.start = RetryOperation.prototype.try;
-
-  RetryOperation.prototype.errors = function() {
-    return this._errors;
-  };
-
-  RetryOperation.prototype.attempts = function() {
-    return this._attempts;
-  };
-
-  RetryOperation.prototype.mainError = function() {
-    if (this._errors.length === 0) {
-      return null;
-    }
-
-    var counts = {};
-    var mainError = null;
-    var mainErrorCount = 0;
-
-    for (var i = 0; i < this._errors.length; i++) {
-      var error = this._errors[i];
-      var message = error.message;
-      var count = (counts[message] || 0) + 1;
-
-      counts[message] = count;
-
-      if (count >= mainErrorCount) {
-        mainError = error;
-        mainErrorCount = count;
-      }
-    }
-
-    return mainError;
-  };
-
-  var retry$1 = createCommonjsModule(function (module, exports) {
-  exports.operation = function(options) {
-    var timeouts = exports.timeouts(options);
-    return new retry_operation(timeouts, {
-        forever: options && options.forever,
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-    });
-  };
-
-  exports.timeouts = function(options) {
-    if (options instanceof Array) {
-      return [].concat(options);
-    }
-
-    var opts = {
-      retries: 10,
-      factor: 2,
-      minTimeout: 1 * 1000,
-      maxTimeout: Infinity,
-      randomize: false
-    };
-    for (var key in options) {
-      opts[key] = options[key];
-    }
-
-    if (opts.minTimeout > opts.maxTimeout) {
-      throw new Error('minTimeout is greater than maxTimeout');
-    }
-
-    var timeouts = [];
-    for (var i = 0; i < opts.retries; i++) {
-      timeouts.push(this.createTimeout(i, opts));
-    }
-
-    if (options && options.forever && !timeouts.length) {
-      timeouts.push(this.createTimeout(i, opts));
-    }
-
-    // sort the array numerically ascending
-    timeouts.sort(function(a,b) {
-      return a - b;
-    });
-
-    return timeouts;
-  };
-
-  exports.createTimeout = function(attempt, opts) {
-    var random = (opts.randomize)
-      ? (Math.random() + 1)
-      : 1;
-
-    var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
-    timeout = Math.min(timeout, opts.maxTimeout);
-
-    return timeout;
-  };
-
-  exports.wrap = function(obj, options, methods) {
-    if (options instanceof Array) {
-      methods = options;
-      options = null;
-    }
 
-    if (!methods) {
-      methods = [];
-      for (var key in obj) {
-        if (typeof obj[key] === 'function') {
-          methods.push(key);
-        }
-      }
-    }
+  var hasRequiredRegeneratorAsync;
+
+  function requireRegeneratorAsync () {
+  	if (hasRequiredRegeneratorAsync) return regeneratorAsync.exports;
+  	hasRequiredRegeneratorAsync = 1;
+  	(function (module) {
+  		var regeneratorAsyncGen = requireRegeneratorAsyncGen();
+  		function _regeneratorAsync(n, e, r, t, o) {
+  		  var a = regeneratorAsyncGen(n, e, r, t, o);
+  		  return a.next().then(function (n) {
+  		    return n.done ? n.value : a.next();
+  		  });
+  		}
+  		module.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorAsync));
+  	return regeneratorAsync.exports;
+  }
 
-    for (var i = 0; i < methods.length; i++) {
-      var method   = methods[i];
-      var original = obj[method];
+  var regeneratorKeys = {exports: {}};
+
+  var hasRequiredRegeneratorKeys;
+
+  function requireRegeneratorKeys () {
+  	if (hasRequiredRegeneratorKeys) return regeneratorKeys.exports;
+  	hasRequiredRegeneratorKeys = 1;
+  	(function (module) {
+  		function _regeneratorKeys(e) {
+  		  var n = Object(e),
+  		    r = [];
+  		  for (var t in n) r.unshift(t);
+  		  return function e() {
+  		    for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = false, e;
+  		    return e.done = true, e;
+  		  };
+  		}
+  		module.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorKeys));
+  	return regeneratorKeys.exports;
+  }
 
-      obj[method] = function retryWrapper(original) {
-        var op       = exports.operation(options);
-        var args     = Array.prototype.slice.call(arguments, 1);
-        var callback = args.pop();
+  var regeneratorValues = {exports: {}};
 
-        args.push(function(err) {
-          if (op.retry(err)) {
-            return;
-          }
-          if (err) {
-            arguments[0] = op.mainError();
-          }
-          callback.apply(this, arguments);
-        });
-
-        op.attempt(function() {
-          original.apply(obj, args);
-        });
-      }.bind(obj, original);
-      obj[method].options = options;
-    }
-  };
-  });
+  var _typeof = {exports: {}};
 
-  var retry = retry$1;
+  var hasRequired_typeof;
 
-  var hasOwn = Object.prototype.hasOwnProperty;
+  function require_typeof () {
+  	if (hasRequired_typeof) return _typeof.exports;
+  	hasRequired_typeof = 1;
+  	(function (module) {
+  		function _typeof(o) {
+  		  "@babel/helpers - typeof";
 
-  function isRetryError(err) {
-      return err && err.code === 'EPROMISERETRY' && hasOwn.call(err, 'retried');
+  		  return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+  		    return typeof o;
+  		  } : function (o) {
+  		    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  		  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
+  		}
+  		module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (_typeof));
+  	return _typeof.exports;
   }
 
-  function promiseRetry(fn, options) {
-      var temp;
-      var operation;
+  var hasRequiredRegeneratorValues;
+
+  function requireRegeneratorValues () {
+  	if (hasRequiredRegeneratorValues) return regeneratorValues.exports;
+  	hasRequiredRegeneratorValues = 1;
+  	(function (module) {
+  		var _typeof = require_typeof()["default"];
+  		function _regeneratorValues(e) {
+  		  if (null != e) {
+  		    var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
+  		      r = 0;
+  		    if (t) return t.call(e);
+  		    if ("function" == typeof e.next) return e;
+  		    if (!isNaN(e.length)) return {
+  		      next: function next() {
+  		        return e && r >= e.length && (e = void 0), {
+  		          value: e && e[r++],
+  		          done: !e
+  		        };
+  		      }
+  		    };
+  		  }
+  		  throw new TypeError(_typeof(e) + " is not iterable");
+  		}
+  		module.exports = _regeneratorValues, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorValues));
+  	return regeneratorValues.exports;
+  }
 
-      if (typeof fn === 'object' && typeof options === 'function') {
-          // Swap options and fn when using alternate signature (options, fn)
-          temp = options;
-          options = fn;
-          fn = temp;
-      }
+  var hasRequiredRegeneratorRuntime;
+
+  function requireRegeneratorRuntime () {
+  	if (hasRequiredRegeneratorRuntime) return regeneratorRuntime$1.exports;
+  	hasRequiredRegeneratorRuntime = 1;
+  	(function (module) {
+  		var OverloadYield = requireOverloadYield();
+  		var regenerator = requireRegenerator$1();
+  		var regeneratorAsync = requireRegeneratorAsync();
+  		var regeneratorAsyncGen = requireRegeneratorAsyncGen();
+  		var regeneratorAsyncIterator = requireRegeneratorAsyncIterator();
+  		var regeneratorKeys = requireRegeneratorKeys();
+  		var regeneratorValues = requireRegeneratorValues();
+  		function _regeneratorRuntime() {
+
+  		  var r = regenerator(),
+  		    e = r.m(_regeneratorRuntime),
+  		    t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;
+  		  function n(r) {
+  		    var e = "function" == typeof r && r.constructor;
+  		    return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name));
+  		  }
+  		  var o = {
+  		    "throw": 1,
+  		    "return": 2,
+  		    "break": 3,
+  		    "continue": 3
+  		  };
+  		  function a(r) {
+  		    var e, t;
+  		    return function (n) {
+  		      e || (e = {
+  		        stop: function stop() {
+  		          return t(n.a, 2);
+  		        },
+  		        "catch": function _catch() {
+  		          return n.v;
+  		        },
+  		        abrupt: function abrupt(r, e) {
+  		          return t(n.a, o[r], e);
+  		        },
+  		        delegateYield: function delegateYield(r, o, a) {
+  		          return e.resultName = o, t(n.d, regeneratorValues(r), a);
+  		        },
+  		        finish: function finish(r) {
+  		          return t(n.f, r);
+  		        }
+  		      }, t = function t(r, _t, o) {
+  		        n.p = e.prev, n.n = e.next;
+  		        try {
+  		          return r(_t, o);
+  		        } finally {
+  		          e.next = n.n;
+  		        }
+  		      }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;
+  		      try {
+  		        return r.call(this, e);
+  		      } finally {
+  		        n.p = e.prev, n.n = e.next;
+  		      }
+  		    };
+  		  }
+  		  return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
+  		    return {
+  		      wrap: function wrap(e, t, n, o) {
+  		        return r.w(a(e), t, n, o && o.reverse());
+  		      },
+  		      isGeneratorFunction: n,
+  		      mark: r.m,
+  		      awrap: function awrap(r, e) {
+  		        return new OverloadYield(r, e);
+  		      },
+  		      AsyncIterator: regeneratorAsyncIterator,
+  		      async: function async(r, e, t, o, u) {
+  		        return (n(e) ? regeneratorAsyncGen : regeneratorAsync)(a(r), e, t, o, u);
+  		      },
+  		      keys: regeneratorKeys,
+  		      values: regeneratorValues
+  		    };
+  		  }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+  		}
+  		module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports; 
+  	} (regeneratorRuntime$1));
+  	return regeneratorRuntime$1.exports;
+  }
 
-      operation = retry.operation(options);
-
-      return new Promise(function (resolve, reject) {
-          operation.attempt(function (number) {
-              Promise.resolve()
-              .then(function () {
-                  return fn(function (err) {
-                      if (isRetryError(err)) {
-                          err = err.retried;
-                      }
-
-                      throw errCode(new Error('Retrying'), 'EPROMISERETRY', { retried: err });
-                  }, number);
-              })
-              .then(resolve, function (err) {
-                  if (isRetryError(err)) {
-                      err = err.retried;
-
-                      if (operation.retry(err || new Error())) {
-                          return;
-                      }
-                  }
-
-                  reject(err);
-              });
-          });
-      });
+  var regenerator;
+  var hasRequiredRegenerator;
+
+  function requireRegenerator () {
+  	if (hasRequiredRegenerator) return regenerator;
+  	hasRequiredRegenerator = 1;
+  	// TODO(Babel 8): Remove this file.
+
+  	var runtime = requireRegeneratorRuntime()();
+  	regenerator = runtime;
+
+  	// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
+  	try {
+  	  regeneratorRuntime = runtime;
+  	} catch (accidentalStrictMode) {
+  	  if (typeof globalThis === "object") {
+  	    globalThis.regeneratorRuntime = runtime;
+  	  } else {
+  	    Function("r", "regeneratorRuntime = r")(runtime);
+  	  }
+  	}
+  	return regenerator;
   }
 
-  var promiseRetry_1 = promiseRetry;
+  var regeneratorExports = requireRegenerator();
+  var _regeneratorRuntime = /*@__PURE__*/getDefaultExportFromCjs(regeneratorExports);
+
+  var browser = {exports: {}};
 
   /*globals self, window */
-  /*eslint-disable @mysticatea/prettier */
+  var hasRequiredBrowser;
+  function requireBrowser() {
+    if (hasRequiredBrowser) return browser.exports;
+    hasRequiredBrowser = 1;
 
-  var _ref = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window :
-  /* otherwise */
-  undefined,
+    /*eslint-disable @mysticatea/prettier */
+    var _ref = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : /* otherwise */undefined,
       AbortController = _ref.AbortController,
       AbortSignal = _ref.AbortSignal;
-  /*eslint-enable @mysticatea/prettier */
+    /*eslint-enable @mysticatea/prettier */
 
+    browser.exports = AbortController;
+    browser.exports.AbortSignal = AbortSignal;
+    browser.exports["default"] = AbortController;
+    return browser.exports;
+  }
 
-  var browser = AbortController;
-  var AbortSignal_1 = AbortSignal;
-  var _default = AbortController;
-  browser.AbortSignal = AbortSignal_1;
-  browser["default"] = _default;
+  var browserExports = requireBrowser();
+  var AbortController = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
   /**
    * @param { Promise } promise
@@ -1312,6 +605,401 @@
       });
   }
 
+  var errCode;
+  var hasRequiredErrCode;
+  function requireErrCode() {
+    if (hasRequiredErrCode) return errCode;
+    hasRequiredErrCode = 1;
+    function assign(obj, props) {
+      for (var key in props) {
+        Object.defineProperty(obj, key, {
+          value: props[key],
+          enumerable: true,
+          configurable: true
+        });
+      }
+      return obj;
+    }
+    function createError(err, code, props) {
+      if (!err || typeof err === 'string') {
+        throw new TypeError('Please pass an Error to err-code');
+      }
+      if (!props) {
+        props = {};
+      }
+      if (_typeof$1(code) === 'object') {
+        props = code;
+        code = undefined;
+      }
+      if (code != null) {
+        props.code = code;
+      }
+      try {
+        return assign(err, props);
+      } catch (_) {
+        props.message = err.message;
+        props.stack = err.stack;
+        var ErrClass = function ErrClass() {};
+        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
+        return assign(new ErrClass(), props);
+      }
+    }
+    errCode = createError;
+    return errCode;
+  }
+
+  var retry$1 = {};
+
+  var retry_operation;
+  var hasRequiredRetry_operation;
+
+  function requireRetry_operation () {
+  	if (hasRequiredRetry_operation) return retry_operation;
+  	hasRequiredRetry_operation = 1;
+  	function RetryOperation(timeouts, options) {
+  	  // Compatibility for the old (timeouts, retryForever) signature
+  	  if (typeof options === 'boolean') {
+  	    options = { forever: options };
+  	  }
+
+  	  this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+  	  this._timeouts = timeouts;
+  	  this._options = options || {};
+  	  this._maxRetryTime = options && options.maxRetryTime || Infinity;
+  	  this._fn = null;
+  	  this._errors = [];
+  	  this._attempts = 1;
+  	  this._operationTimeout = null;
+  	  this._operationTimeoutCb = null;
+  	  this._timeout = null;
+  	  this._operationStart = null;
+
+  	  if (this._options.forever) {
+  	    this._cachedTimeouts = this._timeouts.slice(0);
+  	  }
+  	}
+  	retry_operation = RetryOperation;
+
+  	RetryOperation.prototype.reset = function() {
+  	  this._attempts = 1;
+  	  this._timeouts = this._originalTimeouts;
+  	};
+
+  	RetryOperation.prototype.stop = function() {
+  	  if (this._timeout) {
+  	    clearTimeout(this._timeout);
+  	  }
+
+  	  this._timeouts       = [];
+  	  this._cachedTimeouts = null;
+  	};
+
+  	RetryOperation.prototype.retry = function(err) {
+  	  if (this._timeout) {
+  	    clearTimeout(this._timeout);
+  	  }
+
+  	  if (!err) {
+  	    return false;
+  	  }
+  	  var currentTime = new Date().getTime();
+  	  if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+  	    this._errors.unshift(new Error('RetryOperation timeout occurred'));
+  	    return false;
+  	  }
+
+  	  this._errors.push(err);
+
+  	  var timeout = this._timeouts.shift();
+  	  if (timeout === undefined) {
+  	    if (this._cachedTimeouts) {
+  	      // retry forever, only keep last error
+  	      this._errors.splice(this._errors.length - 1, this._errors.length);
+  	      this._timeouts = this._cachedTimeouts.slice(0);
+  	      timeout = this._timeouts.shift();
+  	    } else {
+  	      return false;
+  	    }
+  	  }
+
+  	  var self = this;
+  	  var timer = setTimeout(function() {
+  	    self._attempts++;
+
+  	    if (self._operationTimeoutCb) {
+  	      self._timeout = setTimeout(function() {
+  	        self._operationTimeoutCb(self._attempts);
+  	      }, self._operationTimeout);
+
+  	      if (self._options.unref) {
+  	          self._timeout.unref();
+  	      }
+  	    }
+
+  	    self._fn(self._attempts);
+  	  }, timeout);
+
+  	  if (this._options.unref) {
+  	      timer.unref();
+  	  }
+
+  	  return true;
+  	};
+
+  	RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+  	  this._fn = fn;
+
+  	  if (timeoutOps) {
+  	    if (timeoutOps.timeout) {
+  	      this._operationTimeout = timeoutOps.timeout;
+  	    }
+  	    if (timeoutOps.cb) {
+  	      this._operationTimeoutCb = timeoutOps.cb;
+  	    }
+  	  }
+
+  	  var self = this;
+  	  if (this._operationTimeoutCb) {
+  	    this._timeout = setTimeout(function() {
+  	      self._operationTimeoutCb();
+  	    }, self._operationTimeout);
+  	  }
+
+  	  this._operationStart = new Date().getTime();
+
+  	  this._fn(this._attempts);
+  	};
+
+  	RetryOperation.prototype.try = function(fn) {
+  	  console.log('Using RetryOperation.try() is deprecated');
+  	  this.attempt(fn);
+  	};
+
+  	RetryOperation.prototype.start = function(fn) {
+  	  console.log('Using RetryOperation.start() is deprecated');
+  	  this.attempt(fn);
+  	};
+
+  	RetryOperation.prototype.start = RetryOperation.prototype.try;
+
+  	RetryOperation.prototype.errors = function() {
+  	  return this._errors;
+  	};
+
+  	RetryOperation.prototype.attempts = function() {
+  	  return this._attempts;
+  	};
+
+  	RetryOperation.prototype.mainError = function() {
+  	  if (this._errors.length === 0) {
+  	    return null;
+  	  }
+
+  	  var counts = {};
+  	  var mainError = null;
+  	  var mainErrorCount = 0;
+
+  	  for (var i = 0; i < this._errors.length; i++) {
+  	    var error = this._errors[i];
+  	    var message = error.message;
+  	    var count = (counts[message] || 0) + 1;
+
+  	    counts[message] = count;
+
+  	    if (count >= mainErrorCount) {
+  	      mainError = error;
+  	      mainErrorCount = count;
+  	    }
+  	  }
+
+  	  return mainError;
+  	};
+  	return retry_operation;
+  }
+
+  var hasRequiredRetry$1;
+
+  function requireRetry$1 () {
+  	if (hasRequiredRetry$1) return retry$1;
+  	hasRequiredRetry$1 = 1;
+  	(function (exports) {
+  		var RetryOperation = requireRetry_operation();
+
+  		exports.operation = function(options) {
+  		  var timeouts = exports.timeouts(options);
+  		  return new RetryOperation(timeouts, {
+  		      forever: options && options.forever,
+  		      unref: options && options.unref,
+  		      maxRetryTime: options && options.maxRetryTime
+  		  });
+  		};
+
+  		exports.timeouts = function(options) {
+  		  if (options instanceof Array) {
+  		    return [].concat(options);
+  		  }
+
+  		  var opts = {
+  		    retries: 10,
+  		    factor: 2,
+  		    minTimeout: 1 * 1000,
+  		    maxTimeout: Infinity,
+  		    randomize: false
+  		  };
+  		  for (var key in options) {
+  		    opts[key] = options[key];
+  		  }
+
+  		  if (opts.minTimeout > opts.maxTimeout) {
+  		    throw new Error('minTimeout is greater than maxTimeout');
+  		  }
+
+  		  var timeouts = [];
+  		  for (var i = 0; i < opts.retries; i++) {
+  		    timeouts.push(this.createTimeout(i, opts));
+  		  }
+
+  		  if (options && options.forever && !timeouts.length) {
+  		    timeouts.push(this.createTimeout(i, opts));
+  		  }
+
+  		  // sort the array numerically ascending
+  		  timeouts.sort(function(a,b) {
+  		    return a - b;
+  		  });
+
+  		  return timeouts;
+  		};
+
+  		exports.createTimeout = function(attempt, opts) {
+  		  var random = (opts.randomize)
+  		    ? (Math.random() + 1)
+  		    : 1;
+
+  		  var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+  		  timeout = Math.min(timeout, opts.maxTimeout);
+
+  		  return timeout;
+  		};
+
+  		exports.wrap = function(obj, options, methods) {
+  		  if (options instanceof Array) {
+  		    methods = options;
+  		    options = null;
+  		  }
+
+  		  if (!methods) {
+  		    methods = [];
+  		    for (var key in obj) {
+  		      if (typeof obj[key] === 'function') {
+  		        methods.push(key);
+  		      }
+  		    }
+  		  }
+
+  		  for (var i = 0; i < methods.length; i++) {
+  		    var method   = methods[i];
+  		    var original = obj[method];
+
+  		    obj[method] = function retryWrapper(original) {
+  		      var op       = exports.operation(options);
+  		      var args     = Array.prototype.slice.call(arguments, 1);
+  		      var callback = args.pop();
+
+  		      args.push(function(err) {
+  		        if (op.retry(err)) {
+  		          return;
+  		        }
+  		        if (err) {
+  		          arguments[0] = op.mainError();
+  		        }
+  		        callback.apply(this, arguments);
+  		      });
+
+  		      op.attempt(function() {
+  		        original.apply(obj, args);
+  		      });
+  		    }.bind(obj, original);
+  		    obj[method].options = options;
+  		  }
+  		}; 
+  	} (retry$1));
+  	return retry$1;
+  }
+
+  var retry;
+  var hasRequiredRetry;
+
+  function requireRetry () {
+  	if (hasRequiredRetry) return retry;
+  	hasRequiredRetry = 1;
+  	retry = requireRetry$1();
+  	return retry;
+  }
+
+  var promiseRetry_1;
+  var hasRequiredPromiseRetry;
+
+  function requirePromiseRetry () {
+  	if (hasRequiredPromiseRetry) return promiseRetry_1;
+  	hasRequiredPromiseRetry = 1;
+
+  	var errcode = requireErrCode();
+  	var retry = requireRetry();
+
+  	var hasOwn = Object.prototype.hasOwnProperty;
+
+  	function isRetryError(err) {
+  	    return err && err.code === 'EPROMISERETRY' && hasOwn.call(err, 'retried');
+  	}
+
+  	function promiseRetry(fn, options) {
+  	    var temp;
+  	    var operation;
+
+  	    if (typeof fn === 'object' && typeof options === 'function') {
+  	        // Swap options and fn when using alternate signature (options, fn)
+  	        temp = options;
+  	        options = fn;
+  	        fn = temp;
+  	    }
+
+  	    operation = retry.operation(options);
+
+  	    return new Promise(function (resolve, reject) {
+  	        operation.attempt(function (number) {
+  	            Promise.resolve()
+  	            .then(function () {
+  	                return fn(function (err) {
+  	                    if (isRetryError(err)) {
+  	                        err = err.retried;
+  	                    }
+
+  	                    throw errcode(new Error('Retrying'), 'EPROMISERETRY', { retried: err });
+  	                }, number);
+  	            })
+  	            .then(resolve, function (err) {
+  	                if (isRetryError(err)) {
+  	                    err = err.retried;
+
+  	                    if (operation.retry(err || new Error())) {
+  	                        return;
+  	                    }
+  	                }
+
+  	                reject(err);
+  	            });
+  	        });
+  	    });
+  	}
+
+  	promiseRetry_1 = promiseRetry;
+  	return promiseRetry_1;
+  }
+
+  var promiseRetryExports = requirePromiseRetry();
+  var promiseRetry = /*@__PURE__*/getDefaultExportFromCjs(promiseRetryExports);
+
   var fetchDefaults = {
     // The timeout to apply to requests that do not supply a timeout option
     timeout: 60 * 1000,
@@ -1324,91 +1012,111 @@
     // Do retry function to examine failures and apply custom retry logic
     // return true to retry the fetch call
     doRetry: function () {
-      var _doRetry = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(attempt, res, _ref) {
+      var _doRetry = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(attempt, res, _ref) {
         var url, options, _options$retry, retry, counter;
-
-        return regenerator.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                url = _ref.url, options = _ref.options;
-                // Get the retry policy from options or fetchDefaults
-                _options$retry = options.retry, retry = _options$retry === void 0 ? fetchDefaults.retry : _options$retry;
-
-                if (!(attempt <= retry.retries)) {
-                  _context.next = 7;
-                  break;
-                }
-
-                counter = "".concat(attempt, "/").concat(retry.retries); // Retry request on any network error,
-                // or 4xx or 5xx status codes. No retry on 404
-
-                if (!(!res.status || res.status >= 400 && res.status !== 404)) {
-                  _context.next = 7;
-                  break;
-                }
-
-                if ('message' in res) console.warn("[fetch] Attempt ".concat(counter, " ").concat(res.name, ": ").concat(res.message, " ").concat(url));else console.warn("[fetch] Attempt ".concat(counter, " ").concat(res.status, ": ").concat(res.statusText, " ").concat(url));
-                return _context.abrupt("return", true);
-
-              case 7:
-                return _context.abrupt("return", false);
-
-              case 8:
-              case "end":
-                return _context.stop();
-            }
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              url = _ref.url, options = _ref.options;
+              // Get the retry policy from options or fetchDefaults
+              _options$retry = options.retry, retry = _options$retry === void 0 ? fetchDefaults.retry : _options$retry;
+              if (!(attempt <= retry.retries)) {
+                _context.next = 1;
+                break;
+              }
+              counter = "".concat(attempt, "/").concat(retry.retries); // Retry request on any network error,
+              // or 4xx or 5xx status codes. No retry on 404
+              if (!(!res.status || res.status >= 400 && res.status !== 404)) {
+                _context.next = 1;
+                break;
+              }
+              if ('message' in res) console.warn("[fetch] Attempt ".concat(counter, " ").concat(res.name, ": ").concat(res.message, " ").concat(url));else console.warn("[fetch] Attempt ".concat(counter, " ").concat(res.status, ": ").concat(res.statusText, " ").concat(url));
+              return _context.abrupt("return", true);
+            case 1:
+              return _context.abrupt("return", false);
+            case 2:
+            case "end":
+              return _context.stop();
           }
         }, _callee);
       }));
-
       function doRetry(_x, _x2, _x3) {
         return _doRetry.apply(this, arguments);
       }
-
       return doRetry;
     }()
   };
 
+  var isClient = function isClient() {
+    return typeof window !== 'undefined';
+  };
+
+  var resolveFetch = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var nodeFetch;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!isClient()) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return", window.fetch);
+          case 1:
+            if (!(typeof globalThis.fetch === 'function')) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return", globalThis.fetch);
+          case 2:
+            _context.next = 3;
+            return ('node-fetch');
+          case 3:
+            nodeFetch = _context.sent;
+            return _context.abrupt("return", nodeFetch["default"]);
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function resolveFetch() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
   // Setting http_proxy in env will inject a proxy agent header and disable certificate verification
   var proxyAgent = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
       var proxyUri, _yield$import, HttpsProxyAgent;
-
-      return regenerator.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              proxyUri = typeof process !== 'undefined' && process.env.http_proxy || false;
-
-              if (!proxyUri) {
-                _context.next = 8;
-                break;
-              }
-
-              // console.info(`Proxying via http_proxy: ${process.env.http_proxy}`);
-              process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-              _context.next = 5;
-              return ('https-proxy-agent');
-
-            case 5:
-              _yield$import = _context.sent;
-              HttpsProxyAgent = _yield$import.HttpsProxyAgent;
-              return _context.abrupt("return", {
-                agent: new HttpsProxyAgent(proxyUri)
-              });
-
-            case 8:
-              return _context.abrupt("return", {});
-
-            case 9:
-            case "end":
-              return _context.stop();
-          }
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            proxyUri = !isClient() && typeof process !== 'undefined' && process.env.http_proxy || false;
+            if (!proxyUri) {
+              _context.next = 2;
+              break;
+            }
+            // console.info(`Proxying via http_proxy: ${process.env.http_proxy}`);
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            // NOTE: This uses the HttpsProxyAgent class from https-proxy-agent v7.x
+            // Will break in v8+ where only a default factory function is exported
+            _context.next = 1;
+            return ('https-proxy-agent');
+          case 1:
+            _yield$import = _context.sent;
+            HttpsProxyAgent = _yield$import.HttpsProxyAgent;
+            return _context.abrupt("return", {
+              agent: new HttpsProxyAgent(proxyUri)
+            });
+          case 2:
+            return _context.abrupt("return", {});
+          case 3:
+          case "end":
+            return _context.stop();
         }
       }, _callee);
     }));
-
     return function proxyAgent() {
       return _ref.apply(this, arguments);
     };
@@ -1418,181 +1126,146 @@
     return typeof func === 'function';
   };
 
-  var isClient = function isClient() {
-    return typeof window !== 'undefined';
-  };
-
-  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-  var thisFetch = isClient() ? window.fetch : fetch__default['default'];
-
+  var _excluded = ["retry", "timeout", "doRetry"];
+  function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+  function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
   var fetchWithDefaults = function fetchWithDefaults() {
     var fetchDefaults$1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : fetchDefaults;
-
     // Fetch function using hoisted defaults wrapped in a promise
     // retry function adhering to a default or supplied policy calling
     // a doRetry function on each failure that requires a boolean return
     var enterpriseFetch = /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(url) {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(url) {
         var init,
-            fetchResponse,
-            _args2 = arguments;
-        return regenerator.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                init = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
-                _context2.next = 3;
-                return promiseRetry_1( /*#__PURE__*/function () {
-                  var _ref2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(retry, attempt) {
-                    var _init$retry, _init$timeout, rtimeout, _init$doRetry, doRetry, options, timeoutMs, controller, _yield$to, _yield$to2, error, response;
-
-                    return regenerator.wrap(function _callee$(_context) {
-                      while (1) {
-                        switch (_context.prev = _context.next) {
-                          case 0:
-                            _init$retry = init.retry, _init$retry === void 0 ? fetchDefaults$1.retry : _init$retry, _init$timeout = init.timeout, rtimeout = _init$timeout === void 0 ? fetchDefaults$1.timeout : _init$timeout, _init$doRetry = init.doRetry, doRetry = _init$doRetry === void 0 ? fetchDefaults$1.doRetry || fetchDefaults.doRetry : _init$doRetry, options = _objectWithoutProperties(init, ["retry", "timeout", "doRetry"]);
-                            timeoutMs = rtimeout || fetchDefaults$1.timeout || 60 * 1000; // Abort signal pattern
-
-                            controller = new browser();
-                            setTimeout(function () {
-                              controller.abort();
-                            }, timeoutMs); // Try fetching, wait for error or response
-
-                            _context.t0 = to;
-                            _context.t1 = thisFetch;
-                            _context.t2 = url;
-                            _context.t3 = _objectSpread;
-                            _context.t4 = _objectSpread;
-                            _context.t5 = _objectSpread({}, options);
-                            _context.next = 12;
-                            return proxyAgent();
-
-                          case 12:
-                            _context.t6 = _context.sent;
-                            _context.t7 = (0, _context.t4)(_context.t5, _context.t6);
-                            _context.t8 = {};
-                            _context.t9 = {
-                              // The signal will recieve abort() after timeout elapsed
-                              signal: controller.signal
-                            };
-                            _context.t10 = (0, _context.t3)(_context.t7, _context.t8, _context.t9);
-                            _context.t11 = (0, _context.t1)(_context.t2, _context.t10);
-                            _context.next = 20;
-                            return (0, _context.t0)(_context.t11);
-
-                          case 20:
-                            _yield$to = _context.sent;
-                            _yield$to2 = _slicedToArray(_yield$to, 2);
-                            error = _yield$to2[0];
-                            response = _yield$to2[1];
-
-                            if (!error) {
-                              _context.next = 33;
-                              break;
-                            }
-
-                            _context.t12 = isFunc(doRetry);
-
-                            if (!_context.t12) {
-                              _context.next = 30;
-                              break;
-                            }
-
-                            _context.next = 29;
-                            return doRetry(attempt, error, {
-                              url: url,
-                              options: init
-                            });
-
-                          case 29:
-                            _context.t12 = _context.sent;
-
-                          case 30:
-                            if (!_context.t12) {
-                              _context.next = 32;
-                              break;
-                            }
-
-                            retry(error);
-
-                          case 32:
-                            throw error;
-
-                          case 33:
-                            if (response.ok) {
-                              _context.next = 42;
-                              break;
-                            }
-
-                            _context.t13 = isFunc(doRetry);
-
-                            if (!_context.t13) {
-                              _context.next = 39;
-                              break;
-                            }
-
-                            _context.next = 38;
-                            return doRetry(attempt, response, {
-                              url: url,
-                              options: init
-                            });
-
-                          case 38:
-                            _context.t13 = _context.sent;
-
-                          case 39:
-                            if (!_context.t13) {
-                              _context.next = 41;
-                              break;
-                            }
-
-                            retry(response);
-
-                          case 41:
-                            return _context.abrupt("return", response);
-
-                          case 42:
-                            return _context.abrupt("return", response);
-
-                          case 43:
-                          case "end":
-                            return _context.stop();
+          thisFetch,
+          fetchResponse,
+          _args2 = arguments;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              init = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+              _context2.next = 1;
+              return resolveFetch();
+            case 1:
+              thisFetch = _context2.sent;
+              _context2.next = 2;
+              return promiseRetry(/*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(retry, attempt) {
+                  var _init$retry, _init$timeout, rtimeout, _init$doRetry, doRetry, options, timeoutMs, controller, timeoutId, _yield$to, _yield$to2, error, response, _t, _t2, _t3, _t4, _t5, _t6, _t7, _t8;
+                  return _regeneratorRuntime.wrap(function (_context) {
+                    while (1) switch (_context.prev = _context.next) {
+                      case 0:
+                        _init$retry = init.retry, _init$retry === void 0 ? fetchDefaults$1.retry : _init$retry, _init$timeout = init.timeout, rtimeout = _init$timeout === void 0 ? fetchDefaults$1.timeout : _init$timeout, _init$doRetry = init.doRetry, doRetry = _init$doRetry === void 0 ? fetchDefaults$1.doRetry || fetchDefaults.doRetry : _init$doRetry, options = _objectWithoutProperties(init, _excluded);
+                        timeoutMs = rtimeout || fetchDefaults$1.timeout || 60 * 1000; // Abort signal pattern
+                        // Since v15.4.0 Node.js comes with AbortController out of the box
+                        controller = new AbortController();
+                        timeoutId = setTimeout(function () {
+                          controller.abort();
+                        }, timeoutMs); // Try fetching, wait for error or response
+                        _t = to;
+                        _t2 = thisFetch;
+                        _t3 = url;
+                        _t4 = _objectSpread;
+                        _t5 = _objectSpread;
+                        _t6 = _objectSpread({}, options);
+                        _context.next = 1;
+                        return proxyAgent();
+                      case 1:
+                        _context.next = 2;
+                        return _t(_t2(_t3, _t4(_t5(_t6, _context.sent), {}, {
+                          // The signal will recieve abort() after timeout elapsed
+                          signal: controller.signal
+                        })));
+                      case 2:
+                        _yield$to = _context.sent;
+                        _yield$to2 = _slicedToArray(_yield$to, 2);
+                        error = _yield$to2[0];
+                        response = _yield$to2[1];
+                        if (!error) {
+                          _context.next = 6;
+                          break;
                         }
-                      }
-                    }, _callee);
-                  }));
-
-                  return function (_x2, _x3) {
-                    return _ref2.apply(this, arguments);
-                  };
-                }(), init.retry || fetchDefaults$1.retry);
-
-              case 3:
-                fetchResponse = _context2.sent;
-                return _context2.abrupt("return", fetchResponse);
-
-              case 5:
-              case "end":
-                return _context2.stop();
-            }
+                        clearTimeout(timeoutId);
+                        _t7 = isFunc(doRetry);
+                        if (!_t7) {
+                          _context.next = 4;
+                          break;
+                        }
+                        _context.next = 3;
+                        return doRetry(attempt, error, {
+                          url: url.toString(),
+                          options: init
+                        });
+                      case 3:
+                        _t7 = _context.sent;
+                      case 4:
+                        if (!_t7) {
+                          _context.next = 5;
+                          break;
+                        }
+                        retry(error);
+                      case 5:
+                        throw error;
+                      case 6:
+                        if (response.ok) {
+                          _context.next = 10;
+                          break;
+                        }
+                        clearTimeout(timeoutId);
+                        _t8 = isFunc(doRetry);
+                        if (!_t8) {
+                          _context.next = 8;
+                          break;
+                        }
+                        _context.next = 7;
+                        return doRetry(attempt, response, {
+                          url: url.toString(),
+                          options: init
+                        });
+                      case 7:
+                        _t8 = _context.sent;
+                      case 8:
+                        if (!_t8) {
+                          _context.next = 9;
+                          break;
+                        }
+                        retry(response);
+                      case 9:
+                        return _context.abrupt("return", response);
+                      case 10:
+                        clearTimeout(timeoutId);
+                        return _context.abrupt("return", response);
+                      case 11:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }, _callee);
+                }));
+                return function (_x2, _x3) {
+                  return _ref2.apply(this, arguments);
+                };
+              }(), init.retry || fetchDefaults$1.retry);
+            case 2:
+              fetchResponse = _context2.sent;
+              return _context2.abrupt("return", fetchResponse);
+            case 3:
+            case "end":
+              return _context2.stop();
           }
         }, _callee2);
       }));
-
       return function enterpriseFetch(_x) {
         return _ref.apply(this, arguments);
       };
     }();
-
     return enterpriseFetch;
   };
-  var enterpriseFetch = fetchWithDefaults(fetchDefaults);
+  var fetch = fetchWithDefaults(fetchDefaults);
 
-  exports.default = enterpriseFetch;
+  exports.default = fetch;
+  exports.fetch = fetch;
   exports.fetchWithDefaults = fetchWithDefaults;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));