sequins/dist/sequins.js

Mutable sequences and native data structures (Map, Set, List) following the Immutable.js API

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Seq = Seq;
exports.isCollection = isMutableCollection;
exports.isKeyed = isMutableKeyed;
exports.isIndexed = isMutableIndexed;
exports.isAssociative = isMutableAssociative;
exports.isSeq = isMutableSeq;
exports.isList = isMutableList;
exports.isMap = isMutableMap;
exports.isSet = isMutableSet;
exports.Range = Range;
exports.Repeat = Repeat;
exports.get = get;
exports.set = set;
exports.has = has;
exports.keys = keys$1;
exports.values = values;
exports.entries = entries$1;
exports.NativeSet = exports.NativeMap = exports.Set = exports.Map = exports.List = exports.SetSequence = exports.KeyedSequence = exports.IndexedSequence = exports.default = void 0;

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _invariant = _interopRequireDefault(require("invariant"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _concat2 = _interopRequireDefault(require("iter-tools/es5/concat"));

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _reduce = _interopRequireDefault(require("iter-tools/es5/reduce"));

var _stable = _interopRequireDefault(require("stable"));

var _zipAll = _interopRequireDefault(require("iter-tools/es5/zip-all"));

var _zip = _interopRequireDefault(require("iter-tools/es5/zip"));

var _size = _interopRequireDefault(require("iter-tools/es5/size"));

var _filter2 = _interopRequireDefault(require("iter-tools/es5/filter"));

var _keys = _interopRequireDefault(require("iter-tools/es5/keys"));

var _slice2 = _interopRequireDefault(require("iter-tools/es5/slice"));

require("iter-tools/es5/compose");

var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));

var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

var _map2 = _interopRequireDefault(require("iter-tools/es5/map"));

var _tap2 = _interopRequireDefault(require("iter-tools/es5/tap"));

var _interpose2 = _interopRequireDefault(require("iter-tools/es5/interpose"));

var _range = _interopRequireDefault(require("iter-tools/es5/range"));

var _entries = _interopRequireDefault(require("iter-tools/es5/entries"));

var _flat = _interopRequireDefault(require("iter-tools/es5/flat"));

var _repeat = _interopRequireDefault(require("iter-tools/es5/repeat"));

function isImmutableCollection(shape) {
  return !!shape['@@__IMMUTABLE_ITERABLE__@@'];
}

function isImmutableRecord(shape) {
  return !!shape['@@__IMMUTABLE_RECORD__@@'];
}

function isImmutable(shape) {
  return isImmutableCollection(shape) || isImmutableRecord(shape);
}

function isMutableCollection(shape) {
  return !!shape['@@__MUTABLE_COLLECTION__@@'];
}

function isMutableSeq(shape) {
  return !!shape['@@__MUTABLE_SEQUENCE__@@'];
}

function isCollection(shape) {
  return isImmutableCollection(shape) || isMutableCollection(shape);
}

function isNative(shape) {
  return isNativeKeyed(shape) || isNativeSet(shape);
} // Impl. borrowed from immutable, Copyright (c) 2014-present, Facebook, Inc.


function isPlainObj(shape) {
  return !shape[Symbol.iterator] && shape.constructor === Object || shape.constructor === undefined;
}

function isDataStructure(shape) {
  return isFancyDataStructure(shape) || isNative(shape) || Array.isArray(shape) || isPlainObj(shape);
}

function isFancyDataStructure(shape) {
  return isMutableCollection(shape) || isImmutable(shape);
}

function isModernDataStructure(shape) {
  return isFancyDataStructure(shape) || isNative(shape);
}

function isMutableConcreteish(shape) {
  return !!shape['@@__MUTABLE_COLLECTION__@@'] && !shape['@@__MUTABLE_SEQUENCE__@@'];
}

function isMutableList(shape) {
  return isMutableConcreteish(shape) && isMutableIndexed(shape);
}

function isMutableMap(shape) {
  return isMutableConcreteish(shape) && isMutableKeyed(shape);
}

function isMutableSet(shape) {
  return isMutableConcreteish(shape) && !isMutableAssociative(shape);
}

function isImmutableIndexed(shape) {
  return !!shape['@@__IMMUTABLE_INDEXED__@@'];
}

function isImmutableKeyed(shape) {
  return !!shape['@@__IMMUTABLE_KEYED__@@'];
}

function isNativeSet(shape) {
  return shape instanceof Set;
}

function isNativeKeyed(shape) {
  return shape instanceof Map;
}

function isMutableIndexed(shape) {
  return !!shape['@@__MUTABLE_INDEXED__@@'];
}

function isMutableKeyed(shape) {
  return !!shape['@@__MUTABLE_KEYED__@@'];
}

function isMutableAssociative(shape) {
  return isMutableIndexed(shape) || isMutableKeyed(shape);
}

function isIndexed(shape) {
  return Array.isArray(shape) || isMutableIndexed(shape) || isImmutableIndexed(shape);
}

function isKeyed(shape) {
  return isNativeKeyed(shape) || isMutableKeyed(shape) || isImmutableKeyed(shape);
}

var Namespace =
/*#__PURE__*/
function () {
  function Namespace() {
    (0, _classCallCheck2.default)(this, Namespace);
  }

  (0, _createClass2.default)(Namespace, [{
    key: "__get",
    value: function __get(key) {
      var _key = "_".concat(key);

      (0, _invariant.default)(this.hasOwnProperty(_key), 'Tried to access member %s of %s, but no such member was registered yet. The module include order was likely wrong.', key, this.__description);
      return this[_key];
    }
  }, {
    key: "__description",
    get: function get() {
      return 'namespace';
    }
  }]);
  return Namespace;
}();

