immutable 4.0.0-rc.6 → 4.0.0

package/dist/immutable.es.js

@@ -1,11 +1,26 @@
 /**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
+ * MIT License
+ * 
+ * Copyright (c) 2014-present, Lee Byron and other contributors.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
-
-// Used for setting prototype methods that IE8 chokes on.
 var DELETE = 'delete';
 
 // Constants describing the size of trie nodes.
@@ -18,16 +33,14 @@ var MASK = SIZE - 1;
 var NOT_SET = {};
 
 // Boolean references, Rough equivalent of `bool &`.
-var CHANGE_LENGTH = { value: false };
-var DID_ALTER = { value: false };
-
-function MakeRef(ref) {
-  ref.value = false;
-  return ref;
+function MakeRef() {
+  return { value: false };
 }
 
 function SetRef(ref) {
-  ref && (ref.value = true);
+  if (ref) {
+    ref.value = true;
+  }
 }
 
 // A function which returns a value representing an "owner" for transient writes
@@ -35,17 +48,6 @@ function SetRef(ref) {
 // the return of any subsequent call of this function.
 function OwnerID() {}
 
-// 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;
-}
-
 function ensureSize(iter) {
   if (iter.size === undefined) {
     iter.size = iter.__iterate(returnTrue);
@@ -97,10 +99,12 @@ function resolveIndex(index, size, defaultIndex) {
   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;
+    ? size === Infinity
+      ? size
+      : Math.max(0, size + index) | 0
+    : size === undefined || size === index
+    ? index
+    : Math.min(size, index) | 0;
 }
 
 function isNeg(value) {
@@ -108,56 +112,33 @@ function isNeg(value) {
   return value < 0 || (value === 0 && 1 / value === -Infinity);
 }
 
-function isImmutable(maybeImmutable) {
-  return (
-    (isCollection(maybeImmutable) || isRecord(maybeImmutable)) &&
-    !maybeImmutable.__ownerID
-  );
-}
+var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';
 
 function isCollection(maybeCollection) {
-  return !!(maybeCollection && maybeCollection[IS_ITERABLE_SENTINEL]);
+  return Boolean(maybeCollection && maybeCollection[IS_COLLECTION_SYMBOL]);
 }
 
+var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';
+
 function isKeyed(maybeKeyed) {
-  return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
+  return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);
 }
 
+var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';
+
 function isIndexed(maybeIndexed) {
-  return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
+  return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);
 }
 
 function isAssociative(maybeAssociative) {
   return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
 }
 
-function isOrdered(maybeOrdered) {
-  return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
-}
-
-function isRecord(maybeRecord) {
-  return !!(maybeRecord && maybeRecord[IS_RECORD_SENTINEL]);
-}
-
-function isValueObject(maybeValue) {
-  return !!(
-    maybeValue &&
-    typeof maybeValue.equals === 'function' &&
-    typeof maybeValue.hashCode === 'function'
-  );
-}
-
-var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
-var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
-var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
-var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
-var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@';
-
 var Collection = function Collection(value) {
   return isCollection(value) ? value : Seq(value);
 };
 
-var KeyedCollection = (function (Collection) {
+var KeyedCollection = /*@__PURE__*/(function (Collection) {
   function KeyedCollection(value) {
     return isKeyed(value) ? value : KeyedSeq(value);
   }
@@ -169,7 +150,7 @@ var KeyedCollection = (function (Collection) {
   return KeyedCollection;
 }(Collection));
 
-var IndexedCollection = (function (Collection) {
+var IndexedCollection = /*@__PURE__*/(function (Collection) {
   function IndexedCollection(value) {
     return isIndexed(value) ? value : IndexedSeq(value);
   }
@@ -181,7 +162,7 @@ var IndexedCollection = (function (Collection) {
   return IndexedCollection;
 }(Collection));
 
-var SetCollection = (function (Collection) {
+var SetCollection = /*@__PURE__*/(function (Collection) {
   function SetCollection(value) {
     return isCollection(value) && !isAssociative(value) ? value : SetSeq(value);
   }
@@ -197,6 +178,28 @@ Collection.Keyed = KeyedCollection;
 Collection.Indexed = IndexedCollection;
 Collection.Set = SetCollection;
 
+var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';
+
+function isSeq(maybeSeq) {
+  return Boolean(maybeSeq && maybeSeq[IS_SEQ_SYMBOL]);
+}
+
+var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';
+
+function isRecord(maybeRecord) {
+  return Boolean(maybeRecord && maybeRecord[IS_RECORD_SYMBOL]);
+}
+
+function isImmutable(maybeImmutable) {
+  return isCollection(maybeImmutable) || isRecord(maybeImmutable);
+}
+
+var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';
+
+function isOrdered(maybeOrdered) {
+  return Boolean(maybeOrdered && maybeOrdered[IS_ORDERED_SYMBOL]);
+}
+
 var ITERATE_KEYS = 0;
 var ITERATE_VALUES = 1;
 var ITERATE_ENTRIES = 2;
@@ -218,10 +221,10 @@ Iterator.KEYS = ITERATE_KEYS;
 Iterator.VALUES = ITERATE_VALUES;
 Iterator.ENTRIES = ITERATE_ENTRIES;
 
-Iterator.prototype.inspect = Iterator.prototype.toSource = function() {
+Iterator.prototype.inspect = Iterator.prototype.toSource = function () {
   return this.toString();
 };
-Iterator.prototype[ITERATOR_SYMBOL] = function() {
+Iterator.prototype[ITERATOR_SYMBOL] = function () {
   return this;
 };
 
@@ -231,7 +234,7 @@ function iteratorValue(type, k, v, iteratorResult) {
     ? (iteratorResult.value = value)
     : (iteratorResult = {
         value: value,
-        done: false
+        done: false,
       });
   return iteratorResult;
 }
@@ -241,6 +244,11 @@ function iteratorDone() {
 }
 
 function hasIterator(maybeIterable) {
+  if (Array.isArray(maybeIterable)) {
+    // IE11 trick as it does not support `Symbol.iterator`
+    return true;
+  }
+
   return !!getIteratorFn(maybeIterable);
 }
 
@@ -263,21 +271,48 @@ function getIteratorFn(iterable) {
   }
 }
 
+function isEntriesIterable(maybeIterable) {
+  var iteratorFn = getIteratorFn(maybeIterable);
+  return iteratorFn && iteratorFn === maybeIterable.entries;
+}
+
+function isKeysIterable(maybeIterable) {
+  var iteratorFn = getIteratorFn(maybeIterable);
+  return iteratorFn && iteratorFn === maybeIterable.keys;
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
 function isArrayLike(value) {
-  return value && typeof value.length === 'number';
+  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))
+  );
 }
 
-var Seq = (function (Collection$$1) {
+var Seq = /*@__PURE__*/(function (Collection) {
   function Seq(value) {
     return value === null || value === undefined
       ? emptySequence()
-      : isCollection(value) || isRecord(value)
-        ? value.toSeq()
-        : seqFromValue(value);
+      : isImmutable(value)
+      ? value.toSeq()
+      : seqFromValue(value);
   }
 
-  if ( Collection$$1 ) Seq.__proto__ = Collection$$1;
-  Seq.prototype = Object.create( Collection$$1 && Collection$$1.prototype );
+  if ( Collection ) Seq.__proto__ = Collection;
+  Seq.prototype = Object.create( Collection && Collection.prototype );
   Seq.prototype.constructor = Seq;
 
   Seq.prototype.toSeq = function toSeq () {
@@ -299,15 +334,13 @@ var Seq = (function (Collection$$1) {
   // abstract __iterateUncached(fn, reverse)
 
   Seq.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
-
     var cache = this._cache;
     if (cache) {
       var size = cache.length;
       var i = 0;
       while (i !== size) {
         var entry = cache[reverse ? size - ++i : i++];
-        if (fn(entry[1], entry[0], this$1) === false) {
+        if (fn(entry[1], entry[0], this) === false) {
           break;
         }
       }
@@ -337,13 +370,17 @@ var Seq = (function (Collection$$1) {
   return Seq;
 }(Collection));
 
-var KeyedSeq = (function (Seq) {
+var KeyedSeq = /*@__PURE__*/(function (Seq) {
   function KeyedSeq(value) {
     return value === null || value === undefined
       ? 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;
@@ -357,15 +394,17 @@ var KeyedSeq = (function (Seq) {
   return KeyedSeq;
 }(Seq));
 
-var IndexedSeq = (function (Seq) {
+var IndexedSeq = /*@__PURE__*/(function (Seq) {
   function IndexedSeq(value) {
     return value === null || value === undefined
       ? 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;
@@ -387,11 +426,10 @@ var IndexedSeq = (function (Seq) {
   return IndexedSeq;
 }(Seq));
 
-var SetSeq = (function (Seq) {
+var SetSeq = /*@__PURE__*/(function (Seq) {
   function SetSeq(value) {
-    return (isCollection(value) && !isAssociative(value)
-      ? value
-      : IndexedSeq(value)
+    return (
+      isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value)
     ).toSetSeq();
   }
 
@@ -415,13 +453,11 @@ Seq.Keyed = KeyedSeq;
 Seq.Set = SetSeq;
 Seq.Indexed = IndexedSeq;
 
-var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
-
-Seq.prototype[IS_SEQ_SENTINEL] = true;
+Seq.prototype[IS_SEQ_SYMBOL] = true;
 
 // #pragma Root Sequences
 
-var ArraySeq = (function (IndexedSeq) {
+var ArraySeq = /*@__PURE__*/(function (IndexedSeq) {
   function ArraySeq(array) {
     this._array = array;
     this.size = array.length;
@@ -436,14 +472,12 @@ var ArraySeq = (function (IndexedSeq) {
   };
 
   ArraySeq.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
-
     var array = this._array;
     var size = array.length;
     var i = 0;
     while (i !== size) {
       var ii = reverse ? size - ++i : i++;
-      if (fn(array[ii], ii, this$1) === false) {
+      if (fn(array[ii], ii, this) === false) {
         break;
       }
     }
@@ -466,7 +500,7 @@ var ArraySeq = (function (IndexedSeq) {
   return ArraySeq;
 }(IndexedSeq));
 
-var ObjectSeq = (function (KeyedSeq) {
+var ObjectSeq = /*@__PURE__*/(function (KeyedSeq) {
   function ObjectSeq(object) {
     var keys = Object.keys(object);
     this._object = object;
@@ -486,19 +520,17 @@ var ObjectSeq = (function (KeyedSeq) {
   };
 
   ObjectSeq.prototype.has = function has (key) {
-    return this._object.hasOwnProperty(key);
+    return hasOwnProperty.call(this._object, key);
   };
 
   ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
-
     var object = this._object;
     var keys = this._keys;
     var size = keys.length;
     var i = 0;
     while (i !== size) {
       var key = keys[reverse ? size - ++i : i++];
-      if (fn(object[key], key, this$1) === false) {
+      if (fn(object[key], key, this) === false) {
         break;
       }
     }
@@ -521,9 +553,9 @@ var ObjectSeq = (function (KeyedSeq) {
 
   return ObjectSeq;
 }(KeyedSeq));
-ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;
+ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;
 
-var CollectionSeq = (function (IndexedSeq) {
+var CollectionSeq = /*@__PURE__*/(function (IndexedSeq) {
   function CollectionSeq(collection) {
     this._collection = collection;
     this.size = collection.length || collection.size;
@@ -534,8 +566,6 @@ var CollectionSeq = (function (IndexedSeq) {
   CollectionSeq.prototype.constructor = CollectionSeq;
 
   CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {
-    var this$1 = this;
-
     if (reverse) {
       return this.cacheResult().__iterate(fn, reverse);
     }
@@ -545,7 +575,7 @@ var CollectionSeq = (function (IndexedSeq) {
     if (isIterator(iterator)) {
       var step;
       while (!(step = iterator.next()).done) {
-        if (fn(step.value, iterations++, this$1) === false) {
+        if (fn(step.value, iterations++, this) === false) {
           break;
         }
       }
@@ -572,69 +602,8 @@ var CollectionSeq = (function (IndexedSeq) {
   return CollectionSeq;
 }(IndexedSeq));
 
-var IteratorSeq = (function (IndexedSeq) {
-  function IteratorSeq(iterator) {
-    this._iterator = iterator;
-    this._iteratorCache = [];
-  }
-
-  if ( IndexedSeq ) IteratorSeq.__proto__ = IndexedSeq;
-  IteratorSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
-  IteratorSeq.prototype.constructor = IteratorSeq;
-
-  IteratorSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {
-    var this$1 = this;
-
-    if (reverse) {
-      return this.cacheResult().__iterate(fn, reverse);
-    }
-    var iterator = this._iterator;
-    var cache = this._iteratorCache;
-    var iterations = 0;
-    while (iterations < cache.length) {
-      if (fn(cache[iterations], iterations++, this$1) === false) {
-        return iterations;
-      }
-    }
-    var step;
-    while (!(step = iterator.next()).done) {
-      var val = step.value;
-      cache[iterations] = val;
-      if (fn(val, iterations++, this$1) === false) {
-        break;
-      }
-    }
-    return iterations;
-  };
-
-  IteratorSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) {
-    if (reverse) {
-      return this.cacheResult().__iterator(type, reverse);
-    }
-    var iterator = this._iterator;
-    var cache = this._iteratorCache;
-    var iterations = 0;
-    return new Iterator(function () {
-      if (iterations >= cache.length) {
-        var step = iterator.next();
-        if (step.done) {
-          return step;
-        }
-        cache[iterations] = step.value;
-      }
-      return iteratorValue(type, iterations, cache[iterations++]);
-    });
-  };
-
-  return IteratorSeq;
-}(IndexedSeq));
-
 // # pragma Helper functions
 
-function isSeq(maybeSeq) {
-  return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
-}
-
 var EMPTY_SEQ;
 
 function emptySequence() {
@@ -642,11 +611,7 @@ function emptySequence() {
 }
 
 function keyedSeqFromValue(value) {
-  var seq = Array.isArray(value)
-    ? new ArraySeq(value)
-    : isIterator(value)
-      ? new IteratorSeq(value)
-      : hasIterator(value) ? new CollectionSeq(value) : undefined;
+  var seq = maybeIndexedSeqFromValue(value);
   if (seq) {
     return seq.fromEntrySeq();
   }
@@ -672,7 +637,11 @@ function indexedSeqFromValue(value) {
 function seqFromValue(value) {
   var seq = maybeIndexedSeqFromValue(value);
   if (seq) {
-    return seq;
+    return isEntriesIterable(value)
+      ? seq.fromEntrySeq()
+      : isKeysIterable(value)
+      ? seq.toSetSeq()
+      : seq;
   }
   if (typeof value === 'object') {
     return new ObjectSeq(value);
@@ -685,9 +654,27 @@ function seqFromValue(value) {
 function maybeIndexedSeqFromValue(value) {
   return isArrayLike(value)
     ? new ArraySeq(value)
-    : isIterator(value)
-      ? new IteratorSeq(value)
-      : hasIterator(value) ? new CollectionSeq(value) : undefined;
+    : hasIterator(value)
+    ? new CollectionSeq(value)
+    : undefined;
+}
+
+var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';
+
+function isMap(maybeMap) {
+  return Boolean(maybeMap && maybeMap[IS_MAP_SYMBOL]);
+}
+
+function isOrderedMap(maybeOrderedMap) {
+  return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
+}
+
+function isValueObject(maybeValue) {
+  return Boolean(
+    maybeValue &&
+      typeof maybeValue.equals === 'function' &&
+      typeof maybeValue.hashCode === 'function'
+  );
 }
 
 /**
@@ -791,50 +778,67 @@ function smi(i32) {
   return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
 }
 
+var defaultValueOf = Object.prototype.valueOf;
+
 function hash(o) {
-  if (o === false || o === null || o === undefined) {
-    return 0;
-  }
-  if (typeof o.valueOf === 'function') {
-    o = o.valueOf();
-    if (o === false || o === null || o === undefined) {
-      return 0;
-    }
-  }
-  if (o === true) {
-    return 1;
-  }
-  var type = typeof o;
-  if (type === 'number') {
-    if (o !== o || o === Infinity) {
-      return 0;
-    }
-    var h = o | 0;
-    if (h !== o) {
-      h ^= o * 0xffffffff;
-    }
-    while (o > 0xffffffff) {
-      o /= 0xffffffff;
-      h ^= o;
-    }
-    return smi(h);
-  }
-  if (type === 'string') {
-    return o.length > STRING_HASH_CACHE_MIN_STRLEN
-      ? cachedHashString(o)
-      : hashString(o);
+  if (o == null) {
+    return hashNullish(o);
   }
+
   if (typeof o.hashCode === 'function') {
     // Drop any high bits from accidentally long hash codes.
-    return smi(o.hashCode());
+    return smi(o.hashCode(o));
+  }
+
+  var v = valueOf(o);
+
+  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;
+}
+
+// Compress arbitrarily large numbers into smi hashes.
+function hashNumber(n) {
+  if (n !== n || n === Infinity) {
+    return 0;
   }
-  if (type === 'object') {
-    return hashJSObj(o);
+  var hash = n | 0;
+  if (hash !== n) {
+    hash ^= n * 0xffffffff;
   }
-  if (typeof o.toString === 'function') {
-    return hashString(o.toString());
+  while (n > 0xffffffff) {
+    n /= 0xffffffff;
+    hash ^= n;
   }
-  throw new Error('Value type ' + type + ' cannot be hashed.');
+  return smi(hash);
 }
 
 function cachedHashString(string) {
@@ -866,6 +870,19 @@ function hashString(string) {
   return smi(hashed);
 }
 
+function hashSymbol(sym) {
+  var hashed = symbolMap[sym];
+  if (hashed !== undefined) {
+    return hashed;
+  }
+
+  hashed = nextHash();
+
+  symbolMap[sym] = hashed;
+
+  return hashed;
+}
+
 function hashJSObj(obj) {
   var hashed;
   if (usingWeakMap) {
@@ -892,10 +909,7 @@ function hashJSObj(obj) {
     }
   }
 
-  hashed = ++objHashUID;
-  if (objHashUID & 0x40000000) {
-    objHashUID = 0;
-  }
+  hashed = nextHash();
 
   if (usingWeakMap) {
     weakMap.set(obj, hashed);
@@ -906,7 +920,7 @@ function hashJSObj(obj) {
       enumerable: false,
       configurable: false,
       writable: false,
-      value: hashed
+      value: hashed,
     });
   } else if (
     obj.propertyIsEnumerable !== undefined &&
@@ -916,7 +930,7 @@ function hashJSObj(obj) {
     // 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() {
+    obj.propertyIsEnumerable = function () {
       return this.constructor.prototype.propertyIsEnumerable.apply(
         this,
         arguments
@@ -940,7 +954,7 @@ function hashJSObj(obj) {
 var isExtensible = Object.isExtensible;
 
 // True if Object.defineProperty works as expected. IE8 fails this test.
-var canDefineProperty = (function() {
+var canDefineProperty = (function () {
   try {
     Object.defineProperty({}, '@', {});
     return true;
@@ -962,6 +976,20 @@ function getIENodeHash(node) {
   }
 }
 
+function valueOf(obj) {
+  return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'
+    ? obj.valueOf(obj)
+    : obj;
+}
+
+function nextHash() {
+  var nextHash = ++_objHashUID;
+  if (_objHashUID & 0x40000000) {
+    _objHashUID = 0;
+  }
+  return nextHash;
+}
+
 // If possible, use a WeakMap.
 var usingWeakMap = typeof WeakMap === 'function';
 var weakMap;
@@ -969,7 +997,9 @@ if (usingWeakMap) {
   weakMap = new WeakMap();
 }
 
-var objHashUID = 0;
+var symbolMap = Object.create(null);
+
+var _objHashUID = 0;
 
 var UID_HASH_KEY = '__immutablehash__';
 if (typeof Symbol === 'function') {
@@ -981,15 +1011,15 @@ var STRING_HASH_CACHE_MAX_SIZE = 255;
 var STRING_HASH_CACHE_SIZE = 0;
 var stringHashCache = {};
 
-var ToKeyedSequence = (function (KeyedSeq$$1) {
+var ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) {
   function ToKeyedSequence(indexed, useKeys) {
     this._iter = indexed;
     this._useKeys = useKeys;
     this.size = indexed.size;
   }
 
-  if ( KeyedSeq$$1 ) ToKeyedSequence.__proto__ = KeyedSeq$$1;
-  ToKeyedSequence.prototype = Object.create( KeyedSeq$$1 && KeyedSeq$$1.prototype );
+  if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq;
+  ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
   ToKeyedSequence.prototype.constructor = ToKeyedSequence;
 
   ToKeyedSequence.prototype.get = function get (key, notSetValue) {
@@ -1005,29 +1035,29 @@ var ToKeyedSequence = (function (KeyedSeq$$1) {
   };
 
   ToKeyedSequence.prototype.reverse = function reverse () {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var reversedSequence = reverseFactory(this, true);
     if (!this._useKeys) {
-      reversedSequence.valueSeq = function () { return this$1._iter.toSeq().reverse(); };
+      reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); };
     }
     return reversedSequence;
   };
 
   ToKeyedSequence.prototype.map = function map (mapper, context) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var mappedSequence = mapFactory(this, mapper, context);
     if (!this._useKeys) {
-      mappedSequence.valueSeq = function () { return this$1._iter.toSeq().map(mapper, context); };
+      mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); };
     }
     return mappedSequence;
   };
 
   ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
-    return this._iter.__iterate(function (v, k) { return fn(v, k, this$1); }, reverse);
+    return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse);
   };
 
   ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) {
@@ -1036,16 +1066,16 @@ var ToKeyedSequence = (function (KeyedSeq$$1) {
 
   return ToKeyedSequence;
 }(KeyedSeq));
-ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;
+ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;
 
-var ToIndexedSequence = (function (IndexedSeq$$1) {
+var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {
   function ToIndexedSequence(iter) {
     this._iter = iter;
     this.size = iter.size;
   }
 
-  if ( IndexedSeq$$1 ) ToIndexedSequence.__proto__ = IndexedSeq$$1;
-  ToIndexedSequence.prototype = Object.create( IndexedSeq$$1 && IndexedSeq$$1.prototype );
+  if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq;
+  ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
   ToIndexedSequence.prototype.constructor = ToIndexedSequence;
 
   ToIndexedSequence.prototype.includes = function includes (value) {
@@ -1053,18 +1083,18 @@ var ToIndexedSequence = (function (IndexedSeq$$1) {
   };
 
   ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var i = 0;
     reverse && ensureSize(this);
     return this._iter.__iterate(
-      function (v) { return fn(v, reverse ? this$1.size - ++i : i++, this$1); },
+      function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); },
       reverse
     );
   };
 
   ToIndexedSequence.prototype.__iterator = function __iterator (type, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
     var i = 0;
@@ -1075,7 +1105,7 @@ var ToIndexedSequence = (function (IndexedSeq$$1) {
         ? step
         : iteratorValue(
             type,
-            reverse ? this$1.size - ++i : i++,
+            reverse ? this$1$1.size - ++i : i++,
             step.value,
             step
           );
@@ -1085,14 +1115,14 @@ var ToIndexedSequence = (function (IndexedSeq$$1) {
   return ToIndexedSequence;
 }(IndexedSeq));
 
-var ToSetSequence = (function (SetSeq$$1) {
+var ToSetSequence = /*@__PURE__*/(function (SetSeq) {
   function ToSetSequence(iter) {
     this._iter = iter;
     this.size = iter.size;
   }
 
-  if ( SetSeq$$1 ) ToSetSequence.__proto__ = SetSeq$$1;
-  ToSetSequence.prototype = Object.create( SetSeq$$1 && SetSeq$$1.prototype );
+  if ( SetSeq ) ToSetSequence.__proto__ = SetSeq;
+  ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype );
   ToSetSequence.prototype.constructor = ToSetSequence;
 
   ToSetSequence.prototype.has = function has (key) {
@@ -1100,9 +1130,9 @@ var ToSetSequence = (function (SetSeq$$1) {
   };
 
   ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
-    return this._iter.__iterate(function (v) { return fn(v, v, this$1); }, reverse);
+    return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse);
   };
 
   ToSetSequence.prototype.__iterator = function __iterator (type, reverse) {
@@ -1118,14 +1148,14 @@ var ToSetSequence = (function (SetSeq$$1) {
   return ToSetSequence;
 }(SetSeq));
 
-var FromEntriesSequence = (function (KeyedSeq$$1) {
+var FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) {
   function FromEntriesSequence(entries) {
     this._iter = entries;
     this.size = entries.size;
   }
 
-  if ( KeyedSeq$$1 ) FromEntriesSequence.__proto__ = KeyedSeq$$1;
-  FromEntriesSequence.prototype = Object.create( KeyedSeq$$1 && KeyedSeq$$1.prototype );
+  if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq;
+  FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
   FromEntriesSequence.prototype.constructor = FromEntriesSequence;
 
   FromEntriesSequence.prototype.entrySeq = function entrySeq () {
@@ -1133,7 +1163,7 @@ var FromEntriesSequence = (function (KeyedSeq$$1) {
   };
 
   FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     return this._iter.__iterate(function (entry) {
       // Check if entry exists first so array access doesn't throw for holes
@@ -1144,7 +1174,7 @@ var FromEntriesSequence = (function (KeyedSeq$$1) {
         return fn(
           indexedCollection ? entry.get(1) : entry[1],
           indexedCollection ? entry.get(0) : entry[0],
-          this$1
+          this$1$1
         );
       }
     }, reverse);
@@ -1178,14 +1208,18 @@ var FromEntriesSequence = (function (KeyedSeq$$1) {
   return FromEntriesSequence;
 }(KeyedSeq));
 
-ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough;
+ToIndexedSequence.prototype.cacheResult =
+  ToKeyedSequence.prototype.cacheResult =
+  ToSetSequence.prototype.cacheResult =
+  FromEntriesSequence.prototype.cacheResult =
+    cacheResultThrough;
 
 function flipFactory(collection) {
   var flipSequence = makeSequence(collection);
   flipSequence._iter = collection;
   flipSequence.size = collection.size;
   flipSequence.flip = function () { return collection; };
-  flipSequence.reverse = function() {
+  flipSequence.reverse = function () {
     var reversedSequence = collection.reverse.apply(this); // super.reverse()
     reversedSequence.flip = function () { return collection.reverse(); };
     return reversedSequence;
@@ -1193,12 +1227,12 @@ function flipFactory(collection) {
   flipSequence.has = function (key) { return collection.includes(key); };
   flipSequence.includes = function (key) { return collection.has(key); };
   flipSequence.cacheResult = cacheResultThrough;
-  flipSequence.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  flipSequence.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
-    return collection.__iterate(function (v, k) { return fn(k, v, this$1) !== false; }, reverse);
+    return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse);
   };
-  flipSequence.__iteratorUncached = function(type, reverse) {
+  flipSequence.__iteratorUncached = function (type, reverse) {
     if (type === ITERATE_ENTRIES) {
       var iterator = collection.__iterator(type, reverse);
       return new Iterator(function () {
@@ -1229,15 +1263,15 @@ function mapFactory(collection, mapper, context) {
       ? notSetValue
       : mapper.call(context, v, key, collection);
   };
-  mappedSequence.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  mappedSequence.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
     return collection.__iterate(
-      function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1) !== false; },
+      function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1$1) !== false; },
       reverse
     );
   };
-  mappedSequence.__iteratorUncached = function(type, reverse) {
+  mappedSequence.__iteratorUncached = function (type, reverse) {
     var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
     return new Iterator(function () {
       var step = iterator.next();
@@ -1258,14 +1292,14 @@ function mapFactory(collection, mapper, context) {
 }
 
 function reverseFactory(collection, useKeys) {
-  var this$1 = this;
+  var this$1$1 = this;
 
   var reversedSequence = makeSequence(collection);
   reversedSequence._iter = collection;
   reversedSequence.size = collection.size;
   reversedSequence.reverse = function () { return collection; };
   if (collection.flip) {
-    reversedSequence.flip = function() {
+    reversedSequence.flip = function () {
       var flipSequence = flipFactory(collection);
       flipSequence.reverse = function () { return collection.flip(); };
       return flipSequence;
@@ -1275,13 +1309,13 @@ function reverseFactory(collection, useKeys) {
   reversedSequence.has = function (key) { return collection.has(useKeys ? key : -1 - key); };
   reversedSequence.includes = function (value) { return collection.includes(value); };
   reversedSequence.cacheResult = cacheResultThrough;
-  reversedSequence.__iterate = function(fn, reverse) {
-    var this$1 = this;
+  reversedSequence.__iterate = function (fn, reverse) {
+    var this$1$1 = this;
 
     var i = 0;
     reverse && ensureSize(collection);
     return collection.__iterate(
-      function (v, k) { return fn(v, useKeys ? k : reverse ? this$1.size - ++i : i++, this$1); },
+      function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); },
       !reverse
     );
   };
@@ -1297,7 +1331,7 @@ function reverseFactory(collection, useKeys) {
       var entry = step.value;
       return iteratorValue(
         type,
-        useKeys ? entry[0] : reverse ? this$1.size - ++i : i++,
+        useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++,
         entry[1],
         step
       );
@@ -1320,19 +1354,19 @@ function filterFactory(collection, predicate, context, useKeys) {
         : notSetValue;
     };
   }
-  filterSequence.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  filterSequence.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
     var iterations = 0;
     collection.__iterate(function (v, k, c) {
       if (predicate.call(context, v, k, c)) {
         iterations++;
-        return fn(v, useKeys ? k : iterations - 1, this$1);
+        return fn(v, useKeys ? k : iterations - 1, this$1$1);
       }
     }, reverse);
     return iterations;
   };
-  filterSequence.__iteratorUncached = function(type, reverse) {
+  filterSequence.__iteratorUncached = function (type, reverse) {
     var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
     var iterations = 0;
     return new Iterator(function () {
@@ -1371,7 +1405,7 @@ function groupByFactory(collection, grouper, context) {
     );
   });
   var coerce = collectionClass(collection);
-  return groups.map(function (arr) { return reify(collection, coerce(arr)); });
+  return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable();
 }
 
 function sliceFactory(collection, begin, end, useKeys) {
@@ -1409,7 +1443,7 @@ function sliceFactory(collection, begin, end, useKeys) {
     sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined;
 
   if (!useKeys && isSeq(collection) && sliceSize >= 0) {
-    sliceSeq.get = function(index, notSetValue) {
+    sliceSeq.get = function (index, notSetValue) {
       index = wrapIndex(this, index);
       return index >= 0 && index < sliceSize
         ? collection.get(index + resolvedBegin, notSetValue)
@@ -1417,8 +1451,8 @@ function sliceFactory(collection, begin, end, useKeys) {
     };
   }
 
-  sliceSeq.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  sliceSeq.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
     if (sliceSize === 0) {
       return 0;
@@ -1433,7 +1467,7 @@ function sliceFactory(collection, begin, end, useKeys) {
       if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
         iterations++;
         return (
-          fn(v, useKeys ? k : iterations - 1, this$1) !== false &&
+          fn(v, useKeys ? k : iterations - 1, this$1$1) !== false &&
           iterations !== sliceSize
         );
       }
@@ -1441,7 +1475,7 @@ function sliceFactory(collection, begin, end, useKeys) {
     return iterations;
   };
 
-  sliceSeq.__iteratorUncached = function(type, reverse) {
+  sliceSeq.__iteratorUncached = function (type, reverse) {
     if (sliceSize !== 0 && reverse) {
       return this.cacheResult().__iterator(type, reverse);
     }
@@ -1475,20 +1509,20 @@ function sliceFactory(collection, begin, end, useKeys) {
 
 function takeWhileFactory(collection, predicate, context) {
   var takeSequence = makeSequence(collection);
-  takeSequence.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  takeSequence.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
     if (reverse) {
       return this.cacheResult().__iterate(fn, reverse);
     }
     var iterations = 0;
     collection.__iterate(
-      function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1); }
+      function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1); }
     );
     return iterations;
   };
-  takeSequence.__iteratorUncached = function(type, reverse) {
-    var this$1 = this;
+  takeSequence.__iteratorUncached = function (type, reverse) {
+    var this$1$1 = this;
 
     if (reverse) {
       return this.cacheResult().__iterator(type, reverse);
@@ -1506,7 +1540,7 @@ function takeWhileFactory(collection, predicate, context) {
       var entry = step.value;
       var k = entry[0];
       var v = entry[1];
-      if (!predicate.call(context, v, k, this$1)) {
+      if (!predicate.call(context, v, k, this$1$1)) {
         iterating = false;
         return iteratorDone();
       }
@@ -1518,8 +1552,8 @@ function takeWhileFactory(collection, predicate, context) {
 
 function skipWhileFactory(collection, predicate, context, useKeys) {
   var skipSequence = makeSequence(collection);
-  skipSequence.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  skipSequence.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
     if (reverse) {
       return this.cacheResult().__iterate(fn, reverse);
@@ -1529,13 +1563,13 @@ function skipWhileFactory(collection, predicate, context, useKeys) {
     collection.__iterate(function (v, k, c) {
       if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {
         iterations++;
-        return fn(v, useKeys ? k : iterations - 1, this$1);
+        return fn(v, useKeys ? k : iterations - 1, this$1$1);
       }
     });
     return iterations;
   };
-  skipSequence.__iteratorUncached = function(type, reverse) {
-    var this$1 = this;
+  skipSequence.__iteratorUncached = function (type, reverse) {
+    var this$1$1 = this;
 
     if (reverse) {
       return this.cacheResult().__iterator(type, reverse);
@@ -1561,7 +1595,7 @@ function skipWhileFactory(collection, predicate, context, useKeys) {
         var entry = step.value;
         k = entry[0];
         v = entry[1];
-        skipping && (skipping = predicate.call(context, v, k, this$1));
+        skipping && (skipping = predicate.call(context, v, k, this$1$1));
       } while (skipping);
       return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
     });
@@ -1620,7 +1654,7 @@ function concatFactory(collection, values) {
 
 function flattenFactory(collection, depth, useKeys) {
   var flatSequence = makeSequence(collection);
-  flatSequence.__iterateUncached = function(fn, reverse) {
+  flatSequence.__iterateUncached = function (fn, reverse) {
     if (reverse) {
       return this.cacheResult().__iterate(fn, reverse);
     }
@@ -1642,7 +1676,7 @@ function flattenFactory(collection, depth, useKeys) {
     flatDeep(collection, 0);
     return iterations;
   };
-  flatSequence.__iteratorUncached = function(type, reverse) {
+  flatSequence.__iteratorUncached = function (type, reverse) {
     if (reverse) {
       return this.cacheResult().__iterator(type, reverse);
     }
@@ -1684,18 +1718,18 @@ function flatMapFactory(collection, mapper, context) {
 function interposeFactory(collection, separator) {
   var interposedSequence = makeSequence(collection);
   interposedSequence.size = collection.size && collection.size * 2 - 1;
-  interposedSequence.__iterateUncached = function(fn, reverse) {
-    var this$1 = this;
+  interposedSequence.__iterateUncached = function (fn, reverse) {
+    var this$1$1 = this;
 
     var iterations = 0;
     collection.__iterate(
-      function (v) { return (!iterations || fn(separator, iterations++, this$1) !== false) &&
-        fn(v, iterations++, this$1) !== false; },
+      function (v) { return (!iterations || fn(separator, iterations++, this$1$1) !== false) &&
+        fn(v, iterations++, this$1$1) !== false; },
       reverse
     );
     return iterations;
   };
-  interposedSequence.__iteratorUncached = function(type, reverse) {
+  interposedSequence.__iteratorUncached = function (type, reverse) {
     var iterator = collection.__iterator(ITERATE_VALUES, reverse);
     var iterations = 0;
     var step;
@@ -1725,18 +1759,22 @@ function sortFactory(collection, comparator, mapper) {
     .map(function (v, k) { return [k, v, index++, mapper ? mapper(v, k, collection) : v]; })
     .valueSeq()
     .toArray();
-  entries.sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; }).forEach(
-    isKeyedCollection
-      ? function (v, i) {
-          entries[i].length = 2;
-        }
-      : function (v, i) {
-          entries[i] = v[1];
-        }
-  );
+  entries
+    .sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; })
+    .forEach(
+      isKeyedCollection
+        ? function (v, i) {
+            entries[i].length = 2;
+          }
+        : function (v, i) {
+            entries[i] = v[1];
+          }
+    );
   return isKeyedCollection
     ? KeyedSeq(entries)
-    : isIndexed(collection) ? IndexedSeq(entries) : SetSeq(entries);
+    : isIndexed(collection)
+    ? IndexedSeq(entries)
+    : SetSeq(entries);
 }
 
 function maxFactory(collection, comparator, mapper) {
@@ -1769,9 +1807,7 @@ function zipWithFactory(keyIter, zipper, iters, zipAll) {
   zipSequence.size = zipAll ? sizes.max() : sizes.min();
   // Note: this a generic base implementation of __iterate in terms of
   // __iterator which may be more generically useful in the future.
-  zipSequence.__iterate = function(fn, reverse) {
-    var this$1 = this;
-
+  zipSequence.__iterate = function (fn, reverse) {
     /* generic:
     var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
     var step;
@@ -1789,13 +1825,13 @@ function zipWithFactory(keyIter, zipper, iters, zipAll) {
     var step;
     var iterations = 0;
     while (!(step = iterator.next()).done) {
-      if (fn(step.value, iterations++, this$1) === false) {
+      if (fn(step.value, iterations++, this) === false) {
         break;
       }
     }
     return iterations;
   };
-  zipSequence.__iteratorUncached = function(type, reverse) {
+  zipSequence.__iteratorUncached = function (type, reverse) {
     var iterators = iters.map(
       function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); }
     );
@@ -1813,7 +1849,10 @@ function zipWithFactory(keyIter, zipper, iters, zipAll) {
       return iteratorValue(
         type,
         iterations++,
-        zipper.apply(null, steps.map(function (s) { return s.value; }))
+        zipper.apply(
+          null,
+          steps.map(function (s) { return s.value; })
+        )
       );
     });
   };
@@ -1835,14 +1874,18 @@ function validateEntry(entry) {
 function collectionClass(collection) {
   return isKeyed(collection)
     ? KeyedCollection
-    : isIndexed(collection) ? IndexedCollection : SetCollection;
+    : isIndexed(collection)
+    ? IndexedCollection
+    : SetCollection;
 }
 
 function makeSequence(collection) {
   return Object.create(
     (isKeyed(collection)
       ? KeyedSeq
-      : isIndexed(collection) ? IndexedSeq : SetSeq
+      : isIndexed(collection)
+      ? IndexedSeq
+      : SetSeq
     ).prototype
   );
 }
@@ -1872,6 +1915,27 @@ function defaultComparator(a, b) {
   return a > b ? 1 : a < b ? -1 : 0;
 }
 
+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;
+}
+
+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;
@@ -1884,20 +1948,44 @@ function coerceKeyPath(keyPath) {
   );
 }
 
-function invariant(condition, error) {
-  if (!condition) { throw new Error(error); }
-}
+var toString = Object.prototype.toString;
 
-function assertNotInfinite(size) {
-  invariant(
-    size !== Infinity,
-    'Cannot perform this action with an infinite size.'
-  );
+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;
 }
 
 /**
- * Converts a value to a string, adding quotes if a string was provided.
+ * 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))
+  );
+}
+
 function quoteString(value) {
   try {
     return typeof value === 'string' ? JSON.stringify(value) : String(value);
@@ -1906,21 +1994,387 @@ function quoteString(value) {
   }
 }
 
-var Map = (function (KeyedCollection$$1) {
+function has(collection, key) {
+  return isImmutable(collection)
+    ? collection.has(key)
+    : 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];
+}
+
+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)) {
+    if (!collection.remove) {
+      throw new TypeError(
+        'Cannot update immutable value without .remove() method: ' + 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;
+}
+
+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
+      );
+    }
+    return collection.set(key, value);
+  }
+  if (hasOwnProperty.call(collection, key) && value === collection[key]) {
+    return collection;
+  }
+  var collectionCopy = shallowCopy(collection);
+  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
+      );
+}
+
+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);
+}
+
+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(collection, [key], notSetValue, updater);
+}
+
+function update(key, notSetValue, updater) {
+  return arguments.length === 1
+    ? key(this)
+    : update$1(this, key, notSetValue, updater);
+}
+
+function updateIn(keyPath, notSetValue, updater) {
+  return updateIn$1(this, keyPath, notSetValue, updater);
+}
+
+function merge$1() {
+  var iters = [], len = arguments.length;
+  while ( len-- ) iters[ len ] = arguments[ len ];
+
+  return mergeIntoKeyedWith(this, iters);
+}
+
+function mergeWith$1(merger) {
+  var iters = [], len = arguments.length - 1;
+  while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
+
+  if (typeof merger !== 'function') {
+    throw new TypeError('Invalid merger function: ' + merger);
+  }
+  return mergeIntoKeyedWith(this, iters, merger);
+}
+
+function mergeIntoKeyedWith(collection, collections, merger) {
+  var iters = [];
+  for (var ii = 0; ii < collections.length; ii++) {
+    var collection$1 = KeyedCollection(collections[ii]);
+    if (collection$1.size !== 0) {
+      iters.push(collection$1);
+    }
+  }
+  if (iters.length === 0) {
+    return collection;
+  }
+  if (
+    collection.toSeq().size === 0 &&
+    !collection.__ownerID &&
+    iters.length === 1
+  ) {
+    return collection.constructor(iters[0]);
+  }
+  return collection.withMutations(function (collection) {
+    var mergeIntoCollection = merger
+      ? function (value, key) {
+          update$1(collection, key, NOT_SET, function (oldVal) { return oldVal === NOT_SET ? value : merger(oldVal, value, key); }
+          );
+        }
+      : function (value, key) {
+          collection.set(key, value);
+        };
+    for (var ii = 0; ii < iters.length; ii++) {
+      iters[ii].forEach(mergeIntoCollection);
+    }
+  });
+}
+
+function merge(collection) {
+  var sources = [], len = arguments.length - 1;
+  while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
+
+  return mergeWithSources(collection, sources);
+}
+
+function mergeWith(merger, collection) {
+  var sources = [], len = arguments.length - 2;
+  while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];
+
+  return mergeWithSources(collection, sources, merger);
+}
+
+function mergeDeep$1(collection) {
+  var sources = [], len = arguments.length - 1;
+  while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
+
+  return mergeDeepWithSources(collection, sources);
+}
+
+function mergeDeepWith$1(merger, collection) {
+  var sources = [], len = arguments.length - 2;
+  while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];
+
+  return mergeDeepWithSources(collection, sources, merger);
+}
+
+function mergeDeepWithSources(collection, sources, merger) {
+  return mergeWithSources(collection, sources, deepMergerWith(merger));
+}
+
+function mergeWithSources(collection, sources, merger) {
+  if (!isDataStructure(collection)) {
+    throw new TypeError(
+      'Cannot merge into non-data-structure value: ' + collection
+    );
+  }
+  if (isImmutable(collection)) {
+    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);
+  }
+  var isArray = Array.isArray(collection);
+  var merged = collection;
+  var Collection = isArray ? IndexedCollection : KeyedCollection;
+  var mergeItem = isArray
+    ? function (value) {
+        // Copy on write
+        if (merged === collection) {
+          merged = shallowCopy(merged);
+        }
+        merged.push(value);
+      }
+    : function (value, key) {
+        var hasVal = hasOwnProperty.call(merged, key);
+        var nextVal =
+          hasVal && merger ? merger(merged[key], value, key) : value;
+        if (!hasVal || nextVal !== merged[key]) {
+          // Copy on write
+          if (merged === collection) {
+            merged = shallowCopy(merged);
+          }
+          merged[key] = nextVal;
+        }
+      };
+  for (var i = 0; i < sources.length; i++) {
+    Collection(sources[i]).forEach(mergeItem);
+  }
+  return merged;
+}
+
+function deepMergerWith(merger) {
+  function deepMerger(oldValue, newValue, key) {
+    return isDataStructure(oldValue) &&
+      isDataStructure(newValue) &&
+      areMergeable(oldValue, newValue)
+      ? mergeWithSources(oldValue, [newValue], deepMerger)
+      : merger
+      ? merger(oldValue, newValue, key)
+      : newValue;
+  }
+  return deepMerger;
+}
+
+/**
+ * It's unclear what the desired behavior is for merging two collections that
+ * fall into separate categories between keyed, indexed, or set-like, so we only
+ * consider them mergeable if they fall into the same category.
+ */
+function areMergeable(oldDataStructure, newDataStructure) {
+  var oldSeq = Seq(oldDataStructure);
+  var newSeq = Seq(newDataStructure);
+  // This logic assumes that a sequence can only fall into one of the three
+  // categories mentioned above (since there's no `isSetLike()` method).
+  return (
+    isIndexed(oldSeq) === isIndexed(newSeq) &&
+    isKeyed(oldSeq) === isKeyed(newSeq)
+  );
+}
+
+function mergeDeep() {
+  var iters = [], len = arguments.length;
+  while ( len-- ) iters[ len ] = arguments[ len ];
+
+  return mergeDeepWithSources(this, iters);
+}
+
+function mergeDeepWith(merger) {
+  var iters = [], len = arguments.length - 1;
+  while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
+
+  return mergeDeepWithSources(this, iters, merger);
+}
+
+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 mergeWithSources(m, iters); });
+}
+
+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 mergeDeepWithSources(m, iters); }
+  );
+}
+
+function withMutations(fn) {
+  var mutable = this.asMutable();
+  fn(mutable);
+  return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
+}
+
+function asMutable() {
+  return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
+}
+
+function asImmutable() {
+  return this.__ensureOwner();
+}
+
+function wasAltered() {
+  return this.__altered;
+}
+
+var Map = /*@__PURE__*/(function (KeyedCollection) {
   function Map(value) {
     return value === null || value === undefined
       ? emptyMap()
       : isMap(value) && !isOrdered(value)
-        ? value
-        : emptyMap().withMutations(function (map) {
-            var iter = KeyedCollection$$1(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$$1 ) Map.__proto__ = KeyedCollection$$1;
-  Map.prototype = Object.create( KeyedCollection$$1 && KeyedCollection$$1.prototype );
+  if ( KeyedCollection ) Map.__proto__ = KeyedCollection;
+  Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype );
   Map.prototype.constructor = Map;
 
   Map.of = function of () {
@@ -1955,22 +2409,10 @@ var Map = (function (KeyedCollection$$1) {
     return updateMap(this, k, v);
   };
 
-  Map.prototype.setIn = function setIn (keyPath, v) {
-    return this.updateIn(keyPath, NOT_SET, function () { return v; });
-  };
-
   Map.prototype.remove = function remove (k) {
     return updateMap(this, k, NOT_SET);
   };
 
-  Map.prototype.deleteIn = function deleteIn (keyPath) {
-    keyPath = [].concat( coerceKeyPath(keyPath) );
-    if (keyPath.length) {
-      var lastKey = keyPath.pop();
-      return this.updateIn(keyPath, function (c) { return c && c.remove(lastKey); });
-    }
-  };
-
   Map.prototype.deleteAll = function deleteAll (keys) {
     var collection = Collection(keys);
 
@@ -1983,27 +2425,6 @@ var Map = (function (KeyedCollection$$1) {
     });
   };
 
-  Map.prototype.update = function update (k, notSetValue, updater) {
-    return arguments.length === 1
-      ? k(this)
-      : this.updateIn([k], notSetValue, updater);
-  };
-
-  Map.prototype.updateIn = function updateIn (keyPath, notSetValue, updater) {
-    if (!updater) {
-      updater = notSetValue;
-      notSetValue = undefined;
-    }
-    var updatedValue = updateInDeepMap(
-      this,
-      coerceKeyPath(keyPath),
-      0,
-      notSetValue,
-      updater
-    );
-    return updatedValue === NOT_SET ? notSetValue : updatedValue;
-  };
-
   Map.prototype.clear = function clear () {
     if (this.size === 0) {
       return this;
@@ -2020,54 +2441,6 @@ var Map = (function (KeyedCollection$$1) {
 
   // @pragma Composition
 
-  Map.prototype.merge = function merge (/*...iters*/) {
-    return mergeIntoMapWith(this, undefined, arguments);
-  };
-
-  Map.prototype.mergeWith = function mergeWith (merger) {
-    var iters = [], len = arguments.length - 1;
-    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
-
-    return mergeIntoMapWith(this, merger, iters);
-  };
-
-  Map.prototype.mergeIn = function mergeIn (keyPath) {
-    var iters = [], len = arguments.length - 1;
-    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
-
-    return this.updateIn(
-      keyPath,
-      emptyMap(),
-      function (m) { return typeof m.merge === 'function'
-          ? m.merge.apply(m, iters)
-          : iters[iters.length - 1]; }
-    );
-  };
-
-  Map.prototype.mergeDeep = function mergeDeep (/*...iters*/) {
-    return mergeIntoMapWith(this, deepMergerWith(alwaysNewVal), arguments);
-  };
-
-  Map.prototype.mergeDeepWith = function mergeDeepWith (merger) {
-    var iters = [], len = arguments.length - 1;
-    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
-
-    return mergeIntoMapWith(this, deepMergerWith(merger), iters);
-  };
-
-  Map.prototype.mergeDeepIn = function mergeDeepIn (keyPath) {
-    var iters = [], len = arguments.length - 1;
-    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];
-
-    return this.updateIn(
-      keyPath,
-      emptyMap(),
-      function (m) { return typeof m.mergeDeep === 'function'
-          ? m.mergeDeep.apply(m, iters)
-          : iters[iters.length - 1]; }
-    );
-  };
-
   Map.prototype.sort = function sort (comparator) {
     // Late binding
     return OrderedMap(sortFactory(this, comparator));
@@ -2078,38 +2451,30 @@ var Map = (function (KeyedCollection$$1) {
     return OrderedMap(sortFactory(this, comparator, mapper));
   };
 
-  // @pragma Mutability
-
-  Map.prototype.withMutations = function withMutations (fn) {
-    var mutable = this.asMutable();
-    fn(mutable);
-    return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
-  };
+  Map.prototype.map = function map (mapper, context) {
+    var this$1$1 = this;
 
-  Map.prototype.asMutable = function asMutable () {
-    return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
-  };
-
-  Map.prototype.asImmutable = function asImmutable () {
-    return this.__ensureOwner();
+    return this.withMutations(function (map) {
+      map.forEach(function (value, key) {
+        map.set(key, mapper.call(context, value, key, this$1$1));
+      });
+    });
   };
 
-  Map.prototype.wasAltered = function wasAltered () {
-    return this.__altered;
-  };
+  // @pragma Mutability
 
   Map.prototype.__iterator = function __iterator (type, reverse) {
     return new MapIterator(this, type, reverse);
   };
 
   Map.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var iterations = 0;
     this._root &&
       this._root.iterate(function (entry) {
         iterations++;
-        return fn(entry[1], entry[0], this$1);
+        return fn(entry[1], entry[0], this$1$1);
       }, reverse);
     return iterations;
   };
@@ -2132,24 +2497,30 @@ var Map = (function (KeyedCollection$$1) {
   return Map;
 }(KeyedCollection));
 
-function isMap(maybeMap) {
-  return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
-}
-
 Map.isMap = isMap;
 
-var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
-
 var MapPrototype = Map.prototype;
-MapPrototype[IS_MAP_SENTINEL] = true;
+MapPrototype[IS_MAP_SYMBOL] = true;
 MapPrototype[DELETE] = MapPrototype.remove;
-MapPrototype.removeIn = MapPrototype.deleteIn;
 MapPrototype.removeAll = MapPrototype.deleteAll;
-MapPrototype['@@transducer/init'] = MapPrototype.asMutable;
-MapPrototype['@@transducer/step'] = function(result, arr) {
+MapPrototype.setIn = setIn;
+MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;
+MapPrototype.update = update;
+MapPrototype.updateIn = updateIn;
+MapPrototype.merge = MapPrototype.concat = merge$1;
+MapPrototype.mergeWith = mergeWith$1;
+MapPrototype.mergeDeep = mergeDeep;
+MapPrototype.mergeDeepWith = mergeDeepWith;
+MapPrototype.mergeIn = mergeIn;
+MapPrototype.mergeDeepIn = mergeDeepIn;
+MapPrototype.withMutations = withMutations;
+MapPrototype.wasAltered = wasAltered;
+MapPrototype.asImmutable = asImmutable;
+MapPrototype['@@transducer/init'] = MapPrototype.asMutable = asMutable;
+MapPrototype['@@transducer/step'] = function (result, arr) {
   return result.set(arr[0], arr[1]);
 };
-MapPrototype['@@transducer/result'] = function(obj) {
+MapPrototype['@@transducer/result'] = function (obj) {
   return obj.asImmutable();
 };
 
@@ -2295,7 +2666,7 @@ BitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, k
   var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
   var newNodes = exists
     ? newNode
-      ? setIn(nodes, idx, newNode, isEditable)
+      ? setAt(nodes, idx, newNode, isEditable)
       : spliceOut(nodes, idx, isEditable)
     : spliceIn(nodes, idx, newNode, isEditable);
 
@@ -2363,7 +2734,7 @@ HashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, ke
   }
 
   var isEditable = ownerID && ownerID === this.ownerID;
-  var newNodes = setIn(nodes, idx, newNode, isEditable);
+  var newNodes = setAt(nodes, idx, newNode, isEditable);
 
   if (isEditable) {
     this.count = newCount;
@@ -2488,50 +2859,44 @@ ValueNode.prototype.update = function update (ownerID, shift, keyHash, key, valu
 
 // #pragma Iterators
 
-ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(
-  fn,
-  reverse
-) {
-  var entries = this.entries;
-  for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
-    if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
-      return false;
+ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate =
+  function (fn, reverse) {
+    var entries = this.entries;
+    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
+      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
+        return false;
+      }
     }
-  }
-};
+  };
 
-BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(
-  fn,
-  reverse
-) {
-  var nodes = this.nodes;
-  for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
-    var node = nodes[reverse ? maxIndex - ii : ii];
-    if (node && node.iterate(fn, reverse) === false) {
-      return false;
+BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate =
+  function (fn, reverse) {
+    var nodes = this.nodes;
+    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
+      var node = nodes[reverse ? maxIndex - ii : ii];
+      if (node && node.iterate(fn, reverse) === false) {
+        return false;
+      }
     }
-  }
-};
+  };
 
 // eslint-disable-next-line no-unused-vars
-ValueNode.prototype.iterate = function(fn, reverse) {
+ValueNode.prototype.iterate = function (fn, reverse) {
   return fn(this.entry);
 };
 
-var MapIterator = (function (Iterator$$1) {
+var MapIterator = /*@__PURE__*/(function (Iterator) {
   function MapIterator(map, type, reverse) {
     this._type = type;
     this._reverse = reverse;
     this._stack = map._root && mapIteratorFrame(map._root);
   }
 
-  if ( Iterator$$1 ) MapIterator.__proto__ = Iterator$$1;
-  MapIterator.prototype = Object.create( Iterator$$1 && Iterator$$1.prototype );
+  if ( Iterator ) MapIterator.__proto__ = Iterator;
+  MapIterator.prototype = Object.create( Iterator && Iterator.prototype );
   MapIterator.prototype.constructor = MapIterator;
 
   MapIterator.prototype.next = function next () {
-    var this$1 = this;
-
     var type = this._type;
     var stack = this._stack;
     while (stack) {
@@ -2547,23 +2912,23 @@ var MapIterator = (function (Iterator$$1) {
         if (index <= maxIndex) {
           return mapIteratorValue(
             type,
-            node.entries[this$1._reverse ? maxIndex - index : index]
+            node.entries[this._reverse ? maxIndex - index : index]
           );
         }
       } else {
         maxIndex = node.nodes.length - 1;
         if (index <= maxIndex) {
-          var subNode = node.nodes[this$1._reverse ? maxIndex - index : index];
+          var subNode = node.nodes[this._reverse ? maxIndex - index : index];
           if (subNode) {
             if (subNode.entry) {
               return mapIteratorValue(type, subNode.entry);
             }
-            stack = this$1._stack = mapIteratorFrame(subNode, stack);
+            stack = this._stack = mapIteratorFrame(subNode, stack);
           }
           continue;
         }
       }
-      stack = this$1._stack = this$1._stack.__prev;
+      stack = this._stack = this._stack.__prev;
     }
     return iteratorDone();
   };
@@ -2579,16 +2944,16 @@ function mapIteratorFrame(node, prev) {
   return {
     node: node,
     index: 0,
-    __prev: prev
+    __prev: prev,
   };
 }
 
-function makeMap(size, root, ownerID, hash$$1) {
+function makeMap(size, root, ownerID, hash) {
   var map = Object.create(MapPrototype);
   map.size = size;
   map._root = root;
   map.__ownerID = ownerID;
-  map.__hash = hash$$1;
+  map.__hash = hash;
   map.__altered = false;
   return map;
 }
@@ -2608,8 +2973,8 @@ function updateMap(map, k, v) {
     newSize = 1;
     newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
   } else {
-    var didChangeSize = MakeRef(CHANGE_LENGTH);
-    var didAlter = MakeRef(DID_ALTER);
+    var didChangeSize = MakeRef();
+    var didAlter = MakeRef();
     newRoot = updateNode(
       map._root,
       map.__ownerID,
@@ -2724,90 +3089,6 @@ function expandNodes(ownerID, nodes, bitmap, including, node) {
   return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
 }
 
-function mergeIntoMapWith(map, merger, collections) {
-  var iters = [];
-  for (var ii = 0; ii < collections.length; ii++) {
-    iters.push(KeyedCollection(collections[ii]));
-  }
-  return mergeIntoCollectionWith(map, merger, iters);
-}
-
-function alwaysNewVal(oldVal, newVal) {
-  return newVal;
-}
-
-function deepMergerWith(merger) {
-  return function(oldVal, newVal, key) {
-    if (oldVal && newVal && typeof newVal === 'object') {
-      if (oldVal.mergeDeepWith) {
-        return oldVal.mergeDeepWith(merger, newVal);
-      }
-      if (oldVal.merge) {
-        return oldVal.merge(newVal);
-      }
-    }
-    var nextValue = merger(oldVal, newVal, key);
-    return is(oldVal, nextValue) ? oldVal : nextValue;
-  };
-}
-
-function mergeIntoCollectionWith(collection, merger, iters) {
-  iters = iters.filter(function (x) { return x.size !== 0; });
-  if (iters.length === 0) {
-    return collection;
-  }
-  if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {
-    return collection.constructor(iters[0]);
-  }
-  return collection.withMutations(function (collection) {
-    var mergeIntoCollection = merger
-      ? function (value, key) {
-          collection.update(
-            key,
-            NOT_SET,
-            function (oldVal) { return (oldVal === NOT_SET ? value : merger(oldVal, value, key)); }
-          );
-        }
-      : function (value, key) {
-          collection.set(key, value);
-        };
-    for (var ii = 0; ii < iters.length; ii++) {
-      iters[ii].forEach(mergeIntoCollection);
-    }
-  });
-}
-
-function updateInDeepMap(existing, keyPath, i, notSetValue, updater) {
-  var isNotSet = existing === NOT_SET;
-  if (i === keyPath.length) {
-    var existingValue = isNotSet ? notSetValue : existing;
-    var newValue = updater(existingValue);
-    return newValue === existingValue ? existing : newValue;
-  }
-  if (!(isNotSet || (existing && existing.set))) {
-    throw new TypeError(
-      'Invalid keyPath: Value at [' +
-        keyPath.slice(0, i).map(quoteString) +
-        '] does not have a .set() method and cannot be updated: ' +
-        existing
-    );
-  }
-  var key = keyPath[i];
-  var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
-  var nextUpdated = updateInDeepMap(
-    nextExisting,
-    keyPath,
-    i + 1,
-    notSetValue,
-    updater
-  );
-  return nextUpdated === nextExisting
-    ? existing
-    : nextUpdated === NOT_SET
-      ? existing.remove(key)
-      : (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
-}
-
 function popCount(x) {
   x -= (x >> 1) & 0x55555555;
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
@@ -2817,7 +3098,7 @@ function popCount(x) {
   return x & 0x7f;
 }
 
-function setIn(array, idx, val, canEdit) {
+function setAt(array, idx, val, canEdit) {
   var newArray = canEdit ? array : arrCopy(array);
   newArray[idx] = val;
   return newArray;
@@ -2863,7 +3144,13 @@ var MAX_ARRAY_MAP_SIZE = SIZE / 4;
 var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
 var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
 
-var List = (function (IndexedCollection$$1) {
+var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';
+
+function isList(maybeList) {
+  return Boolean(maybeList && maybeList[IS_LIST_SYMBOL]);
+}
+
+var List = /*@__PURE__*/(function (IndexedCollection) {
   function List(value) {
     var empty = emptyList();
     if (value === null || value === undefined) {
@@ -2872,7 +3159,7 @@ var List = (function (IndexedCollection$$1) {
     if (isList(value)) {
       return value;
     }
-    var iter = IndexedCollection$$1(value);
+    var iter = IndexedCollection(value);
     var size = iter.size;
     if (size === 0) {
       return empty;
@@ -2887,8 +3174,8 @@ var List = (function (IndexedCollection$$1) {
     });
   }
 
-  if ( IndexedCollection$$1 ) List.__proto__ = IndexedCollection$$1;
-  List.prototype = Object.create( IndexedCollection$$1 && IndexedCollection$$1.prototype );
+  if ( IndexedCollection ) List.__proto__ = IndexedCollection;
+  List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );
   List.prototype.constructor = List;
 
   List.of = function of (/*...values*/) {
@@ -2921,8 +3208,10 @@ var List = (function (IndexedCollection$$1) {
     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) {
@@ -2936,8 +3225,7 @@ var List = (function (IndexedCollection$$1) {
     if (this.__ownerID) {
       this.size = this._origin = this._capacity = 0;
       this._level = SHIFT;
-      this._root = this._tail = null;
-      this.__hash = undefined;
+      this._root = this._tail = this.__hash = undefined;
       this.__altered = true;
       return this;
     }
@@ -2975,14 +3263,46 @@ var List = (function (IndexedCollection$$1) {
 
   // @pragma Composition
 
-  List.prototype.merge = function merge (/*...collections*/) {
-    return this.concat.apply(this, arguments);
+  List.prototype.concat = function concat (/*...collections*/) {
+    var arguments$1 = arguments;
+
+    var seqs = [];
+    for (var i = 0; i < arguments.length; i++) {
+      var argument = arguments$1[i];
+      var seq = IndexedCollection(
+        typeof argument !== 'string' && hasIterator(argument)
+          ? argument
+          : [argument]
+      );
+      if (seq.size !== 0) {
+        seqs.push(seq);
+      }
+    }
+    if (seqs.length === 0) {
+      return this;
+    }
+    if (this.size === 0 && !this.__ownerID && seqs.length === 1) {
+      return this.constructor(seqs[0]);
+    }
+    return this.withMutations(function (list) {
+      seqs.forEach(function (seq) { return seq.forEach(function (value) { return list.push(value); }); });
+    });
   };
 
   List.prototype.setSize = function setSize (size) {
     return setListBounds(this, 0, size);
   };
 
+  List.prototype.map = function map (mapper, context) {
+    var this$1$1 = this;
+
+    return this.withMutations(function (list) {
+      for (var i = 0; i < this$1$1.size; i++) {
+        list.set(i, mapper.call(context, list.get(i), i, this$1$1));
+      }
+    });
+  };
+
   // @pragma Iteration
 
   List.prototype.slice = function slice (begin, end) {
@@ -3009,13 +3329,11 @@ var List = (function (IndexedCollection$$1) {
   };
 
   List.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
-
     var index = reverse ? this.size : 0;
     var values = iterateList(this, reverse);
     var value;
     while ((value = values()) !== DONE) {
-      if (fn(value, reverse ? --index : index++, this$1) === false) {
+      if (fn(value, reverse ? --index : index++, this) === false) {
         break;
       }
     }
@@ -3048,32 +3366,28 @@ var List = (function (IndexedCollection$$1) {
   return List;
 }(IndexedCollection));
 
-function isList(maybeList) {
-  return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
-}
-
 List.isList = isList;
 
-var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
-
 var ListPrototype = List.prototype;
-ListPrototype[IS_LIST_SENTINEL] = true;
+ListPrototype[IS_LIST_SYMBOL] = true;
 ListPrototype[DELETE] = ListPrototype.remove;
-ListPrototype.setIn = MapPrototype.setIn;
-ListPrototype.deleteIn = ListPrototype.removeIn = MapPrototype.removeIn;
-ListPrototype.update = MapPrototype.update;
-ListPrototype.updateIn = MapPrototype.updateIn;
-ListPrototype.mergeIn = MapPrototype.mergeIn;
-ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
-ListPrototype.withMutations = MapPrototype.withMutations;
-ListPrototype.asMutable = MapPrototype.asMutable;
-ListPrototype.asImmutable = MapPrototype.asImmutable;
-ListPrototype.wasAltered = MapPrototype.wasAltered;
-ListPrototype['@@transducer/init'] = ListPrototype.asMutable;
-ListPrototype['@@transducer/step'] = function(result, arr) {
+ListPrototype.merge = ListPrototype.concat;
+ListPrototype.setIn = setIn;
+ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;
+ListPrototype.update = update;
+ListPrototype.updateIn = updateIn;
+ListPrototype.mergeIn = mergeIn;
+ListPrototype.mergeDeepIn = mergeDeepIn;
+ListPrototype.withMutations = withMutations;
+ListPrototype.wasAltered = wasAltered;
+ListPrototype.asImmutable = asImmutable;
+ListPrototype['@@transducer/init'] = ListPrototype.asMutable = asMutable;
+ListPrototype['@@transducer/step'] = function (result, arr) {
   return result.push(arr);
 };
-ListPrototype['@@transducer/result'] = MapPrototype['@@transducer/result'];
+ListPrototype['@@transducer/result'] = function (obj) {
+  return obj.asImmutable();
+};
 
 var VNode = function VNode(array, ownerID) {
   this.array = array;
@@ -3083,7 +3397,7 @@ var VNode = function VNode(array, ownerID) {
 // TODO: seems like these methods are very similar
 
 VNode.prototype.removeBefore = function removeBefore (ownerID, level, index) {
-  if (index === level ? 1 << level : 0 || this.array.length === 0) {
+  if (index === level ? 1 << level : this.array.length === 0) {
     return this;
   }
   var originIndex = (index >>> level) & MASK;
@@ -3243,7 +3557,7 @@ function updateList(list, index, value) {
 
   var newTail = list._tail;
   var newRoot = list._root;
-  var didAlter = MakeRef(DID_ALTER);
+  var didAlter = MakeRef();
   if (index >= getTailOffset(list._capacity)) {
     newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
   } else {
@@ -3302,7 +3616,9 @@ function updateVNode(node, ownerID, level, index, value, didAlter) {
     return node;
   }
 
-  SetRef(didAlter);
+  if (didAlter) {
+    SetRef(didAlter);
+  }
 
   newNode = editableVNode(node, ownerID);
   if (value === undefined && idx === newNode.array.length - 1) {
@@ -3351,7 +3667,9 @@ function setListBounds(list, begin, end) {
   var newCapacity =
     end === undefined
       ? oldCapacity
-      : end < 0 ? oldCapacity + end : oldOrigin + end;
+      : end < 0
+      ? oldCapacity + end
+      : oldOrigin + end;
   if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
     return list;
   }
@@ -3398,7 +3716,9 @@ function setListBounds(list, begin, end) {
   var newTail =
     newTailOffset < oldTailOffset
       ? listNodeFor(list, newCapacity - 1)
-      : newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;
+      : newTailOffset > oldTailOffset
+      ? new VNode([], owner)
+      : oldTail;
 
   // Merge Tail into tree.
   if (
@@ -3481,21 +3801,21 @@ function getTailOffset(size) {
   return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
 }
 
-var OrderedMap = (function (Map$$1) {
+var OrderedMap = /*@__PURE__*/(function (Map) {
   function OrderedMap(value) {
     return value === null || value === undefined
       ? 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$$1 ) OrderedMap.__proto__ = Map$$1;
-  OrderedMap.prototype = Object.create( Map$$1 && Map$$1.prototype );
+  if ( Map ) OrderedMap.__proto__ = Map;
+  OrderedMap.prototype = Object.create( Map && Map.prototype );
   OrderedMap.prototype.constructor = OrderedMap;
 
   OrderedMap.of = function of (/*...values*/) {
@@ -3523,6 +3843,7 @@ var OrderedMap = (function (Map$$1) {
       this.size = 0;
       this._map.clear();
       this._list.clear();
+      this.__altered = true;
       return this;
     }
     return emptyOrderedMap();
@@ -3536,15 +3857,11 @@ var OrderedMap = (function (Map$$1) {
     return updateOrderedMap(this, k, NOT_SET);
   };
 
-  OrderedMap.prototype.wasAltered = function wasAltered () {
-    return this._map.wasAltered() || this._list.wasAltered();
-  };
-
   OrderedMap.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     return this._list.__iterate(
-      function (entry) { return entry && fn(entry[1], entry[0], this$1); },
+      function (entry) { return entry && fn(entry[1], entry[0], this$1$1); },
       reverse
     );
   };
@@ -3564,6 +3881,7 @@ var OrderedMap = (function (Map$$1) {
         return emptyOrderedMap();
       }
       this.__ownerID = ownerID;
+      this.__altered = false;
       this._map = newMap;
       this._list = newList;
       return this;
@@ -3574,13 +3892,9 @@ var OrderedMap = (function (Map$$1) {
   return OrderedMap;
 }(Map));
 
-function isOrderedMap(maybeOrderedMap) {
-  return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
-}
-
 OrderedMap.isOrderedMap = isOrderedMap;
 
-OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
+OrderedMap.prototype[IS_ORDERED_SYMBOL] = true;
 OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;
 
 function makeOrderedMap(map, list, ownerID, hash) {
@@ -3590,6 +3904,7 @@ function makeOrderedMap(map, list, ownerID, hash) {
   omap._list = list;
   omap.__ownerID = ownerID;
   omap.__hash = hash;
+  omap.__altered = false;
   return omap;
 }
 
@@ -3642,20 +3957,29 @@ function updateOrderedMap(omap, k, v) {
     omap._map = newMap;
     omap._list = newList;
     omap.__hash = undefined;
+    omap.__altered = true;
     return omap;
   }
   return makeOrderedMap(newMap, newList);
 }
 
-var Stack = (function (IndexedCollection$$1) {
+var IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@';
+
+function isStack(maybeStack) {
+  return Boolean(maybeStack && maybeStack[IS_STACK_SYMBOL]);
+}
+
+var Stack = /*@__PURE__*/(function (IndexedCollection) {
   function Stack(value) {
     return value === null || value === undefined
       ? emptyStack()
-      : isStack(value) ? value : emptyStack().pushAll(value);
+      : isStack(value)
+      ? value
+      : emptyStack().pushAll(value);
   }
 
-  if ( IndexedCollection$$1 ) Stack.__proto__ = IndexedCollection$$1;
-  Stack.prototype = Object.create( IndexedCollection$$1 && IndexedCollection$$1.prototype );
+  if ( IndexedCollection ) Stack.__proto__ = IndexedCollection;
+  Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );
   Stack.prototype.constructor = Stack;
 
   Stack.of = function of (/*...values*/) {
@@ -3694,7 +4018,7 @@ var Stack = (function (IndexedCollection$$1) {
     for (var ii = arguments.length - 1; ii >= 0; ii--) {
       head = {
         value: arguments$1[ii],
-        next: head
+        next: head,
       };
     }
     if (this.__ownerID) {
@@ -3708,7 +4032,7 @@ var Stack = (function (IndexedCollection$$1) {
   };
 
   Stack.prototype.pushAll = function pushAll (iter) {
-    iter = IndexedCollection$$1(iter);
+    iter = IndexedCollection(iter);
     if (iter.size === 0) {
       return this;
     }
@@ -3722,7 +4046,7 @@ var Stack = (function (IndexedCollection$$1) {
       newSize++;
       head = {
         value: value,
-        next: head
+        next: head,
       };
     }, /* reverse */ true);
     if (this.__ownerID) {
@@ -3761,7 +4085,7 @@ var Stack = (function (IndexedCollection$$1) {
     var resolvedEnd = resolveEnd(end, this.size);
     if (resolvedEnd !== this.size) {
       // super.slice(begin, end);
-      return IndexedCollection$$1.prototype.slice.call(this, begin, end);
+      return IndexedCollection.prototype.slice.call(this, begin, end);
     }
     var newSize = this.size - resolvedBegin;
     var head = this._head;
@@ -3798,18 +4122,18 @@ var Stack = (function (IndexedCollection$$1) {
   // @pragma Iteration
 
   Stack.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     if (reverse) {
       return new ArraySeq(this.toArray()).__iterate(
-        function (v, k) { return fn(v, k, this$1); },
+        function (v, k) { return fn(v, k, this$1$1); },
         reverse
       );
     }
     var iterations = 0;
     var node = this._head;
     while (node) {
-      if (fn(node.value, iterations++, this$1) === false) {
+      if (fn(node.value, iterations++, this) === false) {
         break;
       }
       node = node.next;
@@ -3836,28 +4160,23 @@ var Stack = (function (IndexedCollection$$1) {
   return Stack;
 }(IndexedCollection));
 
-function isStack(maybeStack) {
-  return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
-}
-
 Stack.isStack = isStack;
 
-var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
-
 var StackPrototype = Stack.prototype;
-StackPrototype[IS_STACK_SENTINEL] = true;
-StackPrototype.withMutations = MapPrototype.withMutations;
-StackPrototype.asMutable = MapPrototype.asMutable;
-StackPrototype.asImmutable = MapPrototype.asImmutable;
-StackPrototype.wasAltered = MapPrototype.wasAltered;
+StackPrototype[IS_STACK_SYMBOL] = true;
 StackPrototype.shift = StackPrototype.pop;
 StackPrototype.unshift = StackPrototype.push;
 StackPrototype.unshiftAll = StackPrototype.pushAll;
-StackPrototype['@@transducer/init'] = StackPrototype.asMutable;
-StackPrototype['@@transducer/step'] = function(result, arr) {
+StackPrototype.withMutations = withMutations;
+StackPrototype.wasAltered = wasAltered;
+StackPrototype.asImmutable = asImmutable;
+StackPrototype['@@transducer/init'] = StackPrototype.asMutable = asMutable;
+StackPrototype['@@transducer/step'] = function (result, arr) {
   return result.unshift(arr);
 };
-StackPrototype['@@transducer/result'] = MapPrototype['@@transducer/result'];
+StackPrototype['@@transducer/result'] = function (obj) {
+  return obj.asImmutable();
+};
 
 function makeStack(size, head, ownerID, hash) {
   var map = Object.create(StackPrototype);
@@ -3874,6 +4193,16 @@ function emptyStack() {
   return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
 }
 
+var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';
+
+function isSet(maybeSet) {
+  return Boolean(maybeSet && maybeSet[IS_SET_SYMBOL]);
+}
+
+function isOrderedSet(maybeOrderedSet) {
+  return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
+}
+
 function deepEqual(a, b) {
   if (a === b) {
     return true;
@@ -3928,7 +4257,9 @@ function deepEqual(a, b) {
     if (
       notAssociative
         ? !a.has(v)
-        : flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)
+        : flipped
+        ? !is(v, a.get(k, NOT_SET))
+        : !is(a.get(k, NOT_SET), v)
     ) {
       allEqual = false;
       return false;
@@ -3938,9 +4269,6 @@ function deepEqual(a, b) {
   return allEqual && a.size === bSize;
 }
 
-/**
- * Contributes additional methods to a constructor
- */
 function mixin(ctor, methods) {
   var keyCopier = function (key) {
     ctor.prototype[key] = methods[key];
@@ -3951,21 +4279,45 @@ function mixin(ctor, methods) {
   return ctor;
 }
 
-var Set = (function (SetCollection$$1) {
+function toJS(value) {
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  if (!isCollection(value)) {
+    if (!isDataStructure(value)) {
+      return value;
+    }
+    value = Seq(value);
+  }
+  if (isKeyed(value)) {
+    var result$1 = {};
+    value.__iterate(function (v, k) {
+      result$1[k] = toJS(v);
+    });
+    return result$1;
+  }
+  var result = [];
+  value.__iterate(function (v) {
+    result.push(toJS(v));
+  });
+  return result;
+}
+
+var Set = /*@__PURE__*/(function (SetCollection) {
   function Set(value) {
     return value === null || value === undefined
       ? emptySet()
       : isSet(value) && !isOrdered(value)
-        ? value
-        : emptySet().withMutations(function (set) {
-            var iter = SetCollection$$1(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$$1 ) Set.__proto__ = SetCollection$$1;
-  Set.prototype = Object.create( SetCollection$$1 && SetCollection$$1.prototype );
+  if ( SetCollection ) Set.__proto__ = SetCollection;
+  Set.prototype = Object.create( SetCollection && SetCollection.prototype );
   Set.prototype.constructor = Set;
 
   Set.of = function of (/*...values*/) {
@@ -4016,6 +4368,30 @@ var Set = (function (SetCollection$$1) {
 
   // @pragma Composition
 
+  Set.prototype.map = function map (mapper, context) {
+    var this$1$1 = this;
+
+    // keep track if the set is altered by the map function
+    var didChanges = false;
+
+    var newMap = updateSet(
+      this,
+      this._map.mapEntries(function (ref) {
+        var v = ref[1];
+
+        var mapped = mapper.call(context, v, v, this$1$1);
+
+        if (mapped !== v) {
+          didChanges = true;
+        }
+
+        return [mapped, mapped];
+      }, context)
+    );
+
+    return didChanges ? newMap : this;
+  };
+
   Set.prototype.union = function union () {
     var iters = [], len = arguments.length;
     while ( len-- ) iters[ len ] = arguments[ len ];
@@ -4029,7 +4405,7 @@ var Set = (function (SetCollection$$1) {
     }
     return this.withMutations(function (set) {
       for (var ii = 0; ii < iters.length; ii++) {
-        SetCollection$$1(iters[ii]).forEach(function (value) { return set.add(value); });
+        SetCollection(iters[ii]).forEach(function (value) { return set.add(value); });
       }
     });
   };
@@ -4041,7 +4417,7 @@ var Set = (function (SetCollection$$1) {
     if (iters.length === 0) {
       return this;
     }
-    iters = iters.map(function (iter) { return SetCollection$$1(iter); });
+    iters = iters.map(function (iter) { return SetCollection(iter); });
     var toRemove = [];
     this.forEach(function (value) {
       if (!iters.every(function (iter) { return iter.includes(value); })) {
@@ -4062,7 +4438,7 @@ var Set = (function (SetCollection$$1) {
     if (iters.length === 0) {
       return this;
     }
-    iters = iters.map(function (iter) { return SetCollection$$1(iter); });
+    iters = iters.map(function (iter) { return SetCollection(iter); });
     var toRemove = [];
     this.forEach(function (value) {
       if (iters.some(function (iter) { return iter.includes(value); })) {
@@ -4091,9 +4467,9 @@ var Set = (function (SetCollection$$1) {
   };
 
   Set.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
-    return this._map.__iterate(function (k) { return fn(k, k, this$1); }, reverse);
+    return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse);
   };
 
   Set.prototype.__iterator = function __iterator (type, reverse) {
@@ -4119,26 +4495,21 @@ var Set = (function (SetCollection$$1) {
   return Set;
 }(SetCollection));
 
-function isSet(maybeSet) {
-  return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
-}
-
 Set.isSet = isSet;
 
-var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
-
 var SetPrototype = Set.prototype;
-SetPrototype[IS_SET_SENTINEL] = true;
+SetPrototype[IS_SET_SYMBOL] = true;
 SetPrototype[DELETE] = SetPrototype.remove;
-SetPrototype.merge = SetPrototype.union;
-SetPrototype.withMutations = MapPrototype.withMutations;
-SetPrototype.asMutable = MapPrototype.asMutable;
-SetPrototype.asImmutable = MapPrototype.asImmutable;
-SetPrototype['@@transducer/init'] = SetPrototype.asMutable;
-SetPrototype['@@transducer/step'] = function(result, arr) {
+SetPrototype.merge = SetPrototype.concat = SetPrototype.union;
+SetPrototype.withMutations = withMutations;
+SetPrototype.asImmutable = asImmutable;
+SetPrototype['@@transducer/init'] = SetPrototype.asMutable = asMutable;
+SetPrototype['@@transducer/step'] = function (result, arr) {
   return result.add(arr);
 };
-SetPrototype['@@transducer/result'] = MapPrototype['@@transducer/result'];
+SetPrototype['@@transducer/result'] = function (obj) {
+  return obj.asImmutable();
+};
 
 SetPrototype.__empty = emptySet;
 SetPrototype.__make = makeSet;
@@ -4151,7 +4522,9 @@ function updateSet(set, newMap) {
   }
   return newMap === set._map
     ? set
-    : newMap.size === 0 ? set.__empty() : set.__make(newMap);
+    : newMap.size === 0
+    ? set.__empty()
+    : set.__make(newMap);
 }
 
 function makeSet(map, ownerID) {
@@ -4172,7 +4545,7 @@ function emptySet() {
  * (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 = (function (IndexedSeq$$1) {
+var Range = /*@__PURE__*/(function (IndexedSeq) {
   function Range(start, end, step) {
     if (!(this instanceof Range)) {
       return new Range(start, end, step);
@@ -4198,8 +4571,8 @@ var Range = (function (IndexedSeq$$1) {
     }
   }
 
-  if ( IndexedSeq$$1 ) Range.__proto__ = IndexedSeq$$1;
-  Range.prototype = Object.create( IndexedSeq$$1 && IndexedSeq$$1.prototype );
+  if ( IndexedSeq ) Range.__proto__ = IndexedSeq;
+  Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
   Range.prototype.constructor = Range;
 
   Range.prototype.toString = function toString () {
@@ -4263,14 +4636,12 @@ var Range = (function (IndexedSeq$$1) {
   };
 
   Range.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
-
     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$1) === false) {
+      if (fn(value, reverse ? size - ++i : i++, this) === false) {
         break;
       }
       value += reverse ? -step : step;
@@ -4306,6 +4677,39 @@ var Range = (function (IndexedSeq$$1) {
 
 var EMPTY_RANGE;
 
+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;
+    }
+  }
+  return collection;
+}
+
+function getIn(searchKeyPath, notSetValue) {
+  return getIn$1(this, searchKeyPath, notSetValue);
+}
+
+function hasIn$1(collection, keyPath) {
+  return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;
+}
+
+function hasIn(searchKeyPath) {
+  return hasIn$1(this, searchKeyPath);
+}
+
+function toObject() {
+  assertNotInfinite(this.size);
+  var object = {};
+  this.__iterate(function (v, k) {
+    object[k] = v;
+  });
+  return object;
+}
+
 // Note: all of these methods are deprecated.
 Collection.isIterable = isCollection;
 Collection.isKeyed = isKeyed;
@@ -4335,9 +4739,7 @@ mixin(Collection, {
   },
 
   toJS: function toJS$1() {
-    return this.toSeq()
-      .map(toJS)
-      .toJSON();
+    return toJS(this);
   },
 
   toKeyedSeq: function toKeyedSeq() {
@@ -4349,14 +4751,7 @@ mixin(Collection, {
     return Map(this.toKeyedSeq());
   },
 
-  toObject: function toObject() {
-    assertNotInfinite(this.size);
-    var object = {};
-    this.__iterate(function (v, k) {
-      object[k] = v;
-    });
-    return object;
-  },
+  toObject: toObject,
 
   toOrderedMap: function toOrderedMap() {
     // Use Late Binding here to solve the circular dependency.
@@ -4380,7 +4775,9 @@ mixin(Collection, {
   toSeq: function toSeq() {
     return isIndexed(this)
       ? this.toIndexedSeq()
-      : isKeyed(this) ? this.toKeyedSeq() : this.toSetSeq();
+      : isKeyed(this)
+      ? this.toKeyedSeq()
+      : this.toSetSeq();
   },
 
   toStack: function toStack() {
@@ -4406,9 +4803,7 @@ mixin(Collection, {
     return (
       head +
       ' ' +
-      this.toSeq()
-        .map(this.__toStringMapper)
-        .join(', ') +
+      this.toSeq().map(this.__toStringMapper).join(', ') +
       ' ' +
       tail
     );
@@ -4549,18 +4944,8 @@ mixin(Collection, {
       // We cache as an entries array, so we can just return the cache!
       return new ArraySeq(collection._cache);
     }
-    var entriesSequence = collection
-      .toSeq()
-      .map(entryMapper)
-      .toIndexedSeq();
+    var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq();
     entriesSequence.fromEntrySeq = function () { return collection.toSeq(); };
-
-    // Entries are plain Array, which do not define toJS, so it must
-    // manually converts keys and values before conversion.
-    entriesSequence.toJS = function() {
-      return this.map(function (entry) { return [toJS(entry[0]), toJS(entry[1])]; }).toJSON();
-    };
-
     return entriesSequence;
   },
 
@@ -4585,9 +4970,7 @@ mixin(Collection, {
   },
 
   findLast: function findLast(predicate, context, notSetValue) {
-    return this.toKeyedSeq()
-      .reverse()
-      .find(predicate, context, notSetValue);
+    return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
   },
 
   findLastEntry: function findLastEntry(predicate, context, notSetValue) {
@@ -4597,13 +4980,11 @@ mixin(Collection, {
   },
 
   findLastKey: function findLastKey(predicate, context) {
-    return this.toKeyedSeq()
-      .reverse()
-      .findKey(predicate, context);
+    return this.toKeyedSeq().reverse().findKey(predicate, context);
   },
 
-  first: function first() {
-    return this.find(returnTrue);
+  first: function first(notSetValue) {
+    return this.find(returnTrue, null, notSetValue);
   },
 
   flatMap: function flatMap(mapper, context) {
@@ -4622,9 +5003,7 @@ mixin(Collection, {
     return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue);
   },
 
-  getIn: function getIn$1(searchKeyPath, notSetValue) {
-    return getIn(this, notSetValue, searchKeyPath, true /* report bad path */);
-  },
+  getIn: getIn,
 
   groupBy: function groupBy(grouper, context) {
     return groupByFactory(this, grouper, context);
@@ -4634,12 +5013,7 @@ mixin(Collection, {
     return this.get(searchKey, NOT_SET) !== NOT_SET;
   },
 
-  hasIn: function hasIn(searchKeyPath) {
-    return (
-      getIn(this, NOT_SET, searchKeyPath, false /* report bad path */) !==
-      NOT_SET
-    );
-  },
+  hasIn: hasIn,
 
   isSubset: function isSubset(iter) {
     iter = typeof iter.includes === 'function' ? iter : Collection(iter);
@@ -4656,21 +5030,15 @@ mixin(Collection, {
   },
 
   keySeq: function keySeq() {
-    return this.toSeq()
-      .map(keyMapper)
-      .toIndexedSeq();
+    return this.toSeq().map(keyMapper).toIndexedSeq();
   },
 
-  last: function last() {
-    return this.toSeq()
-      .reverse()
-      .first();
+  last: function last(notSetValue) {
+    return this.toSeq().reverse().first(notSetValue);
   },
 
   lastKeyOf: function lastKeyOf(searchValue) {
-    return this.toKeyedSeq()
-      .reverse()
-      .keyOf(searchValue);
+    return this.toKeyedSeq().reverse().keyOf(searchValue);
   },
 
   max: function max(comparator) {
@@ -4748,7 +5116,7 @@ mixin(Collection, {
 
   hashCode: function hashCode() {
     return this.__hash || (this.__hash = hashCollection(this));
-  }
+  },
 
   // ### Internal
 
@@ -4758,11 +5126,11 @@ mixin(Collection, {
 });
 
 var CollectionPrototype = Collection.prototype;
-CollectionPrototype[IS_ITERABLE_SENTINEL] = true;
+CollectionPrototype[IS_COLLECTION_SYMBOL] = true;
 CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;
 CollectionPrototype.toJSON = CollectionPrototype.toArray;
 CollectionPrototype.__toStringMapper = quoteString;
-CollectionPrototype.inspect = CollectionPrototype.toSource = function() {
+CollectionPrototype.inspect = CollectionPrototype.toSource = function () {
   return this.toString();
 };
 CollectionPrototype.chain = CollectionPrototype.flatMap;
@@ -4776,34 +5144,34 @@ mixin(KeyedCollection, {
   },
 
   mapEntries: function mapEntries(mapper, context) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var iterations = 0;
     return reify(
       this,
       this.toSeq()
-        .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1); })
+        .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1$1); })
         .fromEntrySeq()
     );
   },
 
   mapKeys: function mapKeys(mapper, context) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     return reify(
       this,
       this.toSeq()
         .flip()
-        .map(function (k, v) { return mapper.call(context, k, v, this$1); })
+        .map(function (k, v) { return mapper.call(context, k, v, this$1$1); })
         .flip()
     );
-  }
+  },
 });
 
 var KeyedCollectionPrototype = KeyedCollection.prototype;
-KeyedCollectionPrototype[IS_KEYED_SENTINEL] = true;
+KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;
 KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;
-KeyedCollectionPrototype.toJSON = CollectionPrototype.toObject;
+KeyedCollectionPrototype.toJSON = toObject;
 KeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); };
 
 mixin(IndexedCollection, {
@@ -4868,8 +5236,8 @@ mixin(IndexedCollection, {
     return entry ? entry[0] : -1;
   },
 
-  first: function first() {
-    return this.get(0);
+  first: function first(notSetValue) {
+    return this.get(0, notSetValue);
   },
 
   flatten: function flatten(depth) {
@@ -4879,7 +5247,8 @@ mixin(IndexedCollection, {
   get: function get(index, notSetValue) {
     index = wrapIndex(this, index);
     return index < 0 ||
-      (this.size === Infinity || (this.size !== undefined && index > this.size))
+      this.size === Infinity ||
+      (this.size !== undefined && index > this.size)
       ? notSetValue
       : this.find(function (_, key) { return key === index; }, undefined, notSetValue);
   },
@@ -4912,8 +5281,8 @@ mixin(IndexedCollection, {
     return Range(0, this.size);
   },
 
-  last: function last() {
-    return this.get(-1);
+  last: function last(notSetValue) {
+    return this.get(-1, notSetValue);
   },
 
   skipWhile: function skipWhile(predicate, context) {
@@ -4934,12 +5303,12 @@ mixin(IndexedCollection, {
     var collections = arrCopy(arguments);
     collections[0] = this;
     return reify(this, zipWithFactory(this, zipper, collections));
-  }
+  },
 });
 
 var IndexedCollectionPrototype = IndexedCollection.prototype;
-IndexedCollectionPrototype[IS_INDEXED_SENTINEL] = true;
-IndexedCollectionPrototype[IS_ORDERED_SENTINEL] = true;
+IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;
+IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;
 
 mixin(SetCollection, {
   // ### ES6 Collection methods (ES6 Array and Map)
@@ -4956,17 +5325,19 @@ mixin(SetCollection, {
 
   keySeq: function keySeq() {
     return this.valueSeq();
-  }
+  },
 });
 
-SetCollection.prototype.has = CollectionPrototype.includes;
-SetCollection.prototype.contains = SetCollection.prototype.includes;
+var SetCollectionPrototype = SetCollection.prototype;
+SetCollectionPrototype.has = CollectionPrototype.includes;
+SetCollectionPrototype.contains = SetCollectionPrototype.includes;
+SetCollectionPrototype.keys = SetCollectionPrototype.values;
 
 // Mixin subclasses
 
-mixin(KeyedSeq, KeyedCollection.prototype);
-mixin(IndexedSeq, IndexedCollection.prototype);
-mixin(SetSeq, SetCollection.prototype);
+mixin(KeyedSeq, KeyedCollectionPrototype);
+mixin(IndexedSeq, IndexedCollectionPrototype);
+mixin(SetSeq, SetCollectionPrototype);
 
 // #pragma Helper functions
 
@@ -4991,18 +5362,14 @@ function entryMapper(v, k) {
   return [k, v];
 }
 
-function toJS(value) {
-  return value && typeof value.toJS === 'function' ? value.toJS() : value;
-}
-
 function not(predicate) {
-  return function() {
+  return function () {
     return !predicate.apply(this, arguments);
   };
 }
 
 function neg(predicate) {
-  return function() {
+  return function () {
     return -predicate.apply(this, arguments);
   };
 }
@@ -5032,12 +5399,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(size, h);
 }
@@ -5057,55 +5424,21 @@ function hashMerge(a, b) {
   return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
 }
 
-function warn(message) {
-  /* eslint-disable no-console */
-  if (typeof console === 'object' && console.warn) {
-    console.warn(message);
-  } else {
-    throw new Error(message);
-  }
-  /* eslint-enable no-console */
-}
-
-function getIn(value, notSetValue, searchKeyPath, reportBadKeyPath) {
-  var keyPath = coerceKeyPath(searchKeyPath);
-  var i = 0;
-  while (i !== keyPath.length) {
-    if (!value || !value.get) {
-      if (reportBadKeyPath) {
-        warn(
-          'Invalid keyPath: Value at [' +
-            keyPath.slice(0, i).map(quoteString) +
-            '] does not have a .get() method: ' +
-            value +
-            '\nThis warning will throw in a future version'
-        );
-      }
-      return notSetValue;
-    }
-    value = value.get(keyPath[i++], NOT_SET);
-    if (value === NOT_SET) {
-      return notSetValue;
-    }
-  }
-  return value;
-}
-
-var OrderedSet = (function (Set$$1) {
+var OrderedSet = /*@__PURE__*/(function (Set) {
   function OrderedSet(value) {
     return value === null || value === undefined
       ? 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$$1 ) OrderedSet.__proto__ = Set$$1;
-  OrderedSet.prototype = Object.create( Set$$1 && Set$$1.prototype );
+  if ( Set ) OrderedSet.__proto__ = Set;
+  OrderedSet.prototype = Object.create( Set && Set.prototype );
   OrderedSet.prototype.constructor = OrderedSet;
 
   OrderedSet.of = function of (/*...values*/) {
@@ -5123,16 +5456,13 @@ var OrderedSet = (function (Set$$1) {
   return OrderedSet;
 }(Set));
 
-function isOrderedSet(maybeOrderedSet) {
-  return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
-}
-
 OrderedSet.isOrderedSet = isOrderedSet;
 
 var OrderedSetPrototype = OrderedSet.prototype;
-OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;
+OrderedSetPrototype[IS_ORDERED_SYMBOL] = true;
 OrderedSetPrototype.zip = IndexedCollectionPrototype.zip;
 OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;
+OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll;
 
 OrderedSetPrototype.__empty = emptyOrderedSet;
 OrderedSetPrototype.__make = makeOrderedSet;
@@ -5152,11 +5482,33 @@ function emptyOrderedSet() {
   );
 }
 
+function throwOnInvalidDefaultValues(defaultValues) {
+  if (isRecord(defaultValues)) {
+    throw new Error(
+      'Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.'
+    );
+  }
+
+  if (isImmutable(defaultValues)) {
+    throw new Error(
+      'Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.'
+    );
+  }
+
+  if (defaultValues === null || typeof defaultValues !== 'object') {
+    throw new Error(
+      'Can not call `Record` with a non-object as default values. Use a plain javascript object instead.'
+    );
+  }
+}
+
 var Record = function Record(defaultValues, name) {
   var hasInitialized;
 
+  throwOnInvalidDefaultValues(defaultValues);
+
   var RecordType = function Record(values) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     if (values instanceof RecordType) {
       return values;
@@ -5168,6 +5520,9 @@ var Record = function Record(defaultValues, name) {
       hasInitialized = true;
       var keys = Object.keys(defaultValues);
       var indices = (RecordTypePrototype._indices = {});
+      // Deprecated: left to attempt not to break any external code which
+      // relies on a ._name property existing on record instances.
+      // Use Record.getDescriptiveName() instead
       RecordTypePrototype._name = name;
       RecordTypePrototype._keys = keys;
       RecordTypePrototype._defaultValues = defaultValues;
@@ -5180,7 +5535,7 @@ var Record = function Record(defaultValues, name) {
             console.warn &&
             console.warn(
               'Cannot define ' +
-                recordName(this$1) +
+                recordName(this) +
                 ' with property "' +
                 propName +
                 '" since that property name is part of the Record API.'
@@ -5193,40 +5548,39 @@ var Record = function Record(defaultValues, name) {
     }
     this.__ownerID = undefined;
     this._values = List().withMutations(function (l) {
-      l.setSize(this$1._keys.length);
+      l.setSize(this$1$1._keys.length);
       KeyedCollection(values).forEach(function (v, k) {
-        l.set(this$1._indices[k], v === this$1._defaultValues[k] ? undefined : v);
+        l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v);
       });
     });
+    return this;
   };
 
-  var RecordTypePrototype = (RecordType.prototype = Object.create(
-    RecordPrototype
-  ));
+  var RecordTypePrototype = (RecordType.prototype =
+    Object.create(RecordPrototype));
   RecordTypePrototype.constructor = RecordType;
 
+  if (name) {
+    RecordType.displayName = name;
+  }
+
   return RecordType;
 };
 
 Record.prototype.toString = function toString () {
-    var this$1 = this;
-
   var str = recordName(this) + ' { ';
   var keys = this._keys;
   var k;
   for (var i = 0, l = keys.length; i !== l; i++) {
     k = keys[i];
-    str += (i ? ', ' : '') + k + ': ' + quoteString(this$1.get(k));
+    str += (i ? ', ' : '') + k + ': ' + quoteString(this.get(k));
   }
   return str + ' }';
 };
 
 Record.prototype.equals = function equals (other) {
   return (
-    this === other ||
-    (other &&
-      this._keys === other._keys &&
-      recordSeq(this).equals(recordSeq(other)))
+    this === other || (other && recordSeq(this).equals(recordSeq(other)))
   );
 };
 
@@ -5270,6 +5624,7 @@ Record.prototype.remove = function remove (k) {
 
 Record.prototype.clear = function clear () {
   var newValues = this._values.clear().setSize(this._keys.length);
+
   return this.__ownerID ? this : makeRecord(this, newValues);
 };
 
@@ -5281,8 +5636,12 @@ Record.prototype.toSeq = function toSeq () {
   return recordSeq(this);
 };
 
-Record.prototype.toJS = function toJS () {
-  return recordSeq(this).toJS();
+Record.prototype.toJS = function toJS$1 () {
+  return toJS(this);
+};
+
+Record.prototype.entries = function entries () {
+  return this.__iterator(ITERATE_ENTRIES);
 };
 
 Record.prototype.__iterator = function __iterator (type, reverse) {
@@ -5309,28 +5668,29 @@ Record.prototype.__ensureOwner = function __ensureOwner (ownerID) {
 Record.isRecord = isRecord;
 Record.getDescriptiveName = recordName;
 var RecordPrototype = Record.prototype;
-RecordPrototype[IS_RECORD_SENTINEL] = true;
+RecordPrototype[IS_RECORD_SYMBOL] = true;
 RecordPrototype[DELETE] = RecordPrototype.remove;
-RecordPrototype.deleteIn = RecordPrototype.removeIn = MapPrototype.removeIn;
-RecordPrototype.getIn = CollectionPrototype.getIn;
+RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;
+RecordPrototype.getIn = getIn;
 RecordPrototype.hasIn = CollectionPrototype.hasIn;
-RecordPrototype.merge = MapPrototype.merge;
-RecordPrototype.mergeWith = MapPrototype.mergeWith;
-RecordPrototype.mergeIn = MapPrototype.mergeIn;
-RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
-RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
-RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
-RecordPrototype.setIn = MapPrototype.setIn;
-RecordPrototype.update = MapPrototype.update;
-RecordPrototype.updateIn = MapPrototype.updateIn;
-RecordPrototype.withMutations = MapPrototype.withMutations;
-RecordPrototype.asMutable = MapPrototype.asMutable;
-RecordPrototype.asImmutable = MapPrototype.asImmutable;
-RecordPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;
+RecordPrototype.merge = merge$1;
+RecordPrototype.mergeWith = mergeWith$1;
+RecordPrototype.mergeIn = mergeIn;
+RecordPrototype.mergeDeep = mergeDeep;
+RecordPrototype.mergeDeepWith = mergeDeepWith;
+RecordPrototype.mergeDeepIn = mergeDeepIn;
+RecordPrototype.setIn = setIn;
+RecordPrototype.update = update;
+RecordPrototype.updateIn = updateIn;
+RecordPrototype.withMutations = withMutations;
+RecordPrototype.asMutable = asMutable;
+RecordPrototype.asImmutable = asImmutable;
+RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries;
 RecordPrototype.toJSON = RecordPrototype.toObject =
   CollectionPrototype.toObject;
-RecordPrototype.inspect = RecordPrototype.toSource =
-  CollectionPrototype.toSource;
+RecordPrototype.inspect = RecordPrototype.toSource = function () {
+  return this.toString();
+};
 
 function makeRecord(likeRecord, values, ownerID) {
   var record = Object.create(Object.getPrototypeOf(likeRecord));
@@ -5340,7 +5700,7 @@ function makeRecord(likeRecord, values, ownerID) {
 }
 
 function recordName(record) {
-  return record._name || record.constructor.name || 'Record';
+  return record.constructor.displayName || record.constructor.name || 'Record';
 }
 
 function recordSeq(record) {
@@ -5350,13 +5710,13 @@ function recordSeq(record) {
 function setProp(prototype, name) {
   try {
     Object.defineProperty(prototype, name, {
-      get: function() {
+      get: function () {
         return this.get(name);
       },
-      set: function(value) {
+      set: function (value) {
         invariant(this.__ownerID, 'Cannot set on an immutable record.');
         this.set(name, value);
-      }
+      },
     });
   } catch (error) {
     // Object.defineProperty failed. Probably IE8.
@@ -5367,7 +5727,7 @@ function setProp(prototype, name) {
  * Returns a lazy Seq of `value` repeated `times` times. When `times` is
  * undefined, returns an infinite sequence of `value`.
  */
-var Repeat = (function (IndexedSeq$$1) {
+var Repeat = /*@__PURE__*/(function (IndexedSeq) {
   function Repeat(value, times) {
     if (!(this instanceof Repeat)) {
       return new Repeat(value, times);
@@ -5382,8 +5742,8 @@ var Repeat = (function (IndexedSeq$$1) {
     }
   }
 
-  if ( IndexedSeq$$1 ) Repeat.__proto__ = IndexedSeq$$1;
-  Repeat.prototype = Object.create( IndexedSeq$$1 && IndexedSeq$$1.prototype );
+  if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq;
+  Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
   Repeat.prototype.constructor = Repeat;
 
   Repeat.prototype.toString = function toString () {
@@ -5430,12 +5790,10 @@ var Repeat = (function (IndexedSeq$$1) {
   };
 
   Repeat.prototype.__iterate = function __iterate (fn, reverse) {
-    var this$1 = this;
-
     var size = this.size;
     var i = 0;
     while (i !== size) {
-      if (fn(this$1._value, reverse ? size - ++i : i++, this$1) === false) {
+      if (fn(this._value, reverse ? size - ++i : i++, this) === false) {
         break;
       }
     }
@@ -5443,14 +5801,13 @@ var Repeat = (function (IndexedSeq$$1) {
   };
 
   Repeat.prototype.__iterator = function __iterator (type, reverse) {
-    var this$1 = this;
+    var this$1$1 = this;
 
     var size = this.size;
     var i = 0;
-    return new Iterator(
-      function () { return i === size
-          ? iteratorDone()
-          : iteratorValue(type, reverse ? size - ++i : i++, this$1._value); }
+    return new Iterator(function () { return i === size
+        ? iteratorDone()
+        : iteratorValue(type, reverse ? size - ++i : i++, this$1$1._value); }
     );
   };
 
@@ -5477,10 +5834,11 @@ function fromJS(value, converter) {
 }
 
 function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
-  var toSeq = Array.isArray(value)
-    ? IndexedSeq
-    : isPlainObj(value) ? KeyedSeq : null;
-  if (toSeq) {
+  if (
+    typeof value !== 'string' &&
+    !isImmutable(value) &&
+    (isArrayLike(value) || hasIterator(value) || isPlainObject(value))
+  ) {
     if (~stack.indexOf(value)) {
       throw new TypeError('Cannot convert circular structure to Immutable');
     }
@@ -5489,7 +5847,7 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
     var converted = converter.call(
       parentValue,
       key,
-      toSeq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
+      Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
       ),
       keyPath && keyPath.slice()
     );
@@ -5501,16 +5859,11 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
 }
 
 function defaultConverter(k, v) {
-  return isKeyed(v) ? v.toMap() : v.toList();
-}
-
-function isPlainObj(value) {
-  return (
-    value && (value.constructor === Object || value.constructor === undefined)
-  );
+  // Effectively the opposite of "Collection.toSeq()"
+  return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
 }
 
-var version = "4.0.0-rc.6";
+var version = "4.0.0";
 
 var Immutable = {
   version: version,
@@ -5541,11 +5894,35 @@ var Immutable = {
   isIndexed: isIndexed,
   isAssociative: isAssociative,
   isOrdered: isOrdered,
-  isValueObject: isValueObject
+  isValueObject: isValueObject,
+  isPlainObject: isPlainObject,
+  isSeq: isSeq,
+  isList: isList,
+  isMap: isMap,
+  isOrderedMap: isOrderedMap,
+  isStack: isStack,
+  isSet: isSet,
+  isOrderedSet: isOrderedSet,
+  isRecord: isRecord,
+
+  get: get,
+  getIn: getIn$1,
+  has: has,
+  hasIn: hasIn$1,
+  merge: merge,
+  mergeDeep: mergeDeep$1,
+  mergeWith: mergeWith,
+  mergeDeepWith: mergeDeepWith$1,
+  remove: remove,
+  removeIn: removeIn,
+  set: set,
+  setIn: setIn$1,
+  update: update$1,
+  updateIn: updateIn$1,
 };
 
 // Note: Iterable is deprecated
 var Iterable = Collection;
 
-export { version, Collection, Iterable, Seq, Map, OrderedMap, List, Stack, Set, OrderedSet, Record, Range, Repeat, is, fromJS, hash, isImmutable, isCollection, isKeyed, isIndexed, isAssociative, isOrdered, isValueObject };
 export default Immutable;
+export { Collection, Iterable, List, Map, OrderedMap, OrderedSet, Range, Record, Repeat, Seq, Set, Stack, fromJS, get, getIn$1 as getIn, has, hasIn$1 as hasIn, hash, is, isAssociative, isCollection, isImmutable, isIndexed, isKeyed, isList, isMap, isOrdered, isOrderedMap, isOrderedSet, isPlainObject, isRecord, isSeq, isSet, isStack, isValueObject, merge, mergeDeep$1 as mergeDeep, mergeDeepWith$1 as mergeDeepWith, mergeWith, remove, removeIn, set, setIn$1 as setIn, update$1 as update, updateIn$1 as updateIn, version };