'use strict';

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 _arrayWithHoles(r) {
  if (Array.isArray(r)) return r;
}
function _arrayWithoutHoles(r) {
  if (Array.isArray(r)) return _arrayLikeToArray(r);
}
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 _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(r) {
    if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
    var n = r.done;
    return Promise.resolve(r.value).then(function (r) {
      return {
        value: r,
        done: n
      };
    });
  }
  return AsyncFromSyncIterator = function (r) {
    this.s = r, this.n = r.next;
  }, AsyncFromSyncIterator.prototype = {
    s: null,
    n: null,
    next: function () {
      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
    },
    return: function (r) {
      var n = this.s.return;
      return void 0 === n ? Promise.resolve({
        value: r,
        done: !0
      }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
    },
    throw: function (r) {
      var n = this.s.return;
      return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
    }
  }, new AsyncFromSyncIterator(r);
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
  try {
    var i = n[a](c),
      u = i.value;
  } catch (n) {
    return void e(n);
  }
  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(n) {
        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
      }
      function _throw(n) {
        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
      }
      _next(void 0);
    });
  };
}
function _checkPrivateRedeclaration(e, t) {
  if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _classCallCheck(a, n) {
  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _classPrivateMethodInitSpec(e, a) {
  _checkPrivateRedeclaration(e, a), a.add(e);
}
function _defineProperties(e, r) {
  for (var t = 0; t < r.length; t++) {
    var o = r[t];
    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
  }
}
function _createClass(e, r, t) {
  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
    writable: !1
  }), 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) {
      t && (r = t);
      var n = 0,
        F = function () {};
      return {
        s: F,
        n: function () {
          return n >= r.length ? {
            done: !0
          } : {
            done: !1,
            value: r[n++]
          };
        },
        e: function (r) {
          throw r;
        },
        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 = !0,
    u = !1;
  return {
    s: function () {
      t = t.call(r);
    },
    n: function () {
      var r = t.next();
      return a = r.done, r;
    },
    e: function (r) {
      u = !0, o = r;
    },
    f: function () {
      try {
        a || null == t.return || t.return();
      } finally {
        if (u) throw o;
      }
    }
  };
}
function _defineProperty(e, r, t) {
  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
    value: t,
    enumerable: !0,
    configurable: !0,
    writable: !0
  }) : e[r] = t, e;
}
function _iterableToArray(r) {
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
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 = !0,
      o = !1;
    try {
      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
    } catch (r) {
      o = !0, n = r;
    } finally {
      try {
        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
      } finally {
        if (o) throw n;
      }
    }
    return a;
  }
}
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 _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 _regeneratorRuntime() {
  _regeneratorRuntime = function () {
    return e;
  };
  var t,
    e = {},
    r = Object.prototype,
    n = r.hasOwnProperty,
    o = Object.defineProperty || function (t, e, r) {
      t[e] = r.value;
    },
    i = "function" == typeof Symbol ? Symbol : {},
    a = i.iterator || "@@iterator",
    c = i.asyncIterator || "@@asyncIterator",
    u = i.toStringTag || "@@toStringTag";
  function define(t, e, r) {
    return Object.defineProperty(t, e, {
      value: r,
      enumerable: !0,
      configurable: !0,
      writable: !0
    }), t[e];
  }
  try {
    define({}, "");
  } catch (t) {
    define = function (t, e, r) {
      return t[e] = r;
    };
  }
  function wrap(t, e, r, n) {
    var i = e && e.prototype instanceof Generator ? e : Generator,
      a = Object.create(i.prototype),
      c = new Context(n || []);
    return o(a, "_invoke", {
      value: makeInvokeMethod(t, r, c)
    }), a;
  }
  function tryCatch(t, e, r) {
    try {
      return {
        type: "normal",
        arg: t.call(e, r)
      };
    } catch (t) {
      return {
        type: "throw",
        arg: t
      };
    }
  }
  e.wrap = wrap;
  var h = "suspendedStart",
    l = "suspendedYield",
    f = "executing",
    s = "completed",
    y = {};
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  var p = {};
  define(p, a, function () {
    return this;
  });
  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(t) {
    ["next", "throw", "return"].forEach(function (e) {
      define(t, e, function (t) {
        return this._invoke(e, t);
      });
    });
  }
  function AsyncIterator(t, e) {
    function invoke(r, o, i, a) {
      var c = tryCatch(t[r], t, o);
      if ("throw" !== c.type) {
        var u = c.arg,
          h = u.value;
        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
          invoke("next", t, i, a);
        }, function (t) {
          invoke("throw", t, i, a);
        }) : e.resolve(h).then(function (t) {
          u.value = t, i(u);
        }, function (t) {
          return invoke("throw", t, i, a);
        });
      }
      a(c.arg);
    }
    var r;
    o(this, "_invoke", {
      value: function (t, n) {
        function callInvokeWithMethodAndArg() {
          return new e(function (e, r) {
            invoke(t, n, e, r);
          });
        }
        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }
    });
  }
  function makeInvokeMethod(e, r, n) {
    var o = h;
    return function (i, a) {
      if (o === f) throw Error("Generator is already running");
      if (o === s) {
        if ("throw" === i) throw a;
        return {
          value: t,
          done: !0
        };
      }
      for (n.method = i, n.arg = a;;) {
        var c = n.delegate;
        if (c) {
          var u = maybeInvokeDelegate(c, n);
          if (u) {
            if (u === y) continue;
            return u;
          }
        }
        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
          if (o === h) throw o = s, n.arg;
          n.dispatchException(n.arg);
        } else "return" === n.method && n.abrupt("return", n.arg);
        o = f;
        var p = tryCatch(e, r, n);
        if ("normal" === p.type) {
          if (o = n.done ? s : l, p.arg === y) continue;
          return {
            value: p.arg,
            done: n.done
          };
        }
        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
      }
    };
  }
  function maybeInvokeDelegate(e, r) {
    var n = r.method,
      o = e.iterator[n];
    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
    var i = tryCatch(o, e.iterator, r.arg);
    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
    var a = i.arg;
    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
  }
  function pushTryEntry(t) {
    var e = {
      tryLoc: t[0]
    };
    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
  }
  function resetTryEntry(t) {
    var e = t.completion || {};
    e.type = "normal", delete e.arg, t.completion = e;
  }
  function Context(t) {
    this.tryEntries = [{
      tryLoc: "root"
    }], t.forEach(pushTryEntry, this), this.reset(!0);
  }
  function values(e) {
    if (e || "" === e) {
      var r = e[a];
      if (r) return r.call(e);
      if ("function" == typeof e.next) return e;
      if (!isNaN(e.length)) {
        var o = -1,
          i = function next() {
            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
            return next.value = t, next.done = !0, next;
          };
        return i.next = i;
      }
    }
    throw new TypeError(typeof e + " is not iterable");
  }
  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
    value: GeneratorFunctionPrototype,
    configurable: !0
  }), o(GeneratorFunctionPrototype, "constructor", {
    value: GeneratorFunction,
    configurable: !0
  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
    var e = "function" == typeof t && t.constructor;
    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
  }, e.mark = function (t) {
    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
  }, e.awrap = function (t) {
    return {
      __await: t
    };
  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
    return this;
  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
    void 0 === i && (i = Promise);
    var a = new AsyncIterator(wrap(t, r, n, o), i);
    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
      return t.done ? t.value : a.next();
    });
  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
    return this;
  }), define(g, "toString", function () {
    return "[object Generator]";
  }), e.keys = function (t) {
    var e = Object(t),
      r = [];
    for (var n in e) r.push(n);
    return r.reverse(), function next() {
      for (; r.length;) {
        var t = r.pop();
        if (t in e) return next.value = t, next.done = !1, next;
      }
      return next.done = !0, next;
    };
  }, e.values = values, Context.prototype = {
    constructor: Context,
    reset: function (e) {
      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
    },
    stop: function () {
      this.done = !0;
      var t = this.tryEntries[0].completion;
      if ("throw" === t.type) throw t.arg;
      return this.rval;
    },
    dispatchException: function (e) {
      if (this.done) throw e;
      var r = this;
      function handle(n, o) {
        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
      }
      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
        var i = this.tryEntries[o],
          a = i.completion;
        if ("root" === i.tryLoc) return handle("end");
        if (i.tryLoc <= this.prev) {
          var c = n.call(i, "catchLoc"),
            u = n.call(i, "finallyLoc");
          if (c && u) {
            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
          } else if (c) {
            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
          } else {
            if (!u) throw Error("try statement without catch or finally");
            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
          }
        }
      }
    },
    abrupt: function (t, e) {
      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
        var o = this.tryEntries[r];
        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
          var i = o;
          break;
        }
      }
      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
      var a = i ? i.completion : {};
      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
    },
    complete: function (t, e) {
      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 && e && (this.next = e), y;
    },
    finish: function (t) {
      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
        var r = this.tryEntries[e];
        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
      }
    },
    catch: function (t) {
      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
        var r = this.tryEntries[e];
        if (r.tryLoc === t) {
          var n = r.completion;
          if ("throw" === n.type) {
            var o = n.arg;
            resetTryEntry(r);
          }
          return o;
        }
      }
      throw Error("illegal catch attempt");
    },
    delegateYield: function (e, r, n) {
      return this.delegate = {
        iterator: values(e),
        resultName: r,
        nextLoc: n
      }, "next" === this.method && (this.arg = t), y;
    }
  }, e;
}
function _slicedToArray(r, e) {
  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _toConsumableArray(r) {
  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
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 _toPropertyKey(t) {
  var i = _toPrimitive(t, "string");
  return "symbol" == typeof i ? i : i + "";
}
function _typeof(o) {
  "@babel/helpers - typeof";

  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
    return typeof o;
  } : function (o) {
    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
  }, _typeof(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;
  }
}

var createSyncConcatIterator = function createSyncConcatIterator(iterators) {
  var currentIteratorIndex = 0;
  return _defineProperty({
    next: function next() {
      while (currentIteratorIndex < iterators.length) {
        var result = iterators[currentIteratorIndex].next();
        if (!result.done) {
          return result;
        }
        currentIteratorIndex++;
      }
      return {
        done: true,
        value: undefined
      };
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncConcatIterator = function createAsyncConcatIterator(iterators) {
  var currentIteratorIndex = 0;
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var iterator, result;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!(currentIteratorIndex < iterators.length)) {
                _context.next = 10;
                break;
              }
              iterator = iterators[currentIteratorIndex];
              _context.next = 4;
              return iterator.next();
            case 4:
              result = _context.sent;
              if (result.done) {
                _context.next = 7;
                break;
              }
              return _context.abrupt("return", result);
            case 7:
              currentIteratorIndex++;
              _context.next = 0;
              break;
            case 10:
              return _context.abrupt("return", {
                done: true,
                value: undefined
              });
            case 11:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createConcatIterator() {
  for (var _len = arguments.length, iterables = new Array(_len), _key = 0; _key < _len; _key++) {
    iterables[_key] = arguments[_key];
  }
  var iterators = iterables.map(function (iterable) {
    if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
      throw new TypeError('All arguments must be iterable');
    }
    return iterable[Symbol.asyncIterator] ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
  });
  return iterators.some(function (iterator) {
    return typeof iterator[Symbol.asyncIterator] === 'function';
  }) ? createAsyncConcatIterator(iterators) : createSyncConcatIterator(iterators);
}

var createSyncDropIterator = function createSyncDropIterator(iterable, n) {
  if (!iterable[Symbol.iterator]) {
    throw new TypeError('the argument must be an iterable');
  }
  var iterator = iterable[Symbol.iterator]();
  var count = 0;
  return _defineProperty({
    next: function next() {
      while (count < n) {
        iterator.next();
        count++;
      }
      return iterator.next();
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncDropIterator = function createAsyncDropIterator(iterable, n) {
  if (!iterable[Symbol.asyncIterator]) {
    throw new TypeError('the argument must be an iterable');
  }
  var iterator = iterable[Symbol.asyncIterator]();
  var count = 0;
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!(count < n)) {
                _context.next = 6;
                break;
              }
              _context.next = 3;
              return iterator.next();
            case 3:
              count++;
              _context.next = 0;
              break;
            case 6:
              return _context.abrupt("return", iterator.next());
            case 7:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createDropIterator(iterable, n) {
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncDropIterator(iterable, n) : createSyncDropIterator(iterable, n);
}

var createSyncFilterIterator = function createSyncFilterIterator(iterable, predicate) {
  if (!iterable[Symbol.iterator]) {
    throw new TypeError('first argument must be an iterable');
  }
  if (typeof predicate !== 'function') {
    throw new TypeError('second argument must be a function');
  }
  var iterator = iterable[Symbol.iterator]();
  return _defineProperty({
    next: function next() {
      while (true) {
        var _iterator$next = iterator.next(),
          value = _iterator$next.value,
          done = _iterator$next.done;
        if (done || predicate(value)) {
          return {
            value: value,
            done: done
          };
        }
      }
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncFilterIterator = function createAsyncFilterIterator(iterable, predicate) {
  if (!iterable[Symbol.asyncIterator]) {
    throw new TypeError('first argument must be an async iterable');
  }
  if (typeof predicate !== 'function') {
    throw new TypeError('second argument must be a function');
  }
  var iterator = iterable[Symbol.asyncIterator]();
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var _yield$iterator$next, value, done;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              _context.next = 3;
              return iterator.next();
            case 3:
              _yield$iterator$next = _context.sent;
              value = _yield$iterator$next.value;
              done = _yield$iterator$next.done;
              if (!(done || predicate(value))) {
                _context.next = 8;
                break;
              }
              return _context.abrupt("return", {
                value: value,
                done: done
              });
            case 8:
              _context.next = 0;
              break;
            case 10:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createFilterIterator(iterable, predicate) {
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncFilterIterator(iterable, predicate) : createSyncFilterIterator(iterable, predicate);
}

var createSyncFlatMapIterator = function createSyncFlatMapIterator(iterable, fn) {
  var iterator = iterable[Symbol.iterator]();
  var innerIterator = null;
  return _defineProperty({
    next: function next() {
      while (true) {
        if (innerIterator) {
          var innerResult = innerIterator.next();
          if (!innerResult.done) {
            return {
              done: false,
              value: innerResult.value
            };
          }
          innerIterator = null;
        }
        var outerResult = iterator.next();
        if (outerResult.done) {
          return {
            done: true,
            value: undefined
          };
        }
        var mapped = fn(outerResult.value);
        if (mapped && typeof mapped[Symbol.iterator] === 'function') {
          innerIterator = mapped[Symbol.iterator]();
        } else {
          return {
            done: false,
            value: mapped
          };
        }
      }
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncFlatMapIterator = function createAsyncFlatMapIterator(iterable, fn) {
  var iterator = iterable[Symbol.asyncIterator]();
  var innerIterator = null;
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var innerResult, outerResult, mapped;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!innerIterator) {
                _context.next = 8;
                break;
              }
              _context.next = 4;
              return innerIterator.next();
            case 4:
              innerResult = _context.sent;
              if (innerResult.done) {
                _context.next = 7;
                break;
              }
              return _context.abrupt("return", {
                done: false,
                value: innerResult.value
              });
            case 7:
              innerIterator = null;
            case 8:
              _context.next = 10;
              return iterator.next();
            case 10:
              outerResult = _context.sent;
              if (!outerResult.done) {
                _context.next = 13;
                break;
              }
              return _context.abrupt("return", {
                done: true,
                value: undefined
              });
            case 13:
              _context.next = 15;
              return fn(outerResult.value);
            case 15:
              mapped = _context.sent;
              if (!(mapped && typeof mapped[Symbol.asyncIterator] === 'function')) {
                _context.next = 20;
                break;
              }
              innerIterator = mapped[Symbol.asyncIterator]();
              _context.next = 25;
              break;
            case 20:
              if (!(mapped && typeof mapped[Symbol.iterator] === 'function')) {
                _context.next = 24;
                break;
              }
              innerIterator = mapped[Symbol.iterator]();
              _context.next = 25;
              break;
            case 24:
              return _context.abrupt("return", {
                done: false,
                value: mapped
              });
            case 25:
              _context.next = 0;
              break;
            case 27:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createFlatMapIterator(iterable, fn) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('first argument must be an iterable');
  }
  if (typeof fn !== 'function') {
    throw new TypeError('second argument must be a function');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncFlatMapIterator(iterable, fn) : createSyncFlatMapIterator(iterable, fn);
}

var createSyncFlatIterator = function createSyncFlatIterator(iterable, depth) {
  var stack = [{
    iterator: iterable[Symbol.iterator](),
    depth: depth
  }];
  return _defineProperty({
    next: function next() {
      while (stack.length > 0) {
        var _stack = stack[stack.length - 1],
          iterator = _stack.iterator,
          _depth = _stack.depth;
        var result = iterator.next();
        if (result.done) {
          stack.pop();
          continue;
        }
        if (_depth > 0 && result.value && typeof result.value[Symbol.iterator] === 'function') {
          stack.push({
            iterator: result.value[Symbol.iterator](),
            depth: _depth - 1
          });
        } else {
          return {
            done: false,
            value: result.value
          };
        }
      }
      return {
        done: true,
        value: undefined
      };
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncFlatIterator = function createAsyncFlatIterator(iterable, depth) {
  var stack = [{
    iterator: iterable[Symbol.asyncIterator](),
    depth: depth
  }];
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var _stack2, iterator, _depth2, result, value;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!(stack.length > 0)) {
                _context.next = 24;
                break;
              }
              _stack2 = stack[stack.length - 1], iterator = _stack2.iterator, _depth2 = _stack2.depth;
              _context.next = 4;
              return iterator.next();
            case 4:
              result = _context.sent;
              if (!result.done) {
                _context.next = 8;
                break;
              }
              stack.pop();
              return _context.abrupt("continue", 0);
            case 8:
              value = result.value;
              if (!(typeof value === 'function')) {
                _context.next = 13;
                break;
              }
              _context.next = 12;
              return value();
            case 12:
              value = _context.sent;
            case 13:
              if (!(_depth2 > 0 && result.value && typeof result.value[Symbol.asyncIterator] === 'function')) {
                _context.next = 17;
                break;
              }
              stack.push({
                iterator: value[Symbol.asyncIterator](),
                depth: _depth2 - 1
              });
              _context.next = 22;
              break;
            case 17:
              if (!(_depth2 > 0 && result.value && typeof result.value[Symbol.iterator] === 'function')) {
                _context.next = 21;
                break;
              }
              stack.push({
                iterator: value[Symbol.iterator](),
                depth: _depth2 - 1
              });
              _context.next = 22;
              break;
            case 21:
              return _context.abrupt("return", {
                done: false,
                value: value
              });
            case 22:
              _context.next = 0;
              break;
            case 24:
              return _context.abrupt("return", {
                done: true,
                value: undefined
              });
            case 25:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createFlatIterator(iterable) {
  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('first argument must be an iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncFlatIterator(iterable, depth) : createSyncFlatIterator(iterable, depth);
}

var createSyncMapIterator = function createSyncMapIterator(iterable, fn) {
  if (!iterable[Symbol.iterator]) {
    throw new TypeError('first argument must be an iterable');
  }
  if (typeof fn !== 'function') {
    throw new TypeError('second argument must be a function');
  }
  var iterator = iterable[Symbol.iterator]();
  return _defineProperty({
    next: function next() {
      var _iterator$next = iterator.next(),
        value = _iterator$next.value,
        done = _iterator$next.done;
      return done ? {
        value: undefined,
        done: true
      } : {
        value: fn(value),
        done: false
      };
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncMapIterator = function createAsyncMapIterator(iterable, fn) {
  if (!iterable[Symbol.asyncIterator]) {
    throw new TypeError('First argument must be an async iterable or iterable');
  }
  if (typeof fn !== 'function') {
    throw new TypeError('Second argument must be a function');
  }
  var iterator = iterable[Symbol.asyncIterator]();
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var _yield$iterator$next, value, done;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return iterator.next();
            case 2:
              _yield$iterator$next = _context.sent;
              value = _yield$iterator$next.value;
              done = _yield$iterator$next.done;
              if (!done) {
                _context.next = 9;
                break;
              }
              _context.t0 = {
                value: undefined,
                done: true
              };
              _context.next = 13;
              break;
            case 9:
              _context.next = 11;
              return fn(value);
            case 11:
              _context.t1 = _context.sent;
              _context.t0 = {
                value: _context.t1,
                done: false
              };
            case 13:
              return _context.abrupt("return", _context.t0);
            case 14:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createMapIterator(iterable, fn) {
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncMapIterator(iterable, fn) : createSyncMapIterator(iterable, fn);
}

var createSyncReverseIterator = function createSyncReverseIterator(iterable) {
  if (!iterable[Symbol.iterator]) {
    throw new TypeError('the argument must be an iterable');
  }
  var items = _toConsumableArray(iterable);
  var index = items.length - 1;
  return _defineProperty({
    next: function next() {
      if (index >= 0) {
        return {
          value: items[index--],
          done: false
        };
      }
      return {
        done: true,
        value: undefined
      };
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncReverseIterator = function createAsyncReverseIterator(iterable) {
  var items = [];
  var index = 0;
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!(items.length === 0)) {
                _context.next = 30;
                break;
              }
              _iteratorAbruptCompletion = false;
              _didIteratorError = false;
              _context.prev = 3;
              _iterator = _asyncIterator(iterable);
            case 5:
              _context.next = 7;
              return _iterator.next();
            case 7:
              if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
                _context.next = 13;
                break;
              }
              item = _step.value;
              items.push(item);
            case 10:
              _iteratorAbruptCompletion = false;
              _context.next = 5;
              break;
            case 13:
              _context.next = 19;
              break;
            case 15:
              _context.prev = 15;
              _context.t0 = _context["catch"](3);
              _didIteratorError = true;
              _iteratorError = _context.t0;
            case 19:
              _context.prev = 19;
              _context.prev = 20;
              if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
                _context.next = 24;
                break;
              }
              _context.next = 24;
              return _iterator["return"]();
            case 24:
              _context.prev = 24;
              if (!_didIteratorError) {
                _context.next = 27;
                break;
              }
              throw _iteratorError;
            case 27:
              return _context.finish(24);
            case 28:
              return _context.finish(19);
            case 29:
              index = items.length - 1;
            case 30:
              if (!(index >= 0)) {
                _context.next = 34;
                break;
              }
              return _context.abrupt("return", {
                value: items[index--],
                done: false
              });
            case 34:
              return _context.abrupt("return", {
                done: true,
                value: undefined
              });
            case 35:
            case "end":
              return _context.stop();
          }
        }, _callee, null, [[3, 15, 19, 29], [20,, 24, 28]]);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createReverseIterator(iterable) {
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncReverseIterator(iterable) : createSyncReverseIterator(iterable);
}

var createSyncTakeIterator = function createSyncTakeIterator(iterable, n) {
  if (!iterable[Symbol.iterator]) {
    throw new TypeError('first argument must be an iterable');
  }
  var iterator = iterable[Symbol.iterator]();
  var count = 0;
  return _defineProperty({
    next: function next() {
      if (count < n) {
        count++;
        var _iterator$next = iterator.next(),
          done = _iterator$next.done,
          value = _iterator$next.value;
        return {
          done: done,
          value: value
        };
      }
      return {
        done: true,
        value: undefined
      };
    }
  }, Symbol.iterator, function () {
    return this;
  });
};
var createAsyncTakeIterator = function createAsyncTakeIterator(iterable, n) {
  if (!iterable[Symbol.asyncIterator]) {
    throw new TypeError('first argument must be an iterable');
  }
  var iterator = iterable[Symbol.asyncIterator]();
  var count = 0;
  return _defineProperty({
    next: function next() {
      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
        var _yield$iterator$next, done, value;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
          while (1) switch (_context.prev = _context.next) {
            case 0:
              if (!(count < n)) {
                _context.next = 8;
                break;
              }
              count++;
              _context.next = 4;
              return iterator.next();
            case 4:
              _yield$iterator$next = _context.sent;
              done = _yield$iterator$next.done;
              value = _yield$iterator$next.value;
              return _context.abrupt("return", {
                done: done,
                value: value
              });
            case 8:
              return _context.abrupt("return", {
                done: true,
                value: undefined
              });
            case 9:
            case "end":
              return _context.stop();
          }
        }, _callee);
      }))();
    }
  }, Symbol.asyncIterator, function () {
    return this;
  });
};
function createTakeIterator(iterable, predicate) {
  return typeof iterable[Symbol.asyncIterator] === 'function' ? createAsyncTakeIterator(iterable, predicate) : createSyncTakeIterator(iterable, predicate);
}

function avgSync(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  var total = 0;
  var count = 0;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      total += fn(item);
      count++;
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return count === 0 ? 0 : total / count;
}
function avgAsync(_x) {
  return _avgAsync.apply(this, arguments);
}
function _avgAsync() {
  _avgAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var fn,
      total,
      count,
      _iteratorAbruptCompletion,
      _didIteratorError,
      _iteratorError,
      _iterator,
      _step,
      item,
      _args = arguments;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          fn = _args.length > 1 && _args[1] !== undefined ? _args[1] : function (x) {
            return x;
          };
          total = 0;
          count = 0;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 5;
          _iterator = _asyncIterator(iterable);
        case 7:
          _context.next = 9;
          return _iterator.next();
        case 9:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 16;
            break;
          }
          item = _step.value;
          total += fn(item);
          count++;
        case 13:
          _iteratorAbruptCompletion = false;
          _context.next = 7;
          break;
        case 16:
          _context.next = 22;
          break;
        case 18:
          _context.prev = 18;
          _context.t0 = _context["catch"](5);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 22:
          _context.prev = 22;
          _context.prev = 23;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 27;
            break;
          }
          _context.next = 27;
          return _iterator["return"]();
        case 27:
          _context.prev = 27;
          if (!_didIteratorError) {
            _context.next = 30;
            break;
          }
          throw _iteratorError;
        case 30:
          return _context.finish(27);
        case 31:
          return _context.finish(22);
        case 32:
          return _context.abrupt("return", count === 0 ? 0 : total / count);
        case 33:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[5, 18, 22, 32], [23,, 27, 31]]);
  }));
  return _avgAsync.apply(this, arguments);
}
function avg(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('Provided object is not iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? avgAsync(iterable, fn) : avgSync(iterable, fn);
}

function maxSync(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  var max = -Infinity;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      var value = fn(item);
      max = Math.max(max, value);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return max;
}
function maxAsync(_x) {
  return _maxAsync.apply(this, arguments);
}
function _maxAsync() {
  _maxAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var fn,
      max,
      _iteratorAbruptCompletion,
      _didIteratorError,
      _iteratorError,
      _iterator,
      _step,
      item,
      value,
      _args = arguments;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          fn = _args.length > 1 && _args[1] !== undefined ? _args[1] : function (x) {
            return x;
          };
          max = -Infinity;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 4;
          _iterator = _asyncIterator(iterable);
        case 6:
          _context.next = 8;
          return _iterator.next();
        case 8:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 17;
            break;
          }
          item = _step.value;
          _context.next = 12;
          return fn(item);
        case 12:
          value = _context.sent;
          max = Math.max(max, value);
        case 14:
          _iteratorAbruptCompletion = false;
          _context.next = 6;
          break;
        case 17:
          _context.next = 23;
          break;
        case 19:
          _context.prev = 19;
          _context.t0 = _context["catch"](4);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 23:
          _context.prev = 23;
          _context.prev = 24;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 28;
            break;
          }
          _context.next = 28;
          return _iterator["return"]();
        case 28:
          _context.prev = 28;
          if (!_didIteratorError) {
            _context.next = 31;
            break;
          }
          throw _iteratorError;
        case 31:
          return _context.finish(28);
        case 32:
          return _context.finish(23);
        case 33:
          return _context.abrupt("return", max);
        case 34:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[4, 19, 23, 33], [24,, 28, 32]]);
  }));
  return _maxAsync.apply(this, arguments);
}
function max(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('Provided object is not iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? maxAsync(iterable, fn) : maxSync(iterable, fn);
}

function minSync(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  var min = Infinity;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      var value = fn(item);
      min = Math.min(min, value);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return min;
}
function minAsync(_x) {
  return _minAsync.apply(this, arguments);
}
function _minAsync() {
  _minAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var fn,
      min,
      _iteratorAbruptCompletion,
      _didIteratorError,
      _iteratorError,
      _iterator,
      _step,
      item,
      value,
      _args = arguments;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          fn = _args.length > 1 && _args[1] !== undefined ? _args[1] : function (x) {
            return x;
          };
          min = Infinity;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 4;
          _iterator = _asyncIterator(iterable);
        case 6:
          _context.next = 8;
          return _iterator.next();
        case 8:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 17;
            break;
          }
          item = _step.value;
          _context.next = 12;
          return fn(item);
        case 12:
          value = _context.sent;
          min = Math.min(min, value);
        case 14:
          _iteratorAbruptCompletion = false;
          _context.next = 6;
          break;
        case 17:
          _context.next = 23;
          break;
        case 19:
          _context.prev = 19;
          _context.t0 = _context["catch"](4);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 23:
          _context.prev = 23;
          _context.prev = 24;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 28;
            break;
          }
          _context.next = 28;
          return _iterator["return"]();
        case 28:
          _context.prev = 28;
          if (!_didIteratorError) {
            _context.next = 31;
            break;
          }
          throw _iteratorError;
        case 31:
          return _context.finish(28);
        case 32:
          return _context.finish(23);
        case 33:
          return _context.abrupt("return", min);
        case 34:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[4, 19, 23, 33], [24,, 28, 32]]);
  }));
  return _minAsync.apply(this, arguments);
}
function min(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('Provided object is not iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? minAsync(iterable, fn) : minSync(iterable, fn);
}

function reduceSync(iterable, reducer, initialValue) {
  if (!reducer) {
    throw new TypeError('The reducer argument must be provided');
  }
  if (typeof reducer !== 'function') {
    throw new TypeError('The reducer argument must be a function');
  }
  var accumulator = initialValue;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      accumulator = reducer(accumulator, item);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return accumulator;
}
function reduceAsync(_x, _x2, _x3) {
  return _reduceAsync.apply(this, arguments);
}
function _reduceAsync() {
  _reduceAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable, reducer, initialValue) {
    var accumulator, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          accumulator = initialValue;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 3;
          _iterator = _asyncIterator(iterable);
        case 5:
          _context.next = 7;
          return _iterator.next();
        case 7:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 15;
            break;
          }
          item = _step.value;
          _context.next = 11;
          return reducer(accumulator, item);
        case 11:
          accumulator = _context.sent;
        case 12:
          _iteratorAbruptCompletion = false;
          _context.next = 5;
          break;
        case 15:
          _context.next = 21;
          break;
        case 17:
          _context.prev = 17;
          _context.t0 = _context["catch"](3);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 21:
          _context.prev = 21;
          _context.prev = 22;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 26;
            break;
          }
          _context.next = 26;
          return _iterator["return"]();
        case 26:
          _context.prev = 26;
          if (!_didIteratorError) {
            _context.next = 29;
            break;
          }
          throw _iteratorError;
        case 29:
          return _context.finish(26);
        case 30:
          return _context.finish(21);
        case 31:
          return _context.abrupt("return", accumulator);
        case 32:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[3, 17, 21, 31], [22,, 26, 30]]);
  }));
  return _reduceAsync.apply(this, arguments);
}
function reduce(iterable, reducer) {
  var initialValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  if (!reducer) {
    throw new TypeError('The reducer argument must be provided');
  }
  if (typeof reducer !== 'function') {
    throw new TypeError('The reducer argument must be a function');
  }
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('Provided object is not iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? reduceAsync(iterable, reducer, initialValue) : reduceSync(iterable, reducer, initialValue);
}

function sumSync(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  var total = 0;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      total += fn(item);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return total;
}
function sumAsync(_x) {
  return _sumAsync.apply(this, arguments);
}
function _sumAsync() {
  _sumAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var fn,
      total,
      _iteratorAbruptCompletion,
      _didIteratorError,
      _iteratorError,
      _iterator,
      _step,
      item,
      _args = arguments;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          fn = _args.length > 1 && _args[1] !== undefined ? _args[1] : function (x) {
            return x;
          };
          total = 0;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 4;
          _iterator = _asyncIterator(iterable);
        case 6:
          _context.next = 8;
          return _iterator.next();
        case 8:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 17;
            break;
          }
          item = _step.value;
          _context.t0 = total;
          _context.next = 13;
          return fn(item);
        case 13:
          total = _context.t0 += _context.sent;
        case 14:
          _iteratorAbruptCompletion = false;
          _context.next = 6;
          break;
        case 17:
          _context.next = 23;
          break;
        case 19:
          _context.prev = 19;
          _context.t1 = _context["catch"](4);
          _didIteratorError = true;
          _iteratorError = _context.t1;
        case 23:
          _context.prev = 23;
          _context.prev = 24;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 28;
            break;
          }
          _context.next = 28;
          return _iterator["return"]();
        case 28:
          _context.prev = 28;
          if (!_didIteratorError) {
            _context.next = 31;
            break;
          }
          throw _iteratorError;
        case 31:
          return _context.finish(28);
        case 32:
          return _context.finish(23);
        case 33:
          return _context.abrupt("return", total);
        case 34:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[4, 19, 23, 33], [24,, 28, 32]]);
  }));
  return _sumAsync.apply(this, arguments);
}
function sum(iterable) {
  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) {
    return x;
  };
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('Provided object is not iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? sumAsync(iterable, fn) : sumSync(iterable, fn);
}

