@quick-game/cli/dist/cli-weixin/wx-unity-babel/@babel/runtime/helpers/regeneratorRuntime.js

Command line interface for rapid qg development

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) {
      console.error(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;