var RootNamespace =
/*#__PURE__*/
function (_Namespace) {
  (0, _inherits2.default)(RootNamespace, _Namespace);

  function RootNamespace() {
    (0, _classCallCheck2.default)(this, RootNamespace);
    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(RootNamespace).apply(this, arguments));
  }

  (0, _createClass2.default)(RootNamespace, [{
    key: "__register",
    value: function __register(collectionType, NestedNamespace) {
      return this["_".concat(collectionType)] = NestedNamespace;
    }
  }, {
    key: "__description",
    get: function get() {
      return 'the root namespace';
    }
  }, {
    key: "Concrete",
    get: function get() {
      return this.__get('Concrete');
    }
  }, {
    key: "Sequence",
    get: function get() {
      return this.__get('Sequence');
    }
  }]);
  return RootNamespace;
}(Namespace);

var SubtypeNamespace =
/*#__PURE__*/
function (_Namespace2) {
  (0, _inherits2.default)(SubtypeNamespace, _Namespace2);

  function SubtypeNamespace() {
    (0, _classCallCheck2.default)(this, SubtypeNamespace);
    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SubtypeNamespace).apply(this, arguments));
  }

  (0, _createClass2.default)(SubtypeNamespace, [{
    key: "__register",
    value: function __register(collectionSubtype, CollectionConstructor) {
      return this["_".concat(collectionSubtype)] = CollectionConstructor;
    }
  }, {
    key: "Duplicated",
    get: function get() {
      return this.__get('Duplicated');
    }
  }, {
    key: "Indexed",
    get: function get() {
      return this.__get('Indexed');
    }
  }, {
    key: "Keyed",
    get: function get() {
      return this.__get('Keyed');
    }
  }]);
  return SubtypeNamespace;
}(Namespace);

function makeKey(collectionSubtype, collectionType) {
  return "".concat(collectionSubtype, "__").concat(collectionType);
}

function memoizeFactory(factory) {
  var results = Object.create(null);
  return function memoizedFactory(Collection) {
    for (var _len = arguments.length, dynamicArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      dynamicArgs[_key - 1] = arguments[_key];
    }

    var key = makeKey.apply(void 0, dynamicArgs);

    if (!results[key]) {
      results[key] = factory.apply(void 0, [Collection].concat(dynamicArgs));
    }

    return results[key];
  };
}

function makeConcat(Collection, collectionType, collectionSubtype) {
  var SequenceConstructor = Collection.Sequence[collectionSubtype];
  return function concat(iterable) {
    for (var _len = arguments.length, iterables = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      iterables[_key - 1] = arguments[_key];
    }

    return _concat2.default.apply(void 0, [iterable].concat((0, _toConsumableArray2.default)(iterables.map(function (iterable) {
      return new SequenceConstructor(iterable);
    }))));
  };
}

var concat$1 = memoizeFactory(makeConcat);
var reflect = Object.freeze({
  Duplicated: {
    NativeConstructor: Set,
    itemValue: function itemValue(item) {
      return item;
    },
    primitiveIterator: function primitiveIterator(collection) {
      return collection.values();
    }
  },
  Indexed: {
    NativeConstructor: Array,
    itemValue: function itemValue(item) {
      return item;
    },
    primitiveIterator: function primitiveIterator(collection) {
      return collection.values();
    }
  },
  Keyed: {
    NativeConstructor: Map,
    itemValue: function itemValue(item) {
      return item[1];
    },
    primitiveIterator: function primitiveIterator(collection) {
      return collection.entries();
    }
  }
});

function makeFlatten(Collection, collectionType$$1, collectionSubtype) {
  var _reflect$collectionSu = reflect[collectionSubtype],
      itemValue = _reflect$collectionSu.itemValue,
      primitiveIterator = _reflect$collectionSu.primitiveIterator;
  return (
    /*#__PURE__*/
    _regenerator.default.mark(function flatten(iterable) {
      var shallowOrDepth,
          depth,
          _iteratorNormalCompletion,
          _didIteratorError,
          _iteratorError,
          _iterator,
          _step,
          item,
          value,
          _args = arguments;

      return _regenerator.default.wrap(function flatten$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              shallowOrDepth = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;
              depth = Number(shallowOrDepth);
              _iteratorNormalCompletion = true;
              _didIteratorError = false;
              _iteratorError = undefined;
              _context.prev = 5;
              _iterator = iterable[Symbol.iterator]();

            case 7:
              if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
                _context.next = 23;
                break;
              }

              item = _step.value;
              value = itemValue(item);

              if (!(!value || !isMutableCollection(value))) {
                _context.next = 15;
                break;
              }

              _context.next = 13;
              return item;

            case 13:
              _context.next = 20;
              break;

            case 15:
              if (!(depth !== 1)) {
                _context.next = 19;
                break;
              }

              return _context.delegateYield(flatten(primitiveIterator(value), depth === 0 ? 0 : depth - 1), "t0", 17);

            case 17:
              _context.next = 20;
              break;

            case 19:
              return _context.delegateYield(primitiveIterator(value), "t1", 20);

            case 20:
              _iteratorNormalCompletion = true;
              _context.next = 7;
              break;

            case 23:
              _context.next = 29;
              break;

            case 25:
              _context.prev = 25;
              _context.t2 = _context["catch"](5);
              _didIteratorError = true;
              _iteratorError = _context.t2;

            case 29:
              _context.prev = 29;
              _context.prev = 30;

              if (!_iteratorNormalCompletion && _iterator.return != null) {
                _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(29);

            case 37:
            case "end":
              return _context.stop();
          }
        }
      }, flatten, this, [[5, 25, 29, 37], [30,, 32, 36]]);
    })
  );
}