var DigitsIterable = /*#__PURE__*/function () {
  function DigitsIterable(number) {
    _classCallCheck(this, DigitsIterable);
    if (typeof number === 'bigint' || number > Number.MAX_SAFE_INTEGER) {
      this.number = BigInt(number);
    } else {
      this.number = number;
    }
  }
  return _createClass(DigitsIterable, [{
    key: Symbol.iterator,
    value: function value() {
      var number = this.number;
      return {
        next: function next() {
          if (typeof number === 'bigint') {
            if (number > 0n) {
              var digit = number % 10n;
              number = number / 10n;
              return {
                value: Number(digit),
                done: false
              };
            }
          } else {
            if (number > 0) {
              var _digit = number % 10;
              number = Math.floor(number / 10);
              return {
                value: _digit,
                done: false
              };
            }
          }
          return {
            done: true,
            value: undefined
          };
        }
      };
    }
  }]);
}();

var RangeIterable = /*#__PURE__*/function () {
  function RangeIterable(number) {
    _classCallCheck(this, RangeIterable);
    var MAX_LIMIT = Math.pow(2, 32) - 1;
    if (typeof number !== 'number' || number > MAX_LIMIT || number < -MAX_LIMIT) {
      throw new RangeError('Number exceeds MAX_LIMIT. You can create a range up to ±(2 ** 32 - 1).');
    }
    this.number = number;
  }
  return _createClass(RangeIterable, [{
    key: Symbol.iterator,
    value: function value() {
      var i = this.number > 0 ? 1 : -1;
      var number = this.number;
      return {
        next: function next() {
          if (number > 0 && i <= number) {
            return {
              done: false,
              value: i++
            };
          }
          if (number < 0 && i >= number) {
            return {
              done: false,
              value: i--
            };
          }
          return {
            done: true,
            value: undefined
          };
        }
      };
    }
  }]);
}();

