immutable 5.0.3 → 5.1.1

package/dist/immutable.es.js

@@ -24,117 +24,162 @@
  */
 // 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 };
+    return { value: false };
 }
-
 function SetRef(ref) {
-  if (ref) {
-    ref.value = true;
-  }
+    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 OwnerID() { }
 function ensureSize(iter) {
-  if (iter.size === undefined) {
-    iter.size = iter.__iterate(returnTrue);
-  }
-  return iter.size;
+    // @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;
+    // 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;
     }
-    index = uint32Index;
-  }
-  return index < 0 ? ensureSize(iter) + index : index;
+    return index < 0 ? ensureSize(iter) + index : index;
 }
-
 function returnTrue() {
-  return true;
+    return true;
 }
-
 function wholeSlice(begin, end, size) {
-  return (
-    ((begin === 0 && !isNeg(begin)) ||
-      (size !== undefined && begin <= -size)) &&
-    (end === undefined || (size !== undefined && 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);
+    return resolveIndex(begin, size, 0);
 }
-
 function resolveEnd(end, size) {
-  return resolveIndex(end, size, 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;
+    // 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);
+    // 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__@@';
-
+/**
+ * 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 && maybeCollection[IS_COLLECTION_SYMBOL]);
+    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 IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';
-
+/**
+ * True if `maybeKeyed` is a Collection.Keyed, or any of its subclasses.
+ *
+ * ```js
+ * import { isKeyed, Map, List, Stack } from 'immutable';
+ *
+ * isKeyed([]); // false
+ * isKeyed({}); // false
+ * isKeyed(Map()); // true
+ * isKeyed(List()); // false
+ * isKeyed(Stack()); // false
+ * ```
+ */
 function isKeyed(maybeKeyed) {
-  return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);
+    return Boolean(maybeKeyed &&
+        // @ts-expect-error: maybeKeyed is typed as `{}`, need to change in 6.0 to `maybeKeyed && typeof maybeKeyed === 'object' && IS_KEYED_SYMBOL in maybeKeyed`
+        maybeKeyed[IS_KEYED_SYMBOL]);
 }
 
 var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';
-
+/**
+ * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses.
+ *
+ * ```js
+ * import { isIndexed, Map, List, Stack, Set } from 'immutable';
+ *
+ * isIndexed([]); // false
+ * isIndexed({}); // false
+ * isIndexed(Map()); // false
+ * isIndexed(List()); // true
+ * isIndexed(Stack()); // true
+ * isIndexed(Set()); // false
+ * ```
+ */
 function isIndexed(maybeIndexed) {
-  return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);
+    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.
+ *
+ * ```js
+ * import { isAssociative, Map, List, Stack, Set } from 'immutable';
+ *
+ * isAssociative([]); // false
+ * isAssociative({}); // false
+ * isAssociative(Map()); // true
+ * isAssociative(List()); // true
+ * isAssociative(Stack()); // true
+ * isAssociative(Set()); // false
+ * ```
+ */
 function isAssociative(maybeAssociative) {
-  return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
+    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
 }
 
 var Collection = function Collection(value) {
@@ -186,25 +231,49 @@ Collection.Indexed = IndexedCollection;
 Collection.Set = SetCollection;
 
 var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';
-
+/**
+ * True if `maybeSeq` is a Seq.
+ */
 function isSeq(maybeSeq) {
-  return Boolean(maybeSeq && maybeSeq[IS_SEQ_SYMBOL]);
+    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 && maybeRecord[IS_RECORD_SYMBOL]);
+    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);
+    return isCollection(maybeImmutable) || isRecord(maybeImmutable);
 }
 
 var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';
-
 function isOrdered(maybeOrdered) {
-  return Boolean(maybeOrdered && maybeOrdered[IS_ORDERED_SYMBOL]);
+    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;
@@ -236,7 +305,9 @@ Iterator.prototype[ITERATOR_SYMBOL] = function () {
 };
 
 function iteratorValue(type, k, v, iteratorResult) {
-  var value = type === 0 ? k : type === 1 ? v : [k, v];
+  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 = {
@@ -291,22 +362,24 @@ function isKeysIterable(maybeIterable) {
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
 function isArrayLike(value) {
-  if (Array.isArray(value) || typeof value === 'string') {
-    return true;
-  }
-
-  return (
-    value &&
-    typeof value === 'object' &&
-    Number.isInteger(value.length) &&
-    value.length >= 0 &&
-    (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).
-        value.hasOwnProperty(value.length - 1))
-  );
+    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) {
@@ -315,8 +388,8 @@ var Seq = /*@__PURE__*/(function (Collection) {
     return value === undefined || value === null
       ? emptySequence()
       : isImmutable(value)
-      ? value.toSeq()
-      : seqFromValue(value);
+        ? value.toSeq()
+        : seqFromValue(value);
   }
 
   if ( Collection ) Seq.__proto__ = Collection;
@@ -384,12 +457,12 @@ var KeyedSeq = /*@__PURE__*/(function (Seq) {
     return value === undefined || value === null
       ? emptySequence().toKeyedSeq()
       : isCollection(value)
-      ? isKeyed(value)
-        ? value.toSeq()
-        : value.fromEntrySeq()
-      : isRecord(value)
-      ? value.toSeq()
-      : keyedSeqFromValue(value);
+        ? isKeyed(value)
+          ? value.toSeq()
+          : value.fromEntrySeq()
+        : isRecord(value)
+          ? value.toSeq()
+          : keyedSeqFromValue(value);
   }
 
   if ( Seq ) KeyedSeq.__proto__ = Seq;
@@ -409,12 +482,12 @@ var IndexedSeq = /*@__PURE__*/(function (Seq) {
     return value === undefined || value === null
       ? emptySequence()
       : isCollection(value)
-      ? isKeyed(value)
-        ? value.entrySeq()
-        : value.toIndexedSeq()
-      : isRecord(value)
-      ? value.toSeq().entrySeq()
-      : indexedSeqFromValue(value);
+        ? isKeyed(value)
+          ? value.entrySeq()
+          : value.toIndexedSeq()
+        : isRecord(value)
+          ? value.toSeq().entrySeq()
+          : indexedSeqFromValue(value);
   }
 
   if ( Seq ) IndexedSeq.__proto__ = Seq;
@@ -653,8 +726,8 @@ function seqFromValue(value) {
     return isEntriesIterable(value)
       ? seq.fromEntrySeq()
       : isKeysIterable(value)
-      ? seq.toSetSeq()
-      : seq;
+        ? seq.toSetSeq()
+        : seq;
   }
   if (typeof value === 'object') {
     return new ObjectSeq(value);
@@ -668,26 +741,42 @@ function maybeIndexedSeqFromValue(value) {
   return isArrayLike(value)
     ? new ArraySeq(value)
     : hasIterator(value)
-    ? new CollectionSeq(value)
-    : undefined;
+      ? new CollectionSeq(value)
+      : undefined;
 }
 
 var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';
-
+/**
+ * True if `maybeMap` is a Map.
+ *
+ * Also true for OrderedMaps.
+ */
 function isMap(maybeMap) {
-  return Boolean(maybeMap && maybeMap[IS_MAP_SYMBOL]);
+    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);
+    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 &&
-      typeof maybeValue.equals === 'function' &&
-      typeof maybeValue.hashCode === 'function'
-  );
+    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');
 }
 
 /**
@@ -745,30 +834,26 @@ function isValueObject(maybeValue) {
  * 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;
+        return true;
     }
     if (!valueA || !valueB) {
-      return false;
+        return false;
     }
-  }
-  return !!(
-    isValueObject(valueA) &&
-    isValueObject(valueB) &&
-    valueA.equals(valueB)
-  );
+    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));
 }
 
 var imul =
@@ -794,6 +879,7 @@ function smi(i32) {
 var defaultValueOf = Object.prototype.valueOf;
 
 function hash(o) {
+  // eslint-disable-next-line eqeqeq
   if (o == null) {
     return hashNullish(o);
   }
@@ -805,6 +891,7 @@ function hash(o) {
 
   var v = valueOf(o);
 
+  // eslint-disable-next-line eqeqeq
   if (v == null) {
     return hashNullish(v);
   }
@@ -971,6 +1058,7 @@ var canDefineProperty = (function () {
   try {
     Object.defineProperty({}, '@', {});
     return true;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (e) {
     return false;
   }
@@ -1099,6 +1187,7 @@ var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {
     var this$1$1 = this;
 
     var i = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     reverse && ensureSize(this);
     return this._iter.__iterate(
       function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); },
@@ -1111,6 +1200,7 @@ var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {
 
     var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
     var i = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     reverse && ensureSize(this);
     return new Iterator(function () {
       var step = iterator.next();
@@ -1326,6 +1416,7 @@ function reverseFactory(collection, useKeys) {
     var this$1$1 = this;
 
     var i = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     reverse && ensureSize(collection);
     return collection.__iterate(
       function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); },
@@ -1334,6 +1425,7 @@ function reverseFactory(collection, useKeys) {
   };
   reversedSequence.__iterator = function (type, reverse) {
     var i = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     reverse && ensureSize(collection);
     var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse);
     return new Iterator(function () {
@@ -1620,6 +1712,7 @@ function skipWhileFactory(collection, predicate, context, useKeys) {
         var entry = step.value;
         k = entry[0];
         v = entry[1];
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
         skipping && (skipping = predicate.call(context, v, k, this$1$1));
       } while (skipping);
       return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
@@ -1628,6 +1721,108 @@ function skipWhileFactory(collection, predicate, context, useKeys) {
   return skipSequence;
 }
 
+var ConcatSeq = /*@__PURE__*/(function (Seq) {
+  function ConcatSeq(iterables) {
+    this._wrappedIterables = iterables.flatMap(function (iterable) {
+      if (iterable._wrappedIterables) {
+        return iterable._wrappedIterables;
+      }
+      return [iterable];
+    });
+    this.size = this._wrappedIterables.reduce(function (sum, iterable) {
+      if (sum !== undefined) {
+        var size = iterable.size;
+        if (size !== undefined) {
+          return sum + size;
+        }
+      }
+    }, 0);
+    this[IS_KEYED_SYMBOL] = this._wrappedIterables[0][IS_KEYED_SYMBOL];
+    this[IS_INDEXED_SYMBOL] = this._wrappedIterables[0][IS_INDEXED_SYMBOL];
+    this[IS_ORDERED_SYMBOL] = this._wrappedIterables[0][IS_ORDERED_SYMBOL];
+  }
+
+  if ( Seq ) ConcatSeq.__proto__ = Seq;
+  ConcatSeq.prototype = Object.create( Seq && Seq.prototype );
+  ConcatSeq.prototype.constructor = ConcatSeq;
+
+  ConcatSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {
+    if (this._wrappedIterables.length === 0) {
+      return;
+    }
+
+    if (reverse) {
+      return this.cacheResult().__iterate(fn, reverse);
+    }
+
+    var iterableIndex = 0;
+    var useKeys = isKeyed(this);
+    var iteratorType = useKeys ? ITERATE_ENTRIES : ITERATE_VALUES;
+    var currentIterator = this._wrappedIterables[iterableIndex].__iterator(
+      iteratorType,
+      reverse
+    );
+
+    var keepGoing = true;
+    var index = 0;
+    while (keepGoing) {
+      var next = currentIterator.next();
+      while (next.done) {
+        iterableIndex++;
+        if (iterableIndex === this._wrappedIterables.length) {
+          return index;
+        }
+        currentIterator = this._wrappedIterables[iterableIndex].__iterator(
+          iteratorType,
+          reverse
+        );
+        next = currentIterator.next();
+      }
+      var fnResult = useKeys
+        ? fn(next.value[1], next.value[0], this)
+        : fn(next.value, index, this);
+      keepGoing = fnResult !== false;
+      index++;
+    }
+    return index;
+  };
+
+  ConcatSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) {
+    var this$1$1 = this;
+
+    if (this._wrappedIterables.length === 0) {
+      return new Iterator(iteratorDone);
+    }
+
+    if (reverse) {
+      return this.cacheResult().__iterator(type, reverse);
+    }
+
+    var iterableIndex = 0;
+    var currentIterator = this._wrappedIterables[iterableIndex].__iterator(
+      type,
+      reverse
+    );
+    return new Iterator(function () {
+      var next = currentIterator.next();
+      while (next.done) {
+        iterableIndex++;
+        if (iterableIndex === this$1$1._wrappedIterables.length) {
+          return next;
+        }
+        currentIterator = this$1$1._wrappedIterables[iterableIndex].__iterator(
+          type,
+          reverse
+        );
+        next = currentIterator.next();
+      }
+      return next;
+    });
+  };
+
+  return ConcatSeq;
+}(Seq));
+
 function concatFactory(collection, values) {
   var isKeyedCollection = isKeyed(collection);
   var iters = [collection]
@@ -1659,22 +1854,7 @@ function concatFactory(collection, values) {
     }
   }
 
-  var concatSeq = new ArraySeq(iters);
-  if (isKeyedCollection) {
-    concatSeq = concatSeq.toKeyedSeq();
-  } else if (!isIndexed(collection)) {
-    concatSeq = concatSeq.toSetSeq();
-  }
-  concatSeq = concatSeq.flatten(true);
-  concatSeq.size = iters.reduce(function (sum, seq) {
-    if (sum !== undefined) {
-      var size = seq.size;
-      if (size !== undefined) {
-        return sum + size;
-      }
-    }
-  }, 0);
-  return concatSeq;
+  return new ConcatSeq(iters);
 }
 
 function flattenFactory(collection, depth, useKeys) {
@@ -1798,8 +1978,8 @@ function sortFactory(collection, comparator, mapper) {
   return isKeyedCollection
     ? KeyedSeq(entries)
     : isIndexed(collection)
-    ? IndexedSeq(entries)
-    : SetSeq(entries);
+      ? IndexedSeq(entries)
+      : SetSeq(entries);
 }
 
 function maxFactory(collection, comparator, mapper) {
@@ -1866,7 +2046,9 @@ function zipWithFactory(keyIter, zipper, iters, zipAll) {
       var steps;
       if (!isDone) {
         steps = iterators.map(function (i) { return i.next(); });
-        isDone = zipAll ? steps.every(function (s) { return s.done; }) : steps.some(function (s) { return s.done; });
+        isDone = zipAll
+          ? steps.every(function (s) { return s.done; })
+          : steps.some(function (s) { return s.done; });
       }
       if (isDone) {
         return iteratorDone();
@@ -1900,8 +2082,8 @@ function collectionClass(collection) {
   return isKeyed(collection)
     ? KeyedCollection
     : isIndexed(collection)
-    ? IndexedCollection
-    : SetCollection;
+      ? IndexedCollection
+      : SetCollection;
 }
 
 function makeSequence(collection) {
@@ -1909,8 +2091,8 @@ function makeSequence(collection) {
     (isKeyed(collection)
       ? KeyedSeq
       : isIndexed(collection)
-      ? IndexedSeq
-      : SetSeq
+        ? IndexedSeq
+        : SetSeq
     ).prototype
   );
 }
@@ -1942,63 +2124,55 @@ function defaultComparator(a, b) {
 
 // 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++) {
-    newArr[ii] = arr[ii + offset];
-  }
-  return newArr;
+    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); }
+    if (!condition)
+        { throw new Error(error); }
 }
 
 function assertNotInfinite(size) {
-  invariant(
-    size !== Infinity,
-    'Cannot perform this action with an infinite 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
-  );
+    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;
+    // 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;
 }
 
 /**
@@ -2006,169 +2180,206 @@ function isPlainObject(value) {
  * provided by Immutable.js or a plain Array or Object.
  */
 function isDataStructure(value) {
-  return (
-    typeof value === 'object' &&
-    (isImmutable(value) || Array.isArray(value) || isPlainObject(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.
  */
 function quoteString(value) {
-  try {
-    return typeof value === 'string' ? JSON.stringify(value) : String(value);
-  } catch (_ignoreError) {
-    return JSON.stringify(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)`.
+ *
+ * <!-- runkit:activate -->
+ * ```js
+ * import { has } from 'immutable';
+ *
+ * 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)
-    ? collection.has(key)
-    : isDataStructure(collection) && hasOwnProperty.call(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
-    : typeof collection.get === 'function'
-    ? collection.get(key)
-    : collection[key];
+    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];
+    if (Array.isArray(from)) {
+        return arrCopy(from);
     }
-  }
-  return to;
+    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)) {
-    if (!collection.remove) {
-      throw new TypeError(
-        'Cannot update immutable value without .remove() method: ' + collection
-      );
+    if (!isDataStructure(collection)) {
+        throw new TypeError('Cannot update non-data-structure value: ' + collection);
     }
-    return collection.remove(key);
-  }
-  if (!hasOwnProperty.call(collection, key)) {
-    return collection;
-  }
-  var collectionCopy = shallowCopy(collection);
-  if (Array.isArray(collectionCopy)) {
-    collectionCopy.splice(key, 1);
-  } else {
-    delete collectionCopy[key];
-  }
-  return collectionCopy;
+    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);
+    }
+    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 {
+        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)) {
-    if (!collection.set) {
-      throw new TypeError(
-        'Cannot update immutable value without .set() method: ' + collection
-      );
+    if (!isDataStructure(collection)) {
+        throw new TypeError('Cannot update non-data-structure value: ' + collection);
     }
-    return collection.set(key, value);
-  }
-  if (hasOwnProperty.call(collection, key) && value === collection[key]) {
-    return collection;
-  }
-  var collectionCopy = shallowCopy(collection);
-  collectionCopy[key] = value;
-  return collectionCopy;
+    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) {
-    updater = notSetValue;
-    notSetValue = undefined;
-  }
-  var updatedValue = updateInDeeply(
-    isImmutable(collection),
-    collection,
-    coerceKeyPath(keyPath),
-    0,
-    notSetValue,
-    updater
-  );
-  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;
-    var newValue = updater(existingValue);
-    return newValue === existingValue ? existing : newValue;
-  }
-  if (!wasNotSet && !isDataStructure(existing)) {
-    throw new TypeError(
-      'Cannot update within non-data-structure value in path [' +
-        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),
-    nextExisting,
-    keyPath,
-    i + 1,
-    notSetValue,
-    updater
-  );
-  return nextUpdated === nextExisting
-    ? existing
-    : nextUpdated === NOT_SET
-    ? remove(existing, key)
-    : set(
-        wasNotSet ? (inImmutable ? emptyMap() : {}) : existing,
-        key,
-        nextUpdated
-      );
+    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];
+    if (typeof key === 'undefined') {
+        throw new TypeError('Index can not be undefined in updateIn(). This should not happen');
+    }
+    var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
+    var nextUpdated = updateInDeeply(nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting), 
+    // @ts-expect-error mixed type
+    nextExisting, keyPath, i + 1, notSetValue, updater);
+    return nextUpdated === nextExisting
+        ? existing
+        : nextUpdated === NOT_SET
+            ? remove(existing, key)
+            : set(wasNotSet ? (inImmutable ? emptyMap() : {}) : existing, key, nextUpdated);
 }
 
+/**
+ * Returns a copy of the collection with the value at the key path set to the
+ * provided value.
+ *
+ * A functional alternative to `collection.setIn(keypath)` which will also
+ * work with plain Objects and Arrays.
+ *
+ * <!-- runkit:activate -->
+ * ```js
+ * import { setIn } from 'immutable';
+ *
+ * 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; });
+    return updateIn$1(collection, keyPath, NOT_SET, function () { return value; });
 }
 
 function setIn(keyPath, v) {
   return setIn$1(this, keyPath, v);
 }
 
+/**
+ * Returns a copy of the collection with the value at the key path removed.
+ *
+ * A functional alternative to `collection.removeIn(keypath)` which will also
+ * work with plain Objects and Arrays.
+ *
+ * <!-- runkit:activate -->
+ * ```js
+ * import { removeIn } from 'immutable';
+ *
+ * const original = { x: { y: { z: 123 }}}
+ * removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}}
+ * console.log(original) // { x: { y: { z: 123 }}}
+ * ```
+ */
 function removeIn(collection, keyPath) {
-  return updateIn$1(collection, keyPath, function () { return NOT_SET; });
+    return updateIn$1(collection, keyPath, function () { return NOT_SET; });
 }
 
 function deleteIn(keyPath) {
@@ -2176,7 +2387,9 @@ function deleteIn(keyPath) {
 }
 
 function update$1(collection, key, notSetValue, updater) {
-  return updateIn$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) {
@@ -2281,8 +2494,8 @@ function mergeWithSources(collection, sources, merger) {
     return typeof merger === 'function' && collection.mergeWith
       ? collection.mergeWith.apply(collection, [ merger ].concat( sources ))
       : collection.merge
-      ? collection.merge.apply(collection, sources)
-      : collection.concat.apply(collection, sources);
+        ? collection.merge.apply(collection, sources)
+        : collection.concat.apply(collection, sources);
   }
   var isArray = Array.isArray(collection);
   var merged = collection;
@@ -2320,8 +2533,8 @@ function deepMergerWith(merger) {
       areMergeable(oldValue, newValue)
       ? mergeWithSources(oldValue, [newValue], deepMerger)
       : merger
-      ? merger(oldValue, newValue, key)
-      : newValue;
+        ? merger(oldValue, newValue, key)
+        : newValue;
   }
   return deepMerger;
 }
@@ -2395,12 +2608,12 @@ var Map = /*@__PURE__*/(function (KeyedCollection) {
     return value === undefined || value === null
       ? emptyMap()
       : isMap(value) && !isOrdered(value)
-      ? value
-      : emptyMap().withMutations(function (map) {
-          var iter = KeyedCollection(value);
-          assertNotInfinite(iter.size);
-          iter.forEach(function (v, k) { return map.set(k, v); });
-        });
+        ? value
+        : emptyMap().withMutations(function (map) {
+            var iter = KeyedCollection(value);
+            assertNotInfinite(iter.size);
+            iter.forEach(function (v, k) { return map.set(k, v); });
+          });
   }
 
   if ( KeyedCollection ) Map.__proto__ = KeyedCollection;
@@ -2487,6 +2700,7 @@ var Map = /*@__PURE__*/(function (KeyedCollection) {
     var this$1$1 = this;
 
     var iterations = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     this._root &&
       this._root.iterate(function (entry) {
         iterations++;
@@ -2575,6 +2789,7 @@ ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, v
   }
 
   SetRef(didAlter);
+  // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
   (removed || !exists) && SetRef(didChangeSize);
 
   if (removed && entries.length === 1) {
@@ -2590,6 +2805,7 @@ ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, v
 
   if (exists) {
     if (removed) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
       idx === len - 1
         ? newEntries.pop()
         : (newEntries[idx] = newEntries.pop());
@@ -2808,6 +3024,7 @@ HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, k
   }
 
   SetRef(didAlter);
+  // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
   (removed || !exists) && SetRef(didChangeSize);
 
   if (removed && len === 2) {
@@ -2819,6 +3036,7 @@ HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, k
 
   if (exists) {
     if (removed) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
       idx === len - 1
         ? newEntries.pop()
         : (newEntries[idx] = newEntries.pop());
@@ -3161,9 +3379,13 @@ var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
 var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
 
 var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';
-
+/**
+ * True if `maybeList` is a List.
+ */
 function isList(maybeList) {
-  return Boolean(maybeList && maybeList[IS_LIST_SYMBOL]);
+    return Boolean(maybeList &&
+        // @ts-expect-error: maybeList is typed as `{}`, need to change in 6.0 to `maybeList && typeof maybeList === 'object' && IS_LIST_SYMBOL in maybeList`
+        maybeList[IS_LIST_SYMBOL]);
 }
 
 var List = /*@__PURE__*/(function (IndexedCollection) {
@@ -3229,10 +3451,10 @@ var List = /*@__PURE__*/(function (IndexedCollection) {
     return !this.has(index)
       ? this
       : index === 0
-      ? this.shift()
-      : index === this.size - 1
-      ? this.pop()
-      : this.splice(index, 1);
+        ? this.shift()
+        : index === this.size - 1
+          ? this.pop()
+          : this.splice(index, 1);
   };
 
   List.prototype.insert = function insert (index, value) {
@@ -3282,6 +3504,25 @@ var List = /*@__PURE__*/(function (IndexedCollection) {
     return setListBounds(this, 1);
   };
 
+  List.prototype.shuffle = function shuffle (random) {
+    if ( random === void 0 ) random = Math.random;
+
+    return this.withMutations(function (mutable) {
+      // implementation of the Fisher-Yates shuffle: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
+      var current = mutable.size;
+      var destination;
+      var tmp;
+
+      while (current) {
+        destination = Math.floor(random() * current--);
+
+        tmp = mutable.get(destination);
+        mutable.set(destination, mutable.get(current));
+        mutable.set(current, tmp);
+      }
+    });
+  };
+
   // @pragma Composition
 
   List.prototype.concat = function concat (/*...collections*/) {
@@ -3573,6 +3814,7 @@ function updateList(list, index, value) {
 
   if (index >= list.size || index < 0) {
     return list.withMutations(function (list) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
       index < 0
         ? setListBounds(list, index).set(0, value)
         : setListBounds(list, 0, index + 1).set(index, value);
@@ -3694,8 +3936,8 @@ function setListBounds(list, begin, end) {
     end === undefined
       ? oldCapacity
       : end < 0
-      ? oldCapacity + end
-      : oldOrigin + end;
+        ? oldCapacity + end
+        : oldOrigin + end;
   if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
     return list;
   }
@@ -3743,8 +3985,8 @@ function setListBounds(list, begin, end) {
     newTailOffset < oldTailOffset
       ? listNodeFor(list, newCapacity - 1)
       : newTailOffset > oldTailOffset
-      ? new VNode([], owner)
-      : oldTail;
+        ? new VNode([], owner)
+        : oldTail;
 
   // Merge Tail into tree.
   if (
@@ -3833,12 +4075,12 @@ var OrderedMap = /*@__PURE__*/(function (Map) {
     return value === undefined || value === null
       ? emptyOrderedMap()
       : isOrderedMap(value)
-      ? value
-      : emptyOrderedMap().withMutations(function (map) {
-          var iter = KeyedCollection(value);
-          assertNotInfinite(iter.size);
-          iter.forEach(function (v, k) { return map.set(k, v); });
-        });
+        ? value
+        : emptyOrderedMap().withMutations(function (map) {
+            var iter = KeyedCollection(value);
+            assertNotInfinite(iter.size);
+            iter.forEach(function (v, k) { return map.set(k, v); });
+          });
   }
 
   if ( Map ) OrderedMap.__proto__ = Map;
@@ -3991,9 +4233,13 @@ function updateOrderedMap(omap, k, v) {
 }
 
 var IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@';
-
+/**
+ * True if `maybeStack` is a Stack.
+ */
 function isStack(maybeStack) {
-  return Boolean(maybeStack && maybeStack[IS_STACK_SYMBOL]);
+    return Boolean(maybeStack &&
+        // @ts-expect-error: maybeStack is typed as `{}`, need to change in 6.0 to `maybeStack && typeof maybeStack === 'object' && MAYBE_STACK_SYMBOL in maybeStack`
+        maybeStack[IS_STACK_SYMBOL]);
 }
 
 var Stack = /*@__PURE__*/(function (IndexedCollection) {
@@ -4002,8 +4248,8 @@ var Stack = /*@__PURE__*/(function (IndexedCollection) {
     return value === undefined || value === null
       ? emptyStack()
       : isStack(value)
-      ? value
-      : emptyStack().pushAll(value);
+        ? value
+        : emptyStack().pushAll(value);
   }
 
   if ( IndexedCollection ) Stack.__proto__ = IndexedCollection;
@@ -4222,92 +4468,108 @@ function emptyStack() {
 }
 
 var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';
-
+/**
+ * True if `maybeSet` is a Set.
+ *
+ * Also true for OrderedSets.
+ */
 function isSet(maybeSet) {
-  return Boolean(maybeSet && maybeSet[IS_SET_SYMBOL]);
+    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]);
 }
 
+/**
+ * True if `maybeOrderedSet` is an OrderedSet.
+ */
 function isOrderedSet(maybeOrderedSet) {
-  return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
+    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
 }
 
 function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-
-  if (
-    !isCollection(b) ||
-    (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
-    (a.__hash !== undefined &&
-      b.__hash !== undefined &&
-      a.__hash !== b.__hash) ||
-    isKeyed(a) !== isKeyed(b) ||
-    isIndexed(a) !== isIndexed(b) ||
-    isOrdered(a) !== isOrdered(b)
-  ) {
-    return false;
-  }
-
-  if (a.size === 0 && b.size === 0) {
-    return true;
-  }
-
-  var notAssociative = !isAssociative(a);
-
-  if (isOrdered(a)) {
-    var entries = a.entries();
-    return (
-      b.every(function (v, k) {
-        var entry = entries.next().value;
-        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
-      }) && entries.next().done
-    );
-  }
-
-  var flipped = false;
-
-  if (a.size === undefined) {
-    if (b.size === undefined) {
-      if (typeof a.cacheResult === 'function') {
-        a.cacheResult();
-      }
-    } else {
-      flipped = true;
-      var _ = a;
-      a = b;
-      b = _;
+    if (a === b) {
+        return true;
+    }
+    if (!isCollection(b) ||
+        // @ts-expect-error size should exists on Collection
+        (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
+        // @ts-expect-error __hash exists on Collection
+        (a.__hash !== undefined &&
+            // @ts-expect-error __hash exists on Collection
+            b.__hash !== undefined &&
+            // @ts-expect-error __hash exists on Collection
+            a.__hash !== b.__hash) ||
+        isKeyed(a) !== isKeyed(b) ||
+        isIndexed(a) !== isIndexed(b) ||
+        // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid
+        isOrdered(a) !== isOrdered(b)) {
+        return false;
     }
-  }
-
-  var allEqual = true;
-  var bSize = b.__iterate(function (v, k) {
-    if (
-      notAssociative
-        ? !a.has(v)
-        : flipped
-        ? !is(v, a.get(k, NOT_SET))
-        : !is(a.get(k, NOT_SET), v)
-    ) {
-      allEqual = false;
-      return false;
+    // @ts-expect-error size should exists on Collection
+    if (a.size === 0 && b.size === 0) {
+        return true;
+    }
+    var notAssociative = !isAssociative(a);
+    // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid
+    if (isOrdered(a)) {
+        var entries = a.entries();
+        // @ts-expect-error need to cast as boolean
+        return (b.every(function (v, k) {
+            var entry = entries.next().value;
+            return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
+        }) && entries.next().done);
+    }
+    var flipped = false;
+    if (a.size === undefined) {
+        // @ts-expect-error size should exists on Collection
+        if (b.size === undefined) {
+            if (typeof a.cacheResult === 'function') {
+                a.cacheResult();
+            }
+        }
+        else {
+            flipped = true;
+            var _ = a;
+            a = b;
+            b = _;
+        }
     }
-  });
-
-  return allEqual && a.size === bSize;
+    var allEqual = true;
+    var bSize = 
+    // @ts-expect-error b is Range | Repeat | Collection<unknown, unknown> as it may have been flipped, and __iterate is valid
+    b.__iterate(function (v, k) {
+        if (notAssociative
+            ? // @ts-expect-error has exists on Collection
+                !a.has(v)
+            : flipped
+                ? // @ts-expect-error type of `get` does not "catch" the version with `notSetValue`
+                    !is(v, a.get(k, NOT_SET))
+                : // @ts-expect-error type of `get` does not "catch" the version with `notSetValue`
+                    !is(a.get(k, NOT_SET), v)) {
+            allEqual = false;
+            return false;
+        }
+    });
+    return (allEqual &&
+        // @ts-expect-error size should exists on Collection
+        a.size === bSize);
 }
 
 /**
  * Contributes additional methods to a constructor
  */
-function mixin(ctor, methods) {
-  var keyCopier = function (key) {
-    ctor.prototype[key] = methods[key];
-  };
-  Object.keys(methods).forEach(keyCopier);
-  Object.getOwnPropertySymbols &&
-    Object.getOwnPropertySymbols(methods).forEach(keyCopier);
-  return ctor;
+function mixin(ctor, 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+methods) {
+    var keyCopier = function (key) {
+        // @ts-expect-error how to handle symbol ?
+        ctor.prototype[key] = methods[key];
+    };
+    Object.keys(methods).forEach(keyCopier);
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
+    Object.getOwnPropertySymbols &&
+        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
+    return ctor;
 }
 
 function toJS(value) {
@@ -4340,12 +4602,12 @@ var Set = /*@__PURE__*/(function (SetCollection) {
     return value === undefined || value === null
       ? emptySet()
       : isSet(value) && !isOrdered(value)
-      ? value
-      : emptySet().withMutations(function (set) {
-          var iter = SetCollection(value);
-          assertNotInfinite(iter.size);
-          iter.forEach(function (v) { return set.add(v); });
-        });
+        ? value
+        : emptySet().withMutations(function (set) {
+            var iter = SetCollection(value);
+            assertNotInfinite(iter.size);
+            iter.forEach(function (v) { return set.add(v); });
+          });
   }
 
   if ( SetCollection ) Set.__proto__ = SetCollection;
@@ -4559,8 +4821,8 @@ function updateSet(set, newMap) {
   return newMap === set._map
     ? set
     : newMap.size === 0
-    ? set.__empty()
-    : set.__make(newMap);
+      ? set.__empty()
+      : set.__make(newMap);
 }
 
 function makeSet(map, ownerID) {
@@ -4622,17 +4884,9 @@ var Range = /*@__PURE__*/(function (IndexedSeq) {
   Range.prototype.constructor = Range;
 
   Range.prototype.toString = function toString () {
-    if (this.size === 0) {
-      return 'Range []';
-    }
-    return (
-      'Range [ ' +
-      this._start +
-      '...' +
-      this._end +
-      (this._step !== 1 ? ' by ' + this._step : '') +
-      ' ]'
-    );
+    return this.size === 0
+      ? 'Range []'
+      : ("Range [ " + (this._start) + "..." + (this._end) + (this._step !== 1 ? ' by ' + this._step : '') + " ]");
   };
 
   Range.prototype.get = function get (index, notSetValue) {
@@ -4723,24 +4977,54 @@ var Range = /*@__PURE__*/(function (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);
-  var i = 0;
-  while (i !== keyPath.length) {
-    collection = get(collection, keyPath[i++], NOT_SET);
-    if (collection === NOT_SET) {
-      return notSetValue;
+    var keyPath = coerceKeyPath(searchKeyPath);
+    var i = 0;
+    while (i !== keyPath.length) {
+        // @ts-expect-error keyPath[i++] can not be undefined by design
+        collection = get(collection, keyPath[i++], NOT_SET);
+        if (collection === NOT_SET) {
+            return notSetValue;
+        }
     }
-  }
-  return collection;
+    return collection;
 }
 
 function getIn(searchKeyPath, notSetValue) {
   return getIn$1(this, searchKeyPath, notSetValue);
 }
 
+/**
+ * Returns true if the key path is defined in the provided collection.
+ *
+ * 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;
+    return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;
 }
 
 function hasIn(searchKeyPath) {
@@ -4815,8 +5099,8 @@ mixin(Collection, {
     return isIndexed(this)
       ? this.toIndexedSeq()
       : isKeyed(this)
-      ? this.toKeyedSeq()
-      : this.toSetSeq();
+        ? this.toKeyedSeq()
+        : this.toSetSeq();
   },
 
   toStack: function toStack() {
@@ -4901,6 +5185,7 @@ mixin(Collection, {
     var joined = '';
     var isFirst = true;
     this.__iterate(function (v) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
       isFirst ? (isFirst = false) : (joined += separator);
       joined += v !== null && v !== undefined ? v.toString() : '';
     });
@@ -5452,12 +5737,12 @@ function hashCollection(collection) {
             h = (h + hashMerge(hash(v), hash(k))) | 0;
           }
       : ordered
-      ? function (v) {
-          h = (31 * h + hash(v)) | 0;
-        }
-      : function (v) {
-          h = (h + hash(v)) | 0;
-        }
+        ? function (v) {
+            h = (31 * h + hash(v)) | 0;
+          }
+        : function (v) {
+            h = (h + hash(v)) | 0;
+          }
   );
 
   return murmurHashOfSize(collection.size, h);
@@ -5484,12 +5769,12 @@ var OrderedSet = /*@__PURE__*/(function (Set) {
     return value === undefined || value === null
       ? emptyOrderedSet()
       : isOrderedSet(value)
-      ? value
-      : emptyOrderedSet().withMutations(function (set) {
-          var iter = SetCollection(value);
-          assertNotInfinite(iter.size);
-          iter.forEach(function (v) { return set.add(v); });
-        });
+        ? value
+        : emptyOrderedSet().withMutations(function (set) {
+            var iter = SetCollection(value);
+            assertNotInfinite(iter.size);
+            iter.forEach(function (v) { return set.add(v); });
+          });
   }
 
   if ( Set ) OrderedSet.__proto__ = Set;
@@ -5539,7 +5824,7 @@ function emptyOrderedSet() {
 
 var PairSorting = {
   LeftThenRight: -1,
-  RightThenLeft: +1,
+  RightThenLeft: 1,
 };
 
 function throwOnInvalidDefaultValues(defaultValues) {
@@ -5591,6 +5876,7 @@ var Record = function Record(defaultValues, name) {
         indices[propName] = i;
         if (RecordTypePrototype[propName]) {
           /* eslint-disable no-console */
+          // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
           typeof console === 'object' &&
             console.warn &&
             console.warn(
@@ -5780,6 +6066,7 @@ function setProp(prototype, name) {
         this.set(name, value);
       },
     });
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO enable eslint here
   } catch (error) {
     // Object.defineProperty failed. Probably IE8.
   }
@@ -5908,6 +6195,7 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
       throw new TypeError('Cannot convert circular structure to Immutable');
     }
     stack.push(value);
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     keyPath && key !== '' && keyPath.push(key);
     var converted = converter.call(
       parentValue,
@@ -5917,6 +6205,7 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
       keyPath && keyPath.slice()
     );
     stack.pop();
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- TODO enable eslint here
     keyPath && keyPath.pop();
     return converted;
   }
@@ -5928,7 +6217,7 @@ function defaultConverter(k, v) {
   return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
 }
 
-var version = "5.0.3";
+var version = "5.1.1";
 
 // Note: Iterable is deprecated
 var Iterable = Collection;