var flatten = memoizeFactory(makeFlatten);

function makePush(Collection, collectionType, collectionSubtype) {
  if (collectionSubtype === 'Indexed') {
    return function (collection, _, value) {
      return collection.push(value);
    };
  } else if (collectionSubtype === 'Keyed') {
    return function (collection, key, value) {
      return collection.set(key, value);
    };
  } else {
    return function (collection, _, value) {
      return collection.add(value);
    };
  }
}

var makePush$1 = memoizeFactory(makePush);
var reduceByType = {
  Duplicated: function reduce(iterable, reducer, initial) {
    var setReducer = function setReducer(acc, item) {
      return reducer(acc, item, item);
    };

    var reduced;

    if (arguments.length > 2) {
      reduced = (0, _reduce.default)(initial, setReducer, iterable);
    } else {
      reduced = (0, _reduce.default)(setReducer, iterable);
    }

    return reduced;
  },
  Indexed: function reduce(iterable, reducer, initial) {
    var reduced;

    if (arguments.length > 2) {
      reduced = (0, _reduce.default)(initial, reducer, iterable);
    } else {
      reduced = (0, _reduce.default)(reducer, iterable);
    }

    return reduced;
  },
  Keyed: function reduce(iterable, reducer, initial) {
    var invocations = 0;
    var hasInitial = arguments.length > 2;
    var reduced;

    var keyedReducer = function keyedReducer(acc, _ref) {
      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
          key = _ref2[0],
          value = _ref2[1];

      if (invocations++ === 0 && !hasInitial) {
        acc = acc[1];
      }

      return reducer(acc, value, key);
    };

    if (hasInitial) {
      reduced = (0, _reduce.default)(initial, keyedReducer, iterable);
    } else {
      reduced = (0, _reduce.default)(keyedReducer, iterable);
    }

    return reduced;
  }
};

function makeReduce(Collection, collectionType, collectionSubtype) {
  return reduceByType[collectionSubtype];
}

function makeGroupBy(Collection, collectionType, collectionSubtype) {
  var concreteType = collectionType === 'Sequence' ? 'Concrete' : collectionType;
  var CollectionConstructor = Collection[collectionType][collectionSubtype];
  var ConcreteCollectionConstructor = Collection[concreteType][collectionSubtype];
  var Map = Collection.Concrete.Keyed;
  var push = makePush$1.apply(void 0, arguments);
  var reduce = makeReduce.apply(void 0, arguments);
  return function groupBy(collection, grouper) {
    var map = reduce(collection, function (result, value, key) {
      var groupKey = grouper(value, key);

      if (!result.get(groupKey)) {
        var concrete = new ConcreteCollectionConstructor();
        result.set(groupKey, concrete);
      }

      push(result.get(groupKey), key, value);
      return result;
    }, new Map());
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = map.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var key = _step.value;
        map.set(key, new CollectionConstructor(map.get(key)));
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }

    return map;
  };
}

var groupBy = memoizeFactory(makeGroupBy);

function ensureArray(iterable) {
  return Array.isArray(iterable) ? iterable : Array.from(iterable);
}

var defaultComparator = function defaultComparator(a, b) {
  return a > b ? 1 : a < b ? -1 : 0;
};

function makeSort(Collection, collectionType, collectionSubtype) {
  var _reflect$collectionSu = reflect[collectionSubtype],
      itemValue = _reflect$collectionSu.itemValue,
      NativeConstructor = _reflect$collectionSu.NativeConstructor;
  return function sort(inPlace, iterable, selector) {
    var comparator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : defaultComparator;
    var array = ensureArray(iterable);
    var wrappedComparator = selector ? function (a, b) {
      return comparator(selector(itemValue(a)), selector(itemValue(b)));
    } : function (a, b) {
      return comparator(itemValue(a), itemValue(b));
    };

    if (inPlace) {
      _stable.default.inplace(array, wrappedComparator);
    } else {
      array = (0, _stable.default)(array, wrappedComparator);
    }

    if (collectionType === 'Sequence' || collectionSubtype === 'Indexed') {
      return array;
    }

    return new NativeConstructor(array);
  };
}

var sort = memoizeFactory(makeSort);

function makeToConcrete(Collection, collectionType, collectionSubtype) {
  var ConcreteConstructor = Collection.Concrete[collectionSubtype];
  return function toNative(value) {
    return new ConcreteConstructor(value);
  };
}

var toConcrete = memoizeFactory(makeToConcrete);

function makeToJS(Collection) {
  return function toJS(value) {
    return isDataStructure(value) ? Collection.Sequence.from(value).map(toJS).toJSON() : value;
  };
}

var toJs = memoizeFactory(makeToJS);

function makeZipAll(Collection, collectionType, collectionSubtype) {
  var SequenceConstructor = Collection.Sequence[collectionSubtype];
  return function zipAll(iterable) {
    for (var _len = arguments.length, iterables = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      iterables[_key - 1] = arguments[_key];
    }

    return _zipAll.default.apply(void 0, [iterable].concat((0, _toConsumableArray2.default)(iterables.map(function (iterable) {
      return new SequenceConstructor(iterable);
    }))));
  };
}