var ObjectIterable = /*#__PURE__*/function () {
  function ObjectIterable(object) {
    _classCallCheck(this, ObjectIterable);
    this.object = object;
  }
  return _createClass(ObjectIterable, [{
    key: Symbol.iterator,
    value: function value() {
      var object = this.object;
      var keys = Object.keys(object);
      var i = 0;
      return {
        next: function next() {
          if (i < keys.length) {
            return {
              done: false,
              value: [keys[i], object[keys[i++]]]
            };
          }
          return {
            done: true,
            value: undefined
          };
        }
      };
    }
  }, {
    key: Symbol.asyncIterator,
    value: function value() {
      var object = this.object;
      var keys = Object.keys(object);
      var i = 0;
      return {
        next: function next() {
          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
            var key, value;
            return _regeneratorRuntime().wrap(function _callee$(_context) {
              while (1) switch (_context.prev = _context.next) {
                case 0:
                  if (!(i < keys.length)) {
                    _context.next = 14;
                    break;
                  }
                  key = keys[i++];
                  value = object[key];
                  if (!(typeof value === 'function')) {
                    _context.next = 9;
                    break;
                  }
                  _context.next = 6;
                  return value();
                case 6:
                  value = _context.sent;
                  _context.next = 13;
                  break;
                case 9:
                  if (!(value instanceof Promise)) {
                    _context.next = 13;
                    break;
                  }
                  _context.next = 12;
                  return value;
                case 12:
                  value = _context.sent;
                case 13:
                  return _context.abrupt("return", {
                    done: false,
                    value: [key, value]
                  });
                case 14:
                  return _context.abrupt("return", {
                    done: true,
                    value: undefined
                  });
                case 15:
                case "end":
                  return _context.stop();
              }
            }, _callee);
          }))();
        }
      };
    }
  }]);
}();

