tinacms-authjs 2.0.4 → 2.0.6

package/dist/tinacms.mjs

@@ -3,9 +3,9 @@ import { AbstractAuthProvider } from "tinacms";
 var react = {};
 var interopRequireDefault = { exports: {} };
 (function(module) {
-  function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-      "default": obj
+  function _interopRequireDefault(e) {
+    return e && e.__esModule ? e : {
+      "default": e
     };
   }
   module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
@@ -13,13 +13,13 @@ var interopRequireDefault = { exports: {} };
 var interopRequireDefaultExports = interopRequireDefault.exports;
 var _typeof = { exports: {} };
 (function(module) {
-  function _typeof2(obj) {
+  function _typeof2(o) {
     "@babel/helpers - typeof";
-    return module.exports = _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof2(obj);
+    return module.exports = _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+      return typeof o2;
+    } : function(o2) {
+      return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof2(o);
   }
   module.exports = _typeof2, module.exports.__esModule = true, module.exports["default"] = module.exports;
 })(_typeof);
@@ -34,319 +34,314 @@ function requireRegeneratorRuntime() {
     var _typeof2 = _typeofExports["default"];
     function _regeneratorRuntime() {
       module.exports = _regeneratorRuntime = function _regeneratorRuntime2() {
-        return exports;
+        return e;
       }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-      var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty2 = Object.defineProperty || function(obj, key, desc) {
-        obj[key] = desc.value;
-      }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-      function define(obj, key, value) {
-        return Object.defineProperty(obj, key, {
-          value,
+      var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t2, e2, r2) {
+        t2[e2] = r2.value;
+      }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
+      function define(t2, e2, r2) {
+        return Object.defineProperty(t2, e2, {
+          value: r2,
           enumerable: true,
           configurable: true,
           writable: true
-        }), obj[key];
+        }), t2[e2];
       }
       try {
         define({}, "");
-      } catch (err) {
-        define = function define2(obj, key, value) {
-          return obj[key] = value;
+      } catch (t2) {
+        define = function define2(t3, e2, r2) {
+          return t3[e2] = r2;
         };
       }
-      function wrap(innerFn, outerFn, self, tryLocsList) {
-        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []);
-        return defineProperty2(generator, "_invoke", {
-          value: makeInvokeMethod(innerFn, self, context)
-        }), generator;
+      function wrap(t2, e2, r2, n2) {
+        var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype), c2 = new Context(n2 || []);
+        return o(a2, "_invoke", {
+          value: makeInvokeMethod(t2, r2, c2)
+        }), a2;
       }
-      function tryCatch(fn, obj, arg) {
+      function tryCatch(t2, e2, r2) {
         try {
           return {
             type: "normal",
-            arg: fn.call(obj, arg)
+            arg: t2.call(e2, r2)
           };
-        } catch (err) {
+        } catch (t3) {
           return {
             type: "throw",
-            arg: err
+            arg: t3
           };
         }
       }
-      exports.wrap = wrap;
-      var ContinueSentinel = {};
+      e.wrap = wrap;
+      var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
       function Generator() {
       }
       function GeneratorFunction() {
       }
       function GeneratorFunctionPrototype() {
       }
-      var IteratorPrototype = {};
-      define(IteratorPrototype, iteratorSymbol, function() {
+      var p = {};
+      define(p, a, function() {
         return this;
       });
-      var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-      NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-      var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-      function defineIteratorMethods(prototype) {
-        ["next", "throw", "return"].forEach(function(method) {
-          define(prototype, method, function(arg) {
-            return this._invoke(method, arg);
+      var d = Object.getPrototypeOf, v = d && d(d(values([])));
+      v && v !== r && n.call(v, a) && (p = v);
+      var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+      function defineIteratorMethods(t2) {
+        ["next", "throw", "return"].forEach(function(e2) {
+          define(t2, e2, function(t3) {
+            return this._invoke(e2, t3);
           });
         });
       }
-      function AsyncIterator(generator, PromiseImpl) {
-        function invoke(method, arg, resolve, reject) {
-          var record = tryCatch(generator[method], generator, arg);
-          if ("throw" !== record.type) {
-            var result = record.arg, value = result.value;
-            return value && "object" == _typeof2(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function(value2) {
-              invoke("next", value2, resolve, reject);
-            }, function(err) {
-              invoke("throw", err, resolve, reject);
-            }) : PromiseImpl.resolve(value).then(function(unwrapped) {
-              result.value = unwrapped, resolve(result);
-            }, function(error) {
-              return invoke("throw", error, resolve, reject);
+      function AsyncIterator(t2, e2) {
+        function invoke(r3, o2, i2, a2) {
+          var c2 = tryCatch(t2[r3], t2, o2);
+          if ("throw" !== c2.type) {
+            var u2 = c2.arg, h2 = u2.value;
+            return h2 && "object" == _typeof2(h2) && n.call(h2, "__await") ? e2.resolve(h2.__await).then(function(t3) {
+              invoke("next", t3, i2, a2);
+            }, function(t3) {
+              invoke("throw", t3, i2, a2);
+            }) : e2.resolve(h2).then(function(t3) {
+              u2.value = t3, i2(u2);
+            }, function(t3) {
+              return invoke("throw", t3, i2, a2);
             });
           }
-          reject(record.arg);
+          a2(c2.arg);
         }
-        var previousPromise;
-        defineProperty2(this, "_invoke", {
-          value: function value(method, arg) {
+        var r2;
+        o(this, "_invoke", {
+          value: function value(t3, n2) {
             function callInvokeWithMethodAndArg() {
-              return new PromiseImpl(function(resolve, reject) {
-                invoke(method, arg, resolve, reject);
+              return new e2(function(e3, r3) {
+                invoke(t3, n2, e3, r3);
               });
             }
-            return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+            return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
           }
         });
       }
-      function makeInvokeMethod(innerFn, self, context) {
-        var state = "suspendedStart";
-        return function(method, arg) {
-          if ("executing" === state)
-            throw new Error("Generator is already running");
-          if ("completed" === state) {
-            if ("throw" === method)
-              throw arg;
-            return doneResult();
-          }
-          for (context.method = method, context.arg = arg; ; ) {
-            var delegate = context.delegate;
-            if (delegate) {
-              var delegateResult = maybeInvokeDelegate(delegate, context);
-              if (delegateResult) {
-                if (delegateResult === ContinueSentinel)
+      function makeInvokeMethod(e2, r2, n2) {
+        var o2 = h;
+        return function(i2, a2) {
+          if (o2 === f)
+            throw Error("Generator is already running");
+          if (o2 === s) {
+            if ("throw" === i2)
+              throw a2;
+            return {
+              value: t,
+              done: true
+            };
+          }
+          for (n2.method = i2, n2.arg = a2; ; ) {
+            var c2 = n2.delegate;
+            if (c2) {
+              var u2 = maybeInvokeDelegate(c2, n2);
+              if (u2) {
+                if (u2 === y)
                   continue;
-                return delegateResult;
+                return u2;
               }
             }
-            if ("next" === context.method)
-              context.sent = context._sent = context.arg;
-            else if ("throw" === context.method) {
-              if ("suspendedStart" === state)
-                throw state = "completed", context.arg;
-              context.dispatchException(context.arg);
+            if ("next" === n2.method)
+              n2.sent = n2._sent = n2.arg;
+            else if ("throw" === n2.method) {
+              if (o2 === h)
+                throw o2 = s, n2.arg;
+              n2.dispatchException(n2.arg);
             } else
-              "return" === context.method && context.abrupt("return", context.arg);
-            state = "executing";
-            var record = tryCatch(innerFn, self, context);
-            if ("normal" === record.type) {
-              if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel)
+              "return" === n2.method && n2.abrupt("return", n2.arg);
+            o2 = f;
+            var p2 = tryCatch(e2, r2, n2);
+            if ("normal" === p2.type) {
+              if (o2 = n2.done ? s : l, p2.arg === y)
                 continue;
               return {
-                value: record.arg,
-                done: context.done
+                value: p2.arg,
+                done: n2.done
               };
             }
-            "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+            "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
           }
         };
       }
-      function maybeInvokeDelegate(delegate, context) {
-        var methodName = context.method, method = delegate.iterator[methodName];
-        if (void 0 === method)
-          return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = void 0, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
-        var record = tryCatch(method, delegate.iterator, context.arg);
-        if ("throw" === record.type)
-          return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
-        var info = record.arg;
-        return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = void 0), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
-      }
-      function pushTryEntry(locs) {
-        var entry = {
-          tryLoc: locs[0]
+      function maybeInvokeDelegate(e2, r2) {
+        var n2 = r2.method, o2 = e2.iterator[n2];
+        if (o2 === t)
+          return r2.delegate = null, "throw" === n2 && e2.iterator["return"] && (r2.method = "return", r2.arg = t, maybeInvokeDelegate(e2, r2), "throw" === r2.method) || "return" !== n2 && (r2.method = "throw", r2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), y;
+        var i2 = tryCatch(o2, e2.iterator, r2.arg);
+        if ("throw" === i2.type)
+          return r2.method = "throw", r2.arg = i2.arg, r2.delegate = null, y;
+        var a2 = i2.arg;
+        return a2 ? a2.done ? (r2[e2.resultName] = a2.value, r2.next = e2.nextLoc, "return" !== r2.method && (r2.method = "next", r2.arg = t), r2.delegate = null, y) : a2 : (r2.method = "throw", r2.arg = new TypeError("iterator result is not an object"), r2.delegate = null, y);
+      }
+      function pushTryEntry(t2) {
+        var e2 = {
+          tryLoc: t2[0]
         };
-        1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+        1 in t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
       }
-      function resetTryEntry(entry) {
-        var record = entry.completion || {};
-        record.type = "normal", delete record.arg, entry.completion = record;
+      function resetTryEntry(t2) {
+        var e2 = t2.completion || {};
+        e2.type = "normal", delete e2.arg, t2.completion = e2;
       }
-      function Context(tryLocsList) {
+      function Context(t2) {
         this.tryEntries = [{
           tryLoc: "root"
-        }], tryLocsList.forEach(pushTryEntry, this), this.reset(true);
-      }
-      function values(iterable) {
-        if (iterable) {
-          var iteratorMethod = iterable[iteratorSymbol];
-          if (iteratorMethod)
-            return iteratorMethod.call(iterable);
-          if ("function" == typeof iterable.next)
-            return iterable;
-          if (!isNaN(iterable.length)) {
-            var i = -1, next = function next2() {
-              for (; ++i < iterable.length; )
-                if (hasOwn.call(iterable, i))
-                  return next2.value = iterable[i], next2.done = false, next2;
-              return next2.value = void 0, next2.done = true, next2;
+        }], t2.forEach(pushTryEntry, this), this.reset(true);
+      }
+      function values(e2) {
+        if (e2 || "" === e2) {
+          var r2 = e2[a];
+          if (r2)
+            return r2.call(e2);
+          if ("function" == typeof e2.next)
+            return e2;
+          if (!isNaN(e2.length)) {
+            var o2 = -1, i2 = function next() {
+              for (; ++o2 < e2.length; )
+                if (n.call(e2, o2))
+                  return next.value = e2[o2], next.done = false, next;
+              return next.value = t, next.done = true, next;
             };
-            return next.next = next;
+            return i2.next = i2;
           }
         }
-        return {
-          next: doneResult
-        };
+        throw new TypeError(_typeof2(e2) + " is not iterable");
       }
-      function doneResult() {
-        return {
-          value: void 0,
-          done: true
-        };
-      }
-      return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty2(Gp, "constructor", {
+      return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
         value: GeneratorFunctionPrototype,
         configurable: true
-      }), defineProperty2(GeneratorFunctionPrototype, "constructor", {
+      }), o(GeneratorFunctionPrototype, "constructor", {
         value: GeneratorFunction,
         configurable: true
-      }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function(genFun) {
-        var ctor = "function" == typeof genFun && genFun.constructor;
-        return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-      }, exports.mark = function(genFun) {
-        return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-      }, exports.awrap = function(arg) {
+      }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function(t2) {
+        var e2 = "function" == typeof t2 && t2.constructor;
+        return !!e2 && (e2 === GeneratorFunction || "GeneratorFunction" === (e2.displayName || e2.name));
+      }, e.mark = function(t2) {
+        return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, define(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
+      }, e.awrap = function(t2) {
         return {
-          __await: arg
+          __await: t2
         };
-      }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
+      }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function() {
         return this;
-      }), exports.AsyncIterator = AsyncIterator, exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-        void 0 === PromiseImpl && (PromiseImpl = Promise);
-        var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-        return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
-          return result.done ? result.value : iter.next();
+      }), e.AsyncIterator = AsyncIterator, e.async = function(t2, r2, n2, o2, i2) {
+        void 0 === i2 && (i2 = Promise);
+        var a2 = new AsyncIterator(wrap(t2, r2, n2, o2), i2);
+        return e.isGeneratorFunction(r2) ? a2 : a2.next().then(function(t3) {
+          return t3.done ? t3.value : a2.next();
         });
-      }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function() {
+      }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function() {
         return this;
-      }), define(Gp, "toString", function() {
+      }), define(g, "toString", function() {
         return "[object Generator]";
-      }), exports.keys = function(val) {
-        var object = Object(val), keys = [];
-        for (var key in object)
-          keys.push(key);
-        return keys.reverse(), function next() {
-          for (; keys.length; ) {
-            var key2 = keys.pop();
-            if (key2 in object)
-              return next.value = key2, next.done = false, next;
+      }), e.keys = function(t2) {
+        var e2 = Object(t2), r2 = [];
+        for (var n2 in e2)
+          r2.push(n2);
+        return r2.reverse(), function next() {
+          for (; r2.length; ) {
+            var t3 = r2.pop();
+            if (t3 in e2)
+              return next.value = t3, next.done = false, next;
           }
           return next.done = true, next;
         };
-      }, exports.values = values, Context.prototype = {
+      }, e.values = values, Context.prototype = {
         constructor: Context,
-        reset: function reset(skipTempReset) {
-          if (this.prev = 0, this.next = 0, this.sent = this._sent = void 0, this.done = false, this.delegate = null, this.method = "next", this.arg = void 0, this.tryEntries.forEach(resetTryEntry), !skipTempReset)
-            for (var name in this)
-              "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = void 0);
+        reset: function reset(e2) {
+          if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e2)
+            for (var r2 in this)
+              "t" === r2.charAt(0) && n.call(this, r2) && !isNaN(+r2.slice(1)) && (this[r2] = t);
         },
         stop: function stop() {
           this.done = true;
-          var rootRecord = this.tryEntries[0].completion;
-          if ("throw" === rootRecord.type)
-            throw rootRecord.arg;
+          var t2 = this.tryEntries[0].completion;
+          if ("throw" === t2.type)
+            throw t2.arg;
           return this.rval;
         },
-        dispatchException: function dispatchException(exception) {
+        dispatchException: function dispatchException(e2) {
           if (this.done)
-            throw exception;
-          var context = this;
-          function handle(loc, caught) {
-            return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = void 0), !!caught;
-          }
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i], record = entry.completion;
-            if ("root" === entry.tryLoc)
+            throw e2;
+          var r2 = this;
+          function handle(n2, o3) {
+            return a2.type = "throw", a2.arg = e2, r2.next = n2, o3 && (r2.method = "next", r2.arg = t), !!o3;
+          }
+          for (var o2 = this.tryEntries.length - 1; o2 >= 0; --o2) {
+            var i2 = this.tryEntries[o2], a2 = i2.completion;
+            if ("root" === i2.tryLoc)
               return handle("end");
-            if (entry.tryLoc <= this.prev) {
-              var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc");
-              if (hasCatch && hasFinally) {
-                if (this.prev < entry.catchLoc)
-                  return handle(entry.catchLoc, true);
-                if (this.prev < entry.finallyLoc)
-                  return handle(entry.finallyLoc);
-              } else if (hasCatch) {
-                if (this.prev < entry.catchLoc)
-                  return handle(entry.catchLoc, true);
+            if (i2.tryLoc <= this.prev) {
+              var c2 = n.call(i2, "catchLoc"), u2 = n.call(i2, "finallyLoc");
+              if (c2 && u2) {
+                if (this.prev < i2.catchLoc)
+                  return handle(i2.catchLoc, true);
+                if (this.prev < i2.finallyLoc)
+                  return handle(i2.finallyLoc);
+              } else if (c2) {
+                if (this.prev < i2.catchLoc)
+                  return handle(i2.catchLoc, true);
               } else {
-                if (!hasFinally)
-                  throw new Error("try statement without catch or finally");
-                if (this.prev < entry.finallyLoc)
-                  return handle(entry.finallyLoc);
+                if (!u2)
+                  throw Error("try statement without catch or finally");
+                if (this.prev < i2.finallyLoc)
+                  return handle(i2.finallyLoc);
               }
             }
           }
         },
-        abrupt: function abrupt(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;
+        abrupt: function abrupt(t2, e2) {
+          for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+            var o2 = this.tryEntries[r2];
+            if (o2.tryLoc <= this.prev && n.call(o2, "finallyLoc") && this.prev < o2.finallyLoc) {
+              var i2 = o2;
               break;
             }
           }
-          finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
-          var record = finallyEntry ? finallyEntry.completion : {};
-          return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+          i2 && ("break" === t2 || "continue" === t2) && i2.tryLoc <= e2 && e2 <= i2.finallyLoc && (i2 = null);
+          var a2 = i2 ? i2.completion : {};
+          return a2.type = t2, a2.arg = e2, i2 ? (this.method = "next", this.next = i2.finallyLoc, y) : this.complete(a2);
         },
-        complete: function complete(record, afterLoc) {
-          if ("throw" === record.type)
-            throw record.arg;
-          return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+        complete: function complete(t2, e2) {
+          if ("throw" === t2.type)
+            throw t2.arg;
+          return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && e2 && (this.next = e2), y;
         },
-        finish: function finish(finallyLoc) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-            if (entry.finallyLoc === finallyLoc)
-              return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+        finish: function finish(t2) {
+          for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+            var r2 = this.tryEntries[e2];
+            if (r2.finallyLoc === t2)
+              return this.complete(r2.completion, r2.afterLoc), resetTryEntry(r2), y;
           }
         },
-        "catch": function _catch(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 ("throw" === record.type) {
-                var thrown = record.arg;
-                resetTryEntry(entry);
+        "catch": function _catch(t2) {
+          for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+            var r2 = this.tryEntries[e2];
+            if (r2.tryLoc === t2) {
+              var n2 = r2.completion;
+              if ("throw" === n2.type) {
+                var o2 = n2.arg;
+                resetTryEntry(r2);
               }
-              return thrown;
+              return o2;
             }
           }
-          throw new Error("illegal catch attempt");
+          throw Error("illegal catch attempt");
         },
-        delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+        delegateYield: function delegateYield(e2, r2, n2) {
           return this.delegate = {
-            iterator: values(iterable),
-            resultName,
-            nextLoc
-          }, "next" === this.method && (this.arg = void 0), ContinueSentinel;
+            iterator: values(e2),
+            resultName: r2,
+            nextLoc: n2
+          }, "next" === this.method && (this.arg = t), y;
         }
-      }, exports;
+      }, e;
     }
     module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(regeneratorRuntime$1);
@@ -381,19 +376,19 @@ function requireToPrimitive() {
   hasRequiredToPrimitive = 1;
   (function(module) {
     var _typeof2 = _typeofExports["default"];
-    function _toPrimitive(input, hint) {
-      if (_typeof2(input) !== "object" || input === null)
-        return input;
-      var prim = input[Symbol.toPrimitive];
-      if (prim !== void 0) {
-        var res = prim.call(input, hint || "default");
-        if (_typeof2(res) !== "object")
-          return res;
+    function toPrimitive2(t, r) {
+      if ("object" != _typeof2(t) || !t)
+        return t;
+      var e = t[Symbol.toPrimitive];
+      if (void 0 !== e) {
+        var i = e.call(t, r || "default");
+        if ("object" != _typeof2(i))
+          return i;
         throw new TypeError("@@toPrimitive must return a primitive value.");
       }
-      return (hint === "string" ? String : Number)(input);
+      return ("string" === r ? String : Number)(t);
     }
-    module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    module.exports = toPrimitive2, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(toPrimitive);
   return toPrimitive.exports;
 }
@@ -405,11 +400,11 @@ function requireToPropertyKey() {
   (function(module) {
     var _typeof2 = _typeofExports["default"];
     var toPrimitive2 = requireToPrimitive();
-    function _toPropertyKey(arg) {
-      var key = toPrimitive2(arg, "string");
-      return _typeof2(key) === "symbol" ? key : String(key);
+    function toPropertyKey2(t) {
+      var i = toPrimitive2(t, "string");
+      return "symbol" == _typeof2(i) ? i : i + "";
     }
-    module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
+    module.exports = toPropertyKey2, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(toPropertyKey);
   return toPropertyKey.exports;
 }
@@ -420,19 +415,13 @@ function requireDefineProperty() {
   hasRequiredDefineProperty = 1;
   (function(module) {
     var toPropertyKey2 = requireToPropertyKey();
-    function _defineProperty(obj, key, value) {
-      key = toPropertyKey2(key);
-      if (key in obj) {
-        Object.defineProperty(obj, key, {
-          value,
-          enumerable: true,
-          configurable: true,
-          writable: true
-        });
-      } else {
-        obj[key] = value;
-      }
-      return obj;
+    function _defineProperty(e, r, t) {
+      return (r = toPropertyKey2(r)) in e ? Object.defineProperty(e, r, {
+        value: t,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      }) : e[r] = t, e;
     }
     module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(defineProperty);
@@ -445,30 +434,24 @@ function requireAsyncToGenerator() {
     return asyncToGenerator.exports;
   hasRequiredAsyncToGenerator = 1;
   (function(module) {
-    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 (n2) {
+        return void e(n2);
       }
+      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(n2) {
+            asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
           }
-          function _throw(err) {
-            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+          function _throw(n2) {
+            asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
           }
           _next(void 0);
         });
@@ -486,9 +469,9 @@ function requireArrayWithHoles() {
     return arrayWithHoles.exports;
   hasRequiredArrayWithHoles = 1;
   (function(module) {
-    function _arrayWithHoles(arr) {
-      if (Array.isArray(arr))
-        return arr;
+    function _arrayWithHoles(r) {
+      if (Array.isArray(r))
+        return r;
     }
     module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(arrayWithHoles);
@@ -501,30 +484,30 @@ function requireIterableToArrayLimit() {
     return iterableToArrayLimit.exports;
   hasRequiredIterableToArrayLimit = 1;
   (function(module) {
-    function _iterableToArrayLimit(arr, i) {
-      var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-      if (null != _i) {
-        var _s, _e, _x, _r, _arr = [], _n = true, _d = false;
+    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 (_x = (_i = _i.call(arr)).next, 0 === i) {
-            if (Object(_i) !== _i)
+          if (i = (t = t.call(r)).next, 0 === l) {
+            if (Object(t) !== t)
               return;
-            _n = false;
+            f = false;
           } else
-            for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = true)
+            for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true)
               ;
-        } catch (err) {
-          _d = true, _e = err;
+        } catch (r2) {
+          o = true, n = r2;
         } finally {
           try {
-            if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r))
+            if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u))
               return;
           } finally {
-            if (_d)
-              throw _e;
+            if (o)
+              throw n;
           }
         }
-        return _arr;
+        return a;
       }
     }
     module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
@@ -539,12 +522,11 @@ function requireArrayLikeToArray() {
     return arrayLikeToArray.exports;
   hasRequiredArrayLikeToArray = 1;
   (function(module) {
-    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;
     }
     module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(arrayLikeToArray);
@@ -557,18 +539,13 @@ function requireUnsupportedIterableToArray() {
   hasRequiredUnsupportedIterableToArray = 1;
   (function(module) {
     var arrayLikeToArray2 = requireArrayLikeToArray();
-    function _unsupportedIterableToArray(o, minLen) {
-      if (!o)
-        return;
-      if (typeof o === "string")
-        return arrayLikeToArray2(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 arrayLikeToArray2(o, minLen);
+    function _unsupportedIterableToArray(r, a) {
+      if (r) {
+        if ("string" == typeof r)
+          return arrayLikeToArray2(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) ? arrayLikeToArray2(r, a) : void 0;
+      }
     }
     module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(unsupportedIterableToArray);
@@ -598,8 +575,8 @@ function requireSlicedToArray() {
     var iterableToArrayLimit2 = requireIterableToArrayLimit();
     var unsupportedIterableToArray2 = requireUnsupportedIterableToArray();
     var nonIterableRest2 = requireNonIterableRest();
-    function _slicedToArray(arr, i) {
-      return arrayWithHoles2(arr) || iterableToArrayLimit2(arr, i) || unsupportedIterableToArray2(arr, i) || nonIterableRest2();
+    function _slicedToArray(r, e) {
+      return arrayWithHoles2(r) || iterableToArrayLimit2(r, e) || unsupportedIterableToArray2(r, e) || nonIterableRest2();
     }
     module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(slicedToArray);
@@ -614,11 +591,10 @@ function requireAssertThisInitialized() {
     return assertThisInitialized.exports;
   hasRequiredAssertThisInitialized = 1;
   (function(module) {
-    function _assertThisInitialized(self) {
-      if (self === void 0) {
+    function _assertThisInitialized(e) {
+      if (void 0 === e)
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-      }
-      return self;
+      return e;
     }
     module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(assertThisInitialized);
@@ -631,10 +607,9 @@ function requireClassCallCheck() {
     return classCallCheck.exports;
   hasRequiredClassCallCheck = 1;
   (function(module) {
-    function _classCallCheck(instance, Constructor) {
-      if (!(instance instanceof Constructor)) {
+    function _classCallCheck(a, n) {
+      if (!(a instanceof n))
         throw new TypeError("Cannot call a class as a function");
-      }
     }
     module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(classCallCheck);
@@ -648,25 +623,16 @@ function requireCreateClass() {
   hasRequiredCreateClass = 1;
   (function(module) {
     var toPropertyKey2 = requireToPropertyKey();
-    function _defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor)
-          descriptor.writable = true;
-        Object.defineProperty(target, toPropertyKey2(descriptor.key), descriptor);
+    function _defineProperties(e, r) {
+      for (var t = 0; t < r.length; t++) {
+        var o = r[t];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey2(o.key), o);
       }
     }
-    function _createClass(Constructor, protoProps, staticProps) {
-      if (protoProps)
-        _defineProperties(Constructor.prototype, protoProps);
-      if (staticProps)
-        _defineProperties(Constructor, staticProps);
-      Object.defineProperty(Constructor, "prototype", {
+    function _createClass(e, r, t) {
+      return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
         writable: false
-      });
-      return Constructor;
+      }), e;
     }
     module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(createClass);
@@ -680,12 +646,10 @@ function requireSetPrototypeOf() {
     return setPrototypeOf.exports;
   hasRequiredSetPrototypeOf = 1;
   (function(module) {
-    function _setPrototypeOf(o, p) {
-      module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
-        o2.__proto__ = p2;
-        return o2;
-      }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-      return _setPrototypeOf(o, p);
+    function _setPrototypeOf(t, e) {
+      return module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+        return t2.__proto__ = e2, t2;
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _setPrototypeOf(t, e);
     }
     module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(setPrototypeOf);
@@ -698,22 +662,18 @@ function requireInherits() {
   hasRequiredInherits = 1;
   (function(module) {
     var setPrototypeOf2 = requireSetPrototypeOf();
-    function _inherits(subClass, superClass) {
-      if (typeof superClass !== "function" && superClass !== null) {
+    function _inherits(t, e) {
+      if ("function" != typeof e && null !== e)
         throw new TypeError("Super expression must either be null or a function");
-      }
-      subClass.prototype = Object.create(superClass && superClass.prototype, {
+      t.prototype = Object.create(e && e.prototype, {
         constructor: {
-          value: subClass,
+          value: t,
           writable: true,
           configurable: true
         }
-      });
-      Object.defineProperty(subClass, "prototype", {
+      }), Object.defineProperty(t, "prototype", {
         writable: false
-      });
-      if (superClass)
-        setPrototypeOf2(subClass, superClass);
+      }), e && setPrototypeOf2(t, e);
     }
     module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(inherits);
@@ -728,13 +688,12 @@ function requirePossibleConstructorReturn() {
   (function(module) {
     var _typeof2 = _typeofExports["default"];
     var assertThisInitialized2 = requireAssertThisInitialized();
-    function _possibleConstructorReturn(self, call) {
-      if (call && (_typeof2(call) === "object" || typeof call === "function")) {
-        return call;
-      } else if (call !== void 0) {
+    function _possibleConstructorReturn(t, e) {
+      if (e && ("object" == _typeof2(e) || "function" == typeof e))
+        return e;
+      if (void 0 !== e)
         throw new TypeError("Derived constructors may only return object or undefined");
-      }
-      return assertThisInitialized2(self);
+      return assertThisInitialized2(t);
     }
     module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(possibleConstructorReturn);
@@ -747,11 +706,10 @@ function requireGetPrototypeOf() {
     return getPrototypeOf.exports;
   hasRequiredGetPrototypeOf = 1;
   (function(module) {
-    function _getPrototypeOf(o) {
-      module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
-        return o2.__proto__ || Object.getPrototypeOf(o2);
-      }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-      return _getPrototypeOf(o);
+    function _getPrototypeOf(t) {
+      return module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
+        return t2.__proto__ || Object.getPrototypeOf(t2);
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _getPrototypeOf(t);
     }
     module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(getPrototypeOf);
@@ -765,8 +723,12 @@ function requireIsNativeFunction() {
     return isNativeFunction.exports;
   hasRequiredIsNativeFunction = 1;
   (function(module) {
-    function _isNativeFunction(fn) {
-      return Function.toString.call(fn).indexOf("[native code]") !== -1;
+    function _isNativeFunction(t) {
+      try {
+        return -1 !== Function.toString.call(t).indexOf("[native code]");
+      } catch (n) {
+        return "function" == typeof t;
+      }
     }
     module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(isNativeFunction);
@@ -781,19 +743,14 @@ function requireIsNativeReflectConstruct() {
   hasRequiredIsNativeReflectConstruct = 1;
   (function(module) {
     function _isNativeReflectConstruct() {
-      if (typeof Reflect === "undefined" || !Reflect.construct)
-        return false;
-      if (Reflect.construct.sham)
-        return false;
-      if (typeof Proxy === "function")
-        return true;
       try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
         }));
-        return true;
-      } catch (e) {
-        return false;
+      } catch (t2) {
       }
+      return (module.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+        return !!t;
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
     }
     module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(isNativeReflectConstruct);
@@ -805,23 +762,15 @@ function requireConstruct() {
     return construct.exports;
   hasRequiredConstruct = 1;
   (function(module) {
-    var setPrototypeOf2 = requireSetPrototypeOf();
     var isNativeReflectConstruct2 = requireIsNativeReflectConstruct();
-    function _construct(Parent, args, Class) {
-      if (isNativeReflectConstruct2()) {
-        module.exports = _construct = Reflect.construct.bind(), module.exports.__esModule = true, module.exports["default"] = module.exports;
-      } else {
-        module.exports = _construct = function _construct2(Parent2, args2, Class2) {
-          var a = [null];
-          a.push.apply(a, args2);
-          var Constructor = Function.bind.apply(Parent2, a);
-          var instance = new Constructor();
-          if (Class2)
-            setPrototypeOf2(instance, Class2.prototype);
-          return instance;
-        }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-      }
-      return _construct.apply(null, arguments);
+    var setPrototypeOf2 = requireSetPrototypeOf();
+    function _construct(t, e, r) {
+      if (isNativeReflectConstruct2())
+        return Reflect.construct.apply(null, arguments);
+      var o = [null];
+      o.push.apply(o, e);
+      var p = new (t.bind.apply(t, o))();
+      return r && setPrototypeOf2(p, r.prototype), p;
     }
     module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(construct);
@@ -837,33 +786,30 @@ function requireWrapNativeSuper() {
     var setPrototypeOf2 = requireSetPrototypeOf();
     var isNativeFunction2 = requireIsNativeFunction();
     var construct2 = requireConstruct();
-    function _wrapNativeSuper(Class) {
-      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
-      module.exports = _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
-        if (Class2 === null || !isNativeFunction2(Class2))
-          return Class2;
-        if (typeof Class2 !== "function") {
+    function _wrapNativeSuper(t) {
+      var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
+      return module.exports = _wrapNativeSuper = function _wrapNativeSuper2(t2) {
+        if (null === t2 || !isNativeFunction2(t2))
+          return t2;
+        if ("function" != typeof t2)
           throw new TypeError("Super expression must either be null or a function");
-        }
-        if (typeof _cache !== "undefined") {
-          if (_cache.has(Class2))
-            return _cache.get(Class2);
-          _cache.set(Class2, Wrapper);
+        if (void 0 !== r) {
+          if (r.has(t2))
+            return r.get(t2);
+          r.set(t2, Wrapper);
         }
         function Wrapper() {
-          return construct2(Class2, arguments, getPrototypeOf2(this).constructor);
+          return construct2(t2, arguments, getPrototypeOf2(this).constructor);
         }
-        Wrapper.prototype = Object.create(Class2.prototype, {
+        return Wrapper.prototype = Object.create(t2.prototype, {
           constructor: {
             value: Wrapper,
             enumerable: false,
             writable: true,
             configurable: true
           }
-        });
-        return setPrototypeOf2(Wrapper, Class2);
-      }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-      return _wrapNativeSuper(Class);
+        }), setPrototypeOf2(Wrapper, t2);
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _wrapNativeSuper(t);
     }
     module.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;
   })(wrapNativeSuper);