var zipAll = memoizeFactory(makeZipAll);

function makeZip(Collection, collectionType, collectionSubtype) {
  var SequenceConstructor = Collection.Sequence[collectionSubtype];
  return function zip(iterable) {
    for (var _len = arguments.length, iterables = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      iterables[_key - 1] = arguments[_key];
    }

    return _zip.default.apply(void 0, [iterable].concat((0, _toConsumableArray2.default)(iterables.map(function (iterable) {
      return new SequenceConstructor(iterable);
    }))));
  };
}

var zip = memoizeFactory(makeZip);
var factories =
/*#__PURE__*/
Object.freeze({
  concat: concat$1,
  flatten: flatten,
  groupBy: groupBy,
  reduce: makeReduce,
  sort: sort,
  toConcrete: toConcrete,
  toJS: toJs,
  zipAll: zipAll,
  zip: zip
});
var Namespace$1 = new RootNamespace();
var Collection = Namespace$1;
var emptyArray = [];

var MethodFactory = function MethodFactory(collectionType, collectionSubtype) {
  (0, _classCallCheck2.default)(this, MethodFactory);
  this._collectionType = collectionType;
  this._collectionSubtype = collectionSubtype;
};

var nativeFactories = new Map([[Map, function (coll) {
  return new Map(new Collection.Sequence.Keyed(coll));
}], [Set, function (coll) {
  return new Set(new Collection.Sequence.Duplicated(coll));
}], [Array, function (coll) {
  return Array.from(new Collection.Sequence.Indexed(coll));
}], [Object, // TODO use Object.fromEntries here when it is ready.
function (coll) {
  return new Collection.Sequence.Keyed(coll).reduce(function (obj, value, key) {
    obj[key] = value;
    return obj;
  }, {});
}]]);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;

try {
  var _loop = function _loop() {
    var name = _step.value;
    Object.defineProperty(MethodFactory.prototype, name, {
      get: function get() {
        return factories[name](Collection, this._collectionType, this._collectionSubtype);
      }
    });
  };

  for (var _iterator = (0, _keys.default)(factories)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
    _loop();
  }
} catch (err) {
  _didIteratorError = true;
  _iteratorError = err;
} finally {
  try {
    if (!_iteratorNormalCompletion && _iterator.return != null) {
      _iterator.return();
    }
  } finally {
    if (_didIteratorError) {
      throw _iteratorError;
    }
  }
}

var CollectionMixin = function CollectionMixin(Base) {
  var CollectionMixin =
  /*#__PURE__*/
  function (_Base) {
    (0, _inherits2.default)(CollectionMixin, _Base);

    function CollectionMixin(iterable, collectionType, collectionSubtype) {
      var _this;

      (0, _classCallCheck2.default)(this, CollectionMixin);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(CollectionMixin).call(this, iterable, collectionSubtype));
      _this.__selfParam = emptyArray;
      _this.__dynamicMethods = new MethodFactory(collectionType, collectionSubtype);
      return _this;
    }

    (0, _createClass2.default)(CollectionMixin, [{
      key: "slice",
      value: function slice() {
        var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
        return this.__doCollectionTransform((0, _slice2.default)({
          start: start,
          end: end
        }));
      }
    }, {
      key: "concat",
      value: function concat() {
        var _this2 = this;

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return this.__doCollectionTransform(function (iterable) {
          var _this2$__dynamicMetho;

          return (_this2$__dynamicMetho = _this2.__dynamicMethods).concat.apply(_this2$__dynamicMetho, [iterable].concat(args));
        });
      }
    }, {
      key: "flatten",
      value: function flatten$$1() {
        var _this3 = this;

        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        return this.__doCollectionTransform(function (iterable) {
          var _this3$__dynamicMetho;

          return (_this3$__dynamicMetho = _this3.__dynamicMethods).flatten.apply(_this3$__dynamicMetho, [iterable].concat(args));
        });
      }
    }, {
      key: "groupBy",
      value: function groupBy$$1(grouper) {
        var _this4 = this;

        return this.__doCollectionTransform(function (iterable) {
          return _this4.__dynamicMethods.groupBy(iterable, grouper);
        });
      }
    }, {
      key: "flatMap",
      value: function flatMap(mapFn) {
        return this.map(mapFn).flatten(true);
      }
    }, {
      key: "sort",
      value: function sort$$1() {
        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
          args[_key3] = arguments[_key3];
        }

        return this.sortBy.apply(this, [null].concat(args));
      }
    }, {
      key: "count",
      value: function count(predicate) {
        return (0, _size.default)(predicate ? this.filter(predicate) : this);
      } // Reductive functions

    }, {
      key: "reduce",
      value: function reduce(reducer) {
        var _this5 = this;

        for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
          args[_key4 - 1] = arguments[_key4];
        }

        return this.__doReductiveTransform(function (iterable) {
          var _this5$__dynamicMetho;

          return (_this5$__dynamicMetho = _this5.__dynamicMethods).reduce.apply(_this5$__dynamicMetho, [iterable, function (acc, value, index) {
            return reducer.apply(void 0, [acc, value, index].concat((0, _toConsumableArray2.default)(_this5.__selfParam)));
          }].concat(args));
        });
      } // Deep conversions

    }, {
      key: "toJS",
      value: function toJS() {
        return this.__dynamicMethods.toJS(this);
      } // Shallow conversions

    }, {
      key: "toSeq",
      value: function toSeq() {
        return new Collection.Sequence.from(this);
      }
    }, {
      key: "toConcrete",
      value: function toConcrete$$1() {
        return this.__dynamicMethods.toConcrete(this);
      }
    }, {
      key: "to",
      value: function to(CollectionConstructor) {
        if (nativeFactories.has(CollectionConstructor)) {
          return nativeFactories.get(CollectionConstructor)(this);
        } else {
          return this instanceof CollectionConstructor ? this : new CollectionConstructor(this);
        }
      }
    }]);
    return CollectionMixin;
  }(Base);

  Object.defineProperty(CollectionMixin.prototype, '@@__MUTABLE_COLLECTION__@@', {
    value: true
  });
  return CollectionMixin;
};