var convertToAsyncIterator = function convertToAsyncIterator(iterator) {
  if (iterator[Symbol.asyncIterator]) {
    return iterator;
  }
  var resolveItem = /*#__PURE__*/function () {
    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(item) {
      return _regeneratorRuntime().wrap(function _callee$(_context) {
        while (1) switch (_context.prev = _context.next) {
          case 0:
            if (!(typeof item === 'function')) {
              _context.next = 4;
              break;
            }
            _context.next = 3;
            return item();
          case 3:
            return _context.abrupt("return", _context.sent);
          case 4:
            _context.next = 6;
            return item;
          case 6:
            return _context.abrupt("return", _context.sent);
          case 7:
          case "end":
            return _context.stop();
        }
      }, _callee);
    }));
    return function resolveItem(_x) {
      return _ref.apply(this, arguments);
    };
  }();
  return _defineProperty({}, Symbol.asyncIterator, function () {
    var syncIterator = iterator[Symbol.iterator] ? iterator[Symbol.iterator]() : iterator;
    return {
      next: function next() {
        return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
          var _syncIterator$next, value, done, resolvedValue;
          return _regeneratorRuntime().wrap(function _callee2$(_context2) {
            while (1) switch (_context2.prev = _context2.next) {
              case 0:
                _syncIterator$next = syncIterator.next(), value = _syncIterator$next.value, done = _syncIterator$next.done;
                if (!done) {
                  _context2.next = 5;
                  break;
                }
                return _context2.abrupt("return", {
                  value: undefined,
                  done: true
                });
              case 5:
                _context2.next = 7;
                return resolveItem(value);
              case 7:
                resolvedValue = _context2.sent;
                return _context2.abrupt("return", {
                  value: resolvedValue,
                  done: false
                });
              case 9:
              case "end":
                return _context2.stop();
            }
          }, _callee2);
        }))();
      }
    };
  });
};

