immutable 5.1.3 → 5.1.4

package/dist/immutable.es.js

@@ -22,105 +22,25 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-// Used for setting prototype methods that IE8 chokes on.
-var DELETE = 'delete';
-// Constants describing the size of trie nodes.
-var SHIFT = 5; // Resulted in best performance after ______?
-var SIZE = 1 << SHIFT;
-var MASK = SIZE - 1;
-// A consistent shared value representing "not set" which equals nothing other
-// than itself, and nothing that could be provided externally.
-var NOT_SET = {};
-// Boolean references, Rough equivalent of `bool &`.
-function MakeRef() {
-    return { value: false };
-}
-function SetRef(ref) {
-    if (ref) {
-        ref.value = true;
-    }
-}
-// A function which returns a value representing an "owner" for transient writes
-// to tries. The return value will only ever equal itself, and will not equal
-// the return of any subsequent call of this function.
-function OwnerID() { }
-function ensureSize(iter) {
-    // @ts-expect-error size should exists on Collection
-    if (iter.size === undefined) {
-        // @ts-expect-error size should exists on Collection, __iterate does exist on Collection
-        iter.size = iter.__iterate(returnTrue);
-    }
-    // @ts-expect-error size should exists on Collection
-    return iter.size;
-}
-function wrapIndex(iter, index) {
-    // This implements "is array index" which the ECMAString spec defines as:
-    //
-    //     A String property name P is an array index if and only if
-    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
-    //     to 2^32−1.
-    //
-    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
-    if (typeof index !== 'number') {
-        var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
-        if ('' + uint32Index !== index || uint32Index === 4294967295) {
-            return NaN;
-        }
-        index = uint32Index;
-    }
-    return index < 0 ? ensureSize(iter) + index : index;
-}
-function returnTrue() {
-    return true;
-}
-function wholeSlice(begin, end, size) {
-    return (((begin === 0 && !isNeg(begin)) ||
-        (size !== undefined && begin <= -size)) &&
-        (end === undefined || (size !== undefined && end >= size)));
-}
-function resolveBegin(begin, size) {
-    return resolveIndex(begin, size, 0);
-}
-function resolveEnd(end, size) {
-    return resolveIndex(end, size, size);
-}
-function resolveIndex(index, size, defaultIndex) {
-    // Sanitize indices using this shorthand for ToInt32(argument)
-    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
-    return index === undefined
-        ? defaultIndex
-        : isNeg(index)
-            ? size === Infinity
-                ? size
-                : Math.max(0, size + index) | 0
-            : size === undefined || size === index
-                ? index
-                : Math.min(size, index) | 0;
-}
-function isNeg(value) {
-    // Account for -0 which is negative, but not less than 0.
-    return value < 0 || (value === 0 && 1 / value === -Infinity);
-}
-
-// Note: value is unchanged to not break immutable-devtools.
-var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';
+var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';
 /**
- * True if `maybeCollection` is a Collection, or any of its subclasses.
+ * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses.
  *
  * ```js
- * import { isCollection, Map, List, Stack } from 'immutable';
+ * import { isIndexed, Map, List, Stack, Set } from 'immutable';
  *
- * isCollection([]); // false
- * isCollection({}); // false
- * isCollection(Map()); // true
- * isCollection(List()); // true
- * isCollection(Stack()); // true
+ * isIndexed([]); // false
+ * isIndexed({}); // false
+ * isIndexed(Map()); // false
+ * isIndexed(List()); // true
+ * isIndexed(Stack()); // true
+ * isIndexed(Set()); // false
  * ```
  */
-function isCollection(maybeCollection) {
-    return Boolean(maybeCollection &&
-        // @ts-expect-error: maybeCollection is typed as `{}`, need to change in 6.0 to `maybeCollection && typeof maybeCollection === 'object' && IS_COLLECTION_SYMBOL in maybeCollection`
-        maybeCollection[IS_COLLECTION_SYMBOL]);
+function isIndexed(maybeIndexed) {
+    return Boolean(maybeIndexed &&
+        // @ts-expect-error: maybeIndexed is typed as `{}`, need to change in 6.0 to `maybeIndexed && typeof maybeIndexed === 'object' && IS_INDEXED_SYMBOL in maybeIndexed`
+        maybeIndexed[IS_INDEXED_SYMBOL]);
 }
 
 var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';
@@ -143,27 +63,6 @@ function isKeyed(maybeKeyed) {
         maybeKeyed[IS_KEYED_SYMBOL]);
 }
 
-var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';
-/**
- * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses.
- *
- * ```js
- * import { isIndexed, Map, List, Stack, Set } from 'immutable';
- *
- * isIndexed([]); // false
- * isIndexed({}); // false
- * isIndexed(Map()); // false
- * isIndexed(List()); // true
- * isIndexed(Stack()); // true
- * isIndexed(Set()); // false
- * ```
- */
-function isIndexed(maybeIndexed) {
-    return Boolean(maybeIndexed &&
-        // @ts-expect-error: maybeIndexed is typed as `{}`, need to change in 6.0 to `maybeIndexed && typeof maybeIndexed === 'object' && IS_INDEXED_SYMBOL in maybeIndexed`
-        maybeIndexed[IS_INDEXED_SYMBOL]);
-}
-
 /**
  * True if `maybeAssociative` is either a Keyed or Indexed Collection.
  *
@@ -182,6 +81,27 @@ function isAssociative(maybeAssociative) {
     return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
 }
 
+// Note: value is unchanged to not break immutable-devtools.
+var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';
+/**
+ * True if `maybeCollection` is a Collection, or any of its subclasses.
+ *
+ * ```js
+ * import { isCollection, Map, List, Stack } from 'immutable';
+ *
+ * isCollection([]); // false
+ * isCollection({}); // false
+ * isCollection(Map()); // true
+ * isCollection(List()); // true
+ * isCollection(Stack()); // true
+ * ```
+ */
+function isCollection(maybeCollection) {
+    return Boolean(maybeCollection &&
+        // @ts-expect-error: maybeCollection is typed as `{}`, need to change in 6.0 to `maybeCollection && typeof maybeCollection === 'object' && IS_COLLECTION_SYMBOL in maybeCollection`
+        maybeCollection[IS_COLLECTION_SYMBOL]);
+}
+
 var Collection = function Collection(value) {
   // eslint-disable-next-line no-constructor-return
   return isCollection(value) ? value : Seq(value);
@@ -230,158 +150,236 @@ Collection.Keyed = KeyedCollection;
 Collection.Indexed = IndexedCollection;
 Collection.Set = SetCollection;
 
-var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';
-/**
- * True if `maybeSeq` is a Seq.
- */
-function isSeq(maybeSeq) {
-    return Boolean(maybeSeq &&
-        // @ts-expect-error: maybeSeq is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSeq === 'object' && MAYBE_SEQ_SYMBOL in maybeSeq`
-        maybeSeq[IS_SEQ_SYMBOL]);
-}
-
-var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';
-/**
- * True if `maybeRecord` is a Record.
- */
-function isRecord(maybeRecord) {
-    return Boolean(maybeRecord &&
-        // @ts-expect-error: maybeRecord is typed as `{}`, need to change in 6.0 to `maybeRecord && typeof maybeRecord === 'object' && IS_RECORD_SYMBOL in maybeRecord`
-        maybeRecord[IS_RECORD_SYMBOL]);
-}
-
-/**
- * True if `maybeImmutable` is an Immutable Collection or Record.
- *
- * Note: Still returns true even if the collections is within a `withMutations()`.
- *
- * ```js
- * import { isImmutable, Map, List, Stack } from 'immutable';
- * isImmutable([]); // false
- * isImmutable({}); // false
- * isImmutable(Map()); // true
- * isImmutable(List()); // true
- * isImmutable(Stack()); // true
- * isImmutable(Map().asMutable()); // true
- * ```
- */
-function isImmutable(maybeImmutable) {
-    return isCollection(maybeImmutable) || isRecord(maybeImmutable);
-}
-
-var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';
-function isOrdered(maybeOrdered) {
-    return Boolean(maybeOrdered &&
-        // @ts-expect-error: maybeOrdered is typed as `{}`, need to change in 6.0 to `maybeOrdered && typeof maybeOrdered === 'object' && IS_ORDERED_SYMBOL in maybeOrdered`
-        maybeOrdered[IS_ORDERED_SYMBOL]);
-}
-
 var ITERATE_KEYS = 0;
 var ITERATE_VALUES = 1;
 var ITERATE_ENTRIES = 2;
-
+// TODO Symbol is widely available in modern JavaScript environments, clean this
 var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
 var FAUX_ITERATOR_SYMBOL = '@@iterator';
-
 var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;
-
+// @ts-expect-error: properties are not supported in buble
 var Iterator = function Iterator(next) {
-  this.next = next;
+    // @ts-expect-error: properties are not supported in buble
+    this.next = next;
 };
-
 Iterator.prototype.toString = function toString () {
-  return '[Iterator]';
+    return '[Iterator]';
 };
-
+// @ts-expect-error: static properties are not supported in buble
 Iterator.KEYS = ITERATE_KEYS;
+// @ts-expect-error: static properties are not supported in buble
 Iterator.VALUES = ITERATE_VALUES;
+// @ts-expect-error: static properties are not supported in buble
 Iterator.ENTRIES = ITERATE_ENTRIES;
-
+// @ts-expect-error: properties are not supported in buble
 Iterator.prototype.inspect = Iterator.prototype.toSource = function () {
-  return this.toString();
+    return this.toString();
 };
+// @ts-expect-error don't know how to type this
 Iterator.prototype[ITERATOR_SYMBOL] = function () {
-  return this;
+    return this;
 };
-
 function iteratorValue(type, k, v, iteratorResult) {
-  var value =
-    type === ITERATE_KEYS ? k : type === ITERATE_VALUES ? v : [k, v];
-  // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
-  iteratorResult
-    ? (iteratorResult.value = value)
-    : (iteratorResult = {
-        value: value,
-        done: false,
-      });
-  return iteratorResult;
+    var value = type === ITERATE_KEYS ? k : type === ITERATE_VALUES ? v : [k, v];
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
+    iteratorResult
+        ? (iteratorResult.value = value)
+        : (iteratorResult = {
+            // @ts-expect-error ensure value is not undefined
+            value: value,
+            done: false,
+        });
+    return iteratorResult;
 }
-
 function iteratorDone() {
-  return { value: undefined, done: true };
+    return { value: undefined, done: true };
 }
-
 function hasIterator(maybeIterable) {
-  if (Array.isArray(maybeIterable)) {
-    // IE11 trick as it does not support `Symbol.iterator`
-    return true;
-  }
-
-  return !!getIteratorFn(maybeIterable);
+    if (Array.isArray(maybeIterable)) {
+        // IE11 trick as it does not support `Symbol.iterator`
+        return true;
+    }
+    return !!getIteratorFn(maybeIterable);
 }
-
 function isIterator(maybeIterator) {
-  return maybeIterator && typeof maybeIterator.next === 'function';
+    return !!(maybeIterator &&
+        // @ts-expect-error: maybeIterator is typed as `{}`
+        typeof maybeIterator.next === 'function');
 }
-
 function getIterator(iterable) {
-  var iteratorFn = getIteratorFn(iterable);
-  return iteratorFn && iteratorFn.call(iterable);
+    var iteratorFn = getIteratorFn(iterable);
+    return iteratorFn && iteratorFn.call(iterable);
 }
-
 function getIteratorFn(iterable) {
-  var iteratorFn =
-    iterable &&
-    ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
-      iterable[FAUX_ITERATOR_SYMBOL]);
-  if (typeof iteratorFn === 'function') {
-    return iteratorFn;
-  }
+    var iteratorFn = iterable &&
+        // @ts-expect-error: maybeIterator is typed as `{}`
+        ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
+            // @ts-expect-error: maybeIterator is typed as `{}`
+            iterable[FAUX_ITERATOR_SYMBOL]);
+    if (typeof iteratorFn === 'function') {
+        return iteratorFn;
+    }
 }
