@vela-ventures/aosync-strategy/dist/index.es.js

AOsync strategy for the Arweave Wallet Kit

function _superPropGet(t, o, e, r) {
  var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e);
  return 2 & r && "function" == typeof p ? function(t2) {
    return p.apply(e, t2);
  } : p;
}
function _get() {
  return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function(e, t, r) {
    var p = _superPropBase(e, t);
    if (p) {
      var n = Object.getOwnPropertyDescriptor(p, t);
      return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
    }
  }, _get.apply(null, arguments);
}
function _superPropBase(t, o) {
  for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)); )
    ;
  return t;
}
function _slicedToArray(r, e) {
  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _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 (i = (t = t.call(r)).next, 0 === l) {
        if (Object(t) !== t)
          return;
        f = false;
      } else
        for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true)
          ;
    } catch (r2) {
      o = true, n = r2;
    } finally {
      try {
        if (!f && null != t.return && (u = t.return(), Object(u) !== u))
          return;
      } finally {
        if (o)
          throw n;
      }
    }
    return a;
  }
}
function _arrayWithHoles(r) {
  if (Array.isArray(r))
    return r;
}
function _classPrivateMethodInitSpec(e, a) {
  _checkPrivateRedeclaration(e, a), a.add(e);
}
function _classPrivateFieldInitSpec(e, t, a) {
  _checkPrivateRedeclaration(e, t), t.set(e, a);
}
function _checkPrivateRedeclaration(e, t) {
  if (t.has(e))
    throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _classPrivateFieldSet(s, a, r) {
  return s.set(_assertClassBrand(s, a), r), r;
}
function _classPrivateFieldGet(s, a) {
  return s.get(_assertClassBrand(s, a));
}
function _assertClassBrand(e, t, n) {
  if ("function" == typeof e ? e === t : e.has(t))
    return arguments.length < 3 ? t : n;
  throw new TypeError("Private element is not present on this object");
}
function ownKeys(e, r) {
  var t = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var o = Object.getOwnPropertySymbols(e);
    r && (o = o.filter(function(r2) {
      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
    })), t.push.apply(t, o);
  }
  return t;
}
function _objectSpread(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
      _defineProperty(e, r2, t[r2]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
    });
  }
  return e;
}
function _defineProperty(e, r, t) {
  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toConsumableArray(r) {
  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _iterableToArray(r) {
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"])
    return Array.from(r);
}
function _arrayWithoutHoles(r) {
  if (Array.isArray(r))
    return _arrayLikeToArray(r);
}
function _wrapNativeSuper(t) {
  var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
  return _wrapNativeSuper = function _wrapNativeSuper2(t2) {
    if (null === t2 || !_isNativeFunction(t2))
      return t2;
    if ("function" != typeof t2)
      throw new TypeError("Super expression must either be null or a function");
    if (void 0 !== r) {
      if (r.has(t2))
        return r.get(t2);
      r.set(t2, Wrapper);
    }
    function Wrapper() {
      return _construct(t2, arguments, _getPrototypeOf(this).constructor);
    }
    return Wrapper.prototype = Object.create(t2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }), _setPrototypeOf(Wrapper, t2);
  }, _wrapNativeSuper(t);
}
function _construct(t, e, r) {
  if (_isNativeReflectConstruct())
    return Reflect.construct.apply(null, arguments);
  var o = [null];
  o.push.apply(o, e);
  var p = new (t.bind.apply(t, o))();
  return r && _setPrototypeOf(p, r.prototype), p;
}
function _isNativeFunction(t) {
  try {
    return -1 !== Function.toString.call(t).indexOf("[native code]");
  } catch (n) {
    return "function" == typeof t;
  }
}
function _regeneratorRuntime() {
  "use strict";
  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
  _regeneratorRuntime = function _regeneratorRuntime2() {
    return e;
  };
  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 }), t2[e2];
  }
  try {
    define2({}, "");
  } catch (t2) {
    define2 = function define3(t3, e2, r2) {
      return t3[e2] = r2;
    };
  }
  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(t2, e2, r2) {
    try {
      return { type: "normal", arg: t2.call(e2, r2) };
    } catch (t3) {
      return { type: "throw", arg: t3 };
    }
  }
  e.wrap = wrap;
  var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
  function Generator() {
  }
  function GeneratorFunction() {
  }
  function GeneratorFunctionPrototype() {
  }
  var p = {};
  define2(p, a, function() {
    return this;
  });
  var d = Object.getPrototypeOf, v2 = d && d(d(values([])));
  v2 && v2 !== r && n.call(v2, a) && (p = v2);
  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(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" == _typeof(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);
        });
      }
      a2(c2.arg);
    }
    var r2;
    o(this, "_invoke", { value: function value(t3, n2) {
      function callInvokeWithMethodAndArg() {
        return new e2(function(e3, r3) {
          invoke(t3, n2, e3, r3);
        });
      }
      return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
    } });
  }
  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 u2;
          }
        }
        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" === 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: p2.arg, done: n2.done };
        }
        "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
      }
    };
  }
  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 t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
  }
  function resetTryEntry(t2) {
    var e2 = t2.completion || {};
    e2.type = "normal", delete e2.arg, t2.completion = e2;
  }
  function Context(t2) {
    this.tryEntries = [{ tryLoc: "root" }], 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 i2.next = i2;
      }
    }
    throw new TypeError(_typeof(e2) + " is not iterable");
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: true }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: true }), 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: t2 };
  }, defineIteratorMethods(AsyncIterator.prototype), define2(AsyncIterator.prototype, c, function() {
    return this;
  }), 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(g), define2(g, u, "Generator"), define2(g, a, function() {
    return this;
  }), define2(g, "toString", function() {
    return "[object Generator]";
  }), 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;
    };
  }, e.values = values, Context.prototype = { constructor: Context, 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 t2 = this.tryEntries[0].completion;
    if ("throw" === t2.type)
      throw t2.arg;
    return this.rval;
  }, dispatchException: function dispatchException(e2) {
    if (this.done)
      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 (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 (!u2)
            throw Error("try statement without catch or finally");
          if (this.prev < i2.finallyLoc)
            return handle(i2.finallyLoc);
        }
      }
    }
  }, 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;
      }
    }
    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(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(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(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 o2;
      }
    }
    throw Error("illegal catch attempt");
  }, delegateYield: function delegateYield(e2, r2, n2) {
    return this.delegate = { iterator: values(e2), resultName: r2, nextLoc: n2 }, "next" === this.method && (this.arg = t), y;
  } }, e;
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
  try {
    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(n) {
  return function() {
    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(n2) {
        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
      }
      _next(void 0);
    });
  };
}
function _classCallCheck(a, n) {
  if (!(a instanceof n))
    throw new TypeError("Cannot call a class as a function");
}
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, _toPropertyKey(o.key), o);
  }
}
function _createClass(e, r, t) {
  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: false }), e;
}
function _toPropertyKey(t) {
  var i = _toPrimitive(t, "string");
  return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
  if ("object" != _typeof(t) || !t)
    return t;
  var e = t[Symbol.toPrimitive];
  if (void 0 !== e) {
    var i = e.call(t, r || "default");
    if ("object" != _typeof(i))
      return i;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return ("string" === r ? String : Number)(t);
}
function _callSuper(t, o, e) {
  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
}
function _possibleConstructorReturn(t, e) {
  if (e && ("object" == _typeof(e) || "function" == typeof e))
    return e;
  if (void 0 !== e)
    throw new TypeError("Derived constructors may only return object or undefined");
  return _assertThisInitialized(t);
}
function _assertThisInitialized(e) {
  if (void 0 === e)
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  return e;
}
function _isNativeReflectConstruct() {
  try {
    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
    }));
  } catch (t2) {
  }
  return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
    return !!t;
  })();
}
function _getPrototypeOf(t) {
  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
    return t2.__proto__ || Object.getPrototypeOf(t2);
  }, _getPrototypeOf(t);
}
function _inherits(t, e) {
  if ("function" != typeof e && null !== e)
    throw new TypeError("Super expression must either be null or a function");
  t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: true, configurable: true } }), Object.defineProperty(t, "prototype", { writable: false }), e && _setPrototypeOf(t, e);
}
function _setPrototypeOf(t, e) {
  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
    return t2.__proto__ = e2, t2;
  }, _setPrototypeOf(t, e);
}
function _createForOfIteratorHelper(r, e) {
  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
  if (!t) {
    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
      t && (r = t);
      var n = 0, F = function F2() {
      };
      return { s: F, n: function(_n51) {
        function n2() {
          return _n51.apply(this, arguments);
        }
        n2.toString = function() {
          return _n51.toString();
        };
        return n2;
      }(function() {
        return n >= r.length ? { done: true } : { done: false, value: r[n++] };
      }), e: function e2(r2) {
        throw r2;
      }, f: F };
    }
    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  var o, a = true, u = false;
  return { s: function s() {
    t = t.call(r);
  }, n: function n2() {
    var r2 = t.next();
    return a = r2.done, r2;
  }, e: function e2(r2) {
    u = true, o = r2;
  }, f: function f() {
    try {
      a || null == t.return || t.return();
    } finally {
      if (u)
        throw o;
    }
  } };
}
function _unsupportedIterableToArray(r, a) {
  if (r) {
    if ("string" == typeof r)
      return _arrayLikeToArray(r, a);
    var t = {}.toString.call(r).slice(8, -1);
    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
  }
}
function _arrayLikeToArray(r, a) {
  (null == a || a > r.length) && (a = r.length);
  for (var e = 0, n = Array(a); e < a; e++)
    n[e] = r[e];
  return n;
}
function _typeof(o) {
  "@babel/helpers - typeof";
  return _typeof = "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;
  }, _typeof(o);
}
function _asyncGeneratorDelegate(t) {
  var e = {}, n = false;
  function pump(e2, r) {
    return n = true, r = new Promise(function(n2) {
      n2(t[e2](r));
    }), { done: false, value: new _OverloadYield(r, 1) };
  }
  return e["undefined" != typeof Symbol && Symbol.iterator || "@@iterator"] = function() {
    return this;
  }, e.next = function(t2) {
    return n ? (n = false, t2) : pump("next", t2);
  }, "function" == typeof t.throw && (e.throw = function(t2) {
    if (n)
      throw n = false, t2;
    return pump("throw", t2);
  }), "function" == typeof t.return && (e.return = function(t2) {
    return n ? (n = false, t2) : pump("return", t2);
  }), e;
}
function _asyncIterator(r) {
  var n, t, o, e = 2;
  for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--; ) {
    if (t && null != (n = r[t]))
      return n.call(r);
    if (o && null != (n = r[o]))
      return new AsyncFromSyncIterator(n.call(r));
    t = "@@asyncIterator", o = "@@iterator";
  }
  throw new TypeError("Object is not async iterable");
}
function AsyncFromSyncIterator(r) {
  function AsyncFromSyncIteratorContinuation(r2) {
    if (Object(r2) !== r2)
      return Promise.reject(new TypeError(r2 + " is not an object."));
    var n = r2.done;
    return Promise.resolve(r2.value).then(function(r3) {
      return { value: r3, done: n };
    });
  }
  return AsyncFromSyncIterator = function AsyncFromSyncIterator2(r2) {
    this.s = r2, this.n = r2.next;
  }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() {
    return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
  }, return: function _return(r2) {
    var n = this.s.return;
    return void 0 === n ? Promise.resolve({ value: r2, done: true }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
  }, throw: function _throw(r2) {
    var n = this.s.return;
    return void 0 === n ? Promise.reject(r2) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
  } }, new AsyncFromSyncIterator(r);
}
function _awaitAsyncGenerator(e) {
  return new _OverloadYield(e, 0);
}
function _wrapAsyncGenerator(e) {
  return function() {
    return new AsyncGenerator(e.apply(this, arguments));
  };
}
function AsyncGenerator(e) {
  var r, t;
  function resume(r2, t2) {
    try {
      var n = e[r2](t2), o = n.value, u = o instanceof _OverloadYield;
      Promise.resolve(u ? o.v : o).then(function(t3) {
        if (u) {
          var i = "return" === r2 ? "return" : "next";
          if (!o.k || t3.done)
            return resume(i, t3);
          t3 = e[i](t3).value;
        }
        settle(n.done ? "return" : "normal", t3);
      }, function(e2) {
        resume("throw", e2);
      });
    } catch (e2) {
      settle("throw", e2);
    }
  }
  function settle(e2, n) {
    switch (e2) {
      case "return":
        r.resolve({ value: n, done: true });
        break;
      case "throw":
        r.reject(n);
        break;
      default:
        r.resolve({ value: n, done: false });
    }
    (r = r.next) ? resume(r.key, r.arg) : t = null;
  }
  this._invoke = function(e2, n) {
    return new Promise(function(o, u) {
      var i = { key: e2, arg: n, resolve: o, reject: u, next: null };
      t ? t = t.next = i : (r = t = i, resume(e2, n));
    });
  }, "function" != typeof e.return && (this.return = void 0);
}
AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function() {
  return this;
}, AsyncGenerator.prototype.next = function(e) {
  return this._invoke("next", e);
}, AsyncGenerator.prototype.throw = function(e) {
  return this._invoke("throw", e);
}, AsyncGenerator.prototype.return = function(e) {
  return this._invoke("return", e);
};
function _OverloadYield(e, d) {
  this.v = e, this.k = d;
}
var ys = Object.defineProperty;
var Kg = Object.getOwnPropertyDescriptor;
var Gg = Object.getOwnPropertyNames;
var Qg = Object.prototype.hasOwnProperty;
var _e = function _e2(t, e) {
  return function() {
    return t && (e = t(t = 0)), e;
  };
};
var M = function M2(t, e) {
  return function() {
    return e || t((e = { exports: {} }).exports, e), e.exports;
  };
}, Jt = function Jt2(t, e) {
  for (var r in e)
    ys(t, r, { get: e[r], enumerable: true });
}, Yg = function Yg2(t, e, r, i) {
  if (e && _typeof(e) == "object" || typeof e == "function") {
    var _iterator13 = _createForOfIteratorHelper(Gg(e)), _step13;
    try {
      var _loop = function _loop2() {
        var n = _step13.value;
        !Qg.call(t, n) && n !== r && ys(t, n, { get: function get2() {
          return e[n];
        }, enumerable: !(i = Kg(e, n)) || i.enumerable });
      };
      for (_iterator13.s(); !(_step13 = _iterator13.n()).done; ) {
        _loop();
      }
    } catch (err) {
      _iterator13.e(err);
    } finally {
      _iterator13.f();
    }
  }
  return t;
};
var X = function X2(t) {
  return Yg(ys({}, "__esModule", { value: true }), t);
};
var _ = _e(function() {
});
var B = {};
Jt(B, { _debugEnd: function _debugEnd() {
  return yu;
}, _debugProcess: function _debugProcess() {
  return gu;
}, _events: function _events() {
  return Ou;
}, _eventsCount: function _eventsCount() {
  return xu;
}, _exiting: function _exiting() {
  return Yl;
}, _fatalExceptions: function _fatalExceptions() {
  return cu;
}, _getActiveHandles: function _getActiveHandles() {
  return eu;
}, _getActiveRequests: function _getActiveRequests() {
  return Zl;
}, _kill: function _kill() {
  return ru;
}, _linkedBinding: function _linkedBinding() {
  return Gl;
}, _maxListeners: function _maxListeners() {
  return ku;
}, _preload_modules: function _preload_modules() {
  return Cu;
}, _rawDebug: function _rawDebug() {
  return zl;
}, _startProfilerIdleNotifier: function _startProfilerIdleNotifier() {
  return bu;
}, _stopProfilerIdleNotifier: function _stopProfilerIdleNotifier() {
  return wu;
}, _tickCallback: function _tickCallback() {
  return pu;
}, abort: function abort() {
  return Eu;
}, addListener: function addListener() {
  return Mu;
}, allowedNodeEnvironmentFlags: function allowedNodeEnvironmentFlags() {
  return lu;
}, arch: function arch() {
  return xl;
}, argv: function argv() {
  return Ul;
}, argv0: function argv0() {
  return Ru;
}, assert: function assert() {
  return uu;
}, binding: function binding() {
  return Fl;
}, chdir: function chdir() {
  return Hl;
}, config: function config() {
  return Jl;
}, cpuUsage: function cpuUsage() {
  return $i;
}, cwd: function cwd() {
  return $l;
}, debugPort: function debugPort() {
  return Tu;
}, default: function _default() {
  return $u;
}, dlopen: function dlopen() {
  return Xl;
}, domain: function domain() {
  return Ql;
}, emit: function emit() {
  return Du;
}, emitWarning: function emitWarning() {
  return jl;
}, env: function env() {
  return Ll;
}, execArgv: function execArgv() {
  return Nl;
}, execPath: function execPath() {
  return Iu;
}, exit: function exit() {
  return ou;
}, features: function features() {
  return fu;
}, hasUncaughtExceptionCaptureCallback: function hasUncaughtExceptionCaptureCallback() {
  return du;
}, hrtime: function hrtime() {
  return Wi;
}, kill: function kill() {
  return su;
}, listeners: function listeners() {
  return Wu;
}, memoryUsage: function memoryUsage() {
  return nu;
}, moduleLoadList: function moduleLoadList() {
  return Kl;
}, nextTick: function nextTick() {
  return Pl;
}, off: function off() {
  return Uu;
}, on: function on() {
  return wt;
}, once: function once() {
  return Lu;
}, openStdin: function openStdin() {
  return au;
}, pid: function pid() {
  return Su;
}, platform: function platform() {
  return Ml;
}, ppid: function ppid() {
  return Au;
}, prependListener: function prependListener() {
  return ju;
}, prependOnceListener: function prependOnceListener() {
  return Fu;
}, reallyExit: function reallyExit() {
  return tu;
}, release: function release() {
  return Vl;
}, removeAllListeners: function removeAllListeners() {
  return qu;
}, removeListener: function removeListener() {
  return Nu;
}, resourceUsage: function resourceUsage() {
  return iu;
}, setSourceMapsEnabled: function setSourceMapsEnabled() {
  return Bu;
}, setUncaughtExceptionCaptureCallback: function setUncaughtExceptionCaptureCallback() {
  return hu;
}, stderr: function stderr() {
  return mu;
}, stdin: function stdin() {
  return vu;
}, stdout: function stdout() {
  return _u;
}, title: function title() {
  return Ol;
}, umask: function umask() {
  return Wl;
}, uptime: function uptime() {
  return Pu;
}, version: function version() {
  return ql;
}, versions: function versions() {
  return Dl;
} });
function _s(t) {
  throw new Error("Node.js process " + t + " is not supported by JSPM core outside of Node.js");
}
function Jg() {
  !Lr || !Xt || (Lr = false, Xt.length ? bt = Xt.concat(bt) : Fi = -1, bt.length && Bl());
}
function Bl() {
  if (!Lr) {
    var t = setTimeout(Jg, 0);
    Lr = true;
    for (var e = bt.length; e; ) {
      for (Xt = bt, bt = []; ++Fi < e; )
        Xt && Xt[Fi].run();
      Fi = -1, e = bt.length;
    }
    Xt = null, Lr = false, clearTimeout(t);
  }
}
function Pl(t) {
  var e = new Array(arguments.length - 1);
  if (arguments.length > 1)
    for (var r = 1; r < arguments.length; r++)
      e[r - 1] = arguments[r];
  bt.push(new kl(t, e)), bt.length === 1 && !Lr && setTimeout(Bl, 0);
}
function kl(t, e) {
  this.fun = t, this.array = e;
}
function Ee() {
}
function Gl(t) {
  _s("_linkedBinding");
}
function Xl(t) {
  _s("dlopen");
}
function Zl() {
  return [];
}
function eu() {
  return [];
}
function uu(t, e) {
  if (!t)
    throw new Error(e || "assertion error");
}
function du() {
  return false;
}
function Pu() {
  return Lt.now() / 1e3;
}
function Wi(t) {
  var e = Math.floor((Date.now() - Lt.now()) * 1e-3), r = Lt.now() * 1e-3, i = Math.floor(r) + e, n = Math.floor(r % 1 * 1e9);
  return t && (i = i - t[0], n = n - t[1], n < 0 && (i--, n += ws)), [i, n];
}
function wt() {
  return $u;
}
function Wu(t) {
  return [];
}
var bt, Lr, Xt, Fi, Ol, xl, Ml, Ll, Ul, Nl, ql, Dl, jl, Fl, Wl, $l, Hl, Vl, zl, Kl, Ql, Yl, Jl, tu, ru, $i, iu, nu, su, ou, au, lu, fu, cu, hu, pu, gu, yu, bu, wu, _u, mu, vu, Eu, Su, Au, Iu, Tu, Ru, Cu, Bu, Lt, bs, ws, ku, Ou, xu, Mu, Lu, Uu, Nu, qu, Du, ju, Fu, $u, Hu = _e(function() {
  _();
  v();
  m();
  bt = [], Lr = false, Fi = -1;
  kl.prototype.run = function() {
    this.fun.apply(null, this.array);
  };
  Ol = "browser", xl = "x64", Ml = "browser", Ll = { PATH: "/usr/bin", LANG: navigator.language + ".UTF-8", PWD: "/", HOME: "/home", TMP: "/tmp" }, Ul = ["/usr/bin/node"], Nl = [], ql = "v16.8.0", Dl = {}, jl = function jl2(t, e) {
    console.warn((e ? e + ": " : "") + t);
  }, Fl = function Fl2(t) {
    _s("binding");
  }, Wl = function Wl2(t) {
    return 0;
  }, $l = function $l2() {
    return "/";
  }, Hl = function Hl2(t) {
  }, Vl = { name: "node", sourceUrl: "", headersUrl: "", libUrl: "" };
  zl = Ee, Kl = [];
  Ql = {}, Yl = false, Jl = {};
  tu = Ee, ru = Ee, $i = function $i2() {
    return {};
  }, iu = $i, nu = $i, su = Ee, ou = Ee, au = Ee, lu = {};
  fu = { inspector: false, debug: false, uv: false, ipv6: false, tls_alpn: false, tls_sni: false, tls_ocsp: false, tls: false, cached_builtins: true }, cu = Ee, hu = Ee;
  pu = Ee, gu = Ee, yu = Ee, bu = Ee, wu = Ee, _u = void 0, mu = void 0, vu = void 0, Eu = Ee, Su = 2, Au = 1, Iu = "/bin/usr/node", Tu = 9229, Ru = "node", Cu = [], Bu = Ee, Lt = { now: (typeof performance === "undefined" ? "undefined" : _typeof(performance)) < "u" ? performance.now.bind(performance) : void 0, timing: (typeof performance === "undefined" ? "undefined" : _typeof(performance)) < "u" ? performance.timing : void 0 };
  Lt.now === void 0 && (bs = Date.now(), Lt.timing && Lt.timing.navigationStart && (bs = Lt.timing.navigationStart), Lt.now = function() {
    return Date.now() - bs;
  });
  ws = 1e9;
  Wi.bigint = function(t) {
    var e = Wi(t);
    return (typeof BigInt === "undefined" ? "undefined" : _typeof(BigInt)) > "u" ? e[0] * ws + e[1] : BigInt(e[0] * ws) + BigInt(e[1]);
  };
  ku = 10, Ou = {}, xu = 0;
  Mu = wt, Lu = wt, Uu = wt, Nu = wt, qu = wt, Du = Ee, ju = wt, Fu = wt;
  $u = { version: ql, versions: Dl, arch: xl, platform: Ml, release: Vl, _rawDebug: zl, moduleLoadList: Kl, binding: Fl, _linkedBinding: Gl, _events: Ou, _eventsCount: xu, _maxListeners: ku, on: wt, addListener: Mu, once: Lu, off: Uu, removeListener: Nu, removeAllListeners: qu, emit: Du, prependListener: ju, prependOnceListener: Fu, listeners: Wu, domain: Ql, _exiting: Yl, config: Jl, dlopen: Xl, uptime: Pu, _getActiveRequests: Zl, _getActiveHandles: eu, reallyExit: tu, _kill: ru, cpuUsage: $i, resourceUsage: iu, memoryUsage: nu, kill: su, exit: ou, openStdin: au, allowedNodeEnvironmentFlags: lu, assert: uu, features: fu, _fatalExceptions: cu, setUncaughtExceptionCaptureCallback: hu, hasUncaughtExceptionCaptureCallback: du, emitWarning: jl, nextTick: Pl, _tickCallback: pu, _debugProcess: gu, _debugEnd: yu, _startProfilerIdleNotifier: bu, _stopProfilerIdleNotifier: wu, stdout: _u, stdin: vu, stderr: mu, abort: Eu, umask: Wl, chdir: Hl, cwd: $l, env: Ll, title: Ol, argv: Ul, execArgv: Nl, pid: Su, ppid: Au, execPath: Iu, debugPort: Tu, hrtime: Wi, argv0: Ru, _preload_modules: Cu, setSourceMapsEnabled: Bu };
});
var m = _e(function() {
  Hu();
});
var me = {};
Jt(me, { Buffer: function Buffer() {
  return x;
}, INSPECT_MAX_BYTES: function INSPECT_MAX_BYTES() {
  return ty;
}, default: function _default2() {
  return Ut;
}, kMaxLength: function kMaxLength() {
  return ry;
} });
function Xg() {
  if (Vu)
    return ci;
  Vu = true, ci.byteLength = a, ci.toByteArray = c, ci.fromByteArray = g;
  for (var t = [], e = [], r = (typeof Uint8Array === "undefined" ? "undefined" : _typeof(Uint8Array)) < "u" ? Uint8Array : Array, i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", n = 0, o = i.length; n < o; ++n)
    t[n] = i[n], e[i.charCodeAt(n)] = n;
  e["-".charCodeAt(0)] = 62, e["_".charCodeAt(0)] = 63;
  function s(y) {
    var w = y.length;
    if (w % 4 > 0)
      throw new Error("Invalid string. Length must be a multiple of 4");
    var S = y.indexOf("=");
    S === -1 && (S = w);
    var E = S === w ? 0 : 4 - S % 4;
    return [S, E];
  }
  function a(y) {
    var w = s(y), S = w[0], E = w[1];
    return (S + E) * 3 / 4 - E;
  }
  function l(y, w, S) {
    return (w + S) * 3 / 4 - S;
  }
  function c(y) {
    var w, S = s(y), E = S[0], I = S[1], C = new r(l(y, E, I)), R = 0, U = I > 0 ? E - 4 : E, N;
    for (N = 0; N < U; N += 4)
      w = e[y.charCodeAt(N)] << 18 | e[y.charCodeAt(N + 1)] << 12 | e[y.charCodeAt(N + 2)] << 6 | e[y.charCodeAt(N + 3)], C[R++] = w >> 16 & 255, C[R++] = w >> 8 & 255, C[R++] = w & 255;
    return I === 2 && (w = e[y.charCodeAt(N)] << 2 | e[y.charCodeAt(N + 1)] >> 4, C[R++] = w & 255), I === 1 && (w = e[y.charCodeAt(N)] << 10 | e[y.charCodeAt(N + 1)] << 4 | e[y.charCodeAt(N + 2)] >> 2, C[R++] = w >> 8 & 255, C[R++] = w & 255), C;
  }
  function h(y) {
    return t[y >> 18 & 63] + t[y >> 12 & 63] + t[y >> 6 & 63] + t[y & 63];
  }
  function d(y, w, S) {
    for (var E, I = [], C = w; C < S; C += 3)
      E = (y[C] << 16 & 16711680) + (y[C + 1] << 8 & 65280) + (y[C + 2] & 255), I.push(h(E));
    return I.join("");
  }
  function g(y) {
    for (var w, S = y.length, E = S % 3, I = [], C = 16383, R = 0, U = S - E; R < U; R += C)
      I.push(d(y, R, R + C > U ? U : R + C));
    return E === 1 ? (w = y[S - 1], I.push(t[w >> 2] + t[w << 4 & 63] + "==")) : E === 2 && (w = (y[S - 2] << 8) + y[S - 1], I.push(t[w >> 10] + t[w >> 4 & 63] + t[w << 2 & 63] + "=")), I.join("");
  }
  return ci;
}
function Zg() {
  if (zu)
    return Hi;
  zu = true;
  return Hi.read = function(t, e, r, i, n) {
    var o, s, a = n * 8 - i - 1, l = (1 << a) - 1, c = l >> 1, h = -7, d = r ? n - 1 : 0, g = r ? -1 : 1, y = t[e + d];
    for (d += g, o = y & (1 << -h) - 1, y >>= -h, h += a; h > 0; o = o * 256 + t[e + d], d += g, h -= 8)
      ;
    for (s = o & (1 << -h) - 1, o >>= -h, h += i; h > 0; s = s * 256 + t[e + d], d += g, h -= 8)
      ;
    if (o === 0)
      o = 1 - c;
    else {
      if (o === l)
        return s ? NaN : (y ? -1 : 1) * (1 / 0);
      s = s + Math.pow(2, i), o = o - c;
    }
    return (y ? -1 : 1) * s * Math.pow(2, o - i);
  }, Hi.write = function(t, e, r, i, n, o) {
    var s, a, l, c = o * 8 - n - 1, h = (1 << c) - 1, d = h >> 1, g = n === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, y = i ? 0 : o - 1, w = i ? 1 : -1, S = e < 0 || e === 0 && 1 / e < 0 ? 1 : 0;
    for (e = Math.abs(e), isNaN(e) || e === 1 / 0 ? (a = isNaN(e) ? 1 : 0, s = h) : (s = Math.floor(Math.log(e) / Math.LN2), e * (l = Math.pow(2, -s)) < 1 && (s--, l *= 2), s + d >= 1 ? e += g / l : e += g * Math.pow(2, 1 - d), e * l >= 2 && (s++, l /= 2), s + d >= h ? (a = 0, s = h) : s + d >= 1 ? (a = (e * l - 1) * Math.pow(2, n), s = s + d) : (a = e * Math.pow(2, d - 1) * Math.pow(2, n), s = 0)); n >= 8; t[r + y] = a & 255, y += w, a /= 256, n -= 8)
      ;
    for (s = s << n | a, c += n; c > 0; t[r + y] = s & 255, y += w, s /= 256, c -= 8)
      ;
    t[r + y - w] |= S * 128;
  }, Hi;
}
function ey() {
  if (Ku)
    return Zt;
  Ku = true;
  var t = Xg(), e = Zg(), r = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
  Zt.Buffer = s, Zt.SlowBuffer = I, Zt.INSPECT_MAX_BYTES = 50;
  var i = 2147483647;
  Zt.kMaxLength = i, s.TYPED_ARRAY_SUPPORT = n(), !s.TYPED_ARRAY_SUPPORT && (typeof console === "undefined" ? "undefined" : _typeof(console)) < "u" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
  function n() {
    try {
      var p = new Uint8Array(1), u = { foo: function foo() {
        return 42;
      } };
      return Object.setPrototypeOf(u, Uint8Array.prototype), Object.setPrototypeOf(p, u), p.foo() === 42;
    } catch (_unused) {
      return false;
    }
  }
  Object.defineProperty(s.prototype, "parent", { enumerable: true, get: function get2() {
    if (s.isBuffer(this))
      return this.buffer;
  } }), Object.defineProperty(s.prototype, "offset", { enumerable: true, get: function get2() {
    if (s.isBuffer(this))
      return this.byteOffset;
  } });
  function o(p) {
    if (p > i)
      throw new RangeError('The value "' + p + '" is invalid for option "size"');
    var u = new Uint8Array(p);
    return Object.setPrototypeOf(u, s.prototype), u;
  }
  function s(p, u, f) {
    if (typeof p == "number") {
      if (typeof u == "string")
        throw new TypeError('The "string" argument must be of type string. Received type number');
      return h(p);
    }
    return a(p, u, f);
  }
  s.poolSize = 8192;
  function a(p, u, f) {
    if (typeof p == "string")
      return d(p, u);
    if (ArrayBuffer.isView(p))
      return y(p);
    if (p == null)
      throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + _typeof(p));
    if (Ye(p, ArrayBuffer) || p && Ye(p.buffer, ArrayBuffer) || (typeof SharedArrayBuffer === "undefined" ? "undefined" : _typeof(SharedArrayBuffer)) < "u" && (Ye(p, SharedArrayBuffer) || p && Ye(p.buffer, SharedArrayBuffer)))
      return w(p, u, f);
    if (typeof p == "number")
      throw new TypeError('The "value" argument must not be of type number. Received type number');
    var b = p.valueOf && p.valueOf();
    if (b != null && b !== p)
      return s.from(b, u, f);
    var A = S(p);
    if (A)
      return A;
    if ((typeof Symbol === "undefined" ? "undefined" : _typeof(Symbol)) < "u" && Symbol.toPrimitive != null && typeof p[Symbol.toPrimitive] == "function")
      return s.from(p[Symbol.toPrimitive]("string"), u, f);
    throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + _typeof(p));
  }
  s.from = function(p, u, f) {
    return a(p, u, f);
  }, Object.setPrototypeOf(s.prototype, Uint8Array.prototype), Object.setPrototypeOf(s, Uint8Array);
  function l(p) {
    if (typeof p != "number")
      throw new TypeError('"size" argument must be of type number');
    if (p < 0)
      throw new RangeError('The value "' + p + '" is invalid for option "size"');
  }
  function c(p, u, f) {
    return l(p), p <= 0 ? o(p) : u !== void 0 ? typeof f == "string" ? o(p).fill(u, f) : o(p).fill(u) : o(p);
  }
  s.alloc = function(p, u, f) {
    return c(p, u, f);
  };
  function h(p) {
    return l(p), o(p < 0 ? 0 : E(p) | 0);
  }
  s.allocUnsafe = function(p) {
    return h(p);
  }, s.allocUnsafeSlow = function(p) {
    return h(p);
  };
  function d(p, u) {
    if ((typeof u != "string" || u === "") && (u = "utf8"), !s.isEncoding(u))
      throw new TypeError("Unknown encoding: " + u);
    var f = C(p, u) | 0, b = o(f), A = b.write(p, u);
    return A !== f && (b = b.slice(0, A)), b;
  }
  function g(p) {
    var u = p.length < 0 ? 0 : E(p.length) | 0, f = o(u);
    for (var b = 0; b < u; b += 1)
      f[b] = p[b] & 255;
    return f;
  }
  function y(p) {
    if (Ye(p, Uint8Array)) {
      var u = new Uint8Array(p);
      return w(u.buffer, u.byteOffset, u.byteLength);
    }
    return g(p);
  }
  function w(p, u, f) {
    if (u < 0 || p.byteLength < u)
      throw new RangeError('"offset" is outside of buffer bounds');
    if (p.byteLength < u + (f || 0))
      throw new RangeError('"length" is outside of buffer bounds');
    var b;
    return u === void 0 && f === void 0 ? b = new Uint8Array(p) : f === void 0 ? b = new Uint8Array(p, u) : b = new Uint8Array(p, u, f), Object.setPrototypeOf(b, s.prototype), b;
  }
  function S(p) {
    if (s.isBuffer(p)) {
      var u = E(p.length) | 0, f = o(u);
      return f.length === 0 || p.copy(f, 0, 0, u), f;
    }
    if (p.length !== void 0)
      return typeof p.length != "number" || gs(p.length) ? o(0) : g(p);
    if (p.type === "Buffer" && Array.isArray(p.data))
      return g(p.data);
  }
  function E(p) {
    if (p >= i)
      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + i.toString(16) + " bytes");
    return p | 0;
  }
  function I(p) {
    return +p != p && (p = 0), s.alloc(+p);
  }
  s.isBuffer = function(u) {
    return u != null && u._isBuffer === true && u !== s.prototype;
  }, s.compare = function(u, f) {
    if (Ye(u, Uint8Array) && (u = s.from(u, u.offset, u.byteLength)), Ye(f, Uint8Array) && (f = s.from(f, f.offset, f.byteLength)), !s.isBuffer(u) || !s.isBuffer(f))
      throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
    if (u === f)
      return 0;
    var b = u.length, A = f.length;
    for (var T = 0, P = Math.min(b, A); T < P; ++T)
      if (u[T] !== f[T]) {
        b = u[T], A = f[T];
        break;
      }
    return b < A ? -1 : A < b ? 1 : 0;
  }, s.isEncoding = function(u) {
    switch (String(u).toLowerCase()) {
      case "hex":
      case "utf8":
      case "utf-8":
      case "ascii":
      case "latin1":
      case "binary":
      case "base64":
      case "ucs2":
      case "ucs-2":
      case "utf16le":
      case "utf-16le":
        return true;
      default:
        return false;
    }
  }, s.concat = function(u, f) {
    if (!Array.isArray(u))
      throw new TypeError('"list" argument must be an Array of Buffers');
    if (u.length === 0)
      return s.alloc(0);
    var b;
    if (f === void 0)
      for (f = 0, b = 0; b < u.length; ++b)
        f += u[b].length;
    var A = s.allocUnsafe(f), T = 0;
    for (b = 0; b < u.length; ++b) {
      var P = u[b];
      if (Ye(P, Uint8Array))
        T + P.length > A.length ? (s.isBuffer(P) || (P = s.from(P)), P.copy(A, T)) : Uint8Array.prototype.set.call(A, P, T);
      else if (s.isBuffer(P))
        P.copy(A, T);
      else
        throw new TypeError('"list" argument must be an Array of Buffers');
      T += P.length;
    }
    return A;
  };
  function C(p, u) {
    if (s.isBuffer(p))
      return p.length;
    if (ArrayBuffer.isView(p) || Ye(p, ArrayBuffer))
      return p.byteLength;
    if (typeof p != "string")
      throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + _typeof(p));
    var f = p.length, b = arguments.length > 2 && arguments[2] === true;
    if (!b && f === 0)
      return 0;
    var A = false;
    for (; ; )
      switch (u) {
        case "ascii":
        case "latin1":
        case "binary":
          return f;
        case "utf8":
        case "utf-8":
          return ps(p).length;
        case "ucs2":
        case "ucs-2":
        case "utf16le":
        case "utf-16le":
          return f * 2;
        case "hex":
          return f >>> 1;
        case "base64":
          return Cl(p).length;
        default:
          if (A)
            return b ? -1 : ps(p).length;
          u = ("" + u).toLowerCase(), A = true;
      }
  }
  s.byteLength = C;
  function R(p, u, f) {
    var b = false;
    if ((u === void 0 || u < 0) && (u = 0), u > this.length || ((f === void 0 || f > this.length) && (f = this.length), f <= 0) || (f >>>= 0, u >>>= 0, f <= u))
      return "";
    for (p || (p = "utf8"); ; )
      switch (p) {
        case "hex":
          return qg(this, u, f);
        case "utf8":
        case "utf-8":
          return Pr(this, u, f);
        case "ascii":
          return hs(this, u, f);
        case "latin1":
        case "binary":
          return Ng(this, u, f);
        case "base64":
          return ge(this, u, f);
        case "ucs2":
        case "ucs-2":
        case "utf16le":
        case "utf-16le":
          return Dg(this, u, f);
        default:
          if (b)
            throw new TypeError("Unknown encoding: " + p);
          p = (p + "").toLowerCase(), b = true;
      }
  }
  s.prototype._isBuffer = true;
  function U(p, u, f) {
    var b = p[u];
    p[u] = p[f], p[f] = b;
  }
  s.prototype.swap16 = function() {
    var u = this.length;
    if (u % 2 !== 0)
      throw new RangeError("Buffer size must be a multiple of 16-bits");
    for (var f = 0; f < u; f += 2)
      U(this, f, f + 1);
    return this;
  }, s.prototype.swap32 = function() {
    var u = this.length;
    if (u % 4 !== 0)
      throw new RangeError("Buffer size must be a multiple of 32-bits");
    for (var f = 0; f < u; f += 4)
      U(this, f, f + 3), U(this, f + 1, f + 2);
    return this;
  }, s.prototype.swap64 = function() {
    var u = this.length;
    if (u % 8 !== 0)
      throw new RangeError("Buffer size must be a multiple of 64-bits");
    for (var f = 0; f < u; f += 8)
      U(this, f, f + 7), U(this, f + 1, f + 6), U(this, f + 2, f + 5), U(this, f + 3, f + 4);
    return this;
  }, s.prototype.toString = function() {
    var u = this.length;
    return u === 0 ? "" : arguments.length === 0 ? Pr(this, 0, u) : R.apply(this, arguments);
  }, s.prototype.toLocaleString = s.prototype.toString, s.prototype.equals = function(u) {
    if (!s.isBuffer(u))
      throw new TypeError("Argument must be a Buffer");
    return this === u ? true : s.compare(this, u) === 0;
  }, s.prototype.inspect = function() {
    var u = "", f = Zt.INSPECT_MAX_BYTES;
    return u = this.toString("hex", 0, f).replace(/(.{2})/g, "$1 ").trim(), this.length > f && (u += " ... "), "<Buffer " + u + ">";
  }, r && (s.prototype[r] = s.prototype.inspect), s.prototype.compare = function(u, f, b, A, T) {
    if (Ye(u, Uint8Array) && (u = s.from(u, u.offset, u.byteLength)), !s.isBuffer(u))
      throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + _typeof(u));
    if (f === void 0 && (f = 0), b === void 0 && (b = u ? u.length : 0), A === void 0 && (A = 0), T === void 0 && (T = this.length), f < 0 || b > u.length || A < 0 || T > this.length)
      throw new RangeError("out of range index");
    if (A >= T && f >= b)
      return 0;
    if (A >= T)
      return -1;
    if (f >= b)
      return 1;
    if (f >>>= 0, b >>>= 0, A >>>= 0, T >>>= 0, this === u)
      return 0;
    var P = T - A, $ = b - f, se = Math.min(P, $), te = this.slice(A, T), oe = u.slice(f, b);
    for (var J = 0; J < se; ++J)
      if (te[J] !== oe[J]) {
        P = te[J], $ = oe[J];
        break;
      }
    return P < $ ? -1 : $ < P ? 1 : 0;
  };
  functi