var groupBySync = function groupBySync(iterable, grouper) {
  var groups = {};
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      var key = grouper(item);
      if (!groups[key]) {
        groups[key] = [];
      }
      groups[key].push(item);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return groups;
};
var groupByAsync = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable, grouper) {
    var groups, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, key;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          groups = {};
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 3;
          _iterator = _asyncIterator(iterable);
        case 5:
          _context.next = 7;
          return _iterator.next();
        case 7:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 15;
            break;
          }
          item = _step.value;
          key = grouper(item);
          if (!groups[key]) {
            groups[key] = [];
          }
          groups[key].push(item);
        case 12:
          _iteratorAbruptCompletion = false;
          _context.next = 5;
          break;
        case 15:
          _context.next = 21;
          break;
        case 17:
          _context.prev = 17;
          _context.t0 = _context["catch"](3);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 21:
          _context.prev = 21;
          _context.prev = 22;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 26;
            break;
          }
          _context.next = 26;
          return _iterator["return"]();
        case 26:
          _context.prev = 26;
          if (!_didIteratorError) {
            _context.next = 29;
            break;
          }
          throw _iteratorError;
        case 29:
          return _context.finish(26);
        case 30:
          return _context.finish(21);
        case 31:
          return _context.abrupt("return", groups);
        case 32:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[3, 17, 21, 31], [22,, 26, 30]]);
  }));
  return function groupByAsync(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();
function groupBy(iterable, grouper) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? groupByAsync(iterable, grouper) : groupBySync(iterable, grouper);
}

