docs: function extendIterablePrototype(prototype) {
          var exclude = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  
          // always exclude the constructor
          exclude.push("constructor");
          var ex = Collection.from(exclude);
          // check for conflicts
          var patchProperties = [];
          var _iteratorNormalCompletion4 = true;
          var _didIteratorError4 = false;
          var _iteratorError4 = undefined;
  
          try {
              for (var _iterator4 = Object.getOwnPropertyNames(Object.getPrototypeOf(Collection.empty))[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                  var key = _step4.value;
  
                  if (!key.startsWith('_') && !ex.contains(key) && __isFunction(Collection.empty[key])) {
                      if (key in prototype) {
                          throw new Error('The method "' + key + '" already exists on the "' + (prototype.constructor && prototype.constructor.name) + '" prototype. ' + 'Use the exclude parameter to patch without this method.');
                      } else {
                          patchProperties.push(key);
                      }
                  }
              }
              // path prototype
          } catch (err) {
              _didIteratorError4 = true;
              _iteratorError4 = err;
          } finally {
              try {
                  if (!_iteratorNormalCompletion4 && _iterator4.return) {
                      _iterator4.return();
                  }
              } finally {
                  if (_didIteratorError4) {
                      throw _iteratorError4;
                  }
              }
          }
  
          var _loop = function _loop(_key) {
              prototype[_key] = function () {
                  var _collection$_key;
  
                  var collection = Collection.from(this);
  
                  for (var _len = arguments.length, args = Array(_len), _key2 = 0; _key2 < _len; _key2++) {
                      args[_key2] = arguments[_key2];
                  }
  
                  return (_collection$_key = collection[_key]).call.apply(_collection$_key, [collection].concat(args));
              };
          };
  
          var _iteratorNormalCompletion5 = true;
          var _didIteratorError5 = false;
          var _iteratorError5 = undefined;
  
          try {
              for (var _iterator5 = patchProperties[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                  var _key = _step5.value;
  
                  _loop(_key);
              }
          } catch (err) {
              _didIteratorError5 = true;
              _iteratorError5 = err;
          } finally {
              try {
                  if (!_iteratorNormalCompletion5 && _iterator5.return) {
                      _iterator5.return();
                  }
              } finally {
                  if (_didIteratorError5) {
                      throw _iteratorError5;
                  }
              }
          }
      }