var Collection$1 = CollectionMixin(function SequinsBase() {
  (0, _classCallCheck2.default)(this, SequinsBase);
});
var emptyArray$1 = [];

function makeFrom(Collection, collectionType$$1) {
  var TypedCollection = Collection[collectionType$$1];
  return function from(initial) {
    if (initial == null) {
      return new TypedCollection.Indexed(emptyArray$1);
    } else if (isCollection(initial) || isNative(initial)) {
      if (isIndexed(initial)) {
        return new TypedCollection.Indexed(initial);
      } else if (isKeyed(initial)) {
        return new TypedCollection.Keyed(initial);
      } else {
        return new TypedCollection.Duplicated(initial);
      }
    } else if (typeof initial[Symbol.iterator] === 'function') {
      return new TypedCollection.Indexed(initial);
    } else if (isPlainObj(initial)) {
      return new TypedCollection.Keyed(initial);
    }

    return null;
  };
}

var makeFrom$1 = memoizeFactory(makeFrom);

var SequenceNamespace =
/*#__PURE__*/
function (_SubtypeNamespace) {
  (0, _inherits2.default)(SequenceNamespace, _SubtypeNamespace);

  function SequenceNamespace() {
    (0, _classCallCheck2.default)(this, SequenceNamespace);
    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SequenceNamespace).apply(this, arguments));
  }

  (0, _createClass2.default)(SequenceNamespace, [{
    key: "from",
    value: function from(initial) {
      return sequenceFrom(initial);
    }
  }]);
  return SequenceNamespace;
}(SubtypeNamespace);

var Namespace$2 = Namespace$1.__register('Sequence', new SequenceNamespace());

var sequenceFrom = makeFrom$1(Namespace$1, 'Sequence');

var identityFn = function identityFn(_) {
  return _;
};

var Sequence =
/*#__PURE__*/
function (_Collection) {
  (0, _inherits2.default)(Sequence, _Collection);
  (0, _createClass2.default)(Sequence, null, [{
    key: "from",
    value: function from(initial) {
      return sequenceFrom(initial);
    }
  }]);

  function Sequence(iterable, collectionSubtype) {
    var _this;

    (0, _classCallCheck2.default)(this, Sequence);
    iterable = iterable || [];
    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Sequence).call(this, iterable, 'Sequence', collectionSubtype));
    _this.__iterable = iterable;
    _this.__transform = null;
    _this.__constructorTransform = null;
    return _this;
  }

  (0, _createClass2.default)(Sequence, [{
    key: "__doCollectionTransform",
    value: function __doCollectionTransform(transform) {
      var Sequence = this[Symbol.species]();
      var result = new Sequence(this);
      result.__transform = transform;
      return result;
    }
  }, {
    key: "__doReductiveTransform",
    value: function __doReductiveTransform(transform) {
      return transform(this._transform());
    }
  }, {
    key: "_transform",
    value: function _transform() {
      var constructorTransform = this.__constructorTransform || identityFn;
      var transform = this.__transform || identityFn;
      return transform(constructorTransform(this.__iterable));
    }
  }, {
    key: Symbol.iterator,
    value: function value() {
      return this._transform()[Symbol.iterator]();
    }
  }, {
    key: "set",
    value: function set(key, newValue) {
      return this.map(function (value, key) {
        return key === key ? newValue : value;
      });
    }
  }, {
    key: "push",
    value: function push(key, newValue) {
      return this.concat([newValue]);
    }
  }, {
    key: "delete",
    value: function _delete(key) {
      return this.filter(function (_, key) {
        return key !== key;
      });
    }
  }, {
    key: "groupBy",
    value: function groupBy(grouper) {
      var _this2 = this;

      var concrete = this.toConcrete();
      var keyed = new Namespace$2.Keyed(concrete);

      keyed.__transform = function () {
        return _this2.__dynamicMethods.groupBy(concrete, grouper);
      };

      return keyed;
    }
  }, {
    key: "reverse",
    value: function reverse() {
      return this.__doCollectionTransform(function (iterable) {
        return Array.from(iterable).reverse();
      });
    }
  }, {
    key: "sortBy",
    value: function sortBy() {
      var _this3 = this;

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      return this.__doCollectionTransform(function (iterable) {
        var _this3$__dynamicMetho;

        return (_this3$__dynamicMetho = _this3.__dynamicMethods).sort.apply(_this3$__dynamicMetho, [false, iterable].concat(args));
      });
    }
  }]);
  return Sequence;
}(Collection$1);

Object.defineProperty(Sequence.prototype, '@@__MUTABLE_SEQUENCE__@@', {
  value: true
});

var Namespace$3 = Namespace$1.__register('Concrete', new SubtypeNamespace());

var concreteFrom = makeFrom$1(Collection$1, 'Concrete');