var partitionSync = function partitionSync(iterable, predicate) {
  var truthy = [];
  var falsy = [];
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      if (predicate(item)) {
        truthy.push(item);
      } else {
        falsy.push(item);
      }
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return [truthy, falsy];
};
var partitionAsync = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable, predicate) {
    var truthy, falsy, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, result;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          truthy = [];
          falsy = [];
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 4;
          _iterator = _asyncIterator(iterable);
        case 6:
          _context.next = 8;
          return _iterator.next();
        case 8:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 22;
            break;
          }
          item = _step.value;
          if (!(typeof item === 'function')) {
            _context.next = 16;
            break;
          }
          _context.next = 13;
          return item();
        case 13:
          _context.t0 = _context.sent;
          _context.next = 17;
          break;
        case 16:
          _context.t0 = item;
        case 17:
          result = _context.t0;
          if (predicate(result)) {
            truthy.push(result);
          } else {
            falsy.push(result);
          }
        case 19:
          _iteratorAbruptCompletion = false;
          _context.next = 6;
          break;
        case 22:
          _context.next = 28;
          break;
        case 24:
          _context.prev = 24;
          _context.t1 = _context["catch"](4);
          _didIteratorError = true;
          _iteratorError = _context.t1;
        case 28:
          _context.prev = 28;
          _context.prev = 29;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 33;
            break;
          }
          _context.next = 33;
          return _iterator["return"]();
        case 33:
          _context.prev = 33;
          if (!_didIteratorError) {
            _context.next = 36;
            break;
          }
          throw _iteratorError;
        case 36:
          return _context.finish(33);
        case 37:
          return _context.finish(28);
        case 38:
          return _context.abrupt("return", [truthy, falsy]);
        case 39:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[4, 24, 28, 38], [29,, 33, 37]]);
  }));
  return function partitionAsync(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();
function partition(iterable, predicate) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? partitionAsync(iterable, predicate) : partitionSync(iterable, predicate);
}

var toArraySync = function toArraySync(iterable) {
  return Array.from(iterable);
};
var toArrayAsync = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var result, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          result = [];
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 3;
          _iterator = _asyncIterator(iterable);
        case 5:
          _context.next = 7;
          return _iterator.next();
        case 7:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 21;
            break;
          }
          item = _step.value;
          if (!(typeof item === 'function')) {
            _context.next = 17;
            break;
          }
          _context.t0 = result;
          _context.next = 13;
          return item();
        case 13:
          _context.t1 = _context.sent;
          _context.t0.push.call(_context.t0, _context.t1);
          _context.next = 18;
          break;
        case 17:
          result.push(item);
        case 18:
          _iteratorAbruptCompletion = false;
          _context.next = 5;
          break;
        case 21:
          _context.next = 27;
          break;
        case 23:
          _context.prev = 23;
          _context.t2 = _context["catch"](3);
          _didIteratorError = true;
          _iteratorError = _context.t2;
        case 27:
          _context.prev = 27;
          _context.prev = 28;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 32;
            break;
          }
          _context.next = 32;
          return _iterator["return"]();
        case 32:
          _context.prev = 32;
          if (!_didIteratorError) {
            _context.next = 35;
            break;
          }
          throw _iteratorError;
        case 35:
          return _context.finish(32);
        case 36:
          return _context.finish(27);
        case 37:
          return _context.abrupt("return", result);
        case 38:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);
  }));
  return function toArrayAsync(_x) {
    return _ref.apply(this, arguments);
  };
}();
function toArray(iterable) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? toArrayAsync(iterable) : toArraySync(iterable);
}

