tinacms-authjs 2.0.4 → 2.0.6

package/dist/tinacms.js

@@ -5,9 +5,9 @@
   var react = {};
   var interopRequireDefault = { exports: {} };
   (function(module2) {
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : {
-        "default": obj
+    function _interopRequireDefault(e) {
+      return e && e.__esModule ? e : {
+        "default": e
       };
     }
     module2.exports = _interopRequireDefault, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
@@ -15,13 +15,13 @@
   var interopRequireDefaultExports = interopRequireDefault.exports;
   var _typeof = { exports: {} };
   (function(module2) {
-    function _typeof2(obj) {
+    function _typeof2(o) {
       "@babel/helpers - typeof";
-      return module2.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;
-      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _typeof2(obj);
+      return module2.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;
+      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _typeof2(o);
     }
     module2.exports = _typeof2, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
   })(_typeof);
@@ -36,319 +36,314 @@
       var _typeof2 = _typeofExports["default"];
       function _regeneratorRuntime() {
         module2.exports = _regeneratorRuntime = function _regeneratorRuntime2() {
-          return exports3;
+          return e;
         }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
-        var exports3 = {}, 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 define2(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 define2(t2, e2, r2) {
+          return Object.defineProperty(t2, e2, {
+            value: r2,
             enumerable: true,
             configurable: true,
             writable: true
-          }), obj[key];
+          }), t2[e2];
         }
         try {
           define2({}, "");
-        } catch (err) {
-          define2 = function define3(obj, key, value) {
-            return obj[key] = value;
+        } catch (t2) {
+          define2 = function define3(t3, e2, r2) {
+            return t3[e2] = r2;
           };
         }
-        function wrap(innerFn, outerFn, self2, 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, self2, 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
             };
           }
         }
-        exports3.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 = {};
-        define2(IteratorPrototype, iteratorSymbol, function() {
+        var p = {};
+        define2(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) {
-            define2(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) {
+            define2(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, self2, 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, self2, 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 = define2(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports3.isGeneratorFunction = function(genFun) {
-          var ctor = "function" == typeof genFun && genFun.constructor;
-          return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-        }, exports3.mark = function(genFun) {
-          return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define2(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-        }, exports3.awrap = function(arg) {
+        }), GeneratorFunction.displayName = define2(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, define2(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
+        }, e.awrap = function(t2) {
           return {
-            __await: arg
+            __await: t2
           };
-        }, defineIteratorMethods(AsyncIterator.prototype), define2(AsyncIterator.prototype, asyncIteratorSymbol, function() {
+        }, defineIteratorMethods(AsyncIterator.prototype), define2(AsyncIterator.prototype, c, function() {
           return this;
-        }), exports3.AsyncIterator = AsyncIterator, exports3.async = function(innerFn, outerFn, self2, tryLocsList, PromiseImpl) {
-          void 0 === PromiseImpl && (PromiseImpl = Promise);
-          var iter = new AsyncIterator(wrap(innerFn, outerFn, self2, tryLocsList), PromiseImpl);
-          return exports3.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), define2(Gp, toStringTagSymbol, "Generator"), define2(Gp, iteratorSymbol, function() {
+        }, defineIteratorMethods(g), define2(g, u, "Generator"), define2(g, a, function() {
           return this;
-        }), define2(Gp, "toString", function() {
+        }), define2(g, "toString", function() {
           return "[object Generator]";
-        }), exports3.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;
           };
-        }, exports3.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;
           }
-        }, exports3;
+        }, e;
       }
       module2.exports = _regeneratorRuntime, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(regeneratorRuntime$1);
@@ -383,19 +378,19 @@
     hasRequiredToPrimitive = 1;
     (function(module2) {
       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);
       }
-      module2.exports = _toPrimitive, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+      module2.exports = toPrimitive2, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(toPrimitive);
     return toPrimitive.exports;
   }
@@ -407,11 +402,11 @@
     (function(module2) {
       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 + "";
       }
-      module2.exports = _toPropertyKey, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
+      module2.exports = toPropertyKey2, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(toPropertyKey);
     return toPropertyKey.exports;
   }
@@ -422,19 +417,13 @@
     hasRequiredDefineProperty = 1;
     (function(module2) {
       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;
       }
       module2.exports = _defineProperty, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(defineProperty);
@@ -447,30 +436,24 @@
       return asyncToGenerator.exports;
     hasRequiredAsyncToGenerator = 1;
     (function(module2) {
-      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 self2 = this, args = arguments;
-          return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self2, 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);
           });
@@ -488,9 +471,9 @@
       return arrayWithHoles.exports;
     hasRequiredArrayWithHoles = 1;
     (function(module2) {
-      function _arrayWithHoles(arr) {
-        if (Array.isArray(arr))
-          return arr;
+      function _arrayWithHoles(r) {
+        if (Array.isArray(r))
+          return r;
       }
       module2.exports = _arrayWithHoles, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(arrayWithHoles);
@@ -503,30 +486,30 @@
       return iterableToArrayLimit.exports;
     hasRequiredIterableToArrayLimit = 1;
     (function(module2) {
-      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;
         }
       }
       module2.exports = _iterableToArrayLimit, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
@@ -541,12 +524,11 @@
       return arrayLikeToArray.exports;
     hasRequiredArrayLikeToArray = 1;
     (function(module2) {
-      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;
       }
       module2.exports = _arrayLikeToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(arrayLikeToArray);
@@ -559,18 +541,13 @@
     hasRequiredUnsupportedIterableToArray = 1;
     (function(module2) {
       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;
+        }
       }
       module2.exports = _unsupportedIterableToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(unsupportedIterableToArray);
@@ -600,8 +577,8 @@
       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();
       }
       module2.exports = _slicedToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(slicedToArray);
@@ -616,11 +593,10 @@
       return assertThisInitialized.exports;
     hasRequiredAssertThisInitialized = 1;
     (function(module2) {
-      function _assertThisInitialized(self2) {
-        if (self2 === void 0) {
+      function _assertThisInitialized(e) {
+        if (void 0 === e)
           throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-        }
-        return self2;
+        return e;
       }
       module2.exports = _assertThisInitialized, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(assertThisInitialized);
@@ -633,10 +609,9 @@
       return classCallCheck.exports;
     hasRequiredClassCallCheck = 1;
     (function(module2) {
-      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");
-        }
       }
       module2.exports = _classCallCheck, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(classCallCheck);
@@ -650,25 +625,16 @@
     hasRequiredCreateClass = 1;
     (function(module2) {
       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;
       }
       module2.exports = _createClass, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(createClass);
@@ -682,12 +648,10 @@
       return setPrototypeOf.exports;
     hasRequiredSetPrototypeOf = 1;
     (function(module2) {
-      function _setPrototypeOf(o, p) {
-        module2.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
-          o2.__proto__ = p2;
-          return o2;
-        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
-        return _setPrototypeOf(o, p);
+      function _setPrototypeOf(t, e) {
+        return module2.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+          return t2.__proto__ = e2, t2;
+        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _setPrototypeOf(t, e);
       }
       module2.exports = _setPrototypeOf, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(setPrototypeOf);
@@ -700,22 +664,18 @@
     hasRequiredInherits = 1;
     (function(module2) {
       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);
       }
       module2.exports = _inherits, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(inherits);
@@ -730,13 +690,12 @@
     (function(module2) {
       var _typeof2 = _typeofExports["default"];
       var assertThisInitialized2 = requireAssertThisInitialized();
-      function _possibleConstructorReturn(self2, 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(self2);
+        return assertThisInitialized2(t);
       }
       module2.exports = _possibleConstructorReturn, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(possibleConstructorReturn);
@@ -749,11 +708,10 @@
       return getPrototypeOf.exports;
     hasRequiredGetPrototypeOf = 1;
     (function(module2) {
-      function _getPrototypeOf(o) {
-        module2.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
-          return o2.__proto__ || Object.getPrototypeOf(o2);
-        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
-        return _getPrototypeOf(o);
+      function _getPrototypeOf(t) {
+        return module2.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
+          return t2.__proto__ || Object.getPrototypeOf(t2);
+        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _getPrototypeOf(t);
       }
       module2.exports = _getPrototypeOf, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(getPrototypeOf);
@@ -767,8 +725,12 @@
       return isNativeFunction.exports;
     hasRequiredIsNativeFunction = 1;
     (function(module2) {
-      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;
+        }
       }
       module2.exports = _isNativeFunction, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(isNativeFunction);
@@ -783,19 +745,14 @@
     hasRequiredIsNativeReflectConstruct = 1;
     (function(module2) {
       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 (module2.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+          return !!t;
+        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports)();
       }
       module2.exports = _isNativeReflectConstruct, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(isNativeReflectConstruct);
@@ -807,23 +764,15 @@
       return construct.exports;
     hasRequiredConstruct = 1;
     (function(module2) {
-      var setPrototypeOf2 = requireSetPrototypeOf();
       var isNativeReflectConstruct2 = requireIsNativeReflectConstruct();
-      function _construct(Parent, args, Class) {
-        if (isNativeReflectConstruct2()) {
-          module2.exports = _construct = Reflect.construct.bind(), module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
-        } else {
-          module2.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;
-          }, module2.exports.__esModule = true, module2.exports["default"] = module2.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;
       }
       module2.exports = _construct, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(construct);
@@ -839,33 +788,30 @@
       var setPrototypeOf2 = requireSetPrototypeOf();
       var isNativeFunction2 = requireIsNativeFunction();
       var construct2 = requireConstruct();
-      function _wrapNativeSuper(Class) {
-        var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
-        module2.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 module2.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);
-        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
-        return _wrapNativeSuper(Class);
+          }), setPrototypeOf2(Wrapper, t2);
+        }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _wrapNativeSuper(t);
       }
       module2.exports = _wrapNativeSuper, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
     })(wrapNativeSuper);