var ConcreteCollection =
/*#__PURE__*/
function (_Collection) {
  (0, _inherits2.default)(ConcreteCollection, _Collection);

  function ConcreteCollection(iterable, collectionSubtype) {
    var _this;

    (0, _classCallCheck2.default)(this, ConcreteCollection);
    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ConcreteCollection).call(this, iterable, 'Concrete', collectionSubtype));
    _this.__selfParam = [(0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this))];
    return _this;
  }

  (0, _createClass2.default)(ConcreteCollection, [{
    key: "__doCollectionTransform",
    value: function __doCollectionTransform(transform) {
      var CollectionConstructor = this.constructor;
      var transformed = transform(this.__native);

      if (transformed instanceof ConcreteCollection) {
        return transformed;
      } else {
        var coll = new CollectionConstructor();
        coll.__native = this.__constructNative(transformed);
        return coll;
      }
    }
  }, {
    key: "__constructNative",
    value: function __constructNative(iterable) {
      var NativeConstructor = this.__native.constructor;
      return new NativeConstructor(iterable);
    }
  }, {
    key: "__doReductiveTransform",
    value: function __doReductiveTransform(transform) {
      return transform(this.__native);
    }
  }, {
    key: "count",
    value: function count(predicate) {
      return predicate ? (0, _get2.default)((0, _getPrototypeOf2.default)(ConcreteCollection.prototype), "count", this).call(this, predicate) : this.size;
    }
  }, {
    key: "get",
    value: function get(key, defaultValue) {
      return this.has(key) ? this.__native.get(key) : defaultValue;
    }
  }, {
    key: "has",
    value: function has(key) {
      return this.__native.has(key);
    }
  }, {
    key: "delete",
    value: function _delete(key) {
      return this.__native.delete(key);
    }
  }, {
    key: "clear",
    value: function clear() {
      var NativeConstructor = this.__native.constructor;
      this.__native = new NativeConstructor();
      return this;
    }
  }, {
    key: "isEmpty",
    value: function isEmpty() {
      return this.size === 0;
    }
  }, {
    key: "concat",
    value: function (_concat) {
      function concat() {
        return _concat.apply(this, arguments);
      }

      concat.toString = function () {
        return _concat.toString();
      };

      return concat;
    }(function () {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      return this.__doCollectionTransform(function (iterable) {
        return concat.apply(void 0, [iterable].concat(args));
      });
    })
  }, {
    key: "__reverse",
    value: function __reverse() {
      var reversedSeq = Namespace$1.Sequence.from(this).reverse().toConcrete();
      this.clear();
      return reversedSeq;
    }
  }, {
    key: "toConcrete",
    value: function toConcrete() {
      return this;
    } // Iterators

  }, {
    key: "keys",
    value: function keys$$1() {
      return new Namespace$1.Sequence.Duplicated(this.__native.keys());
    }
  }, {
    key: "values",
    value: function values() {
      return new Namespace$1.Sequence.Duplicated(this.__native.values());
    }
  }, {
    key: "entries",
    value: function entries$$1() {
      return new Namespace$1.Sequence.Duplicated(this.__native.entries());
    }
  }, {
    key: Symbol.iterator,
    value: function value() {
      return this.__native[Symbol.iterator]();
    }
  }, {
    key: "size",
    get: function get() {
      return this.__native.size;
    }
  }], [{
    key: "from",
    value: function from(initial) {
      return concreteFrom(initial);
    }
  }]);
  return ConcreteCollection;
}(Collection$1);

function forEach(func, iterable) {
  var c = 0;
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = iterable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var item = _step.value;
      func(item, c++);
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return iterable;
}

function forSome(func, iterable) {
  var c = 0;
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = iterable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var item = _step.value;
      var ret = func(item, c++);

      if (ret === false) {
        break;
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return c;
}

var DuplicatedMixin = function DuplicatedMixin(Base) {
  return (
    /*#__PURE__*/
    function (_Base) {
      (0, _inherits2.default)(SetCollection, _Base);

      function SetCollection(iterable) {
        (0, _classCallCheck2.default)(this, SetCollection);
        return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SetCollection).call(this, iterable, 'Duplicated'));
      } // Collection functions


      (0, _createClass2.default)(SetCollection, [{
        key: "map",
        value: function map(mapFn) {
          var _this = this;

          return this.__doCollectionTransform((0, _map2.default)(function (item) {
            return mapFn.apply(void 0, [item, item].concat((0, _toConsumableArray2.default)(_this.__selfParam)));
          }));
        }
      }, {
        key: "tap",
        value: function tap(tapFn) {
          var _this2 = this;

          return this.__doCollectionTransform((0, _tap2.default)(function (item) {
            return tapFn.apply(void 0, [item, item].concat((0, _toConsumableArray2.default)(_this2.__selfParam)));
          }));
        }
      }, {
        key: "filter",
        value: function filter(filterFn) {
          var _this3 = this;

          return this.__doCollectionTransform((0, _filter2.default)(function (item) {
            return filterFn.apply(void 0, [item, item].concat((0, _toConsumableArray2.default)(_this3.__selfParam)));
          }));
        }
      }, {
        key: "filterNot",
        value: function filterNot(filterFn) {
          var _this4 = this;

          return this.__doCollectionTransform((0, _filter2.default)(function (item) {
            return !filterFn.apply(void 0, [item, item].concat((0, _toConsumableArray2.default)(_this4.__selfParam)));
          }));
        } // Reductive functions

      }, {
        key: "forEach",
        value: function forEach$$1(eachFn) {
          var _this5 = this;

          forEach(function (item) {
            return eachFn.apply(void 0, [item, item].concat((0, _toConsumableArray2.default)(_this5.__selfParam)));
          }, this);
        }
      }, {
        key: "forSome",
        value: function forSome$$1(eachFn) {
          var _this6 = this;

          return forSome(function (item) {
            return eachFn.apply(void 0, [item, item].concat((0, _toConsumableArray2.default)(_this6.__selfParam)));
          }, this);
        } // Conversions

      }, {
        key: "toJSON",
        value: function toJSON() {
          return this.to(Array);
        }
      }]);
      return SetCollection;
    }(Base)
  );
};