var toMapSync$1 = function toMapSync(iterable) {
  var map = new Map();
  var index = 0;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      // for [key,value] syntax
      if (Array.isArray(item) && item.length === 2) {
        var _item = _slicedToArray(item, 2),
          key = _item[0],
          value = _item[1];
        map.set(key, value);
      } else {
        map.set(index, item);
        index++;
      }
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return map;
};
var toMapAsync$1 = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var map, index, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, _item2, key, value;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          map = new Map();
          index = 0;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 4;
          _iterator = _asyncIterator(iterable);
        case 6:
          _context.next = 8;
          return _iterator.next();
        case 8:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 14;
            break;
          }
          item = _step.value;
          // for [key,value] syntax
          if (Array.isArray(item) && item.length === 2) {
            _item2 = _slicedToArray(item, 2), key = _item2[0], value = _item2[1];
            map.set(key, value);
          } else {
            map.set(index, item);
            index++;
          }
        case 11:
          _iteratorAbruptCompletion = false;
          _context.next = 6;
          break;
        case 14:
          _context.next = 20;
          break;
        case 16:
          _context.prev = 16;
          _context.t0 = _context["catch"](4);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 20:
          _context.prev = 20;
          _context.prev = 21;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 25;
            break;
          }
          _context.next = 25;
          return _iterator["return"]();
        case 25:
          _context.prev = 25;
          if (!_didIteratorError) {
            _context.next = 28;
            break;
          }
          throw _iteratorError;
        case 28:
          return _context.finish(25);
        case 29:
          return _context.finish(20);
        case 30:
          return _context.abrupt("return", map);
        case 31:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[4, 16, 20, 30], [21,, 25, 29]]);
  }));
  return function toMapAsync(_x) {
    return _ref.apply(this, arguments);
  };
}();
function toMap$1(iterable) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? toMapAsync$1(iterable) : toMapSync$1(iterable);
}

var toMapSync = function toMapSync(iterable) {
  var obj = {};
  var index = 0;
  var _iterator2 = _createForOfIteratorHelper(iterable),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var item = _step2.value;
      // for [key,value] syntax
      if (Array.isArray(item) && item.length === 2) {
        var _item = _slicedToArray(item, 2),
          key = _item[0],
          value = _item[1];
        obj[key] = value;
      } else {
        obj[index] = item;
        index++;
      }
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return obj;
};
var toMapAsync = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var obj, index, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, _item2, key, value;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          obj = {};
          index = 0;
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 4;
          _iterator = _asyncIterator(iterable);
        case 6:
          _context.next = 8;
          return _iterator.next();
        case 8:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 14;
            break;
          }
          item = _step.value;
          // for [key,value] syntax
          if (Array.isArray(item) && item.length === 2) {
            _item2 = _slicedToArray(item, 2), key = _item2[0], value = _item2[1];
            obj[key] = value;
          } else {
            obj[index] = item;
            index++;
          }
        case 11:
          _iteratorAbruptCompletion = false;
          _context.next = 6;
          break;
        case 14:
          _context.next = 20;
          break;
        case 16:
          _context.prev = 16;
          _context.t0 = _context["catch"](4);
          _didIteratorError = true;
          _iteratorError = _context.t0;
        case 20:
          _context.prev = 20;
          _context.prev = 21;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 25;
            break;
          }
          _context.next = 25;
          return _iterator["return"]();
        case 25:
          _context.prev = 25;
          if (!_didIteratorError) {
            _context.next = 28;
            break;
          }
          throw _iteratorError;
        case 28:
          return _context.finish(25);
        case 29:
          return _context.finish(20);
        case 30:
          return _context.abrupt("return", obj);
        case 31:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[4, 16, 20, 30], [21,, 25, 29]]);
  }));
  return function toMapAsync(_x) {
    return _ref.apply(this, arguments);
  };
}();
function toMap(iterable) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? toMapAsync(iterable) : toMapSync(iterable);
}

var toSetSync = function toSetSync(iterable) {
  return new Set(iterable);
};
var toSetAsync = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var resultSet, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, value;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          resultSet = new Set();
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 3;
          _iterator = _asyncIterator(iterable);
        case 5:
          _context.next = 7;
          return _iterator.next();
        case 7:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 21;
            break;
          }
          value = _step.value;
          if (!(typeof value === 'function')) {
            _context.next = 17;
            break;
          }
          _context.t0 = resultSet;
          _context.next = 13;
          return value();
        case 13:
          _context.t1 = _context.sent;
          _context.t0.add.call(_context.t0, _context.t1);
          _context.next = 18;
          break;
        case 17:
          resultSet.add(value);
        case 18:
          _iteratorAbruptCompletion = false;
          _context.next = 5;
          break;
        case 21:
          _context.next = 27;
          break;
        case 23:
          _context.prev = 23;
          _context.t2 = _context["catch"](3);
          _didIteratorError = true;
          _iteratorError = _context.t2;
        case 27:
          _context.prev = 27;
          _context.prev = 28;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 32;
            break;
          }
          _context.next = 32;
          return _iterator["return"]();
        case 32:
          _context.prev = 32;
          if (!_didIteratorError) {
            _context.next = 35;
            break;
          }
          throw _iteratorError;
        case 35:
          return _context.finish(32);
        case 36:
          return _context.finish(27);
        case 37:
          return _context.abrupt("return", resultSet);
        case 38:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);
  }));
  return function toSetAsync(_x) {
    return _ref.apply(this, arguments);
  };
}();
function toSet(iterable) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? toSetAsync(iterable) : toSetSync(iterable);
}

var toStringSync = function toStringSync(iterable) {
  return Array.from(iterable).join('');
};
var toStringAsync = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(iterable) {
    var array, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, value;
    return _regeneratorRuntime().wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          array = [];
          _iteratorAbruptCompletion = false;
          _didIteratorError = false;
          _context.prev = 3;
          _iterator = _asyncIterator(iterable);
        case 5:
          _context.next = 7;
          return _iterator.next();
        case 7:
          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
            _context.next = 21;
            break;
          }
          value = _step.value;
          if (!(typeof value === 'function')) {
            _context.next = 17;
            break;
          }
          _context.t0 = array;
          _context.next = 13;
          return value();
        case 13:
          _context.t1 = _context.sent;
          _context.t0.push.call(_context.t0, _context.t1);
          _context.next = 18;
          break;
        case 17:
          array.push(value);
        case 18:
          _iteratorAbruptCompletion = false;
          _context.next = 5;
          break;
        case 21:
          _context.next = 27;
          break;
        case 23:
          _context.prev = 23;
          _context.t2 = _context["catch"](3);
          _didIteratorError = true;
          _iteratorError = _context.t2;
        case 27:
          _context.prev = 27;
          _context.prev = 28;
          if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
            _context.next = 32;
            break;
          }
          _context.next = 32;
          return _iterator["return"]();
        case 32:
          _context.prev = 32;
          if (!_didIteratorError) {
            _context.next = 35;
            break;
          }
          throw _iteratorError;
        case 35:
          return _context.finish(32);
        case 36:
          return _context.finish(27);
        case 37:
          return _context.abrupt("return", array.join(''));
        case 38:
        case "end":
          return _context.stop();
      }
    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);
  }));
  return function toStringAsync(_x) {
    return _ref.apply(this, arguments);
  };
}();
function toString(iterable) {
  if (!iterable[Symbol.iterator] && !iterable[Symbol.asyncIterator]) {
    throw new TypeError('The argument must be iterable');
  }
  return typeof iterable[Symbol.asyncIterator] === 'function' ? toStringAsync(iterable) : toStringSync(iterable);
}

