var t = require("./typeof");
function r() {
  (module.exports = r =
    function () {
      return e;
    }),
    (module.exports.__esModule = !0),
    (module.exports.default = module.exports);
  var e = {},
    n = Object.prototype,
    o = n.hasOwnProperty,
    i =
      Object.defineProperty ||
      function (t, r, e) {
        t[r] = e.value;
      },
    a = "function" == typeof Symbol ? Symbol : {},
    c = a.iterator || "@@iterator",
    u = a.asyncIterator || "@@asyncIterator",
    l = a.toStringTag || "@@toStringTag";
  function h(t, r, e) {
    return (
      Object.defineProperty(t, r, {
        value: e,
        enumerable: !0,
        configurable: !0,
        writable: !0,
      }),
      t[r]
    );
  }
  try {
    h({}, "");
  } catch (t) {
    h = function (t, r, e) {
      return (t[r] = e);
    };
  }
  function f(t, r, e, n) {
    var o = r && r.prototype instanceof d ? r : d,
      a = Object.create(o.prototype),
      c = new k(n || []);
    return i(a, "_invoke", { value: E(t, e, c) }), a;
  }
  function s(t, r, e) {
    try {
      return { type: "normal", arg: t.call(r, e) };
    } catch (t) {
      return { type: "throw", arg: t };
    }
  }
  e.wrap = f;
  var p = {};
  function d() {}
  function v() {}
  function y() {}
  var g = {};
  h(g, c, function () {
    return this;
  });
  var m = Object.getPrototypeOf,
    w = m && m(m(G([])));
  w && w !== n && o.call(w, c) && (g = w);
  var x = (y.prototype = d.prototype = Object.create(g));
  function L(t) {
    ["next", "throw", "return"].forEach(function (r) {
      h(t, r, function (t) {
        return this._invoke(r, t);
      });
    });
  }
  function b(r, e) {
    function n(i, a, c, u) {
      var l = s(r[i], r, a);
      if ("throw" !== l.type) {
        var h = l.arg,
          f = h.value;
        return f && "object" == t(f) && o.call(f, "__await")
          ? e.resolve(f.__await).then(
              function (t) {
                n("next", t, c, u);
              },
              function (t) {
                n("throw", t, c, u);
              }
            )
          : e.resolve(f).then(
              function (t) {
                (h.value = t), c(h);
              },
              function (t) {
                return n("throw", t, c, u);
              }
            );
      }
      u(l.arg);
    }
    var a;
    i(this, "_invoke", {
      value: function (t, r) {
        function o() {
          return new e(function (e, o) {
            n(t, r, e, o);
          });
        }
        return (a = a ? a.then(o, o) : o());
      },
    });
  }
  function E(t, r, e) {
    var n = "suspendedStart";
    return function (o, i) {
      if ("executing" === n) throw new Error("Generator is already running");
      if ("completed" === n) {
        if ("throw" === o) throw i;
        return N();
      }
      for (e.method = o, e.arg = i; ; ) {
        var a = e.delegate;
        if (a) {
          var c = _(a, e);
          if (c) {
            if (c === p) continue;
            return c;
          }
        }
        if ("next" === e.method) e.sent = e._sent = e.arg;
        else if ("throw" === e.method) {
          if ("suspendedStart" === n) throw ((n = "completed"), e.arg);
          e.dispatchException(e.arg);
        } else "return" === e.method && e.abrupt("return", e.arg);
        n = "executing";
        var u = s(t, r, e);
        if ("normal" === u.type) {
          if (((n = e.done ? "completed" : "suspendedYield"), u.arg === p))
            continue;
          return { value: u.arg, done: e.done };
        }
        "throw" === u.type &&
          ((n = "completed"), (e.method = "throw"), (e.arg = u.arg));
      }
    };
  }
  function _(t, r) {
    var e = r.method,
      n = t.iterator[e];
    if (void 0 === n)
      return (
        (r.delegate = null),
        ("throw" === e &&
          t.iterator.return &&
          ((r.method = "return"),
          (r.arg = void 0),
          _(t, r),
          "throw" === r.method)) ||
          ("return" !== e &&
            ((r.method = "throw"),
            (r.arg = new TypeError(
              "The iterator does not provide a '" + e + "' method"
            )))),
        p
      );
    var o = s(n, t.iterator, r.arg);
    if ("throw" === o.type)
      return (r.method = "throw"), (r.arg = o.arg), (r.delegate = null), p;
    var i = o.arg;
    return i
      ? i.done
        ? ((r[t.resultName] = i.value),
          (r.next = t.nextLoc),
          "return" !== r.method && ((r.method = "next"), (r.arg = void 0)),
          (r.delegate = null),
          p)
        : i
      : ((r.method = "throw"),
        (r.arg = new TypeError("iterator result is not an object")),
        (r.delegate = null),
        p);
  }
  function O(t) {
    var r = { tryLoc: t[0] };
    1 in t && (r.catchLoc = t[1]),
      2 in t && ((r.finallyLoc = t[2]), (r.afterLoc = t[3])),
      this.tryEntries.push(r);
  }
  function j(t) {
    var r = t.completion || {};
    (r.type = "normal"), delete r.arg, (t.completion = r);
  }
  function k(t) {
    (this.tryEntries = [{ tryLoc: "root" }]),
      t.forEach(O, this),
      this.reset(!0);
  }
  function G(t) {
    if (t) {
      var r = t[c];
      if (r) return r.call(t);
      if ("function" == typeof t.next) return t;
      if (!isNaN(t.length)) {
        var e = -1,
          n = function r() {
            for (; ++e < t.length; )
              if (o.call(t, e)) return (r.value = t[e]), (r.done = !1), r;
            return (r.value = void 0), (r.done = !0), r;
          };
        return (n.next = n);
      }
    }
    return { next: N };
  }
  function N() {
    return { value: void 0, done: !0 };
  }
  return (
    (v.prototype = y),
    i(x, "constructor", { value: y, configurable: !0 }),
    i(y, "constructor", { value: v, configurable: !0 }),
    (v.displayName = h(y, l, "GeneratorFunction")),
    (e.isGeneratorFunction = function (t) {
      var r = "function" == typeof t && t.constructor;
      return (
        !!r && (r === v || "GeneratorFunction" === (r.displayName || r.name))
      );
    }),
    (e.mark = function (t) {
      return (
        Object.setPrototypeOf
          ? Object.setPrototypeOf(t, y)
          : ((t.__proto__ = y), h(t, l, "GeneratorFunction")),
        (t.prototype = Object.create(x)),
        t
      );
    }),
    (e.awrap = function (t) {
      return { __await: t };
    }),
    L(b.prototype),
    h(b.prototype, u, function () {
      return this;
    }),
    (e.AsyncIterator = b),
    (e.async = function (t, r, n, o, i) {
      void 0 === i && (i = Promise);
      var a = new b(f(t, r, n, o), i);
      return e.isGeneratorFunction(r)
        ? a
        : a.next().then(function (t) {
            return t.done ? t.value : a.next();
          });
    }),
    L(x),
    h(x, l, "Generator"),
    h(x, c, function () {
      return this;
    }),
    h(x, "toString", function () {
      return "[object Generator]";
    }),
    (e.keys = function (t) {
      var r = Object(t),
        e = [];
      for (var n in r) e.push(n);
      return (
        e.reverse(),
        function t() {
          for (; e.length; ) {
            var n = e.pop();
            if (n in r) return (t.value = n), (t.done = !1), t;
          }
          return (t.done = !0), t;
        }
      );
    }),
    (e.values = G),
    (k.prototype = {
      constructor: k,
      reset: function (t) {
        if (
          ((this.prev = 0),
          (this.next = 0),
          (this.sent = this._sent = void 0),
          (this.done = !1),
          (this.delegate = null),
          (this.method = "next"),
          (this.arg = void 0),
          this.tryEntries.forEach(j),
          !t)
        )
          for (var r in this)
            "t" === r.charAt(0) &&
              o.call(this, r) &&
              !isNaN(+r.slice(1)) &&
              (this[r] = void 0);
      },
      stop: function () {
        this.done = !0;
        var t = this.tryEntries[0].completion;
        if ("throw" === t.type) throw t.arg;
        return this.rval;
      },
      dispatchException: function (t) {
        if (this.done) throw t;
        var r = this;
        function e(e, n) {
          return (
            (a.type = "throw"),
            (a.arg = t),
            (r.next = e),
            n && ((r.method = "next"), (r.arg = void 0)),
            !!n
          );
        }
        for (var n = this.tryEntries.length - 1; n >= 0; --n) {
          var i = this.tryEntries[n],
            a = i.completion;
          if ("root" === i.tryLoc) return e("end");
          if (i.tryLoc <= this.prev) {
            var c = o.call(i, "catchLoc"),
              u = o.call(i, "finallyLoc");
            if (c && u) {
              if (this.prev < i.catchLoc) return e(i.catchLoc, !0);
              if (this.prev < i.finallyLoc) return e(i.finallyLoc);
            } else if (c) {
              if (this.prev < i.catchLoc) return e(i.catchLoc, !0);
            } else {
              if (!u) throw new Error("try statement without catch or finally");
              if (this.prev < i.finallyLoc) return e(i.finallyLoc);
            }
          }
        }
      },
      abrupt: function (t, r) {
        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
          var n = this.tryEntries[e];
          if (
            n.tryLoc <= this.prev &&
            o.call(n, "finallyLoc") &&
            this.prev < n.finallyLoc
          ) {
            var i = n;
            break;
          }
        }
        i &&
          ("break" === t || "continue" === t) &&
          i.tryLoc <= r &&
          r <= i.finallyLoc &&
          (i = null);
        var a = i ? i.completion : {};
        return (
          (a.type = t),
          (a.arg = r),
          i
            ? ((this.method = "next"), (this.next = i.finallyLoc), p)
            : this.complete(a)
        );
      },
      complete: function (t, r) {
        if ("throw" === t.type) throw t.arg;
        return (
          "break" === t.type || "continue" === t.type
            ? (this.next = t.arg)
            : "return" === t.type
            ? ((this.rval = this.arg = t.arg),
              (this.method = "return"),
              (this.next = "end"))
            : "normal" === t.type && r && (this.next = r),
          p
        );
      },
      finish: function (t) {
        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
          var e = this.tryEntries[r];
          if (e.finallyLoc === t)
            return this.complete(e.completion, e.afterLoc), j(e), p;
        }
      },
      catch: function (t) {
        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
          var e = this.tryEntries[r];
          if (e.tryLoc === t) {
            var n = e.completion;
            if ("throw" === n.type) {
              var o = n.arg;
              j(e);
            }
            return o;
          }
        }
        throw new Error("illegal catch attempt");
      },
      delegateYield: function (t, r, e) {
        return (
          (this.delegate = { iterator: G(t), resultName: r, nextLoc: e }),
          "next" === this.method && (this.arg = void 0),
          p
        );
      },
    }),
    e
  );
}
(module.exports = r),
  (module.exports.__esModule = !0),
  (module.exports.default = module.exports);