var IndexedMixin = function IndexedMixin(Base) {
  var IndexedCollection =
  /*#__PURE__*/
  function (_Base) {
    (0, _inherits2.default)(IndexedCollection, _Base);

    function IndexedCollection(iterable) {
      (0, _classCallCheck2.default)(this, IndexedCollection);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(IndexedCollection).call(this, iterable, 'Indexed'));
    } // prettier-ignore


    (0, _createClass2.default)(IndexedCollection, [{
      key: "zip",
      value: function zip() {
        var _this = this;

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return this.__doCollectionTransform(function (iterable) {
          var _this$__dynamicMethod;

          return (_this$__dynamicMethod = _this.__dynamicMethods).zip.apply(_this$__dynamicMethod, [iterable].concat(args));
        });
      }
    }, {
      key: "zipAll",
      value: function zipAll() {
        var _this2 = this;

        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        return this.__doCollectionTransform(function (iterable) {
          var _this2$__dynamicMetho;

          return (_this2$__dynamicMetho = _this2.__dynamicMethods).zipAll.apply(_this2$__dynamicMetho, [iterable].concat(args));
        });
      }
    }, {
      key: "zipWith",
      value: function zipWith(zipper) {
        var _this3 = this;

        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
          args[_key3 - 1] = arguments[_key3];
        }

        return this.__doCollectionTransform(function (iterable) {
          var _this3$__dynamicMetho;

          return (0, _map2.default)(function (items) {
            return zipper.apply(void 0, (0, _toConsumableArray2.default)(items));
          }, (_this3$__dynamicMetho = _this3.__dynamicMethods).zip.apply(_this3$__dynamicMetho, [iterable].concat(args)));
        });
      }
    }, {
      key: "interpose",
      value: function interpose(separator) {
        return this.__doCollectionTransform((0, _interpose2.default)(separator));
      } // Collection functions

    }, {
      key: "map",
      value: function map(mapFn) {
        var _this4 = this;

        return this.__doCollectionTransform((0, _map2.default)(function (value, i) {
          return mapFn.apply(void 0, [value, i].concat((0, _toConsumableArray2.default)(_this4.__selfParam)));
        }));
      }
    }, {
      key: "tap",
      value: function tap(tapFn) {
        var _this5 = this;

        return this.__doCollectionTransform((0, _tap2.default)(function (value, i) {
          return tapFn.apply(void 0, [value, i].concat((0, _toConsumableArray2.default)(_this5.__selfParam)));
        }));
      }
    }, {
      key: "filter",
      value: function filter(filterFn) {
        var _this6 = this;

        return this.__doCollectionTransform((0, _filter2.default)(function (value, i) {
          return filterFn.apply(void 0, [value, i].concat((0, _toConsumableArray2.default)(_this6.__selfParam)));
        }));
      }
    }, {
      key: "filterNot",
      value: function filterNot(filterFn) {
        var _this7 = this;

        return this.__doCollectionTransform((0, _filter2.default)(function (value, i) {
          return !filterFn.apply(void 0, [value, i].concat((0, _toConsumableArray2.default)(_this7.__selfParam)));
        }));
      } // Reductive functions

    }, {
      key: "forEach",
      value: function forEach$$1(eachFn) {
        var _this8 = this;

        forEach(function (value, i) {
          return eachFn.apply(void 0, [value, i].concat((0, _toConsumableArray2.default)(_this8.__selfParam)));
        }, this);
      }
    }, {
      key: "forSome",
      value: function forSome$$1(eachFn) {
        var _this9 = this;

        return forSome(function (value, i) {
          return eachFn.apply(void 0, [value, i].concat((0, _toConsumableArray2.default)(_this9.__selfParam)));
        }, this);
      } // Conversions

    }, {
      key: "toJSON",
      value: function toJSON() {
        return this.to(Array);
      }
    }]);
    return IndexedCollection;
  }(Base);

  Object.defineProperty(IndexedCollection.prototype, '@@__MUTABLE_INDEXED__@@', {
    value: true
  });
  return IndexedCollection;
};