var _Iter8or_brand = /*#__PURE__*/new WeakSet();
var Iter8or = /*#__PURE__*/function () {
  function Iter8or(_iterable) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    _classCallCheck(this, Iter8or);
    _classPrivateMethodInitSpec(this, _Iter8or_brand);
    if (_iterable === null || _iterable === undefined) {
      throw new TypeError('Cannot create an iterable from null or undefined.');
    }
    if (typeof _iterable === 'boolean') {
      throw new TypeError('Cannot create an iterable from a boolean.');
    }
    if (typeof _iterable === 'function') {
      _iterable = _iterable();
      if (!_iterable || !_iterable[Symbol.iterator] && !_iterable[Symbol.asyncIterator]) {
        throw new TypeError('Cannot create an iterable from a function.');
      }
    }
    this.options = options;
    if (!_iterable[Symbol.iterator] && !_iterable[Symbol.asyncIterator]) {
      _assertClassBrand(_Iter8or_brand, this, _createIterable).call(this, _iterable, options);
    } else {
      if (this.options.async && !_iterable[Symbol.asyncIterator]) {
        this.iterable = convertToAsyncIterator(_iterable);
      } else {
        this.iterable = _iterable;
      }
    }
  }
  return _createClass(Iter8or, [{
    key: Symbol.iterator,
    value: function value() {
      if (this.options.async) {
        throw new TypeError('This is a async iterable. Use Symbol.asyncIterator instead.');
      } else {
        var iterator = this.iterable[Symbol.iterator]();
        var stack = [iterator];
        return _defineProperty({
          next: function next() {
            while (stack.length > 0) {
              var currentIterator = stack[stack.length - 1];
              var _currentIterator$next = currentIterator.next(),
                done = _currentIterator$next.done,
                value = _currentIterator$next.value;
              if (done) {
                stack.pop();
                continue;
              }
              if (value && (typeof value[Symbol.iterator] === 'function' || typeof value[Symbol.asyncIterator] === 'function')) {
                stack.push(value);
                continue;
              }
              return {
                done: false,
                value: value
              };
            }
            return {
              done: true,
              value: undefined
            };
          }
        }, Symbol.iterator, function () {
          return this;
        });
      }
    }
  }, {
    key: Symbol.asyncIterator,
    value: function value() {
      if (!this.options.async) {
        throw new TypeError('This is a sync iterable. Use Symbol.iterator instead.');
      }
      var iterator = this.iterable[Symbol.asyncIterator]();
      var stack = [iterator]; // Стек для хранения текущих итераторов
      return _defineProperty({
        next: function next() {
          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
            var currentIterator, _yield$currentIterato, done, value;
            return _regeneratorRuntime().wrap(function _callee$(_context) {
              while (1) switch (_context.prev = _context.next) {
                case 0:
                  if (!(stack.length > 0)) {
                    _context.next = 16;
                    break;
                  }
                  currentIterator = stack[stack.length - 1];
                  _context.next = 4;
                  return currentIterator.next();
                case 4:
                  _yield$currentIterato = _context.sent;
                  done = _yield$currentIterato.done;
                  value = _yield$currentIterato.value;
                  if (!done) {
                    _context.next = 10;
                    break;
                  }
                  stack.pop();
                  return _context.abrupt("continue", 0);
                case 10:
                  if (!(value && typeof value[Symbol.asyncIterator] === 'function' || typeof value[Symbol.iterator] === 'function')) {
                    _context.next = 13;
                    break;
                  }
                  stack.push(value);
                  return _context.abrupt("continue", 0);
                case 13:
                  return _context.abrupt("return", {
                    done: false,
                    value: value
                  });
                case 16:
                  return _context.abrupt("return", {
                    done: true,
                    value: undefined
                  });
                case 17:
                case "end":
                  return _context.stop();
              }
            }, _callee);
          }))();
        }
      }, Symbol.asyncIterator, function () {
        return this;
      });
    }
  }, {
    key: "next",
    value: function next() {
      if (!this.iterator) {
        this.iterator = this.options.async ? this[Symbol.asyncIterator]() : this[Symbol.iterator]();
      }
      return this.iterator.next();
    }
  }, {
    key: "map",
    value: function map(fn) {
      return new Iter8or(createMapIterator(this.iterable, fn), this.options);
    }
  }, {
    key: "filter",
    value: function filter(predicate) {
      return new Iter8or(createFilterIterator(this.iterable, predicate), this.options);
    }
  }, {
    key: "drop",
    value: function drop(n) {
      return new Iter8or(createDropIterator(this.iterable, n), this.options);
    }
  }, {
    key: "flatMap",
    value: function flatMap(fn) {
      return new Iter8or(createFlatMapIterator(this.iterable, fn), this.options);
    }
  }, {
    key: "flat",
    value: function flat(depth) {
      return new Iter8or(createFlatIterator(this.iterable, depth), this.options);
    }
  }, {
    key: "reverse",
    value: function reverse() {
      return new Iter8or(createReverseIterator(this.iterable), this.options);
    }
  }, {
    key: "take",
    value: function take(n) {
      return new Iter8or(createTakeIterator(this.iterable, n), this.options);
    }
  }, {
    key: "concat",
    value: function concat() {
      for (var _len = arguments.length, iterators = new Array(_len), _key = 0; _key < _len; _key++) {
        iterators[_key] = arguments[_key];
      }
      if (!iterators.some(function (iterator) {
        return iterator instanceof Iter8or;
      })) {
        throw new Error('All concatted iterators must be an Iter8or.');
      }
      return new Iter8or(createConcatIterator.apply(void 0, [this.iterable].concat(_toConsumableArray(iterators.map(function (iterator) {
        return iterator.iterable;
      })))), this.options);
    }
  }, {
    key: "avg",
    value: function avg$1(fn) {
      return avg(this.iterable, fn);
    }
  }, {
    key: "max",
    value: function max$1(fn) {
      return max(this.iterable, fn);
    }
  }, {
    key: "min",
    value: function min$1(fn) {
      return min(this.iterable, fn);
    }
  }, {
    key: "reduce",
    value: function reduce$1(reducer, initialValue) {
      return reduce(this.iterable, reducer, initialValue);
    }
  }, {
    key: "sum",
    value: function sum$1(fn) {
      return sum(this.iterable, fn);
    }
  }, {
    key: "groupBy",
    value: function groupBy$1(grouper) {
      return groupBy(this.iterable, grouper);
    }
  }, {
    key: "partition",
    value: function partition$1(predicate) {
      return partition(this.iterable, predicate);
    }
  }, {
    key: "toArray",
    value: function toArray$1() {
      return toArray(this.iterable);
    }
  }, {
    key: "toMap",
    value: function toMap() {
      return toMap$1(this.iterable);
    }
  }, {
    key: "toObject",
    value: function toObject() {
      return toMap(this.iterable);
    }
  }, {
    key: "toSet",
    value: function toSet$1() {
      return toSet(this.iterable);
    }
  }, {
    key: "toString",
    value: function toString$1() {
      return toString(this.iterable);
    }
  }]);
}();
function _createIterable(iterable) {
  if (typeof iterable === 'number' || typeof iterable === 'bigint') {
    if (this.options.digits) {
      this.iterable = new DigitsIterable(iterable);
    } else {
      this.iterable = new RangeIterable(iterable);
    }
  } else if (_typeof(iterable) === 'object' && iterable !== null) {
    this.iterable = new ObjectIterable(iterable);
  } else {
    throw new TypeError('Unsupported iterable type.');
  }
}

module.exports = Iter8or;
//# sourceMappingURL=iter8or.cjs.map