immutable 5.1.2 → 5.1.4

package/dist/immutable.js

@@ -28,105 +28,25 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Immutable = {}));
 })(this, (function (exports) { 'use strict';
 
-    // 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__@@';
@@ -149,27 +69,6 @@
             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.
      *
@@ -188,6 +87,27 @@
         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);
@@ -236,158 +156,236 @@
     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
@@ -751,119 +749,16 @@
           : 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
@@ -872,247 +767,238 @@
             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;
@@ -2128,283 +2014,102 @@
       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).
      *
-     * <!-- runkit:activate -->
-     * ```js
-     * import { has } from 'immutable';
+     * This is extended further to allow Objects to describe the values they
+     * represent, by way of `valueOf` or `equals` (and `hashCode`).
      *
-     * has([ 'dog', 'frog', 'cat' ], 2) // true
-     * has([ 'dog', 'frog', 'cat' ], 5) // false
-     * has({ x: 123, y: 456 }, 'x') // true
-     * has({ x: 123, y: 456 }, 'z') // false
-     * ```
-     */
-    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];
-            }
-        }
-        return to;
-    }
-
-    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$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.
+     * 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.
      *
-     * A functional alternative to `collection.setIn(keypath)` which will also
-     * work with plain Objects and Arrays.
+     * ### Defining custom values
      *
-     * <!-- runkit:activate -->
-     * ```js
-     * import { setIn } from 'immutable';
+     * 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`:
      *
-     * const original = { x: { y: { z: 123 }}}
-     * setIn(original, ['x', 'y', 'z'], 456) // { x: { y: { z: 456 }}}
-     * console.log(original) // { x: { y: { z: 123 }}}
-     * ```
-     */
-    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.
+     *     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 ) );
      *
-     * A functional alternative to `collection.removeIn(keypath)` which will also
-     * work with plain Objects and Arrays.
+     * Note: overriding `valueOf` may have other implications if you use this object
+     * where JavaScript expects a primitive, such as implicit string coercion.
      *
-     * <!-- runkit:activate -->
-     * ```js
-     * import { removeIn } from 'immutable';
+     * For more complex types, especially collections, implementing `valueOf` may
+     * not be performant. An alternative is to implement `equals` and `hashCode`.
      *
-     * const original = { x: { y: { z: 123 }}}
-     * removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}}
-     * console.log(original) // { x: { y: { z: 123 }}}
-     * ```
+     * `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 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);
+    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 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() {
@@ -2459,6 +2164,62 @@
       });
     }
 
+    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 ];
@@ -2576,19 +2337,48 @@
       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) {
@@ -2597,16 +2387,25 @@
       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) {
@@ -2743,7 +2542,7 @@
     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;
@@ -3345,45 +3144,200 @@
       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__@@';
     /**
@@ -3644,7 +3598,7 @@
     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;
@@ -4076,6 +4030,13 @@
       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
@@ -4474,23 +4435,45 @@
       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) {
@@ -4563,44 +4546,154 @@
     }
 
     /**
-     * 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.
      */
-    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;
-    }
+    var Range = /*@__PURE__*/(function (IndexedSeq) {
+      function Range(start, end, step) {
+        if ( step === void 0 ) step = 1;
 
-    function toJS(value) {
-      if (!value || typeof value !== 'object') {
-        return value;
-      }
-      if (!isCollection(value)) {
-        if (!isDataStructure(value)) {
-          return value;
+        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;
         }
-        value = Seq(value);
       }
-      if (isKeyed(value)) {
-        var result$1 = {};
-        value.__iterate(function (v, k) {
-          result$1[k] = toJS(v);
+
+      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);
         });
-        return result$1;
-      }
-      var result = [];
-      value.__iterate(function (v) {
-        result.push(toJS(v));
-      });
-      return result;
+      };
+
+      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 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) {
@@ -4845,159 +4938,12 @@
       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.
      *
      * A functional alternative to `collection.getIn(keypath)` which will also
      * work with plain Objects and Arrays.
-     *
-     * <!-- runkit:activate -->
-     * ```js
-     * import { getIn } from 'immutable';
-     *
-     * getIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // 123
-     * getIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p'], 'ifNotSet') // 'ifNotSet'
-     * ```
      */
     function getIn$1(collection, searchKeyPath, notSetValue) {
         var keyPath = coerceKeyPath(searchKeyPath);
@@ -5021,14 +4967,6 @@
      *
      * A functional alternative to `collection.hasIn(keypath)` which will also
      * work with plain Objects and Arrays.
-     *
-     * <!-- runkit:activate -->
-     * ```js
-     * import { hasIn } from 'immutable';
-     *
-     * hasIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // true
-     * hasIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p']) // false
-     * ```
      */
     function hasIn$1(collection, keyPath) {
         return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;
@@ -5047,6 +4985,91 @@
       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, {
@@ -5685,89 +5708,15 @@
 
     // #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) {
@@ -5829,9 +5778,12 @@
       );
     }
 
+    /**
+     * 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) {
@@ -6036,7 +5988,7 @@
     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;
@@ -6224,7 +6176,9 @@
       return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
     }
 
-    var version = "5.1.2";
+    var version = "5.1.4";
+
+    /* eslint-disable import/order */
 
     // Note: Iterable is deprecated
     var Iterable = Collection;
@@ -6274,7 +6228,7 @@
     exports.set = set;
     exports.setIn = setIn$1;
     exports.update = update$1;
-    exports.updateIn = updateIn$1;
+    exports.updateIn = updateIn;
     exports.version = version;
 
 }));