-
 function isEntriesIterable(maybeIterable) {
-  var iteratorFn = getIteratorFn(maybeIterable);
-  return iteratorFn && iteratorFn === maybeIterable.entries;
+    var iteratorFn = getIteratorFn(maybeIterable);
+    // @ts-expect-error: maybeIterator is typed as `{}`
+    return iteratorFn && iteratorFn === maybeIterable.entries;
 }
-
 function isKeysIterable(maybeIterable) {
-  var iteratorFn = getIteratorFn(maybeIterable);
-  return iteratorFn && iteratorFn === maybeIterable.keys;
+    var iteratorFn = getIteratorFn(maybeIterable);
+    // @ts-expect-error: maybeIterator is typed as `{}`
+    return iteratorFn && iteratorFn === maybeIterable.keys;
 }
 
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-function isArrayLike(value) {
-    if (Array.isArray(value) || typeof value === 'string') {
-        return true;
-    }
-    // @ts-expect-error "Type 'unknown' is not assignable to type 'boolean'" : convert to Boolean
-    return (value &&
-        typeof value === 'object' &&
-        // @ts-expect-error check that `'length' in value &&`
-        Number.isInteger(value.length) &&
-        // @ts-expect-error check that `'length' in value &&`
-        value.length >= 0 &&
-        // @ts-expect-error check that `'length' in value &&`
-        (value.length === 0
-            ? // Only {length: 0} is considered Array-like.
-                Object.keys(value).length === 1
-            : // An object is only Array-like if it has a property where the last value
-                // in the array-like may be found (which could be undefined).
-                // @ts-expect-error check that `'length' in value &&`
-                value.hasOwnProperty(value.length - 1)));
+// Used for setting prototype methods that IE8 chokes on.
+var DELETE = 'delete';
+// Constants describing the size of trie nodes.
+var SHIFT = 5; // Resulted in best performance after ______?
+var SIZE = 1 << SHIFT;
+var MASK = SIZE - 1;
+// A consistent shared value representing "not set" which equals nothing other
+// than itself, and nothing that could be provided externally.
+var NOT_SET = {};
+// Boolean references, Rough equivalent of `bool &`.
+function MakeRef() {
+    return { value: false };
 }
-
+function SetRef(ref) {
+    if (ref) {
+        ref.value = true;
+    }
+}
+// A function which returns a value representing an "owner" for transient writes
+// to tries. The return value will only ever equal itself, and will not equal
+// the return of any subsequent call of this function.
+function OwnerID() { }
+function ensureSize(iter) {
+    // @ts-expect-error size should exists on Collection
+    if (iter.size === undefined) {
+        // @ts-expect-error size should exists on Collection, __iterate does exist on Collection
+        iter.size = iter.__iterate(returnTrue);
+    }
+    // @ts-expect-error size should exists on Collection
+    return iter.size;
+}
+function wrapIndex(iter, index) {
+    // This implements "is array index" which the ECMAString spec defines as:
+    //
+    //     A String property name P is an array index if and only if
+    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
+    //     to 2^32−1.
+    //
+    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
+    if (typeof index !== 'number') {
+        var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
+        if ('' + uint32Index !== index || uint32Index === 4294967295) {
+            return NaN;
+        }
+        index = uint32Index;
+    }
+    return index < 0 ? ensureSize(iter) + index : index;
+}
+function returnTrue() {
+    return true;
+}
+function wholeSlice(begin, end, size) {
+    return (((begin === 0 && !isNeg(begin)) ||
+        (size !== undefined && begin <= -size)) &&
+        (end === undefined || (size !== undefined && end >= size)));
+}
+function resolveBegin(begin, size) {
+    return resolveIndex(begin, size, 0);
+}
+function resolveEnd(end, size) {
+    return resolveIndex(end, size, size);
+}
+function resolveIndex(index, size, defaultIndex) {
+    // Sanitize indices using this shorthand for ToInt32(argument)
+    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
+    return index === undefined
+        ? defaultIndex
+        : isNeg(index)
+            ? size === Infinity
+                ? size
+                : Math.max(0, size + index) | 0
+            : size === undefined || size === index
+                ? index
+                : Math.min(size, index) | 0;
+}
+function isNeg(value) {
+    // Account for -0 which is negative, but not less than 0.
+    return value < 0 || (value === 0 && 1 / value === -Infinity);
+}
+
+var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';
+/**
+ * True if `maybeRecord` is a Record.
+ */
+function isRecord(maybeRecord) {
+    return Boolean(maybeRecord &&
+        // @ts-expect-error: maybeRecord is typed as `{}`, need to change in 6.0 to `maybeRecord && typeof maybeRecord === 'object' && IS_RECORD_SYMBOL in maybeRecord`
+        maybeRecord[IS_RECORD_SYMBOL]);
+}
+
+/**
+ * True if `maybeImmutable` is an Immutable Collection or Record.
+ *
+ * Note: Still returns true even if the collections is within a `withMutations()`.
+ *
+ * ```js
+ * import { isImmutable, Map, List, Stack } from 'immutable';
+ * isImmutable([]); // false
+ * isImmutable({}); // false
+ * isImmutable(Map()); // true
+ * isImmutable(List()); // true
+ * isImmutable(Stack()); // true
+ * isImmutable(Map().asMutable()); // true
+ * ```
+ */
+function isImmutable(maybeImmutable) {
+    return isCollection(maybeImmutable) || isRecord(maybeImmutable);
+}
+
+var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';
+function isOrdered(maybeOrdered) {
+    return Boolean(maybeOrdered &&
+        // @ts-expect-error: maybeOrdered is typed as `{}`, need to change in 6.0 to `maybeOrdered && typeof maybeOrdered === 'object' && IS_ORDERED_SYMBOL in maybeOrdered`
+        maybeOrdered[IS_ORDERED_SYMBOL]);
+}
+
+var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';
+/**
+ * True if `maybeSeq` is a Seq.
+ */
+function isSeq(maybeSeq) {
+    return Boolean(maybeSeq &&
+        // @ts-expect-error: maybeSeq is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSeq === 'object' && MAYBE_SEQ_SYMBOL in maybeSeq`
+        maybeSeq[IS_SEQ_SYMBOL]);
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function isArrayLike(value) {
+    if (Array.isArray(value) || typeof value === 'string') {
+        return true;
+    }
+    // @ts-expect-error "Type 'unknown' is not assignable to type 'boolean'" : convert to Boolean
+    return (value &&
+        typeof value === 'object' &&
+        // @ts-expect-error check that `'length' in value &&`
+        Number.isInteger(value.length) &&
+        // @ts-expect-error check that `'length' in value &&`
+        value.length >= 0 &&
+        // @ts-expect-error check that `'length' in value &&`
+        (value.length === 0
+            ? // Only {length: 0} is considered Array-like.
+                Object.keys(value).length === 1
+            : // An object is only Array-like if it has a property where the last value
+                // in the array-like may be found (which could be undefined).
+                // @ts-expect-error check that `'length' in value &&`
+                value.hasOwnProperty(value.length - 1)));
+}
+
 var Seq = /*@__PURE__*/(function (Collection) {
   function Seq(value) {
     // eslint-disable-next-line no-constructor-return
@@ -745,119 +743,16 @@ function maybeIndexedSeqFromValue(value) {
       : undefined;
 }
 
-var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';
-/**
- * True if `maybeMap` is a Map.
- *
- * Also true for OrderedMaps.
- */
-function isMap(maybeMap) {
-    return Boolean(maybeMap &&
-        // @ts-expect-error: maybeMap is typed as `{}`, need to change in 6.0 to `maybeMap && typeof maybeMap === 'object' && IS_MAP_SYMBOL in maybeMap`
-        maybeMap[IS_MAP_SYMBOL]);
-}
-
-/**
- * True if `maybeOrderedMap` is an OrderedMap.
- */
-function isOrderedMap(maybeOrderedMap) {
-    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
-}
-
-/**
- * True if `maybeValue` is a JavaScript Object which has *both* `equals()`
- * and `hashCode()` methods.
- *
- * Any two instances of *value objects* can be compared for value equality with
- * `Immutable.is()` and can be used as keys in a `Map` or members in a `Set`.
- */
-function isValueObject(maybeValue) {
-    return Boolean(maybeValue &&
-        // @ts-expect-error: maybeValue is typed as `{}`
-        typeof maybeValue.equals === 'function' &&
-        // @ts-expect-error: maybeValue is typed as `{}`
-        typeof maybeValue.hashCode === 'function');
+function asImmutable() {
+  return this.__ensureOwner();
 }
 
-/**
- * An extension of the "same-value" algorithm as [described for use by ES6 Map
- * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
- *
- * NaN is considered the same as NaN, however -0 and 0 are considered the same
- * value, which is different from the algorithm described by
- * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
- *
- * This is extended further to allow Objects to describe the values they
- * represent, by way of `valueOf` or `equals` (and `hashCode`).
- *
- * Note: because of this extension, the key equality of Immutable.Map and the
- * value equality of Immutable.Set will differ from ES6 Map and Set.
- *
- * ### Defining custom values
- *
- * The easiest way to describe the value an object represents is by implementing
- * `valueOf`. For example, `Date` represents a value by returning a unix
- * timestamp for `valueOf`:
- *
- *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
- *     var date2 = new Date(1234567890000);
- *     date1.valueOf(); // 1234567890000
- *     assert( date1 !== date2 );
- *     assert( Immutable.is( date1, date2 ) );
- *
- * Note: overriding `valueOf` may have other implications if you use this object
- * where JavaScript expects a primitive, such as implicit string coercion.
- *
- * For more complex types, especially collections, implementing `valueOf` may
- * not be performant. An alternative is to implement `equals` and `hashCode`.
- *
- * `equals` takes another object, presumably of similar type, and returns true
- * if it is equal. Equality is symmetrical, so the same result should be
- * returned if this and the argument are flipped.
- *
- *     assert( a.equals(b) === b.equals(a) );
- *
- * `hashCode` returns a 32bit integer number representing the object which will
- * be used to determine how to store the value object in a Map or Set. You must
- * provide both or neither methods, one must not exist without the other.
- *
- * Also, an important relationship between these methods must be upheld: if two
- * values are equal, they *must* return the same hashCode. If the values are not
- * equal, they might have the same hashCode; this is called a hash collision,
- * and while undesirable for performance reasons, it is acceptable.
- *
- *     if (a.equals(b)) {
- *       assert( a.hashCode() === b.hashCode() );
- *     }
- *
- * All Immutable collections are Value Objects: they implement `equals()`
- * and `hashCode()`.
- */
-function is(valueA, valueB) {
-    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
-        return true;
-    }
-    if (!valueA || !valueB) {
-        return false;
-    }
-    if (typeof valueA.valueOf === 'function' &&
-        typeof valueB.valueOf === 'function') {
-        valueA = valueA.valueOf();
-        valueB = valueB.valueOf();
-        if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
-            return true;
-        }
-        if (!valueA || !valueB) {
-            return false;
-        }
-    }
-    return !!(isValueObject(valueA) &&
-        isValueObject(valueB) &&
-        valueA.equals(valueB));
+function asMutable() {
+  return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
 }
 
-var imul =
-  typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2
+// TODO remove in v6 as Math.imul is widely available now: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
+var imul = typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2
     ? Math.imul
     : function imul(a, b) {
         a |= 0; // int
@@ -866,247 +761,238 @@ var imul =
         var d = b & 0xffff;
         // Shift by 0 fixes the sign on the high part.
         return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int
-      };
-
+    };
 // v8 has an optimization for storing 31-bit signed numbers.
 // Values which have either 00 or 11 as the high order bits qualify.
 // This function drops the highest order bit in a signed number, maintaining
 // the sign bit.
 function smi(i32) {
-  return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
+    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
 }
 
 var defaultValueOf = Object.prototype.valueOf;
-
 function hash(o) {
-  // eslint-disable-next-line eqeqeq
-  if (o == null) {
-    return hashNullish(o);
-  }
-
-  if (typeof o.hashCode === 'function') {
-    // Drop any high bits from accidentally long hash codes.
-    return smi(o.hashCode(o));
-  }
-
-  var v = valueOf(o);
-
-  // eslint-disable-next-line eqeqeq
-  if (v == null) {
-    return hashNullish(v);
-  }
-
-  switch (typeof v) {
-    case 'boolean':
-      // The hash values for built-in constants are a 1 value for each 5-byte
-      // shift region expect for the first, which encodes the value. This
-      // reduces the odds of a hash collision for these common values.
-      return v ? 0x42108421 : 0x42108420;
-    case 'number':
-      return hashNumber(v);
-    case 'string':
-      return v.length > STRING_HASH_CACHE_MIN_STRLEN
-        ? cachedHashString(v)
-        : hashString(v);
-    case 'object':
-    case 'function':
-      return hashJSObj(v);
-    case 'symbol':
-      return hashSymbol(v);
-    default:
-      if (typeof v.toString === 'function') {
-        return hashString(v.toString());
-      }
-      throw new Error('Value type ' + typeof v + ' cannot be hashed.');
-  }
+    // eslint-disable-next-line eqeqeq
+    if (o == null) {
+        return hashNullish(o);
+    }
+    // @ts-expect-error don't care about object beeing typed as `{}` here
+    if (typeof o.hashCode === 'function') {
+        // Drop any high bits from accidentally long hash codes.
+        // @ts-expect-error don't care about object beeing typed as `{}` here
+        return smi(o.hashCode(o));
+    }
+    var v = valueOf(o);
+    // eslint-disable-next-line eqeqeq
+    if (v == null) {
+        return hashNullish(v);
+    }
+    switch (typeof v) {
+        case 'boolean':
+            // The hash values for built-in constants are a 1 value for each 5-byte
+            // shift region expect for the first, which encodes the value. This
+            // reduces the odds of a hash collision for these common values.
+            return v ? 0x42108421 : 0x42108420;
+        case 'number':
+            return hashNumber(v);
+        case 'string':
+            return v.length > STRING_HASH_CACHE_MIN_STRLEN
+                ? cachedHashString(v)
+                : hashString(v);
+        case 'object':
+        case 'function':
+            return hashJSObj(v);
+        case 'symbol':
+            return hashSymbol(v);
+        default:
+            if (typeof v.toString === 'function') {
+                return hashString(v.toString());
+            }
+            throw new Error('Value type ' + typeof v + ' cannot be hashed.');
+    }
 }
-
 function hashNullish(nullish) {
-  return nullish === null ? 0x42108422 : /* undefined */ 0x42108423;
+    return nullish === null ? 0x42108422 : /* undefined */ 0x42108423;
 }
-
 // Compress arbitrarily large numbers into smi hashes.
 function hashNumber(n) {
-  if (n !== n || n === Infinity) {
-    return 0;
-  }
-  var hash = n | 0;
-  if (hash !== n) {
-    hash ^= n * 0xffffffff;
-  }
-  while (n > 0xffffffff) {
-    n /= 0xffffffff;
-    hash ^= n;
-  }
-  return smi(hash);
+    if (n !== n || n === Infinity) {
+        return 0;
+    }
+    var hash = n | 0;
+    if (hash !== n) {
+        hash ^= n * 0xffffffff;
+    }
+    while (n > 0xffffffff) {
+        n /= 0xffffffff;
+        hash ^= n;
+    }
+    return smi(hash);
 }
-
 function cachedHashString(string) {
-  var hashed = stringHashCache[string];
-  if (hashed === undefined) {
-    hashed = hashString(string);
-    if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
-      STRING_HASH_CACHE_SIZE = 0;
-      stringHashCache = {};
+    var hashed = stringHashCache[string];
+    if (hashed === undefined) {
+        hashed = hashString(string);
+        if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
+            STRING_HASH_CACHE_SIZE = 0;
+            stringHashCache = {};
+        }
+        STRING_HASH_CACHE_SIZE++;
+        stringHashCache[string] = hashed;
     }
-    STRING_HASH_CACHE_SIZE++;
-    stringHashCache[string] = hashed;
-  }
-  return hashed;
+    return hashed;
 }
-
 // http://jsperf.com/hashing-strings
 function hashString(string) {
-  // This is the hash from JVM
-  // The hash code for a string is computed as
-  // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
-  // where s[i] is the ith character of the string and n is the length of
-  // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
-  // (exclusive) by dropping high bits.
-  var hashed = 0;
-  for (var ii = 0; ii < string.length; ii++) {
-    hashed = (31 * hashed + string.charCodeAt(ii)) | 0;
-  }
-  return smi(hashed);
+    // This is the hash from JVM
+    // The hash code for a string is computed as
+    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
+    // where s[i] is the ith character of the string and n is the length of
+    // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
+    // (exclusive) by dropping high bits.
+    var hashed = 0;
+    for (var ii = 0; ii < string.length; ii++) {
+        hashed = (31 * hashed + string.charCodeAt(ii)) | 0;
+    }
+    return smi(hashed);
 }
-
 function hashSymbol(sym) {
-  var hashed = symbolMap[sym];
-  if (hashed !== undefined) {
+    var hashed = symbolMap[sym];
+    if (hashed !== undefined) {
+        return hashed;
+    }
+    hashed = nextHash();
+    symbolMap[sym] = hashed;
     return hashed;
-  }
-
-  hashed = nextHash();
-
-  symbolMap[sym] = hashed;
-
-  return hashed;
 }
-
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function hashJSObj(obj) {
-  var hashed;
-  if (usingWeakMap) {
-    hashed = weakMap.get(obj);
-    if (hashed !== undefined) {
-      return hashed;
+    var hashed;
+    if (usingWeakMap) {
+        // @ts-expect-error weakMap is defined
+        hashed = weakMap.get(obj);
+        if (hashed !== undefined) {
+            return hashed;
+        }
     }
-  }
-
-  hashed = obj[UID_HASH_KEY];
-  if (hashed !== undefined) {
-    return hashed;
-  }
-
-  if (!canDefineProperty) {
-    hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
+    // @ts-expect-error used for old code, will be removed
+    hashed = obj[UID_HASH_KEY];
     if (hashed !== undefined) {
-      return hashed;
+        return hashed;
     }
-
-    hashed = getIENodeHash(obj);
-    if (hashed !== undefined) {
-      return hashed;
+    if (!canDefineProperty) {
+        // @ts-expect-error used for old code, will be removed
+        hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
+        if (hashed !== undefined) {
+            return hashed;
+        }
+        hashed = getIENodeHash(obj);
+        if (hashed !== undefined) {
+            return hashed;
+        }
     }
-  }
-
-  hashed = nextHash();
-
-  if (usingWeakMap) {
-    weakMap.set(obj, hashed);
-  } else if (isExtensible !== undefined && isExtensible(obj) === false) {
-    throw new Error('Non-extensible objects are not allowed as keys.');
-  } else if (canDefineProperty) {
-    Object.defineProperty(obj, UID_HASH_KEY, {
-      enumerable: false,
-      configurable: false,
-      writable: false,
-      value: hashed,
-    });
-  } else if (
-    obj.propertyIsEnumerable !== undefined &&
-    obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable
-  ) {
-    // Since we can't define a non-enumerable property on the object
-    // we'll hijack one of the less-used non-enumerable properties to
-    // save our hash on it. Since this is a function it will not show up in
-    // `JSON.stringify` which is what we want.
-    obj.propertyIsEnumerable = function () {
-      return this.constructor.prototype.propertyIsEnumerable.apply(
-        this,
-        arguments
-      );
-    };
-    obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
-  } else if (obj.nodeType !== undefined) {
-    // At this point we couldn't get the IE `uniqueID` to use as a hash
-    // and we couldn't use a non-enumerable property to exploit the
-    // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
-    // itself.
-    obj[UID_HASH_KEY] = hashed;
-  } else {
-    throw new Error('Unable to set a non-enumerable property on object.');
-  }
-
-  return hashed;
+    hashed = nextHash();
+    if (usingWeakMap) {
+        // @ts-expect-error weakMap is defined
+        weakMap.set(obj, hashed);
+    }
+    else if (isExtensible !== undefined && isExtensible(obj) === false) {
+        throw new Error('Non-extensible objects are not allowed as keys.');
+    }
+    else if (canDefineProperty) {
+        Object.defineProperty(obj, UID_HASH_KEY, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: hashed,
+        });
+    }
+    else if (obj.propertyIsEnumerable !== undefined &&
+        obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {
+        // Since we can't define a non-enumerable property on the object
+        // we'll hijack one of the less-used non-enumerable properties to
+        // save our hash on it. Since this is a function it will not show up in
+        // `JSON.stringify` which is what we want.
+        obj.propertyIsEnumerable = function () {
+            return this.constructor.prototype.propertyIsEnumerable.apply(this, 
+            // eslint-disable-next-line prefer-rest-params
+            arguments);
+        };
+        // @ts-expect-error used for old code, will be removed
+        obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
+        // @ts-expect-error used for old code, will be removed
+    }
+    else if (obj.nodeType !== undefined) {
+        // At this point we couldn't get the IE `uniqueID` to use as a hash
+        // and we couldn't use a non-enumerable property to exploit the
+        // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
+        // itself.
+        // @ts-expect-error used for old code, will be removed
+        obj[UID_HASH_KEY] = hashed;
+    }
+    else {
+        throw new Error('Unable to set a non-enumerable property on object.');
+    }
+    return hashed;
 }
-
 // Get references to ES5 object methods.
 var isExtensible = Object.isExtensible;
-
 // True if Object.defineProperty works as expected. IE8 fails this test.
+// TODO remove this as widely available https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty
 var canDefineProperty = (function () {
-  try {
-    Object.defineProperty({}, '@', {});
-    return true;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  } catch (e) {
-    return false;
-  }
+    try {
+        Object.defineProperty({}, '@', {});
+        return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        return false;
+    }
 })();
-
 // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
 // and avoid memory leaks from the IE cloneNode bug.
+// TODO remove this method as only used if `canDefineProperty` is false
 function getIENodeHash(node) {
-  if (node && node.nodeType > 0) {
-    switch (node.nodeType) {
-      case 1: // Element
-        return node.uniqueID;
-      case 9: // Document
-        return node.documentElement && node.documentElement.uniqueID;
+    // @ts-expect-error don't care
+    if (node && node.nodeType > 0) {
+        // @ts-expect-error don't care
+        switch (node.nodeType) {
+            case 1: // Element
+                // @ts-expect-error don't care
+                return node.uniqueID;
+            case 9: // Document
+                // @ts-expect-error don't care
+                return node.documentElement && node.documentElement.uniqueID;
+        }
     }
-  }
 }
-
 function valueOf(obj) {
-  return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'
-    ? obj.valueOf(obj)
-    : obj;
+    return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'
+        ? // @ts-expect-error weird the "obj" parameter as `valueOf` should not have a parameter
+            obj.valueOf(obj)
+        : obj;
 }
-
 function nextHash() {
-  var nextHash = ++_objHashUID;
-  if (_objHashUID & 0x40000000) {
-    _objHashUID = 0;
-  }
-  return nextHash;
+    var nextHash = ++_objHashUID;
+    if (_objHashUID & 0x40000000) {
+        _objHashUID = 0;
+    }
+    return nextHash;
 }
-
 // If possible, use a WeakMap.
+// TODO using WeakMap should be true everywhere now that WeakMap is widely supported: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
 var usingWeakMap = typeof WeakMap === 'function';
 var weakMap;
 if (usingWeakMap) {
-  weakMap = new WeakMap();
+    weakMap = new WeakMap();
 }
-
 var symbolMap = Object.create(null);
-
 var _objHashUID = 0;
-
+// TODO remove string as Symbol is now widely supported: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol
 var UID_HASH_KEY = '__immutablehash__';
 if (typeof Symbol === 'function') {
-  UID_HASH_KEY = Symbol(UID_HASH_KEY);
+    UID_HASH_KEY = Symbol(UID_HASH_KEY);
 }
-
 var STRING_HASH_CACHE_MIN_STRLEN = 16;
 var STRING_HASH_CACHE_MAX_SIZE = 255;
 var STRING_HASH_CACHE_SIZE = 0;
@@ -2122,255 +2008,102 @@ function defaultComparator(a, b) {
   return a > b ? 1 : a < b ? -1 : 0;
 }
 
-// http://jsperf.com/copy-array-inline
-function arrCopy(arr, offset) {
-    offset = offset || 0;
-    var len = Math.max(0, arr.length - offset);
-    var newArr = new Array(len);
-    for (var ii = 0; ii < len; ii++) {
-        // @ts-expect-error We may want to guard for undefined values with `if (arr[ii + offset] !== undefined`, but ths should not happen by design
-        newArr[ii] = arr[ii + offset];
-    }
-    return newArr;
-}
-
-function invariant(condition, error) {
-    if (!condition)
-        { throw new Error(error); }
-}
-
-function assertNotInfinite(size) {
-    invariant(size !== Infinity, 'Cannot perform this action with an infinite size.');
-}
-
-function coerceKeyPath(keyPath) {
-    if (isArrayLike(keyPath) && typeof keyPath !== 'string') {
-        return keyPath;
-    }
-    if (isOrdered(keyPath)) {
-        return keyPath.toArray();
-    }
-    throw new TypeError('Invalid keyPath: expected Ordered Collection or Array: ' + keyPath);
-}
-
-var toString = Object.prototype.toString;
-function isPlainObject(value) {
-    // The base prototype's toString deals with Argument objects and native namespaces like Math
-    if (!value ||
-        typeof value !== 'object' ||
-        toString.call(value) !== '[object Object]') {
-        return false;
-    }
-    var proto = Object.getPrototypeOf(value);
-    if (proto === null) {
-        return true;
-    }
-    // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc)
-    var parentProto = proto;
-    var nextProto = Object.getPrototypeOf(proto);
-    while (nextProto !== null) {
-        parentProto = nextProto;
-        nextProto = Object.getPrototypeOf(parentProto);
-    }
-    return parentProto === proto;
-}
-
 /**
- * Returns true if the value is a potentially-persistent data structure, either
- * provided by Immutable.js or a plain Array or Object.
- */
-function isDataStructure(value) {
-    return (typeof value === 'object' &&
-        (isImmutable(value) || Array.isArray(value) || isPlainObject(value)));
-}
-
-/**
- * Converts a value to a string, adding quotes if a string was provided.
+ * True if `maybeValue` is a JavaScript Object which has *both* `equals()`
+ * and `hashCode()` methods.
+ *
+ * Any two instances of *value objects* can be compared for value equality with
+ * `Immutable.is()` and can be used as keys in a `Map` or members in a `Set`.
  */
-function quoteString(value) {
-    try {
-        return typeof value === 'string' ? JSON.stringify(value) : String(value);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    }
-    catch (_ignoreError) {
-        return JSON.stringify(value);
-    }
+function isValueObject(maybeValue) {
+    return Boolean(maybeValue &&
+        // @ts-expect-error: maybeValue is typed as `{}`
+        typeof maybeValue.equals === 'function' &&
+        // @ts-expect-error: maybeValue is typed as `{}`
+        typeof maybeValue.hashCode === 'function');
 }
 
 /**
- * Returns true if the key is defined in the provided collection.
+ * An extension of the "same-value" algorithm as [described for use by ES6 Map
+ * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
  *
- * A functional alternative to `collection.has(key)` which will also work with
- * plain Objects and Arrays as an alternative for
- * `collection.hasOwnProperty(key)`.
+ * NaN is considered the same as NaN, however -0 and 0 are considered the same
+ * value, which is different from the algorithm described by
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
+ *
+ * This is extended further to allow Objects to describe the values they
+ * represent, by way of `valueOf` or `equals` (and `hashCode`).
+ *
+ * Note: because of this extension, the key equality of Immutable.Map and the
+ * value equality of Immutable.Set will differ from ES6 Map and Set.
+ *
+ * ### Defining custom values
+ *
+ * The easiest way to describe the value an object represents is by implementing
+ * `valueOf`. For example, `Date` represents a value by returning a unix
+ * timestamp for `valueOf`:
+ *
+ *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
+ *     var date2 = new Date(1234567890000);
+ *     date1.valueOf(); // 1234567890000
+ *     assert( date1 !== date2 );
+ *     assert( Immutable.is( date1, date2 ) );
+ *
+ * Note: overriding `valueOf` may have other implications if you use this object
+ * where JavaScript expects a primitive, such as implicit string coercion.
+ *
+ * For more complex types, especially collections, implementing `valueOf` may
+ * not be performant. An alternative is to implement `equals` and `hashCode`.
+ *
+ * `equals` takes another object, presumably of similar type, and returns true
+ * if it is equal. Equality is symmetrical, so the same result should be
+ * returned if this and the argument are flipped.
+ *
+ *     assert( a.equals(b) === b.equals(a) );
+ *
+ * `hashCode` returns a 32bit integer number representing the object which will
+ * be used to determine how to store the value object in a Map or Set. You must
+ * provide both or neither methods, one must not exist without the other.
+ *
+ * Also, an important relationship between these methods must be upheld: if two
+ * values are equal, they *must* return the same hashCode. If the values are not
+ * equal, they might have the same hashCode; this is called a hash collision,
+ * and while undesirable for performance reasons, it is acceptable.
+ *
+ *     if (a.equals(b)) {
+ *       assert( a.hashCode() === b.hashCode() );
+ *     }
+ *
+ * All Immutable collections are Value Objects: they implement `equals()`
+ * and `hashCode()`.
  */
-function has(collection, key) {
-    return isImmutable(collection)
-        ? // @ts-expect-error key might be a number or symbol, which is not handled be Record key type
-            collection.has(key)
-        : // @ts-expect-error key might be anything else than PropertyKey, and will return false in that case but runtime is OK
-            isDataStructure(collection) && hasOwnProperty.call(collection, key);
-}
-
-function get(collection, key, notSetValue) {
-    return isImmutable(collection)
-        ? collection.get(key, notSetValue)
-        : !has(collection, key)
-            ? notSetValue
-            : // @ts-expect-error weird "get" here,
-                typeof collection.get === 'function'
-                    ? // @ts-expect-error weird "get" here,
-                        collection.get(key)
-                    : // @ts-expect-error key is unknown here,
-                        collection[key];
-}
-
-function shallowCopy(from) {
-    if (Array.isArray(from)) {
-        return arrCopy(from);
-    }
-    var to = {};
-    for (var key in from) {
-        if (hasOwnProperty.call(from, key)) {
-            to[key] = from[key];
-        }
+function is(valueA, valueB) {
+    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
+        return true;
     }
-    return to;
-}
-
-function remove(collection, key) {
-    if (!isDataStructure(collection)) {
-        throw new TypeError('Cannot update non-data-structure value: ' + collection);
+    if (!valueA || !valueB) {
+        return false;
     }
-    if (isImmutable(collection)) {
-        // @ts-expect-error weird "remove" here,
-        if (!collection.remove) {
-            throw new TypeError('Cannot update immutable value without .remove() method: ' + collection);
+    if (typeof valueA.valueOf === 'function' &&
+        typeof valueB.valueOf === 'function') {
+        valueA = valueA.valueOf();
+        valueB = valueB.valueOf();
+        if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
+            return true;
         }
-        // @ts-expect-error weird "remove" here,
-        return collection.remove(key);
-    }
-    // @ts-expect-error assert that key is a string, a number or a symbol here
-    if (!hasOwnProperty.call(collection, key)) {
-        return collection;
-    }
-    var collectionCopy = shallowCopy(collection);
-    if (Array.isArray(collectionCopy)) {
-        // @ts-expect-error assert that key is a number here
-        collectionCopy.splice(key, 1);
-    }
-    else {
-        // @ts-expect-error assert that key is a string, a number or a symbol here
-        delete collectionCopy[key];
-    }
-    return collectionCopy;
-}
-
-function set(collection, key, value) {
-    if (!isDataStructure(collection)) {
-        throw new TypeError('Cannot update non-data-structure value: ' + collection);
-    }
-    if (isImmutable(collection)) {
-        // @ts-expect-error weird "set" here,
-        if (!collection.set) {
-            throw new TypeError('Cannot update immutable value without .set() method: ' + collection);
+        if (!valueA || !valueB) {
+            return false;
         }
-        // @ts-expect-error weird "set" here,
-        return collection.set(key, value);
-    }
-    // @ts-expect-error mix of key and string here. Probably need a more fine type here
-    if (hasOwnProperty.call(collection, key) && value === collection[key]) {
-        return collection;
-    }
-    var collectionCopy = shallowCopy(collection);
-    // @ts-expect-error mix of key and string here. Probably need a more fine type here
-    collectionCopy[key] = value;
-    return collectionCopy;
-}
-
-function updateIn$1(collection, keyPath, notSetValue, updater) {
-    if (!updater) {
-        // handle the fact that `notSetValue` is optional here, in that case `updater` is the updater function
-        // @ts-expect-error updater is a function here
-        updater = notSetValue;
-        notSetValue = undefined;
-    }
-    var updatedValue = updateInDeeply(isImmutable(collection), 
-    // @ts-expect-error type issues with Record and mixed types
-    collection, coerceKeyPath(keyPath), 0, notSetValue, updater);
-    // @ts-expect-error mixed return type
-    return updatedValue === NOT_SET ? notSetValue : updatedValue;
-}
-function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater) {
-    var wasNotSet = existing === NOT_SET;
-    if (i === keyPath.length) {
-        var existingValue = wasNotSet ? notSetValue : existing;
-        // @ts-expect-error mixed type with optional value
-        var newValue = updater(existingValue);
-        // @ts-expect-error mixed type
-        return newValue === existingValue ? existing : newValue;
-    }
-    if (!wasNotSet && !isDataStructure(existing)) {
-        throw new TypeError('Cannot update within non-data-structure value in path [' +
-            Array.from(keyPath).slice(0, i).map(quoteString) +
-            ']: ' +
-            existing);
-    }
-    var key = keyPath[i];
-    var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
-    var nextUpdated = updateInDeeply(nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting), 
-    // @ts-expect-error mixed type
-    nextExisting, keyPath, i + 1, notSetValue, updater);
-    return nextUpdated === nextExisting
-        ? existing
-        : nextUpdated === NOT_SET
-            ? remove(existing, key)
-            : set(wasNotSet ? (inImmutable ? emptyMap() : {}) : existing, key, nextUpdated);
-}
-
-/**
- * Returns a copy of the collection with the value at the key path set to the
- * provided value.
- *
- * A functional alternative to `collection.setIn(keypath)` which will also
- * work with plain Objects and Arrays.
- */
-function setIn$1(collection, keyPath, value) {
-    return updateIn$1(collection, keyPath, NOT_SET, function () { return value; });
-}
-
-function setIn(keyPath, v) {
-  return setIn$1(this, keyPath, v);
-}
-
-/**
- * Returns a copy of the collection with the value at the key path removed.
- *
- * A functional alternative to `collection.removeIn(keypath)` which will also
- * work with plain Objects and Arrays.
- */
-function removeIn(collection, keyPath) {
-    return updateIn$1(collection, keyPath, function () { return NOT_SET; });
-}
-
-function deleteIn(keyPath) {
-  return removeIn(this, keyPath);
-}
-
-function update$1(collection, key, notSetValue, updater) {
-    return updateIn$1(
-    // @ts-expect-error Index signature for type string is missing in type V[]
-    collection, [key], notSetValue, updater);
-}
-
-function update(key, notSetValue, updater) {
-  return arguments.length === 1
-    ? key(this)
-    : update$1(this, key, notSetValue, updater);
+    }
+    return !!(isValueObject(valueA) &&
+        isValueObject(valueB) &&
+        valueA.equals(valueB));
 }
 
-function updateIn(keyPath, notSetValue, updater) {
-  return updateIn$1(this, keyPath, notSetValue, updater);
+function update$1(collection, key, notSetValue, updater) {
+    return updateIn(
+    // @ts-expect-error Index signature for type string is missing in type V[]
+    collection, [key], notSetValue, updater);
 }
 
 function merge$1() {
@@ -2425,6 +2158,62 @@ function mergeIntoKeyedWith(collection, collections, merger) {
   });
 }
 
+var toString = Object.prototype.toString;
+function isPlainObject(value) {
+    // The base prototype's toString deals with Argument objects and native namespaces like Math
+    if (!value ||
+        typeof value !== 'object' ||
+        toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    var proto = Object.getPrototypeOf(value);
+    if (proto === null) {
+        return true;
+    }
+    // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc)
+    var parentProto = proto;
+    var nextProto = Object.getPrototypeOf(proto);
+    while (nextProto !== null) {
+        parentProto = nextProto;
+        nextProto = Object.getPrototypeOf(parentProto);
+    }
+    return parentProto === proto;
+}
+
+/**
+ * Returns true if the value is a potentially-persistent data structure, either
+ * provided by Immutable.js or a plain Array or Object.
+ */
+function isDataStructure(value) {
+    return (typeof value === 'object' &&
+        (isImmutable(value) || Array.isArray(value) || isPlainObject(value)));
+}
+
+// http://jsperf.com/copy-array-inline
+function arrCopy(arr, offset) {
+    offset = offset || 0;
+    var len = Math.max(0, arr.length - offset);
+    var newArr = new Array(len);
+    for (var ii = 0; ii < len; ii++) {
+        // @ts-expect-error We may want to guard for undefined values with `if (arr[ii + offset] !== undefined`, but ths should not happen by design
+        newArr[ii] = arr[ii + offset];
+    }
+    return newArr;
+}
+
+function shallowCopy(from) {
+    if (Array.isArray(from)) {
+        return arrCopy(from);
+    }
+    var to = {};
+    for (var key in from) {
+        if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+        }
+    }
+    return to;
+}
+
 function merge(collection) {
   var sources = [], len = arguments.length - 1;
   while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
@@ -2542,19 +2331,48 @@ function mergeDeepWith(merger) {
   return mergeDeepWithSources(this, iters, merger);
 }
 
-function mergeIn(keyPath) {
+function mergeDeepIn(keyPath) {
   var iters = [], len = arguments.length - 1;
   while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
 
-  return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); });
+  return updateIn(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); }
+  );
 }
 
-function mergeDeepIn(keyPath) {
+function mergeIn(keyPath) {
   var iters = [], len = arguments.length - 1;
   while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
 
-  return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); }
-  );
+  return updateIn(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); });
+}
+
+/**
+ * Returns a copy of the collection with the value at the key path set to the
+ * provided value.
+ *
+ * A functional alternative to `collection.setIn(keypath)` which will also
+ * work with plain Objects and Arrays.
+ */
+function setIn$1(collection, keyPath, value) {
+    return updateIn(collection, keyPath, NOT_SET, function () { return value; });
+}
+
+function setIn(keyPath, v) {
+  return setIn$1(this, keyPath, v);
+}
+
+function update(key, notSetValue, updater) {
+  return arguments.length === 1
+    ? key(this)
+    : update$1(this, key, notSetValue, updater);
+}
+
+function updateIn$1(keyPath, notSetValue, updater) {
+  return updateIn(this, keyPath, notSetValue, updater);
+}
+
+function wasAltered() {
+  return this.__altered;
 }
 
 function withMutations(fn) {
@@ -2563,16 +2381,25 @@ function withMutations(fn) {
   return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
 }
 
-function asMutable() {
-  return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
+var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';
+/**
+ * True if `maybeMap` is a Map.
+ *
+ * Also true for OrderedMaps.
+ */
+function isMap(maybeMap) {
+    return Boolean(maybeMap &&
+        // @ts-expect-error: maybeMap is typed as `{}`, need to change in 6.0 to `maybeMap && typeof maybeMap === 'object' && IS_MAP_SYMBOL in maybeMap`
+        maybeMap[IS_MAP_SYMBOL]);
 }
 
-function asImmutable() {
-  return this.__ensureOwner();
+function invariant(condition, error) {
+    if (!condition)
+        { throw new Error(error); }
 }
 
-function wasAltered() {
-  return this.__altered;
+function assertNotInfinite(size) {
+    invariant(size !== Infinity, 'Cannot perform this action with an infinite size.');
 }
 
 var Map = /*@__PURE__*/(function (KeyedCollection) {
@@ -2709,7 +2536,7 @@ MapPrototype.removeAll = MapPrototype.deleteAll;
 MapPrototype.setIn = setIn;
 MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;
 MapPrototype.update = update;
-MapPrototype.updateIn = updateIn;
+MapPrototype.updateIn = updateIn$1;
 MapPrototype.merge = MapPrototype.concat = merge$1;
 MapPrototype.mergeWith = mergeWith$1;
 MapPrototype.mergeDeep = mergeDeep;
@@ -3311,45 +3138,200 @@ function setAt(array, idx, val, canEdit) {
   return newArray;
 }
 
-function spliceIn(array, idx, val, canEdit) {
-  var newLen = array.length + 1;
-  if (canEdit && idx + 1 === newLen) {
-    array[idx] = val;
-    return array;
-  }
-  var newArray = new Array(newLen);
-  var after = 0;
-  for (var ii = 0; ii < newLen; ii++) {
-    if (ii === idx) {
-      newArray[ii] = val;
-      after = -1;
-    } else {
-      newArray[ii] = array[ii + after];
+function spliceIn(array, idx, val, canEdit) {
+  var newLen = array.length + 1;
+  if (canEdit && idx + 1 === newLen) {
+    array[idx] = val;
+    return array;
+  }
+  var newArray = new Array(newLen);
+  var after = 0;
+  for (var ii = 0; ii < newLen; ii++) {
+    if (ii === idx) {
+      newArray[ii] = val;
+      after = -1;
+    } else {
+      newArray[ii] = array[ii + after];
+    }
+  }
+  return newArray;
+}
+
+function spliceOut(array, idx, canEdit) {
+  var newLen = array.length - 1;
+  if (canEdit && idx === newLen) {
+    array.pop();
+    return array;
+  }
+  var newArray = new Array(newLen);
+  var after = 0;
+  for (var ii = 0; ii < newLen; ii++) {
+    if (ii === idx) {
+      after = 1;
+    }
+    newArray[ii] = array[ii + after];
+  }
+  return newArray;
+}
+
+var MAX_ARRAY_MAP_SIZE = SIZE / 4;
+var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
+var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
+
+function coerceKeyPath(keyPath) {
+    if (isArrayLike(keyPath) && typeof keyPath !== 'string') {
+        return keyPath;
+    }
+    if (isOrdered(keyPath)) {
+        return keyPath.toArray();
+    }
+    throw new TypeError('Invalid keyPath: expected Ordered Collection or Array: ' + keyPath);
+}
+
+/**
+ * Converts a value to a string, adding quotes if a string was provided.
+ */
+function quoteString(value) {
+    try {
+        return typeof value === 'string' ? JSON.stringify(value) : String(value);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (_ignoreError) {
+        return JSON.stringify(value);
+    }
+}
+
+/**
+ * Returns true if the key is defined in the provided collection.
+ *
+ * A functional alternative to `collection.has(key)` which will also work with
+ * plain Objects and Arrays as an alternative for
+ * `collection.hasOwnProperty(key)`.
+ */
+function has(collection, key) {
+    return isImmutable(collection)
+        ? // @ts-expect-error key might be a number or symbol, which is not handled be Record key type
+            collection.has(key)
+        : // @ts-expect-error key might be anything else than PropertyKey, and will return false in that case but runtime is OK
+            isDataStructure(collection) && hasOwnProperty.call(collection, key);
+}
+
+function get(collection, key, notSetValue) {
+    return isImmutable(collection)
+        ? collection.get(key, notSetValue)
+        : !has(collection, key)
+            ? notSetValue
+            : // @ts-expect-error weird "get" here,
+                typeof collection.get === 'function'
+                    ? // @ts-expect-error weird "get" here,
+                        collection.get(key)
+                    : // @ts-expect-error key is unknown here,
+                        collection[key];
+}
+
+function remove(collection, key) {
+    if (!isDataStructure(collection)) {
+        throw new TypeError('Cannot update non-data-structure value: ' + collection);
+    }
+    if (isImmutable(collection)) {
+        // @ts-expect-error weird "remove" here,
+        if (!collection.remove) {
+            throw new TypeError('Cannot update immutable value without .remove() method: ' + collection);
+        }
+        // @ts-expect-error weird "remove" here,
+        return collection.remove(key);
+    }
+    // @ts-expect-error assert that key is a string, a number or a symbol here
+    if (!hasOwnProperty.call(collection, key)) {
+        return collection;
+    }
+    var collectionCopy = shallowCopy(collection);
+    if (Array.isArray(collectionCopy)) {
+        // @ts-expect-error assert that key is a number here
+        collectionCopy.splice(key, 1);
+    }
+    else {
+        // @ts-expect-error assert that key is a string, a number or a symbol here
+        delete collectionCopy[key];
+    }
+    return collectionCopy;
+}
+
+function set(collection, key, value) {
+    if (!isDataStructure(collection)) {
+        throw new TypeError('Cannot update non-data-structure value: ' + collection);
+    }
+    if (isImmutable(collection)) {
+        // @ts-expect-error weird "set" here,
+        if (!collection.set) {
+            throw new TypeError('Cannot update immutable value without .set() method: ' + collection);
+        }
+        // @ts-expect-error weird "set" here,
+        return collection.set(key, value);
+    }
+    // @ts-expect-error mix of key and string here. Probably need a more fine type here
+    if (hasOwnProperty.call(collection, key) && value === collection[key]) {
+        return collection;
+    }
+    var collectionCopy = shallowCopy(collection);
+    // @ts-expect-error mix of key and string here. Probably need a more fine type here
+    collectionCopy[key] = value;
+    return collectionCopy;
+}
+
+function updateIn(collection, keyPath, notSetValue, updater) {
+    if (!updater) {
+        // handle the fact that `notSetValue` is optional here, in that case `updater` is the updater function
+        // @ts-expect-error updater is a function here
+        updater = notSetValue;
+        notSetValue = undefined;
     }
-  }
-  return newArray;
+    var updatedValue = updateInDeeply(isImmutable(collection), 
+    // @ts-expect-error type issues with Record and mixed types
+    collection, coerceKeyPath(keyPath), 0, notSetValue, updater);
+    // @ts-expect-error mixed return type
+    return updatedValue === NOT_SET ? notSetValue : updatedValue;
 }
-
-function spliceOut(array, idx, canEdit) {
-  var newLen = array.length - 1;
-  if (canEdit && idx === newLen) {
-    array.pop();
-    return array;
-  }
-  var newArray = new Array(newLen);
-  var after = 0;
-  for (var ii = 0; ii < newLen; ii++) {
-    if (ii === idx) {
-      after = 1;
+function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater) {
+    var wasNotSet = existing === NOT_SET;
+    if (i === keyPath.length) {
+        var existingValue = wasNotSet ? notSetValue : existing;
+        // @ts-expect-error mixed type with optional value
+        var newValue = updater(existingValue);
+        // @ts-expect-error mixed type
+        return newValue === existingValue ? existing : newValue;
     }
-    newArray[ii] = array[ii + after];
-  }
-  return newArray;
+    if (!wasNotSet && !isDataStructure(existing)) {
+        throw new TypeError('Cannot update within non-data-structure value in path [' +
+            Array.from(keyPath).slice(0, i).map(quoteString) +
+            ']: ' +
+            existing);
+    }
+    var key = keyPath[i];
+    var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
+    var nextUpdated = updateInDeeply(nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting), 
+    // @ts-expect-error mixed type
+    nextExisting, keyPath, i + 1, notSetValue, updater);
+    return nextUpdated === nextExisting
+        ? existing
+        : nextUpdated === NOT_SET
+            ? remove(existing, key)
+            : set(wasNotSet ? (inImmutable ? emptyMap() : {}) : existing, key, nextUpdated);
 }
 
-var MAX_ARRAY_MAP_SIZE = SIZE / 4;
-var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
-var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
+/**
+ * Returns a copy of the collection with the value at the key path removed.
+ *
+ * A functional alternative to `collection.removeIn(keypath)` which will also
+ * work with plain Objects and Arrays.
+ */
+function removeIn(collection, keyPath) {
+    return updateIn(collection, keyPath, function () { return NOT_SET; });
+}
+
+function deleteIn(keyPath) {
+  return removeIn(this, keyPath);
+}
 
 var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';
 /**
@@ -3610,7 +3592,7 @@ ListPrototype.merge = ListPrototype.concat;
 ListPrototype.setIn = setIn;
 ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;
 ListPrototype.update = update;
-ListPrototype.updateIn = updateIn;
+ListPrototype.updateIn = updateIn$1;
 ListPrototype.mergeIn = mergeIn;
 ListPrototype.mergeDeepIn = mergeDeepIn;
 ListPrototype.withMutations = withMutations;
@@ -4042,6 +4024,13 @@ function getTailOffset(size) {
   return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
 }
 
+/**
+ * True if `maybeOrderedMap` is an OrderedMap.
+ */
+function isOrderedMap(maybeOrderedMap) {
+    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
+}
+
 var OrderedMap = /*@__PURE__*/(function (Map) {
   function OrderedMap(value) {
     // eslint-disable-next-line no-constructor-return
@@ -4440,23 +4429,45 @@ function emptyStack() {
   return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
 }
 
-var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';
-/**
- * True if `maybeSet` is a Set.
- *
- * Also true for OrderedSets.
- */
-function isSet(maybeSet) {
-    return Boolean(maybeSet &&
-        // @ts-expect-error: maybeSet is typed as `{}`,  need to change in 6.0 to `maybeSeq && typeof maybeSet === 'object' && MAYBE_SET_SYMBOL in maybeSet`
-        maybeSet[IS_SET_SYMBOL]);
+function reduce(collection, reducer, reduction, context, useFirst, reverse) {
+    // @ts-expect-error Migrate to CollectionImpl in v6
+    assertNotInfinite(collection.size);
+    // @ts-expect-error Migrate to CollectionImpl in v6
+    collection.__iterate(function (v, k, c) {
+        if (useFirst) {
+            useFirst = false;
+            reduction = v;
+        }
+        else {
+            reduction = reducer.call(context, reduction, v, k, c);
+        }
+    }, reverse);
+    return reduction;
 }
+function keyMapper(v, k) {
+    return k;
+}
+function entryMapper(v, k) {
+    return [k, v];
+}
+function not(predicate) {
+    return function () {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-/**
- * True if `maybeOrderedSet` is an OrderedSet.
- */
-function isOrderedSet(maybeOrderedSet) {
-    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
+        return !predicate.apply(this, args);
+    };
+}
+function neg(predicate) {
+    return function () {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        return -predicate.apply(this, args);
+    };
+}
+function defaultNegComparator(a, b) {
+    return a < b ? 1 : a > b ? -1 : 0;
 }
 
 function deepEqual(a, b) {
@@ -4529,44 +4540,154 @@ function deepEqual(a, b) {
 }
 
 /**
- * Contributes additional methods to a constructor
+ * Returns a lazy seq of nums from start (inclusive) to end
+ * (exclusive), by step, where start defaults to 0, step to 1, and end to
+ * infinity. When start is equal to end, returns empty list.
+ */
+var Range = /*@__PURE__*/(function (IndexedSeq) {
+  function Range(start, end, step) {
+    if ( step === void 0 ) step = 1;
+
+    if (!(this instanceof Range)) {
+      // eslint-disable-next-line no-constructor-return
+      return new Range(start, end, step);
+    }
+    invariant(step !== 0, 'Cannot step a Range by 0');
+    invariant(
+      start !== undefined,
+      'You must define a start value when using Range'
+    );
+    invariant(
+      end !== undefined,
+      'You must define an end value when using Range'
+    );
+
+    step = Math.abs(step);
+    if (end < start) {
+      step = -step;
+    }
+    this._start = start;
+    this._end = end;
+    this._step = step;
+    this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
+    if (this.size === 0) {
+      if (EMPTY_RANGE) {
+        // eslint-disable-next-line no-constructor-return
+        return EMPTY_RANGE;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      EMPTY_RANGE = this;
+    }
+  }
+
+  if ( IndexedSeq ) Range.__proto__ = IndexedSeq;
+  Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
+  Range.prototype.constructor = Range;
+
+  Range.prototype.toString = function toString () {
+    return this.size === 0
+      ? 'Range []'
+      : ("Range [ " + (this._start) + "..." + (this._end) + (this._step !== 1 ? ' by ' + this._step : '') + " ]");
+  };
+
+  Range.prototype.get = function get (index, notSetValue) {
+    return this.has(index)
+      ? this._start + wrapIndex(this, index) * this._step
+      : notSetValue;
+  };
+
+  Range.prototype.includes = function includes (searchValue) {
+    var possibleIndex = (searchValue - this._start) / this._step;
+    return (
+      possibleIndex >= 0 &&
+      possibleIndex < this.size &&
+      possibleIndex === Math.floor(possibleIndex)
+    );
+  };
+
+  Range.prototype.slice = function slice (begin, end) {
+    if (wholeSlice(begin, end, this.size)) {
+      return this;
+    }
+    begin = resolveBegin(begin, this.size);
+    end = resolveEnd(end, this.size);
+    if (end <= begin) {
+      return new Range(0, 0);
+    }
+    return new Range(
+      this.get(begin, this._end),
+      this.get(end, this._end),
+      this._step
+    );
+  };
+
+  Range.prototype.indexOf = function indexOf (searchValue) {
+    var offsetValue = searchValue - this._start;
+    if (offsetValue % this._step === 0) {
+      var index = offsetValue / this._step;
+      if (index >= 0 && index < this.size) {
+        return index;
+      }
+    }
+    return -1;
+  };
+
+  Range.prototype.lastIndexOf = function lastIndexOf (searchValue) {
+    return this.indexOf(searchValue);
+  };
+
+  Range.prototype.__iterate = function __iterate (fn, reverse) {
+    var size = this.size;
+    var step = this._step;
+    var value = reverse ? this._start + (size - 1) * step : this._start;
+    var i = 0;
+    while (i !== size) {
+      if (fn(value, reverse ? size - ++i : i++, this) === false) {
+        break;
+      }
+      value += reverse ? -step : step;
+    }
+    return i;
+  };
+
+  Range.prototype.__iterator = function __iterator (type, reverse) {
+    var size = this.size;
+    var step = this._step;
+    var value = reverse ? this._start + (size - 1) * step : this._start;
+    var i = 0;
+    return new Iterator(function () {
+      if (i === size) {
+        return iteratorDone();
+      }
+      var v = value;
+      value += reverse ? -step : step;
+      return iteratorValue(type, reverse ? size - ++i : i++, v);
+    });
+  };
+
+  Range.prototype.equals = function equals (other) {
+    return other instanceof Range
+      ? this._start === other._start &&
+          this._end === other._end &&
+          this._step === other._step
+      : deepEqual(this, other);
+  };
+
+  return Range;
+}(IndexedSeq));
+
+var EMPTY_RANGE;
+
+var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';
+/**
+ * True if `maybeSet` is a Set.
+ *
+ * Also true for OrderedSets.
  */
-function mixin(ctor, 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-methods) {
-    var keyCopier = function (key) {
-        // @ts-expect-error how to handle symbol ?
-        ctor.prototype[key] = methods[key];
-    };
-    Object.keys(methods).forEach(keyCopier);
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
-    Object.getOwnPropertySymbols &&
-        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
-    return ctor;
-}
-
-function toJS(value) {
-  if (!value || typeof value !== 'object') {
-    return value;
-  }
-  if (!isCollection(value)) {
-    if (!isDataStructure(value)) {
-      return value;
-    }
-    value = Seq(value);
-  }
-  if (isKeyed(value)) {
-    var result$1 = {};
-    value.__iterate(function (v, k) {
-      result$1[k] = toJS(v);
-    });
-    return result$1;
-  }
-  var result = [];
-  value.__iterate(function (v) {
-    result.push(toJS(v));
-  });
-  return result;
+function isSet(maybeSet) {
+    return Boolean(maybeSet &&
+        // @ts-expect-error: maybeSet is typed as `{}`,  need to change in 6.0 to `maybeSeq && typeof maybeSet === 'object' && MAYBE_SET_SYMBOL in maybeSet`
+        maybeSet[IS_SET_SYMBOL]);
 }
 
 var Set = /*@__PURE__*/(function (SetCollection) {
@@ -4811,145 +4932,6 @@ function emptySet() {
   return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
 }
 
-/**
- * Returns a lazy seq of nums from start (inclusive) to end
- * (exclusive), by step, where start defaults to 0, step to 1, and end to
- * infinity. When start is equal to end, returns empty list.
- */
-var Range = /*@__PURE__*/(function (IndexedSeq) {
-  function Range(start, end, step) {
-    if ( step === void 0 ) step = 1;
-
-    if (!(this instanceof Range)) {
-      // eslint-disable-next-line no-constructor-return
-      return new Range(start, end, step);
-    }
-    invariant(step !== 0, 'Cannot step a Range by 0');
-    invariant(
-      start !== undefined,
-      'You must define a start value when using Range'
-    );
-    invariant(
-      end !== undefined,
-      'You must define an end value when using Range'
-    );
-
-    step = Math.abs(step);
-    if (end < start) {
-      step = -step;
-    }
-    this._start = start;
-    this._end = end;
-    this._step = step;
-    this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
-    if (this.size === 0) {
-      if (EMPTY_RANGE) {
-        // eslint-disable-next-line no-constructor-return
-        return EMPTY_RANGE;
-      }
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      EMPTY_RANGE = this;
-    }
-  }
-
-  if ( IndexedSeq ) Range.__proto__ = IndexedSeq;
-  Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
-  Range.prototype.constructor = Range;
-
-  Range.prototype.toString = function toString () {
-    return this.size === 0
-      ? 'Range []'
-      : ("Range [ " + (this._start) + "..." + (this._end) + (this._step !== 1 ? ' by ' + this._step : '') + " ]");
-  };
-
-  Range.prototype.get = function get (index, notSetValue) {
-    return this.has(index)
-      ? this._start + wrapIndex(this, index) * this._step
-      : notSetValue;
-  };
-
-  Range.prototype.includes = function includes (searchValue) {
-    var possibleIndex = (searchValue - this._start) / this._step;
-    return (
-      possibleIndex >= 0 &&
-      possibleIndex < this.size &&
-      possibleIndex === Math.floor(possibleIndex)
-    );
-  };
-
-  Range.prototype.slice = function slice (begin, end) {
-    if (wholeSlice(begin, end, this.size)) {
-      return this;
-    }
-    begin = resolveBegin(begin, this.size);
-    end = resolveEnd(end, this.size);
-    if (end <= begin) {
-      return new Range(0, 0);
-    }
-    return new Range(
-      this.get(begin, this._end),
-      this.get(end, this._end),
-      this._step
-    );
-  };
-
-  Range.prototype.indexOf = function indexOf (searchValue) {
-    var offsetValue = searchValue - this._start;
-    if (offsetValue % this._step === 0) {
-      var index = offsetValue / this._step;
-      if (index >= 0 && index < this.size) {
-        return index;
-      }
-    }
-    return -1;
-  };
-
-  Range.prototype.lastIndexOf = function lastIndexOf (searchValue) {
-    return this.indexOf(searchValue);
-  };
-
-  Range.prototype.__iterate = function __iterate (fn, reverse) {
-    var size = this.size;
-    var step = this._step;
-    var value = reverse ? this._start + (size - 1) * step : this._start;
-    var i = 0;
-    while (i !== size) {
-      if (fn(value, reverse ? size - ++i : i++, this) === false) {
-        break;
-      }
-      value += reverse ? -step : step;
-    }
-    return i;
-  };
-
-  Range.prototype.__iterator = function __iterator (type, reverse) {
-    var size = this.size;
-    var step = this._step;
-    var value = reverse ? this._start + (size - 1) * step : this._start;
-    var i = 0;
-    return new Iterator(function () {
-      if (i === size) {
-        return iteratorDone();
-      }
-      var v = value;
-      value += reverse ? -step : step;
-      return iteratorValue(type, reverse ? size - ++i : i++, v);
-    });
-  };
-
-  Range.prototype.equals = function equals (other) {
-    return other instanceof Range
-      ? this._start === other._start &&
-          this._end === other._end &&
-          this._step === other._step
-      : deepEqual(this, other);
-  };
-
-  return Range;
-}(IndexedSeq));
-
-var EMPTY_RANGE;
-
 /**
  * Returns the value at the provided key path starting at the provided
  * collection, or notSetValue if the key path is not defined.
@@ -4997,6 +4979,91 @@ function toObject() {
   return object;
 }
 
+function toJS(value) {
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (!isCollection(value)) {
+        if (!isDataStructure(value)) {
+            return value;
+        }
+        // @ts-expect-error until Seq has been migrated to TypeScript
+        value = Seq(value);
+    }
+    if (isKeyed(value)) {
+        var result$1 = {};
+        // @ts-expect-error `__iterate` exists on all Keyed collections but method is not defined in the type
+        value.__iterate(function (v, k) {
+            result$1[k] = toJS(v);
+        });
+        return result$1;
+    }
+    var result = [];
+    // @ts-expect-error value "should" be a non-keyed collection, but we may need to assert for stricter types
+    value.__iterate(function (v) {
+        result.push(toJS(v));
+    });
+    return result;
+}
+
+function hashCollection(collection) {
+    // @ts-expect-error Migrate to CollectionImpl in v6
+    if (collection.size === Infinity) {
+        return 0;
+    }
+    var ordered = isOrdered(collection);
+    var keyed = isKeyed(collection);
+    var h = ordered ? 1 : 0;
+    // @ts-expect-error Migrate to CollectionImpl in v6
+    collection.__iterate(keyed
+        ? ordered
+            ? function (v, k) {
+                h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
+            }
+            : function (v, k) {
+                h = (h + hashMerge(hash(v), hash(k))) | 0;
+            }
+        : ordered
+            ? function (v) {
+                h = (31 * h + hash(v)) | 0;
+            }
+            : function (v) {
+                h = (h + hash(v)) | 0;
+            });
+    // @ts-expect-error Migrate to CollectionImpl in v6
+    return murmurHashOfSize(collection.size, h);
+}
+function murmurHashOfSize(size, h) {
+    h = imul(h, 0xcc9e2d51);
+    h = imul((h << 15) | (h >>> -15), 0x1b873593);
+    h = imul((h << 13) | (h >>> -13), 5);
+    h = ((h + 0xe6546b64) | 0) ^ size;
+    h = imul(h ^ (h >>> 16), 0x85ebca6b);
+    h = imul(h ^ (h >>> 13), 0xc2b2ae35);
+    h = smi(h ^ (h >>> 16));
+    return h;
+}
+function hashMerge(a, b) {
+    return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
+}
+
+/**
+ * Contributes additional methods to a constructor
+ */
+function mixin(ctor, 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+methods) {
+    var keyCopier = function (key) {
+        // @ts-expect-error how to handle symbol ?
+        ctor.prototype[key] = methods[key];
+    };
+    Object.keys(methods).forEach(keyCopier);
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
+    Object.getOwnPropertySymbols &&
+        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
+    return ctor;
+}
+
 Collection.Iterator = Iterator;
 
 mixin(Collection, {
@@ -5635,89 +5702,15 @@ mixin(SetSeq, SetCollectionPrototype);
 
 // #pragma Helper functions
 
-function reduce(collection, reducer, reduction, context, useFirst, reverse) {
-  assertNotInfinite(collection.size);
-  collection.__iterate(function (v, k, c) {
-    if (useFirst) {
-      useFirst = false;
-      reduction = v;
-    } else {
-      reduction = reducer.call(context, reduction, v, k, c);
-    }
-  }, reverse);
-  return reduction;
-}
-
-function keyMapper(v, k) {
-  return k;
-}
-
-function entryMapper(v, k) {
-  return [k, v];
-}
-
-function not(predicate) {
-  return function () {
-    return !predicate.apply(this, arguments);
-  };
-}
-
-function neg(predicate) {
-  return function () {
-    return -predicate.apply(this, arguments);
-  };
-}
-
 function defaultZipper() {
   return arrCopy(arguments);
 }
 
-function defaultNegComparator(a, b) {
-  return a < b ? 1 : a > b ? -1 : 0;
-}
-
-function hashCollection(collection) {
-  if (collection.size === Infinity) {
-    return 0;
-  }
-  var ordered = isOrdered(collection);
-  var keyed = isKeyed(collection);
-  var h = ordered ? 1 : 0;
-
-  collection.__iterate(
-    keyed
-      ? ordered
-        ? function (v, k) {
-            h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
-          }
-        : function (v, k) {
-            h = (h + hashMerge(hash(v), hash(k))) | 0;
-          }
-      : ordered
-        ? function (v) {
-            h = (31 * h + hash(v)) | 0;
-          }
-        : function (v) {
-            h = (h + hash(v)) | 0;
-          }
-  );
-
-  return murmurHashOfSize(collection.size, h);
-}
-
-function murmurHashOfSize(size, h) {
-  h = imul(h, 0xcc9e2d51);
-  h = imul((h << 15) | (h >>> -15), 0x1b873593);
-  h = imul((h << 13) | (h >>> -13), 5);
-  h = ((h + 0xe6546b64) | 0) ^ size;
-  h = imul(h ^ (h >>> 16), 0x85ebca6b);
-  h = imul(h ^ (h >>> 13), 0xc2b2ae35);
-  h = smi(h ^ (h >>> 16));
-  return h;
-}
-
-function hashMerge(a, b) {
-  return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
+/**
+ * True if `maybeOrderedSet` is an OrderedSet.
+ */
+function isOrderedSet(maybeOrderedSet) {
+    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
 }
 
 var OrderedSet = /*@__PURE__*/(function (Set) {
@@ -5779,9 +5772,12 @@ function emptyOrderedSet() {
   );
 }
 
+/**
+ * Describes which item in a pair should be placed first when sorting
+ */
 var PairSorting = {
-  LeftThenRight: -1,
-  RightThenLeft: 1,
+    LeftThenRight: -1,
+    RightThenLeft: 1,
 };
 
 function throwOnInvalidDefaultValues(defaultValues) {
@@ -5986,7 +5982,7 @@ RecordPrototype.mergeDeepWith = mergeDeepWith;
 RecordPrototype.mergeDeepIn = mergeDeepIn;
 RecordPrototype.setIn = setIn;
 RecordPrototype.update = update;
-RecordPrototype.updateIn = updateIn;
+RecordPrototype.updateIn = updateIn$1;
 RecordPrototype.withMutations = withMutations;
 RecordPrototype.asMutable = asMutable;
 RecordPrototype.asImmutable = asImmutable;
@@ -6174,9 +6170,11 @@ function defaultConverter(k, v) {
   return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
 }
 
-var version = "5.1.3";
+var version = "5.1.4";
+
+/* eslint-disable import/order */
 
 // Note: Iterable is deprecated
 var Iterable = Collection;
 
-export { Collection, Iterable, List, Map, OrderedMap, OrderedSet, PairSorting, Range, Record, Repeat, Seq, Set, Stack, fromJS, get, getIn$1 as getIn, has, hasIn$1 as hasIn, hash, is, isAssociative, isCollection, isImmutable, isIndexed, isKeyed, isList, isMap, isOrdered, isOrderedMap, isOrderedSet, isPlainObject, isRecord, isSeq, isSet, isStack, isValueObject, merge, mergeDeep$1 as mergeDeep, mergeDeepWith$1 as mergeDeepWith, mergeWith, remove, removeIn, set, setIn$1 as setIn, update$1 as update, updateIn$1 as updateIn, version };
+export { Collection, Iterable, List, Map, OrderedMap, OrderedSet, PairSorting, Range, Record, Repeat, Seq, Set, Stack, fromJS, get, getIn$1 as getIn, has, hasIn$1 as hasIn, hash, is, isAssociative, isCollection, isImmutable, isIndexed, isKeyed, isList, isMap, isOrdered, isOrderedMap, isOrderedSet, isPlainObject, isRecord, isSeq, isSet, isStack, isValueObject, merge, mergeDeep$1 as mergeDeep, mergeDeepWith$1 as mergeDeepWith, mergeWith, remove, removeIn, set, setIn$1 as setIn, update$1 as update, updateIn, version };