var KeyedMixin = function KeyedMixin(Base) {
  var KeyedCollection =
  /*#__PURE__*/
  function (_Base) {
    (0, _inherits2.default)(KeyedCollection, _Base);

    function KeyedCollection(iterable) {
      (0, _classCallCheck2.default)(this, KeyedCollection);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(KeyedCollection).call(this, iterable, 'Keyed'));
    }

    (0, _createClass2.default)(KeyedCollection, [{
      key: "flip",
      value: function flip() {
        return this.__doCollectionTransform((0, _map2.default)(function (_ref) {
          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
              key = _ref2[0],
              value = _ref2[1];

          return [value, key];
        }));
      } // Collection functions

    }, {
      key: "map",
      value: function map(mapFn) {
        var _this = this;

        return this.__doCollectionTransform((0, _map2.default)(function (_ref3) {
          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
              key = _ref4[0],
              value = _ref4[1];

          return [key, mapFn.apply(void 0, [value, key].concat((0, _toConsumableArray2.default)(_this.__selfParam)))];
        }));
      }
    }, {
      key: "mapKeys",
      value: function mapKeys(mapFn) {
        var _this2 = this;

        return this.__doCollectionTransform((0, _map2.default)(function (_ref5) {
          var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
              key = _ref6[0],
              value = _ref6[1];

          return [mapFn.apply(void 0, [key, value].concat((0, _toConsumableArray2.default)(_this2.__selfParam))), value];
        }));
      }
    }, {
      key: "mapEntries",
      value: function mapEntries(mapFn) {
        var _this3 = this;

        return this.__doCollectionTransform((0, _map2.default)(function (entry, i) {
          return mapFn.apply(void 0, [entry, i].concat((0, _toConsumableArray2.default)(_this3.__selfParam)));
        }));
      }
    }, {
      key: "tap",
      value: function tap(tapFn) {
        var _this4 = this;

        return this.__doCollectionTransform((0, _tap2.default)(function (_ref7) {
          var _ref8 = (0, _slicedToArray2.default)(_ref7, 2),
              key = _ref8[0],
              value = _ref8[1];

          return tapFn.apply(void 0, [value, key].concat((0, _toConsumableArray2.default)(_this4.__selfParam)));
        }));
      }
    }, {
      key: "filter",
      value: function filter(filterFn) {
        var _this5 = this;

        return this.__doCollectionTransform((0, _filter2.default)(function (_ref9) {
          var _ref10 = (0, _slicedToArray2.default)(_ref9, 2),
              key = _ref10[0],
              value = _ref10[1];

          return filterFn.apply(void 0, [value, key].concat((0, _toConsumableArray2.default)(_this5.__selfParam)));
        }));
      }
    }, {
      key: "filterNot",
      value: function filterNot(filterFn) {
        var _this6 = this;

        return this.__doCollectionTransform((0, _filter2.default)(function (_ref11) {
          var _ref12 = (0, _slicedToArray2.default)(_ref11, 2),
              key = _ref12[0],
              value = _ref12[1];

          return !filterFn.apply(void 0, [value, key].concat((0, _toConsumableArray2.default)(_this6.__selfParam)));
        }));
      } // Reductive functions

    }, {
      key: "forEach",
      value: function forEach$$1(eachFn) {
        var _this7 = this;

        forEach(function (_ref13) {
          var _ref14 = (0, _slicedToArray2.default)(_ref13, 2),
              key = _ref14[0],
              value = _ref14[1];

          return eachFn.apply(void 0, [value, key].concat((0, _toConsumableArray2.default)(_this7.__selfParam)));
        }, this);
      }
    }, {
      key: "forSome",
      value: function forSome$$1(eachFn) {
        var _this8 = this;

        return forSome(function (_ref15) {
          var _ref16 = (0, _slicedToArray2.default)(_ref15, 2),
              key = _ref16[0],
              value = _ref16[1];

          return eachFn.apply(void 0, [value, key].concat((0, _toConsumableArray2.default)(_this8.__selfParam)));
        }, this);
      } // Conversions

    }, {
      key: "toJSON",
      value: function toJSON() {
        return this.to(Object);
      }
    }]);
    return KeyedCollection;
  }(Base);

  Object.defineProperty(KeyedCollection.prototype, '@@__MUTABLE_KEYED__@@', {
    value: true
  });
  return KeyedCollection;
};

var _marked =
/*#__PURE__*/
_regenerator.default.mark(arrayEntries);

function arrayEntries(array) {
  var i;
  return _regenerator.default.wrap(function arrayEntries$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          i = 0;

        case 1:
          if (!(i < array.length)) {
            _context.next = 7;
            break;
          }

          _context.next = 4;
          return [i, array[i]];

        case 4:
          i++;
          _context.next = 1;
          break;

        case 7:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, this);
}

var List =
/*#__PURE__*/
function (_IndexedMixin) {
  (0, _inherits2.default)(List, _IndexedMixin);
  (0, _createClass2.default)(List, null, [{
    key: "isList",
    value: function isList(shape) {
      return isMutableList(shape);
    }
  }, {
    key: "of",
    value: function of() {
      for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
        values[_key] = arguments[_key];
      }

      return new List(values);
    }
  }]);

  function List(iterable) {
    var _this;

    (0, _classCallCheck2.default)(this, List);
    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(List).call(this, iterable));
    _this.__native = iterable == null ? [] : Array.from(isKeyed(iterable) ? iterable.values() : iterable);
    return _this;
  }

  (0, _createClass2.default)(List, [{
    key: "__constructNative",
    value: function __constructNative(iterable) {
      return Array.from(iterable);
    }
  }, {
    key: "get",
    value: function get(idx) {
      return this.__native[idx];
    }
  }, {
    key: "set",
    value: function set(idx, value) {
      this.__native[idx] = value;
      return this;
    }
  }, {
    key: "has",
    value: function has(idx) {
      return idx < this.__native.length;
    }
  }, {
    key: "push",
    value: function push() {
      var _this$__native;

      (_this$__native = this.__native).push.apply(_this$__native, arguments);

      return this;
    }
  }, {
    key: "pop",
    value: function pop() {
      return this.__native.pop();
    }
  }, {
    key: "shift",
    value: function shift() {
      return this.__native.shift();
    }
  }, {
    key: "unshift",
    value: function unshift(value) {
      this.__native.unshift(value);

      return this;
    }
  }, {