time-to-botec

immutable.js (171571B)

---

 /**
  * 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.
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Immutable = {}));
 }(this, (function (exports) { 'use strict';
 
   var DELETE = 'delete';
 
   // Constants describing the size of trie nodes.
   var SHIFT = 5; // Resulted in best performance after ______?
   var SIZE = 1 << SHIFT;
   var MASK = SIZE - 1;
 
   // A consistent shared value representing "not set" which equals nothing other
   // than itself, and nothing that could be provided externally.
   var NOT_SET = {};
 
   // Boolean references, Rough equivalent of `bool &`.
   function MakeRef() {
     return { value: false };
   }
 
   function SetRef(ref) {
     if (ref) {
       ref.value = true;
     }
   }
 
   // A function which returns a value representing an "owner" for transient writes
   // to tries. The return value will only ever equal itself, and will not equal
   // the return of any subsequent call of this function.
   function OwnerID() {}
 
   function ensureSize(iter) {
     if (iter.size === undefined) {
       iter.size = iter.__iterate(returnTrue);
     }
     return iter.size;
   }
 
   function wrapIndex(iter, index) {
     // This implements "is array index" which the ECMAString spec defines as:
     //
     //     A String property name P is an array index if and only if
     //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
     //     to 2^32−1.
     //
     // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
     if (typeof index !== 'number') {
       var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
       if ('' + uint32Index !== index || uint32Index === 4294967295) {
         return NaN;
       }
       index = uint32Index;
     }
     return index < 0 ? ensureSize(iter) + index : index;
   }
 
   function returnTrue() {
     return true;
   }
 
   function wholeSlice(begin, end, size) {
     return (
       ((begin === 0 && !isNeg(begin)) ||
         (size !== undefined && begin <= -size)) &&
       (end === undefined || (size !== undefined && end >= size))
     );
   }
 
   function resolveBegin(begin, size) {
     return resolveIndex(begin, size, 0);
   }
 
   function resolveEnd(end, size) {
     return resolveIndex(end, size, size);
   }
 
   function resolveIndex(index, size, defaultIndex) {
     // Sanitize indices using this shorthand for ToInt32(argument)
     // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
     return index === undefined
       ? defaultIndex
       : isNeg(index)
       ? size === Infinity
         ? size
         : Math.max(0, size + index) | 0
       : size === undefined || size === index
       ? index
       : Math.min(size, index) | 0;
   }
 
   function isNeg(value) {
     // Account for -0 which is negative, but not less than 0.
     return value < 0 || (value === 0 && 1 / value === -Infinity);
   }
 
   var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';
 
   function isCollection(maybeCollection) {
     return Boolean(maybeCollection && maybeCollection[IS_COLLECTION_SYMBOL]);
   }
 
   var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';
 
   function isKeyed(maybeKeyed) {
     return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);
   }
 
   var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';
 
   function isIndexed(maybeIndexed) {
     return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);
   }
 
   function isAssociative(maybeAssociative) {
     return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
   }
 
   var Collection = function Collection(value) {
     return isCollection(value) ? value : Seq(value);
   };
 
   var KeyedCollection = /*@__PURE__*/(function (Collection) {
     function KeyedCollection(value) {
       return isKeyed(value) ? value : KeyedSeq(value);
     }
 
     if ( Collection ) KeyedCollection.__proto__ = Collection;
     KeyedCollection.prototype = Object.create( Collection && Collection.prototype );
     KeyedCollection.prototype.constructor = KeyedCollection;
 
     return KeyedCollection;
   }(Collection));
 
   var IndexedCollection = /*@__PURE__*/(function (Collection) {
     function IndexedCollection(value) {
       return isIndexed(value) ? value : IndexedSeq(value);
     }
 
     if ( Collection ) IndexedCollection.__proto__ = Collection;
     IndexedCollection.prototype = Object.create( Collection && Collection.prototype );
     IndexedCollection.prototype.constructor = IndexedCollection;
 
     return IndexedCollection;
   }(Collection));
 
   var SetCollection = /*@__PURE__*/(function (Collection) {
     function SetCollection(value) {
       return isCollection(value) && !isAssociative(value) ? value : SetSeq(value);
     }
 
     if ( Collection ) SetCollection.__proto__ = Collection;
     SetCollection.prototype = Object.create( Collection && Collection.prototype );
     SetCollection.prototype.constructor = SetCollection;
 
     return SetCollection;
   }(Collection));
 
   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;
 
   var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
   var FAUX_ITERATOR_SYMBOL = '@@iterator';
 
   var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;
 
   var Iterator = function Iterator(next) {
     this.next = next;
   };
 
   Iterator.prototype.toString = function toString () {
     return '[Iterator]';
   };
 
   Iterator.KEYS = ITERATE_KEYS;
   Iterator.VALUES = ITERATE_VALUES;
   Iterator.ENTRIES = ITERATE_ENTRIES;
 
   Iterator.prototype.inspect = Iterator.prototype.toSource = function () {
     return this.toString();
   };
   Iterator.prototype[ITERATOR_SYMBOL] = function () {
     return this;
   };
 
   function iteratorValue(type, k, v, iteratorResult) {
     var value = type === 0 ? k : type === 1 ? v : [k, v];
     iteratorResult
       ? (iteratorResult.value = value)
       : (iteratorResult = {
           value: value,
           done: false,
         });
     return iteratorResult;
   }
 
   function iteratorDone() {
     return { value: undefined, done: true };
   }
 
   function hasIterator(maybeIterable) {
     if (Array.isArray(maybeIterable)) {
       // IE11 trick as it does not support `Symbol.iterator`
       return true;
     }
 
     return !!getIteratorFn(maybeIterable);
   }
 
   function isIterator(maybeIterator) {
     return maybeIterator && typeof maybeIterator.next === 'function';
   }
 
   function getIterator(iterable) {
     var iteratorFn = getIteratorFn(iterable);
     return iteratorFn && iteratorFn.call(iterable);
   }
 
   function getIteratorFn(iterable) {
     var iteratorFn =
       iterable &&
       ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
         iterable[FAUX_ITERATOR_SYMBOL]);
     if (typeof iteratorFn === 'function') {
       return iteratorFn;
     }
   }
 
   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) {
     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 = /*@__PURE__*/(function (Collection) {
     function Seq(value) {
       return value === undefined || value === null
         ? emptySequence()
         : isImmutable(value)
         ? value.toSeq()
         : seqFromValue(value);
     }
 
     if ( Collection ) Seq.__proto__ = Collection;
     Seq.prototype = Object.create( Collection && Collection.prototype );
     Seq.prototype.constructor = Seq;
 
     Seq.prototype.toSeq = function toSeq () {
       return this;
     };
 
     Seq.prototype.toString = function toString () {
       return this.__toString('Seq {', '}');
     };
 
     Seq.prototype.cacheResult = function cacheResult () {
       if (!this._cache && this.__iterateUncached) {
         this._cache = this.entrySeq().toArray();
         this.size = this._cache.length;
       }
       return this;
     };
 
     // abstract __iterateUncached(fn, reverse)
 
     Seq.prototype.__iterate = function __iterate (fn, reverse) {
       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) === false) {
             break;
           }
         }
         return i;
       }
       return this.__iterateUncached(fn, reverse);
     };
 
     // abstract __iteratorUncached(type, reverse)
 
     Seq.prototype.__iterator = function __iterator (type, reverse) {
       var cache = this._cache;
       if (cache) {
         var size = cache.length;
         var i = 0;
         return new Iterator(function () {
           if (i === size) {
             return iteratorDone();
           }
           var entry = cache[reverse ? size - ++i : i++];
           return iteratorValue(type, entry[0], entry[1]);
         });
       }
       return this.__iteratorUncached(type, reverse);
     };
 
     return Seq;
   }(Collection));
 
   var KeyedSeq = /*@__PURE__*/(function (Seq) {
     function KeyedSeq(value) {
       return value === undefined || value === null
         ? emptySequence().toKeyedSeq()
         : isCollection(value)
         ? isKeyed(value)
           ? value.toSeq()
           : value.fromEntrySeq()
         : isRecord(value)
         ? value.toSeq()
         : keyedSeqFromValue(value);
     }
 
     if ( Seq ) KeyedSeq.__proto__ = Seq;
     KeyedSeq.prototype = Object.create( Seq && Seq.prototype );
     KeyedSeq.prototype.constructor = KeyedSeq;
 
     KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq () {
       return this;
     };
 
     return KeyedSeq;
   }(Seq));
 
   var IndexedSeq = /*@__PURE__*/(function (Seq) {
     function IndexedSeq(value) {
       return value === undefined || value === null
         ? emptySequence()
         : isCollection(value)
         ? isKeyed(value)
           ? value.entrySeq()
           : value.toIndexedSeq()
         : isRecord(value)
         ? value.toSeq().entrySeq()
         : indexedSeqFromValue(value);
     }
 
     if ( Seq ) IndexedSeq.__proto__ = Seq;
     IndexedSeq.prototype = Object.create( Seq && Seq.prototype );
     IndexedSeq.prototype.constructor = IndexedSeq;
 
     IndexedSeq.of = function of (/*...values*/) {
       return IndexedSeq(arguments);
     };
 
     IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq () {
       return this;
     };
 
     IndexedSeq.prototype.toString = function toString () {
       return this.__toString('Seq [', ']');
     };
 
     return IndexedSeq;
   }(Seq));
 
   var SetSeq = /*@__PURE__*/(function (Seq) {
     function SetSeq(value) {
       return (
         isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value)
       ).toSetSeq();
     }
 
     if ( Seq ) SetSeq.__proto__ = Seq;
     SetSeq.prototype = Object.create( Seq && Seq.prototype );
     SetSeq.prototype.constructor = SetSeq;
 
     SetSeq.of = function of (/*...values*/) {
       return SetSeq(arguments);
     };
 
     SetSeq.prototype.toSetSeq = function toSetSeq () {
       return this;
     };
 
     return SetSeq;
   }(Seq));
 
   Seq.isSeq = isSeq;
   Seq.Keyed = KeyedSeq;
   Seq.Set = SetSeq;
   Seq.Indexed = IndexedSeq;
 
   Seq.prototype[IS_SEQ_SYMBOL] = true;
 
   // #pragma Root Sequences
 
   var ArraySeq = /*@__PURE__*/(function (IndexedSeq) {
     function ArraySeq(array) {
       this._array = array;
       this.size = array.length;
     }
 
     if ( IndexedSeq ) ArraySeq.__proto__ = IndexedSeq;
     ArraySeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
     ArraySeq.prototype.constructor = ArraySeq;
 
     ArraySeq.prototype.get = function get (index, notSetValue) {
       return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;
     };
 
     ArraySeq.prototype.__iterate = function __iterate (fn, reverse) {
       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) === false) {
           break;
         }
       }
       return i;
     };
 
     ArraySeq.prototype.__iterator = function __iterator (type, reverse) {
       var array = this._array;
       var size = array.length;
       var i = 0;
       return new Iterator(function () {
         if (i === size) {
           return iteratorDone();
         }
         var ii = reverse ? size - ++i : i++;
         return iteratorValue(type, ii, array[ii]);
       });
     };
 
     return ArraySeq;
   }(IndexedSeq));
 
   var ObjectSeq = /*@__PURE__*/(function (KeyedSeq) {
     function ObjectSeq(object) {
       var keys = Object.keys(object).concat(
         Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []
       );
       this._object = object;
       this._keys = keys;
       this.size = keys.length;
     }
 
     if ( KeyedSeq ) ObjectSeq.__proto__ = KeyedSeq;
     ObjectSeq.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
     ObjectSeq.prototype.constructor = ObjectSeq;
 
     ObjectSeq.prototype.get = function get (key, notSetValue) {
       if (notSetValue !== undefined && !this.has(key)) {
         return notSetValue;
       }
       return this._object[key];
     };
 
     ObjectSeq.prototype.has = function has (key) {
       return hasOwnProperty.call(this._object, key);
     };
 
     ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) {
       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) === false) {
           break;
         }
       }
       return i;
     };
 
     ObjectSeq.prototype.__iterator = function __iterator (type, reverse) {
       var object = this._object;
       var keys = this._keys;
       var size = keys.length;
       var i = 0;
       return new Iterator(function () {
         if (i === size) {
           return iteratorDone();
         }
         var key = keys[reverse ? size - ++i : i++];
         return iteratorValue(type, key, object[key]);
       });
     };
 
     return ObjectSeq;
   }(KeyedSeq));
   ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;
 
   var CollectionSeq = /*@__PURE__*/(function (IndexedSeq) {
     function CollectionSeq(collection) {
       this._collection = collection;
       this.size = collection.length || collection.size;
     }
 
     if ( IndexedSeq ) CollectionSeq.__proto__ = IndexedSeq;
     CollectionSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
     CollectionSeq.prototype.constructor = CollectionSeq;
 
     CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {
       if (reverse) {
         return this.cacheResult().__iterate(fn, reverse);
       }
       var collection = this._collection;
       var iterator = getIterator(collection);
       var iterations = 0;
       if (isIterator(iterator)) {
         var step;
         while (!(step = iterator.next()).done) {
           if (fn(step.value, iterations++, this) === false) {
             break;
           }
         }
       }
       return iterations;
     };
 
     CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) {
       if (reverse) {
         return this.cacheResult().__iterator(type, reverse);
       }
       var collection = this._collection;
       var iterator = getIterator(collection);
       if (!isIterator(iterator)) {
         return new Iterator(iteratorDone);
       }
       var iterations = 0;
       return new Iterator(function () {
         var step = iterator.next();
         return step.done ? step : iteratorValue(type, iterations++, step.value);
       });
     };
 
     return CollectionSeq;
   }(IndexedSeq));
 
   // # pragma Helper functions
 
   var EMPTY_SEQ;
 
   function emptySequence() {
     return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
   }
 
   function keyedSeqFromValue(value) {
     var seq = maybeIndexedSeqFromValue(value);
     if (seq) {
       return seq.fromEntrySeq();
     }
     if (typeof value === 'object') {
       return new ObjectSeq(value);
     }
     throw new TypeError(
       'Expected Array or collection object of [k, v] entries, or keyed object: ' +
         value
     );
   }
 
   function indexedSeqFromValue(value) {
     var seq = maybeIndexedSeqFromValue(value);
     if (seq) {
       return seq;
     }
     throw new TypeError(
       'Expected Array or collection object of values: ' + value
     );
   }
 
   function seqFromValue(value) {
     var seq = maybeIndexedSeqFromValue(value);
     if (seq) {
       return isEntriesIterable(value)
         ? seq.fromEntrySeq()
         : isKeysIterable(value)
         ? seq.toSetSeq()
         : seq;
     }
     if (typeof value === 'object') {
       return new ObjectSeq(value);
     }
     throw new TypeError(
       'Expected Array or collection object of values, or keyed object: ' + value
     );
   }
 
   function maybeIndexedSeqFromValue(value) {
     return isArrayLike(value)
       ? new ArraySeq(value)
       : 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'
     );
   }
 
   /**
    * An extension of the "same-value" algorithm as [described for use by ES6 Map
    * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
    *
    * NaN is considered the same as NaN, however -0 and 0 are considered the same
    * value, which is different from the algorithm described by
    * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
    *
    * This is extended further to allow Objects to describe the values they
    * represent, by way of `valueOf` or `equals` (and `hashCode`).
    *
    * Note: because of this extension, the key equality of Immutable.Map and the
    * value equality of Immutable.Set will differ from ES6 Map and Set.
    *
    * ### Defining custom values
    *
    * The easiest way to describe the value an object represents is by implementing
    * `valueOf`. For example, `Date` represents a value by returning a unix
    * timestamp for `valueOf`:
    *
    *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
    *     var date2 = new Date(1234567890000);
    *     date1.valueOf(); // 1234567890000
    *     assert( date1 !== date2 );
    *     assert( Immutable.is( date1, date2 ) );
    *
    * Note: overriding `valueOf` may have other implications if you use this object
    * where JavaScript expects a primitive, such as implicit string coercion.
    *
    * For more complex types, especially collections, implementing `valueOf` may
    * not be performant. An alternative is to implement `equals` and `hashCode`.
    *
    * `equals` takes another object, presumably of similar type, and returns true
    * if it is equal. Equality is symmetrical, so the same result should be
    * returned if this and the argument are flipped.
    *
    *     assert( a.equals(b) === b.equals(a) );
    *
    * `hashCode` returns a 32bit integer number representing the object which will
    * be used to determine how to store the value object in a Map or Set. You must
    * provide both or neither methods, one must not exist without the other.
    *
    * Also, an important relationship between these methods must be upheld: if two
    * values are equal, they *must* return the same hashCode. If the values are not
    * equal, they might have the same hashCode; this is called a hash collision,
    * and while undesirable for performance reasons, it is acceptable.
    *
    *     if (a.equals(b)) {
    *       assert( a.hashCode() === b.hashCode() );
    *     }
    *
    * All Immutable collections are Value Objects: they implement `equals()`
    * and `hashCode()`.
    */
   function is(valueA, valueB) {
     if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
       return true;
     }
     if (!valueA || !valueB) {
       return false;
     }
     if (
       typeof valueA.valueOf === 'function' &&
       typeof valueB.valueOf === 'function'
     ) {
       valueA = valueA.valueOf();
       valueB = valueB.valueOf();
       if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
         return true;
       }
       if (!valueA || !valueB) {
         return false;
       }
     }
     return !!(
       isValueObject(valueA) &&
       isValueObject(valueB) &&
       valueA.equals(valueB)
     );
   }
 
   var imul =
     typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2
       ? Math.imul
       : function imul(a, b) {
           a |= 0; // int
           b |= 0; // int
           var c = a & 0xffff;
           var d = b & 0xffff;
           // Shift by 0 fixes the sign on the high part.
           return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int
         };
 
   // v8 has an optimization for storing 31-bit signed numbers.
   // Values which have either 00 or 11 as the high order bits qualify.
   // This function drops the highest order bit in a signed number, maintaining
   // the sign bit.
   function smi(i32) {
     return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
   }
 
   var defaultValueOf = Object.prototype.valueOf;
 
   function hash(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(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;
     }
     var hash = n | 0;
     if (hash !== n) {
       hash ^= n * 0xffffffff;
     }
     while (n > 0xffffffff) {
       n /= 0xffffffff;
       hash ^= n;
     }
     return smi(hash);
   }
 
   function cachedHashString(string) {
     var hashed = stringHashCache[string];
     if (hashed === undefined) {
       hashed = hashString(string);
       if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
         STRING_HASH_CACHE_SIZE = 0;
         stringHashCache = {};
       }
       STRING_HASH_CACHE_SIZE++;
       stringHashCache[string] = hashed;
     }
     return hashed;
   }
 
   // http://jsperf.com/hashing-strings
   function hashString(string) {
     // This is the hash from JVM
     // The hash code for a string is computed as
     // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
     // where s[i] is the ith character of the string and n is the length of
     // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
     // (exclusive) by dropping high bits.
     var hashed = 0;
     for (var ii = 0; ii < string.length; ii++) {
       hashed = (31 * hashed + string.charCodeAt(ii)) | 0;
     }
     return smi(hashed);
   }
 
   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) {
       hashed = weakMap.get(obj);
       if (hashed !== undefined) {
         return hashed;
       }
     }
 
     hashed = obj[UID_HASH_KEY];
     if (hashed !== undefined) {
       return hashed;
     }
 
     if (!canDefineProperty) {
       hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
       if (hashed !== undefined) {
         return hashed;
       }
 
       hashed = getIENodeHash(obj);
       if (hashed !== undefined) {
         return hashed;
       }
     }
 
     hashed = nextHash();
 
     if (usingWeakMap) {
       weakMap.set(obj, hashed);
     } else if (isExtensible !== undefined && isExtensible(obj) === false) {
       throw new Error('Non-extensible objects are not allowed as keys.');
     } else if (canDefineProperty) {
       Object.defineProperty(obj, UID_HASH_KEY, {
         enumerable: false,
         configurable: false,
         writable: false,
         value: hashed,
       });
     } else if (
       obj.propertyIsEnumerable !== undefined &&
       obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable
     ) {
       // Since we can't define a non-enumerable property on the object
       // we'll hijack one of the less-used non-enumerable properties to
       // save our hash on it. Since this is a function it will not show up in
       // `JSON.stringify` which is what we want.
       obj.propertyIsEnumerable = function () {
         return this.constructor.prototype.propertyIsEnumerable.apply(
           this,
           arguments
         );
       };
       obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
     } else if (obj.nodeType !== undefined) {
       // At this point we couldn't get the IE `uniqueID` to use as a hash
       // and we couldn't use a non-enumerable property to exploit the
       // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
       // itself.
       obj[UID_HASH_KEY] = hashed;
     } else {
       throw new Error('Unable to set a non-enumerable property on object.');
     }
 
     return hashed;
   }
 
   // Get references to ES5 object methods.
   var isExtensible = Object.isExtensible;
 
   // True if Object.defineProperty works as expected. IE8 fails this test.
   var canDefineProperty = (function () {
     try {
       Object.defineProperty({}, '@', {});
       return true;
     } catch (e) {
       return false;
     }
   })();
 
   // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
   // and avoid memory leaks from the IE cloneNode bug.
   function getIENodeHash(node) {
     if (node && node.nodeType > 0) {
       switch (node.nodeType) {
         case 1: // Element
           return node.uniqueID;
         case 9: // Document
           return node.documentElement && node.documentElement.uniqueID;
       }
     }
   }
 
   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;
   if (usingWeakMap) {
     weakMap = new WeakMap();
   }
 
   var symbolMap = Object.create(null);
 
   var _objHashUID = 0;
 
   var UID_HASH_KEY = '__immutablehash__';
   if (typeof Symbol === 'function') {
     UID_HASH_KEY = Symbol(UID_HASH_KEY);
   }
 
   var STRING_HASH_CACHE_MIN_STRLEN = 16;
   var STRING_HASH_CACHE_MAX_SIZE = 255;
   var STRING_HASH_CACHE_SIZE = 0;
   var stringHashCache = {};
 
   var ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) {
     function ToKeyedSequence(indexed, useKeys) {
       this._iter = indexed;
       this._useKeys = useKeys;
       this.size = indexed.size;
     }
 
     if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq;
     ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
     ToKeyedSequence.prototype.constructor = ToKeyedSequence;
 
     ToKeyedSequence.prototype.get = function get (key, notSetValue) {
       return this._iter.get(key, notSetValue);
     };
 
     ToKeyedSequence.prototype.has = function has (key) {
       return this._iter.has(key);
     };
 
     ToKeyedSequence.prototype.valueSeq = function valueSeq () {
       return this._iter.valueSeq();
     };
 
     ToKeyedSequence.prototype.reverse = function reverse () {
       var this$1$1 = this;
 
       var reversedSequence = reverseFactory(this, true);
       if (!this._useKeys) {
         reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); };
       }
       return reversedSequence;
     };
 
     ToKeyedSequence.prototype.map = function map (mapper, context) {
       var this$1$1 = this;
 
       var mappedSequence = mapFactory(this, mapper, context);
       if (!this._useKeys) {
         mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); };
       }
       return mappedSequence;
     };
 
     ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse);
     };
 
     ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) {
       return this._iter.__iterator(type, reverse);
     };
 
     return ToKeyedSequence;
   }(KeyedSeq));
   ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;
 
   var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {
     function ToIndexedSequence(iter) {
       this._iter = iter;
       this.size = iter.size;
     }
 
     if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq;
     ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
     ToIndexedSequence.prototype.constructor = ToIndexedSequence;
 
     ToIndexedSequence.prototype.includes = function includes (value) {
       return this._iter.includes(value);
     };
 
     ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       var i = 0;
       reverse && ensureSize(this);
       return this._iter.__iterate(
         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$1 = this;
 
       var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
       var i = 0;
       reverse && ensureSize(this);
       return new Iterator(function () {
         var step = iterator.next();
         return step.done
           ? step
           : iteratorValue(
               type,
               reverse ? this$1$1.size - ++i : i++,
               step.value,
               step
             );
       });
     };
 
     return ToIndexedSequence;
   }(IndexedSeq));
 
   var ToSetSequence = /*@__PURE__*/(function (SetSeq) {
     function ToSetSequence(iter) {
       this._iter = iter;
       this.size = iter.size;
     }
 
     if ( SetSeq ) ToSetSequence.__proto__ = SetSeq;
     ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype );
     ToSetSequence.prototype.constructor = ToSetSequence;
 
     ToSetSequence.prototype.has = function has (key) {
       return this._iter.includes(key);
     };
 
     ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse);
     };
 
     ToSetSequence.prototype.__iterator = function __iterator (type, reverse) {
       var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
       return new Iterator(function () {
         var step = iterator.next();
         return step.done
           ? step
           : iteratorValue(type, step.value, step.value, step);
       });
     };
 
     return ToSetSequence;
   }(SetSeq));
 
   var FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) {
     function FromEntriesSequence(entries) {
       this._iter = entries;
       this.size = entries.size;
     }
 
     if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq;
     FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
     FromEntriesSequence.prototype.constructor = FromEntriesSequence;
 
     FromEntriesSequence.prototype.entrySeq = function entrySeq () {
       return this._iter.toSeq();
     };
 
     FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       return this._iter.__iterate(function (entry) {
         // Check if entry exists first so array access doesn't throw for holes
         // in the parent iteration.
         if (entry) {
           validateEntry(entry);
           var indexedCollection = isCollection(entry);
           return fn(
             indexedCollection ? entry.get(1) : entry[1],
             indexedCollection ? entry.get(0) : entry[0],
             this$1$1
           );
         }
       }, reverse);
     };
 
     FromEntriesSequence.prototype.__iterator = function __iterator (type, reverse) {
       var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
       return new Iterator(function () {
         while (true) {
           var step = iterator.next();
           if (step.done) {
             return step;
           }
           var entry = step.value;
           // Check if entry exists first so array access doesn't throw for holes
           // in the parent iteration.
           if (entry) {
             validateEntry(entry);
             var indexedCollection = isCollection(entry);
             return iteratorValue(
               type,
               indexedCollection ? entry.get(0) : entry[0],
               indexedCollection ? entry.get(1) : entry[1],
               step
             );
           }
         }
       });
     };
 
     return FromEntriesSequence;
   }(KeyedSeq));
 
   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 () {
       var reversedSequence = collection.reverse.apply(this); // super.reverse()
       reversedSequence.flip = function () { return collection.reverse(); };
       return reversedSequence;
     };
     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$1 = this;
 
       return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse);
     };
     flipSequence.__iteratorUncached = function (type, reverse) {
       if (type === ITERATE_ENTRIES) {
         var iterator = collection.__iterator(type, reverse);
         return new Iterator(function () {
           var step = iterator.next();
           if (!step.done) {
             var k = step.value[0];
             step.value[0] = step.value[1];
             step.value[1] = k;
           }
           return step;
         });
       }
       return collection.__iterator(
         type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
         reverse
       );
     };
     return flipSequence;
   }
 
   function mapFactory(collection, mapper, context) {
     var mappedSequence = makeSequence(collection);
     mappedSequence.size = collection.size;
     mappedSequence.has = function (key) { return collection.has(key); };
     mappedSequence.get = function (key, notSetValue) {
       var v = collection.get(key, NOT_SET);
       return v === NOT_SET
         ? notSetValue
         : mapper.call(context, v, key, collection);
     };
     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$1) !== false; },
         reverse
       );
     };
     mappedSequence.__iteratorUncached = function (type, reverse) {
       var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
       return new Iterator(function () {
         var step = iterator.next();
         if (step.done) {
           return step;
         }
         var entry = step.value;
         var key = entry[0];
         return iteratorValue(
           type,
           key,
           mapper.call(context, entry[1], key, collection),
           step
         );
       });
     };
     return mappedSequence;
   }
 
   function reverseFactory(collection, useKeys) {
     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 () {
         var flipSequence = flipFactory(collection);
         flipSequence.reverse = function () { return collection.flip(); };
         return flipSequence;
       };
     }
     reversedSequence.get = function (key, notSetValue) { return collection.get(useKeys ? key : -1 - key, notSetValue); };
     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$1 = this;
 
       var i = 0;
       reverse && ensureSize(collection);
       return collection.__iterate(
         function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); },
         !reverse
       );
     };
     reversedSequence.__iterator = function (type, reverse) {
       var i = 0;
       reverse && ensureSize(collection);
       var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse);
       return new Iterator(function () {
         var step = iterator.next();
         if (step.done) {
           return step;
         }
         var entry = step.value;
         return iteratorValue(
           type,
           useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++,
           entry[1],
           step
         );
       });
     };
     return reversedSequence;
   }
 
   function filterFactory(collection, predicate, context, useKeys) {
     var filterSequence = makeSequence(collection);
     if (useKeys) {
       filterSequence.has = function (key) {
         var v = collection.get(key, NOT_SET);
         return v !== NOT_SET && !!predicate.call(context, v, key, collection);
       };
       filterSequence.get = function (key, notSetValue) {
         var v = collection.get(key, NOT_SET);
         return v !== NOT_SET && predicate.call(context, v, key, collection)
           ? v
           : notSetValue;
       };
     }
     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$1);
         }
       }, reverse);
       return iterations;
     };
     filterSequence.__iteratorUncached = function (type, reverse) {
       var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
       var iterations = 0;
       return new Iterator(function () {
         while (true) {
           var step = iterator.next();
           if (step.done) {
             return step;
           }
           var entry = step.value;
           var key = entry[0];
           var value = entry[1];
           if (predicate.call(context, value, key, collection)) {
             return iteratorValue(type, useKeys ? key : iterations++, value, step);
           }
         }
       });
     };
     return filterSequence;
   }
 
   function countByFactory(collection, grouper, context) {
     var groups = Map().asMutable();
     collection.__iterate(function (v, k) {
       groups.update(grouper.call(context, v, k, collection), 0, function (a) { return a + 1; });
     });
     return groups.asImmutable();
   }
 
   function groupByFactory(collection, grouper, context) {
     var isKeyedIter = isKeyed(collection);
     var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable();
     collection.__iterate(function (v, k) {
       groups.update(
         grouper.call(context, v, k, collection),
         function (a) { return ((a = a || []), a.push(isKeyedIter ? [k, v] : v), a); }
       );
     });
     var coerce = collectionClass(collection);
     return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable();
   }
 
   function partitionFactory(collection, predicate, context) {
     var isKeyedIter = isKeyed(collection);
     var groups = [[], []];
     collection.__iterate(function (v, k) {
       groups[predicate.call(context, v, k, collection) ? 1 : 0].push(
         isKeyedIter ? [k, v] : v
       );
     });
     var coerce = collectionClass(collection);
     return groups.map(function (arr) { return reify(collection, coerce(arr)); });
   }
 
   function sliceFactory(collection, begin, end, useKeys) {
     var originalSize = collection.size;
 
     if (wholeSlice(begin, end, originalSize)) {
       return collection;
     }
 
     var resolvedBegin = resolveBegin(begin, originalSize);
     var resolvedEnd = resolveEnd(end, originalSize);
 
     // begin or end will be NaN if they were provided as negative numbers and
     // this collection's size is unknown. In that case, cache first so there is
     // a known size and these do not resolve to NaN.
     if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
       return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys);
     }
 
     // Note: resolvedEnd is undefined when the original sequence's length is
     // unknown and this slice did not supply an end and should contain all
     // elements after resolvedBegin.
     // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
     var resolvedSize = resolvedEnd - resolvedBegin;
     var sliceSize;
     if (resolvedSize === resolvedSize) {
       sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
     }
 
     var sliceSeq = makeSequence(collection);
 
     // If collection.size is undefined, the size of the realized sliceSeq is
     // unknown at this point unless the number of items to slice is 0
     sliceSeq.size =
       sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined;
 
     if (!useKeys && isSeq(collection) && sliceSize >= 0) {
       sliceSeq.get = function (index, notSetValue) {
         index = wrapIndex(this, index);
         return index >= 0 && index < sliceSize
           ? collection.get(index + resolvedBegin, notSetValue)
           : notSetValue;
       };
     }
 
     sliceSeq.__iterateUncached = function (fn, reverse) {
       var this$1$1 = this;
 
       if (sliceSize === 0) {
         return 0;
       }
       if (reverse) {
         return this.cacheResult().__iterate(fn, reverse);
       }
       var skipped = 0;
       var isSkipping = true;
       var iterations = 0;
       collection.__iterate(function (v, k) {
         if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
           iterations++;
           return (
             fn(v, useKeys ? k : iterations - 1, this$1$1) !== false &&
             iterations !== sliceSize
           );
         }
       });
       return iterations;
     };
 
     sliceSeq.__iteratorUncached = function (type, reverse) {
       if (sliceSize !== 0 && reverse) {
         return this.cacheResult().__iterator(type, reverse);
       }
       // Don't bother instantiating parent iterator if taking 0.
       if (sliceSize === 0) {
         return new Iterator(iteratorDone);
       }
       var iterator = collection.__iterator(type, reverse);
       var skipped = 0;
       var iterations = 0;
       return new Iterator(function () {
         while (skipped++ < resolvedBegin) {
           iterator.next();
         }
         if (++iterations > sliceSize) {
           return iteratorDone();
         }
         var step = iterator.next();
         if (useKeys || type === ITERATE_VALUES || step.done) {
           return step;
         }
         if (type === ITERATE_KEYS) {
           return iteratorValue(type, iterations - 1, undefined, step);
         }
         return iteratorValue(type, iterations - 1, step.value[1], step);
       });
     };
 
     return sliceSeq;
   }
 
   function takeWhileFactory(collection, predicate, context) {
     var takeSequence = makeSequence(collection);
     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$1); }
       );
       return iterations;
     };
     takeSequence.__iteratorUncached = function (type, reverse) {
       var this$1$1 = this;
 
       if (reverse) {
         return this.cacheResult().__iterator(type, reverse);
       }
       var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
       var iterating = true;
       return new Iterator(function () {
         if (!iterating) {
           return iteratorDone();
         }
         var step = iterator.next();
         if (step.done) {
           return step;
         }
         var entry = step.value;
         var k = entry[0];
         var v = entry[1];
         if (!predicate.call(context, v, k, this$1$1)) {
           iterating = false;
           return iteratorDone();
         }
         return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
       });
     };
     return takeSequence;
   }
 
   function skipWhileFactory(collection, predicate, context, useKeys) {
     var skipSequence = makeSequence(collection);
     skipSequence.__iterateUncached = function (fn, reverse) {
       var this$1$1 = this;
 
       if (reverse) {
         return this.cacheResult().__iterate(fn, reverse);
       }
       var isSkipping = true;
       var iterations = 0;
       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$1);
         }
       });
       return iterations;
     };
     skipSequence.__iteratorUncached = function (type, reverse) {
       var this$1$1 = this;
 
       if (reverse) {
         return this.cacheResult().__iterator(type, reverse);
       }
       var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
       var skipping = true;
       var iterations = 0;
       return new Iterator(function () {
         var step;
         var k;
         var v;
         do {
           step = iterator.next();
           if (step.done) {
             if (useKeys || type === ITERATE_VALUES) {
               return step;
             }
             if (type === ITERATE_KEYS) {
               return iteratorValue(type, iterations++, undefined, step);
             }
             return iteratorValue(type, iterations++, step.value[1], step);
           }
           var entry = step.value;
           k = entry[0];
           v = entry[1];
           skipping && (skipping = predicate.call(context, v, k, this$1$1));
         } while (skipping);
         return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
       });
     };
     return skipSequence;
   }
 
   function concatFactory(collection, values) {
     var isKeyedCollection = isKeyed(collection);
     var iters = [collection]
       .concat(values)
       .map(function (v) {
         if (!isCollection(v)) {
           v = isKeyedCollection
             ? keyedSeqFromValue(v)
             : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
         } else if (isKeyedCollection) {
           v = KeyedCollection(v);
         }
         return v;
       })
       .filter(function (v) { return v.size !== 0; });
 
     if (iters.length === 0) {
       return collection;
     }
 
     if (iters.length === 1) {
       var singleton = iters[0];
       if (
         singleton === collection ||
         (isKeyedCollection && isKeyed(singleton)) ||
         (isIndexed(collection) && isIndexed(singleton))
       ) {
         return singleton;
       }
     }
 
     var concatSeq = new ArraySeq(iters);
     if (isKeyedCollection) {
       concatSeq = concatSeq.toKeyedSeq();
     } else if (!isIndexed(collection)) {
       concatSeq = concatSeq.toSetSeq();
     }
     concatSeq = concatSeq.flatten(true);
     concatSeq.size = iters.reduce(function (sum, seq) {
       if (sum !== undefined) {
         var size = seq.size;
         if (size !== undefined) {
           return sum + size;
         }
       }
     }, 0);
     return concatSeq;
   }
 
   function flattenFactory(collection, depth, useKeys) {
     var flatSequence = makeSequence(collection);
     flatSequence.__iterateUncached = function (fn, reverse) {
       if (reverse) {
         return this.cacheResult().__iterate(fn, reverse);
       }
       var iterations = 0;
       var stopped = false;
       function flatDeep(iter, currentDepth) {
         iter.__iterate(function (v, k) {
           if ((!depth || currentDepth < depth) && isCollection(v)) {
             flatDeep(v, currentDepth + 1);
           } else {
             iterations++;
             if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) {
               stopped = true;
             }
           }
           return !stopped;
         }, reverse);
       }
       flatDeep(collection, 0);
       return iterations;
     };
     flatSequence.__iteratorUncached = function (type, reverse) {
       if (reverse) {
         return this.cacheResult().__iterator(type, reverse);
       }
       var iterator = collection.__iterator(type, reverse);
       var stack = [];
       var iterations = 0;
       return new Iterator(function () {
         while (iterator) {
           var step = iterator.next();
           if (step.done !== false) {
             iterator = stack.pop();
             continue;
           }
           var v = step.value;
           if (type === ITERATE_ENTRIES) {
             v = v[1];
           }
           if ((!depth || stack.length < depth) && isCollection(v)) {
             stack.push(iterator);
             iterator = v.__iterator(type, reverse);
           } else {
             return useKeys ? step : iteratorValue(type, iterations++, v, step);
           }
         }
         return iteratorDone();
       });
     };
     return flatSequence;
   }
 
   function flatMapFactory(collection, mapper, context) {
     var coerce = collectionClass(collection);
     return collection
       .toSeq()
       .map(function (v, k) { return coerce(mapper.call(context, v, k, collection)); })
       .flatten(true);
   }
 
   function interposeFactory(collection, separator) {
     var interposedSequence = makeSequence(collection);
     interposedSequence.size = collection.size && collection.size * 2 - 1;
     interposedSequence.__iterateUncached = function (fn, reverse) {
       var this$1$1 = this;
 
       var iterations = 0;
       collection.__iterate(
         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) {
       var iterator = collection.__iterator(ITERATE_VALUES, reverse);
       var iterations = 0;
       var step;
       return new Iterator(function () {
         if (!step || iterations % 2) {
           step = iterator.next();
           if (step.done) {
             return step;
           }
         }
         return iterations % 2
           ? iteratorValue(type, iterations++, separator)
           : iteratorValue(type, iterations++, step.value, step);
       });
     };
     return interposedSequence;
   }
 
   function sortFactory(collection, comparator, mapper) {
     if (!comparator) {
       comparator = defaultComparator;
     }
     var isKeyedCollection = isKeyed(collection);
     var index = 0;
     var entries = collection
       .toSeq()
       .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];
             }
       );
     return isKeyedCollection
       ? KeyedSeq(entries)
       : isIndexed(collection)
       ? IndexedSeq(entries)
       : SetSeq(entries);
   }
 
   function maxFactory(collection, comparator, mapper) {
     if (!comparator) {
       comparator = defaultComparator;
     }
     if (mapper) {
       var entry = collection
         .toSeq()
         .map(function (v, k) { return [v, mapper(v, k, collection)]; })
         .reduce(function (a, b) { return (maxCompare(comparator, a[1], b[1]) ? b : a); });
       return entry && entry[0];
     }
     return collection.reduce(function (a, b) { return (maxCompare(comparator, a, b) ? b : a); });
   }
 
   function maxCompare(comparator, a, b) {
     var comp = comparator(b, a);
     // b is considered the new max if the comparator declares them equal, but
     // they are not equal and b is in fact a nullish value.
     return (
       (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||
       comp > 0
     );
   }
 
   function zipWithFactory(keyIter, zipper, iters, zipAll) {
     var zipSequence = makeSequence(keyIter);
     var sizes = new ArraySeq(iters).map(function (i) { return i.size; });
     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) {
       /* generic:
       var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
       var step;
       var iterations = 0;
       while (!(step = iterator.next()).done) {
         iterations++;
         if (fn(step.value[1], step.value[0], this) === false) {
           break;
         }
       }
       return iterations;
       */
       // indexed:
       var iterator = this.__iterator(ITERATE_VALUES, reverse);
       var step;
       var iterations = 0;
       while (!(step = iterator.next()).done) {
         if (fn(step.value, iterations++, this) === false) {
           break;
         }
       }
       return iterations;
     };
     zipSequence.__iteratorUncached = function (type, reverse) {
       var iterators = iters.map(
         function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); }
       );
       var iterations = 0;
       var isDone = false;
       return new Iterator(function () {
         var steps;
         if (!isDone) {
           steps = iterators.map(function (i) { return i.next(); });
           isDone = zipAll ? steps.every(function (s) { return s.done; }) : steps.some(function (s) { return s.done; });
         }
         if (isDone) {
           return iteratorDone();
         }
         return iteratorValue(
           type,
           iterations++,
           zipper.apply(
             null,
             steps.map(function (s) { return s.value; })
           )
         );
       });
     };
     return zipSequence;
   }
 
   // #pragma Helper Functions
 
   function reify(iter, seq) {
     return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq);
   }
 
   function validateEntry(entry) {
     if (entry !== Object(entry)) {
       throw new TypeError('Expected [K, V] tuple: ' + entry);
     }
   }
 
   function collectionClass(collection) {
     return isKeyed(collection)
       ? KeyedCollection
       : isIndexed(collection)
       ? IndexedCollection
       : SetCollection;
   }
 
   function makeSequence(collection) {
     return Object.create(
       (isKeyed(collection)
         ? KeyedSeq
         : isIndexed(collection)
         ? IndexedSeq
         : SetSeq
       ).prototype
     );
   }
 
   function cacheResultThrough() {
     if (this._iter.cacheResult) {
       this._iter.cacheResult();
       this.size = this._iter.size;
       return this;
     }
     return Seq.prototype.cacheResult.call(this);
   }
 
   function defaultComparator(a, b) {
     if (a === undefined && b === undefined) {
       return 0;
     }
 
     if (a === undefined) {
       return 1;
     }
 
     if (b === undefined) {
       return -1;
     }
 
     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;
     }
     if (isOrdered(keyPath)) {
       return keyPath.toArray();
     }
     throw new TypeError(
       'Invalid keyPath: expected Ordered Collection or Array: ' + keyPath
     );
   }
 
   var toString = Object.prototype.toString;
 
   function isPlainObject(value) {
     // The base prototype's toString deals with Argument objects and native namespaces like Math
     if (
       !value ||
       typeof value !== 'object' ||
       toString.call(value) !== '[object Object]'
     ) {
       return false;
     }
 
     var proto = Object.getPrototypeOf(value);
     if (proto === null) {
       return true;
     }
 
     // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc)
     var parentProto = proto;
     var nextProto = Object.getPrototypeOf(proto);
     while (nextProto !== null) {
       parentProto = nextProto;
       nextProto = Object.getPrototypeOf(parentProto);
     }
     return parentProto === proto;
   }
 
   /**
    * Returns true if the value is a potentially-persistent data structure, either
    * provided by Immutable.js or a plain Array or Object.
    */
   function isDataStructure(value) {
     return (
       typeof value === 'object' &&
       (isImmutable(value) || Array.isArray(value) || isPlainObject(value))
     );
   }
 
   function quoteString(value) {
     try {
       return typeof value === 'string' ? JSON.stringify(value) : String(value);
     } catch (_ignoreError) {
       return JSON.stringify(value);
     }
   }
 
   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 === undefined || value === null
         ? emptyMap()
         : isMap(value) && !isOrdered(value)
         ? value
         : emptyMap().withMutations(function (map) {
             var iter = KeyedCollection(value);
             assertNotInfinite(iter.size);
             iter.forEach(function (v, k) { return map.set(k, v); });
           });
     }
 
     if ( KeyedCollection ) Map.__proto__ = KeyedCollection;
     Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype );
     Map.prototype.constructor = Map;
 
     Map.of = function of () {
       var keyValues = [], len = arguments.length;
       while ( len-- ) keyValues[ len ] = arguments[ len ];
 
       return emptyMap().withMutations(function (map) {
         for (var i = 0; i < keyValues.length; i += 2) {
           if (i + 1 >= keyValues.length) {
             throw new Error('Missing value for key: ' + keyValues[i]);
           }
           map.set(keyValues[i], keyValues[i + 1]);
         }
       });
     };
 
     Map.prototype.toString = function toString () {
       return this.__toString('Map {', '}');
     };
 
     // @pragma Access
 
     Map.prototype.get = function get (k, notSetValue) {
       return this._root
         ? this._root.get(0, undefined, k, notSetValue)
         : notSetValue;
     };
 
     // @pragma Modification
 
     Map.prototype.set = function set (k, v) {
       return updateMap(this, k, v);
     };
 
     Map.prototype.remove = function remove (k) {
       return updateMap(this, k, NOT_SET);
     };
 
     Map.prototype.deleteAll = function deleteAll (keys) {
       var collection = Collection(keys);
 
       if (collection.size === 0) {
         return this;
       }
 
       return this.withMutations(function (map) {
         collection.forEach(function (key) { return map.remove(key); });
       });
     };
 
     Map.prototype.clear = function clear () {
       if (this.size === 0) {
         return this;
       }
       if (this.__ownerID) {
         this.size = 0;
         this._root = null;
         this.__hash = undefined;
         this.__altered = true;
         return this;
       }
       return emptyMap();
     };
 
     // @pragma Composition
 
     Map.prototype.sort = function sort (comparator) {
       // Late binding
       return OrderedMap(sortFactory(this, comparator));
     };
 
     Map.prototype.sortBy = function sortBy (mapper, comparator) {
       // Late binding
       return OrderedMap(sortFactory(this, comparator, mapper));
     };
 
     Map.prototype.map = function map (mapper, context) {
       var this$1$1 = this;
 
       return this.withMutations(function (map) {
         map.forEach(function (value, key) {
           map.set(key, mapper.call(context, value, key, this$1$1));
         });
       });
     };
 
     // @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$1 = this;
 
       var iterations = 0;
       this._root &&
         this._root.iterate(function (entry) {
           iterations++;
           return fn(entry[1], entry[0], this$1$1);
         }, reverse);
       return iterations;
     };
 
     Map.prototype.__ensureOwner = function __ensureOwner (ownerID) {
       if (ownerID === this.__ownerID) {
         return this;
       }
       if (!ownerID) {
         if (this.size === 0) {
           return emptyMap();
         }
         this.__ownerID = ownerID;
         this.__altered = false;
         return this;
       }
       return makeMap(this.size, this._root, ownerID, this.__hash);
     };
 
     return Map;
   }(KeyedCollection));
 
   Map.isMap = isMap;
 
   var MapPrototype = Map.prototype;
   MapPrototype[IS_MAP_SYMBOL] = true;
   MapPrototype[DELETE] = MapPrototype.remove;
   MapPrototype.removeAll = MapPrototype.deleteAll;
   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) {
     return obj.asImmutable();
   };
 
   // #pragma Trie Nodes
 
   var ArrayMapNode = function ArrayMapNode(ownerID, entries) {
     this.ownerID = ownerID;
     this.entries = entries;
   };
 
   ArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
     var entries = this.entries;
     for (var ii = 0, len = entries.length; ii < len; ii++) {
       if (is(key, entries[ii][0])) {
         return entries[ii][1];
       }
     }
     return notSetValue;
   };
 
   ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
     var removed = value === NOT_SET;
 
     var entries = this.entries;
     var idx = 0;
     var len = entries.length;
     for (; idx < len; idx++) {
       if (is(key, entries[idx][0])) {
         break;
       }
     }
     var exists = idx < len;
 
     if (exists ? entries[idx][1] === value : removed) {
       return this;
     }
 
     SetRef(didAlter);
     (removed || !exists) && SetRef(didChangeSize);
 
     if (removed && entries.length === 1) {
       return; // undefined
     }
 
     if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
       return createNodes(ownerID, entries, key, value);
     }
 
     var isEditable = ownerID && ownerID === this.ownerID;
     var newEntries = isEditable ? entries : arrCopy(entries);
 
     if (exists) {
       if (removed) {
         idx === len - 1
           ? newEntries.pop()
           : (newEntries[idx] = newEntries.pop());
       } else {
         newEntries[idx] = [key, value];
       }
     } else {
       newEntries.push([key, value]);
     }
 
     if (isEditable) {
       this.entries = newEntries;
       return this;
     }
 
     return new ArrayMapNode(ownerID, newEntries);
   };
 
   var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) {
     this.ownerID = ownerID;
     this.bitmap = bitmap;
     this.nodes = nodes;
   };
 
   BitmapIndexedNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
     if (keyHash === undefined) {
       keyHash = hash(key);
     }
     var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
     var bitmap = this.bitmap;
     return (bitmap & bit) === 0
       ? notSetValue
       : this.nodes[popCount(bitmap & (bit - 1))].get(
           shift + SHIFT,
           keyHash,
           key,
           notSetValue
         );
   };
 
   BitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
     if (keyHash === undefined) {
       keyHash = hash(key);
     }
     var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
     var bit = 1 << keyHashFrag;
     var bitmap = this.bitmap;
     var exists = (bitmap & bit) !== 0;
 
     if (!exists && value === NOT_SET) {
       return this;
     }
 
     var idx = popCount(bitmap & (bit - 1));
     var nodes = this.nodes;
     var node = exists ? nodes[idx] : undefined;
     var newNode = updateNode(
       node,
       ownerID,
       shift + SHIFT,
       keyHash,
       key,
       value,
       didChangeSize,
       didAlter
     );
 
     if (newNode === node) {
       return this;
     }
 
     if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
       return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
     }
 
     if (
       exists &&
       !newNode &&
       nodes.length === 2 &&
       isLeafNode(nodes[idx ^ 1])
     ) {
       return nodes[idx ^ 1];
     }
 
     if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
       return newNode;
     }
 
     var isEditable = ownerID && ownerID === this.ownerID;
     var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
     var newNodes = exists
       ? newNode
         ? setAt(nodes, idx, newNode, isEditable)
         : spliceOut(nodes, idx, isEditable)
       : spliceIn(nodes, idx, newNode, isEditable);
 
     if (isEditable) {
       this.bitmap = newBitmap;
       this.nodes = newNodes;
       return this;
     }
 
     return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
   };
 
   var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) {
     this.ownerID = ownerID;
     this.count = count;
     this.nodes = nodes;
   };
 
   HashArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
     if (keyHash === undefined) {
       keyHash = hash(key);
     }
     var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
     var node = this.nodes[idx];
     return node
       ? node.get(shift + SHIFT, keyHash, key, notSetValue)
       : notSetValue;
   };
 
   HashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
     if (keyHash === undefined) {
       keyHash = hash(key);
     }
     var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
     var removed = value === NOT_SET;
     var nodes = this.nodes;
     var node = nodes[idx];
 
     if (removed && !node) {
       return this;
     }
 
     var newNode = updateNode(
       node,
       ownerID,
       shift + SHIFT,
       keyHash,
       key,
       value,
       didChangeSize,
       didAlter
     );
     if (newNode === node) {
       return this;
     }
 
     var newCount = this.count;
     if (!node) {
       newCount++;
     } else if (!newNode) {
       newCount--;
       if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
         return packNodes(ownerID, nodes, newCount, idx);
       }
     }
 
     var isEditable = ownerID && ownerID === this.ownerID;
     var newNodes = setAt(nodes, idx, newNode, isEditable);
 
     if (isEditable) {
       this.count = newCount;
       this.nodes = newNodes;
       return this;
     }
 
     return new HashArrayMapNode(ownerID, newCount, newNodes);
   };
 
   var HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) {
     this.ownerID = ownerID;
     this.keyHash = keyHash;
     this.entries = entries;
   };
 
   HashCollisionNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
     var entries = this.entries;
     for (var ii = 0, len = entries.length; ii < len; ii++) {
       if (is(key, entries[ii][0])) {
         return entries[ii][1];
       }
     }
     return notSetValue;
   };
 
   HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
     if (keyHash === undefined) {
       keyHash = hash(key);
     }
 
     var removed = value === NOT_SET;
 
     if (keyHash !== this.keyHash) {
       if (removed) {
         return this;
       }
       SetRef(didAlter);
       SetRef(didChangeSize);
       return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
     }
 
     var entries = this.entries;
     var idx = 0;
     var len = entries.length;
     for (; idx < len; idx++) {
       if (is(key, entries[idx][0])) {
         break;
       }
     }
     var exists = idx < len;
 
     if (exists ? entries[idx][1] === value : removed) {
       return this;
     }
 
     SetRef(didAlter);
     (removed || !exists) && SetRef(didChangeSize);
 
     if (removed && len === 2) {
       return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
     }
 
     var isEditable = ownerID && ownerID === this.ownerID;
     var newEntries = isEditable ? entries : arrCopy(entries);
 
     if (exists) {
       if (removed) {
         idx === len - 1
           ? newEntries.pop()
           : (newEntries[idx] = newEntries.pop());
       } else {
         newEntries[idx] = [key, value];
       }
     } else {
       newEntries.push([key, value]);
     }
 
     if (isEditable) {
       this.entries = newEntries;
       return this;
     }
 
     return new HashCollisionNode(ownerID, this.keyHash, newEntries);
   };
 
   var ValueNode = function ValueNode(ownerID, keyHash, entry) {
     this.ownerID = ownerID;
     this.keyHash = keyHash;
     this.entry = entry;
   };
 
   ValueNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
     return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
   };
 
   ValueNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
     var removed = value === NOT_SET;
     var keyMatch = is(key, this.entry[0]);
     if (keyMatch ? value === this.entry[1] : removed) {
       return this;
     }
 
     SetRef(didAlter);
 
     if (removed) {
       SetRef(didChangeSize);
       return; // undefined
     }
 
     if (keyMatch) {
       if (ownerID && ownerID === this.ownerID) {
         this.entry[1] = value;
         return this;
       }
       return new ValueNode(ownerID, this.keyHash, [key, value]);
     }
 
     SetRef(didChangeSize);
     return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
   };
 
   // #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;
         }
       }
     };
 
   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) {
     return fn(this.entry);
   };
 
   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 ) MapIterator.__proto__ = Iterator;
     MapIterator.prototype = Object.create( Iterator && Iterator.prototype );
     MapIterator.prototype.constructor = MapIterator;
 
     MapIterator.prototype.next = function next () {
       var type = this._type;
       var stack = this._stack;
       while (stack) {
         var node = stack.node;
         var index = stack.index++;
         var maxIndex = (void 0);
         if (node.entry) {
           if (index === 0) {
             return mapIteratorValue(type, node.entry);
           }
         } else if (node.entries) {
           maxIndex = node.entries.length - 1;
           if (index <= maxIndex) {
             return mapIteratorValue(
               type,
               node.entries[this._reverse ? maxIndex - index : index]
             );
           }
         } else {
           maxIndex = node.nodes.length - 1;
           if (index <= maxIndex) {
             var subNode = node.nodes[this._reverse ? maxIndex - index : index];
             if (subNode) {
               if (subNode.entry) {
                 return mapIteratorValue(type, subNode.entry);
               }
               stack = this._stack = mapIteratorFrame(subNode, stack);
             }
             continue;
           }
         }
         stack = this._stack = this._stack.__prev;
       }
       return iteratorDone();
     };
 
     return MapIterator;
   }(Iterator));
 
   function mapIteratorValue(type, entry) {
     return iteratorValue(type, entry[0], entry[1]);
   }
 
   function mapIteratorFrame(node, prev) {
     return {
       node: node,
       index: 0,
       __prev: prev,
     };
   }
 
   function makeMap(size, root, ownerID, hash) {
     var map = Object.create(MapPrototype);
     map.size = size;
     map._root = root;
     map.__ownerID = ownerID;
     map.__hash = hash;
     map.__altered = false;
     return map;
   }
 
   var EMPTY_MAP;
   function emptyMap() {
     return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
   }
 
   function updateMap(map, k, v) {
     var newRoot;
     var newSize;
     if (!map._root) {
       if (v === NOT_SET) {
         return map;
       }
       newSize = 1;
       newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
     } else {
       var didChangeSize = MakeRef();
       var didAlter = MakeRef();
       newRoot = updateNode(
         map._root,
         map.__ownerID,
         0,
         undefined,
         k,
         v,
         didChangeSize,
         didAlter
       );
       if (!didAlter.value) {
         return map;
       }
       newSize = map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);
     }
     if (map.__ownerID) {
       map.size = newSize;
       map._root = newRoot;
       map.__hash = undefined;
       map.__altered = true;
       return map;
     }
     return newRoot ? makeMap(newSize, newRoot) : emptyMap();
   }
 
   function updateNode(
     node,
     ownerID,
     shift,
     keyHash,
     key,
     value,
     didChangeSize,
     didAlter
   ) {
     if (!node) {
       if (value === NOT_SET) {
         return node;
       }
       SetRef(didAlter);
       SetRef(didChangeSize);
       return new ValueNode(ownerID, keyHash, [key, value]);
     }
     return node.update(
       ownerID,
       shift,
       keyHash,
       key,
       value,
       didChangeSize,
       didAlter
     );
   }
 
   function isLeafNode(node) {
     return (
       node.constructor === ValueNode || node.constructor === HashCollisionNode
     );
   }
 
   function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
     if (node.keyHash === keyHash) {
       return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
     }
 
     var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
     var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
 
     var newNode;
     var nodes =
       idx1 === idx2
         ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]
         : ((newNode = new ValueNode(ownerID, keyHash, entry)),
           idx1 < idx2 ? [node, newNode] : [newNode, node]);
 
     return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
   }
 
   function createNodes(ownerID, entries, key, value) {
     if (!ownerID) {
       ownerID = new OwnerID();
     }
     var node = new ValueNode(ownerID, hash(key), [key, value]);
     for (var ii = 0; ii < entries.length; ii++) {
       var entry = entries[ii];
       node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
     }
     return node;
   }
 
   function packNodes(ownerID, nodes, count, excluding) {
     var bitmap = 0;
     var packedII = 0;
     var packedNodes = new Array(count);
     for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
       var node = nodes[ii];
       if (node !== undefined && ii !== excluding) {
         bitmap |= bit;
         packedNodes[packedII++] = node;
       }
     }
     return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
   }
 
   function expandNodes(ownerID, nodes, bitmap, including, node) {
     var count = 0;
     var expandedNodes = new Array(SIZE);
     for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
       expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
     }
     expandedNodes[including] = node;
     return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
   }
 
   function popCount(x) {
     x -= (x >> 1) & 0x55555555;
     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
     x = (x + (x >> 4)) & 0x0f0f0f0f;
     x += x >> 8;
     x += x >> 16;
     return x & 0x7f;
   }
 
   function setAt(array, idx, val, canEdit) {
     var newArray = canEdit ? array : arrCopy(array);
     newArray[idx] = val;
     return newArray;
   }
 
   function spliceIn(array, idx, val, canEdit) {
     var newLen = array.length + 1;
     if (canEdit && idx + 1 === newLen) {
       array[idx] = val;
       return array;
     }
     var newArray = new Array(newLen);
     var after = 0;
     for (var ii = 0; ii < newLen; ii++) {
       if (ii === idx) {
         newArray[ii] = val;
         after = -1;
       } else {
         newArray[ii] = array[ii + after];
       }
     }
     return newArray;
   }
 
   function spliceOut(array, idx, canEdit) {
     var newLen = array.length - 1;
     if (canEdit && idx === newLen) {
       array.pop();
       return array;
     }
     var newArray = new Array(newLen);
     var after = 0;
     for (var ii = 0; ii < newLen; ii++) {
       if (ii === idx) {
         after = 1;
       }
       newArray[ii] = array[ii + after];
     }
     return newArray;
   }
 
   var MAX_ARRAY_MAP_SIZE = SIZE / 4;
   var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
   var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
 
   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 === undefined || value === null) {
         return empty;
       }
       if (isList(value)) {
         return value;
       }
       var iter = IndexedCollection(value);
       var size = iter.size;
       if (size === 0) {
         return empty;
       }
       assertNotInfinite(size);
       if (size > 0 && size < SIZE) {
         return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
       }
       return empty.withMutations(function (list) {
         list.setSize(size);
         iter.forEach(function (v, i) { return list.set(i, v); });
       });
     }
 
     if ( IndexedCollection ) List.__proto__ = IndexedCollection;
     List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );
     List.prototype.constructor = List;
 
     List.of = function of (/*...values*/) {
       return this(arguments);
     };
 
     List.prototype.toString = function toString () {
       return this.__toString('List [', ']');
     };
 
     // @pragma Access
 
     List.prototype.get = function get (index, notSetValue) {
       index = wrapIndex(this, index);
       if (index >= 0 && index < this.size) {
         index += this._origin;
         var node = listNodeFor(this, index);
         return node && node.array[index & MASK];
       }
       return notSetValue;
     };
 
     // @pragma Modification
 
     List.prototype.set = function set (index, value) {
       return updateList(this, index, value);
     };
 
     List.prototype.remove = function remove (index) {
       return !this.has(index)
         ? this
         : index === 0
         ? this.shift()
         : index === this.size - 1
         ? this.pop()
         : this.splice(index, 1);
     };
 
     List.prototype.insert = function insert (index, value) {
       return this.splice(index, 0, value);
     };
 
     List.prototype.clear = function clear () {
       if (this.size === 0) {
         return this;
       }
       if (this.__ownerID) {
         this.size = this._origin = this._capacity = 0;
         this._level = SHIFT;
         this._root = this._tail = this.__hash = undefined;
         this.__altered = true;
         return this;
       }
       return emptyList();
     };
 
     List.prototype.push = function push (/*...values*/) {
       var values = arguments;
       var oldSize = this.size;
       return this.withMutations(function (list) {
         setListBounds(list, 0, oldSize + values.length);
         for (var ii = 0; ii < values.length; ii++) {
           list.set(oldSize + ii, values[ii]);
         }
       });
     };
 
     List.prototype.pop = function pop () {
       return setListBounds(this, 0, -1);
     };
 
     List.prototype.unshift = function unshift (/*...values*/) {
       var values = arguments;
       return this.withMutations(function (list) {
         setListBounds(list, -values.length);
         for (var ii = 0; ii < values.length; ii++) {
           list.set(ii, values[ii]);
         }
       });
     };
 
     List.prototype.shift = function shift () {
       return setListBounds(this, 1);
     };
 
     // @pragma Composition
 
     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) {
       var size = this.size;
       if (wholeSlice(begin, end, size)) {
         return this;
       }
       return setListBounds(
         this,
         resolveBegin(begin, size),
         resolveEnd(end, size)
       );
     };
 
     List.prototype.__iterator = function __iterator (type, reverse) {
       var index = reverse ? this.size : 0;
       var values = iterateList(this, reverse);
       return new Iterator(function () {
         var value = values();
         return value === DONE
           ? iteratorDone()
           : iteratorValue(type, reverse ? --index : index++, value);
       });
     };
 
     List.prototype.__iterate = function __iterate (fn, reverse) {
       var index = reverse ? this.size : 0;
       var values = iterateList(this, reverse);
       var value;
       while ((value = values()) !== DONE) {
         if (fn(value, reverse ? --index : index++, this) === false) {
           break;
         }
       }
       return index;
     };
 
     List.prototype.__ensureOwner = function __ensureOwner (ownerID) {
       if (ownerID === this.__ownerID) {
         return this;
       }
       if (!ownerID) {
         if (this.size === 0) {
           return emptyList();
         }
         this.__ownerID = ownerID;
         this.__altered = false;
         return this;
       }
       return makeList(
         this._origin,
         this._capacity,
         this._level,
         this._root,
         this._tail,
         ownerID,
         this.__hash
       );
     };
 
     return List;
   }(IndexedCollection));
 
   List.isList = isList;
 
   var ListPrototype = List.prototype;
   ListPrototype[IS_LIST_SYMBOL] = true;
   ListPrototype[DELETE] = ListPrototype.remove;
   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'] = function (obj) {
     return obj.asImmutable();
   };
 
   var VNode = function VNode(array, ownerID) {
     this.array = array;
     this.ownerID = ownerID;
   };
 
   // TODO: seems like these methods are very similar
 
   VNode.prototype.removeBefore = function removeBefore (ownerID, level, index) {
     if (index === level ? 1 << level : this.array.length === 0) {
       return this;
     }
     var originIndex = (index >>> level) & MASK;
     if (originIndex >= this.array.length) {
       return new VNode([], ownerID);
     }
     var removingFirst = originIndex === 0;
     var newChild;
     if (level > 0) {
       var oldChild = this.array[originIndex];
       newChild =
         oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
       if (newChild === oldChild && removingFirst) {
         return this;
       }
     }
     if (removingFirst && !newChild) {
       return this;
     }
     var editable = editableVNode(this, ownerID);
     if (!removingFirst) {
       for (var ii = 0; ii < originIndex; ii++) {
         editable.array[ii] = undefined;
       }
     }
     if (newChild) {
       editable.array[originIndex] = newChild;
     }
     return editable;
   };
 
   VNode.prototype.removeAfter = function removeAfter (ownerID, level, index) {
     if (index === (level ? 1 << level : 0) || this.array.length === 0) {
       return this;
     }
     var sizeIndex = ((index - 1) >>> level) & MASK;
     if (sizeIndex >= this.array.length) {
       return this;
     }
 
     var newChild;
     if (level > 0) {
       var oldChild = this.array[sizeIndex];
       newChild =
         oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
       if (newChild === oldChild && sizeIndex === this.array.length - 1) {
         return this;
       }
     }
 
     var editable = editableVNode(this, ownerID);
     editable.array.splice(sizeIndex + 1);
     if (newChild) {
       editable.array[sizeIndex] = newChild;
     }
     return editable;
   };
 
   var DONE = {};
 
   function iterateList(list, reverse) {
     var left = list._origin;
     var right = list._capacity;
     var tailPos = getTailOffset(right);
     var tail = list._tail;
 
     return iterateNodeOrLeaf(list._root, list._level, 0);
 
     function iterateNodeOrLeaf(node, level, offset) {
       return level === 0
         ? iterateLeaf(node, offset)
         : iterateNode(node, level, offset);
     }
 
     function iterateLeaf(node, offset) {
       var array = offset === tailPos ? tail && tail.array : node && node.array;
       var from = offset > left ? 0 : left - offset;
       var to = right - offset;
       if (to > SIZE) {
         to = SIZE;
       }
       return function () {
         if (from === to) {
           return DONE;
         }
         var idx = reverse ? --to : from++;
         return array && array[idx];
       };
     }
 
     function iterateNode(node, level, offset) {
       var values;
       var array = node && node.array;
       var from = offset > left ? 0 : (left - offset) >> level;
       var to = ((right - offset) >> level) + 1;
       if (to > SIZE) {
         to = SIZE;
       }
       return function () {
         while (true) {
           if (values) {
             var value = values();
             if (value !== DONE) {
               return value;
             }
             values = null;
           }
           if (from === to) {
             return DONE;
           }
           var idx = reverse ? --to : from++;
           values = iterateNodeOrLeaf(
             array && array[idx],
             level - SHIFT,
             offset + (idx << level)
           );
         }
       };
     }
   }
 
   function makeList(origin, capacity, level, root, tail, ownerID, hash) {
     var list = Object.create(ListPrototype);
     list.size = capacity - origin;
     list._origin = origin;
     list._capacity = capacity;
     list._level = level;
     list._root = root;
     list._tail = tail;
     list.__ownerID = ownerID;
     list.__hash = hash;
     list.__altered = false;
     return list;
   }
 
   var EMPTY_LIST;
   function emptyList() {
     return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
   }
 
   function updateList(list, index, value) {
     index = wrapIndex(list, index);
 
     if (index !== index) {
       return list;
     }
 
     if (index >= list.size || index < 0) {
       return list.withMutations(function (list) {
         index < 0
           ? setListBounds(list, index).set(0, value)
           : setListBounds(list, 0, index + 1).set(index, value);
       });
     }
 
     index += list._origin;
 
     var newTail = list._tail;
     var newRoot = list._root;
     var didAlter = MakeRef();
     if (index >= getTailOffset(list._capacity)) {
       newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
     } else {
       newRoot = updateVNode(
         newRoot,
         list.__ownerID,
         list._level,
         index,
         value,
         didAlter
       );
     }
 
     if (!didAlter.value) {
       return list;
     }
 
     if (list.__ownerID) {
       list._root = newRoot;
       list._tail = newTail;
       list.__hash = undefined;
       list.__altered = true;
       return list;
     }
     return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
   }
 
   function updateVNode(node, ownerID, level, index, value, didAlter) {
     var idx = (index >>> level) & MASK;
     var nodeHas = node && idx < node.array.length;
     if (!nodeHas && value === undefined) {
       return node;
     }
 
     var newNode;
 
     if (level > 0) {
       var lowerNode = node && node.array[idx];
       var newLowerNode = updateVNode(
         lowerNode,
         ownerID,
         level - SHIFT,
         index,
         value,
         didAlter
       );
       if (newLowerNode === lowerNode) {
         return node;
       }
       newNode = editableVNode(node, ownerID);
       newNode.array[idx] = newLowerNode;
       return newNode;
     }
 
     if (nodeHas && node.array[idx] === value) {
       return node;
     }
 
     if (didAlter) {
       SetRef(didAlter);
     }
 
     newNode = editableVNode(node, ownerID);
     if (value === undefined && idx === newNode.array.length - 1) {
       newNode.array.pop();
     } else {
       newNode.array[idx] = value;
     }
     return newNode;
   }
 
   function editableVNode(node, ownerID) {
     if (ownerID && node && ownerID === node.ownerID) {
       return node;
     }
     return new VNode(node ? node.array.slice() : [], ownerID);
   }
 
   function listNodeFor(list, rawIndex) {
     if (rawIndex >= getTailOffset(list._capacity)) {
       return list._tail;
     }
     if (rawIndex < 1 << (list._level + SHIFT)) {
       var node = list._root;
       var level = list._level;
       while (node && level > 0) {
         node = node.array[(rawIndex >>> level) & MASK];
         level -= SHIFT;
       }
       return node;
     }
   }
 
   function setListBounds(list, begin, end) {
     // Sanitize begin & end using this shorthand for ToInt32(argument)
     // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
     if (begin !== undefined) {
       begin |= 0;
     }
     if (end !== undefined) {
       end |= 0;
     }
     var owner = list.__ownerID || new OwnerID();
     var oldOrigin = list._origin;
     var oldCapacity = list._capacity;
     var newOrigin = oldOrigin + begin;
     var newCapacity =
       end === undefined
         ? oldCapacity
         : end < 0
         ? oldCapacity + end
         : oldOrigin + end;
     if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
       return list;
     }
 
     // If it's going to end after it starts, it's empty.
     if (newOrigin >= newCapacity) {
       return list.clear();
     }
 
     var newLevel = list._level;
     var newRoot = list._root;
 
     // New origin might need creating a higher root.
     var offsetShift = 0;
     while (newOrigin + offsetShift < 0) {
       newRoot = new VNode(
         newRoot && newRoot.array.length ? [undefined, newRoot] : [],
         owner
       );
       newLevel += SHIFT;
       offsetShift += 1 << newLevel;
     }
     if (offsetShift) {
       newOrigin += offsetShift;
       oldOrigin += offsetShift;
       newCapacity += offsetShift;
       oldCapacity += offsetShift;
     }
 
     var oldTailOffset = getTailOffset(oldCapacity);
     var newTailOffset = getTailOffset(newCapacity);
 
     // New size might need creating a higher root.
     while (newTailOffset >= 1 << (newLevel + SHIFT)) {
       newRoot = new VNode(
         newRoot && newRoot.array.length ? [newRoot] : [],
         owner
       );
       newLevel += SHIFT;
     }
 
     // Locate or create the new tail.
     var oldTail = list._tail;
     var newTail =
       newTailOffset < oldTailOffset
         ? listNodeFor(list, newCapacity - 1)
         : newTailOffset > oldTailOffset
         ? new VNode([], owner)
         : oldTail;
 
     // Merge Tail into tree.
     if (
       oldTail &&
       newTailOffset > oldTailOffset &&
       newOrigin < oldCapacity &&
       oldTail.array.length
     ) {
       newRoot = editableVNode(newRoot, owner);
       var node = newRoot;
       for (var level = newLevel; level > SHIFT; level -= SHIFT) {
         var idx = (oldTailOffset >>> level) & MASK;
         node = node.array[idx] = editableVNode(node.array[idx], owner);
       }
       node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
     }
 
     // If the size has been reduced, there's a chance the tail needs to be trimmed.
     if (newCapacity < oldCapacity) {
       newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
     }
 
     // If the new origin is within the tail, then we do not need a root.
     if (newOrigin >= newTailOffset) {
       newOrigin -= newTailOffset;
       newCapacity -= newTailOffset;
       newLevel = SHIFT;
       newRoot = null;
       newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);
 
       // Otherwise, if the root has been trimmed, garbage collect.
     } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
       offsetShift = 0;
 
       // Identify the new top root node of the subtree of the old root.
       while (newRoot) {
         var beginIndex = (newOrigin >>> newLevel) & MASK;
         if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {
           break;
         }
         if (beginIndex) {
           offsetShift += (1 << newLevel) * beginIndex;
         }
         newLevel -= SHIFT;
         newRoot = newRoot.array[beginIndex];
       }
 
       // Trim the new sides of the new root.
       if (newRoot && newOrigin > oldOrigin) {
         newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);
       }
       if (newRoot && newTailOffset < oldTailOffset) {
         newRoot = newRoot.removeAfter(
           owner,
           newLevel,
           newTailOffset - offsetShift
         );
       }
       if (offsetShift) {
         newOrigin -= offsetShift;
         newCapacity -= offsetShift;
       }
     }
 
     if (list.__ownerID) {
       list.size = newCapacity - newOrigin;
       list._origin = newOrigin;
       list._capacity = newCapacity;
       list._level = newLevel;
       list._root = newRoot;
       list._tail = newTail;
       list.__hash = undefined;
       list.__altered = true;
       return list;
     }
     return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
   }
 
   function getTailOffset(size) {
     return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
   }
 
   var OrderedMap = /*@__PURE__*/(function (Map) {
     function OrderedMap(value) {
       return value === undefined || value === null
         ? emptyOrderedMap()
         : isOrderedMap(value)
         ? value
         : emptyOrderedMap().withMutations(function (map) {
             var iter = KeyedCollection(value);
             assertNotInfinite(iter.size);
             iter.forEach(function (v, k) { return map.set(k, v); });
           });
     }
 
     if ( Map ) OrderedMap.__proto__ = Map;
     OrderedMap.prototype = Object.create( Map && Map.prototype );
     OrderedMap.prototype.constructor = OrderedMap;
 
     OrderedMap.of = function of (/*...values*/) {
       return this(arguments);
     };
 
     OrderedMap.prototype.toString = function toString () {
       return this.__toString('OrderedMap {', '}');
     };
 
     // @pragma Access
 
     OrderedMap.prototype.get = function get (k, notSetValue) {
       var index = this._map.get(k);
       return index !== undefined ? this._list.get(index)[1] : notSetValue;
     };
 
     // @pragma Modification
 
     OrderedMap.prototype.clear = function clear () {
       if (this.size === 0) {
         return this;
       }
       if (this.__ownerID) {
         this.size = 0;
         this._map.clear();
         this._list.clear();
         this.__altered = true;
         return this;
       }
       return emptyOrderedMap();
     };
 
     OrderedMap.prototype.set = function set (k, v) {
       return updateOrderedMap(this, k, v);
     };
 
     OrderedMap.prototype.remove = function remove (k) {
       return updateOrderedMap(this, k, NOT_SET);
     };
 
     OrderedMap.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       return this._list.__iterate(
         function (entry) { return entry && fn(entry[1], entry[0], this$1$1); },
         reverse
       );
     };
 
     OrderedMap.prototype.__iterator = function __iterator (type, reverse) {
       return this._list.fromEntrySeq().__iterator(type, reverse);
     };
 
     OrderedMap.prototype.__ensureOwner = function __ensureOwner (ownerID) {
       if (ownerID === this.__ownerID) {
         return this;
       }
       var newMap = this._map.__ensureOwner(ownerID);
       var newList = this._list.__ensureOwner(ownerID);
       if (!ownerID) {
         if (this.size === 0) {
           return emptyOrderedMap();
         }
         this.__ownerID = ownerID;
         this.__altered = false;
         this._map = newMap;
         this._list = newList;
         return this;
       }
       return makeOrderedMap(newMap, newList, ownerID, this.__hash);
     };
 
     return OrderedMap;
   }(Map));
 
   OrderedMap.isOrderedMap = isOrderedMap;
 
   OrderedMap.prototype[IS_ORDERED_SYMBOL] = true;
   OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;
 
   function makeOrderedMap(map, list, ownerID, hash) {
     var omap = Object.create(OrderedMap.prototype);
     omap.size = map ? map.size : 0;
     omap._map = map;
     omap._list = list;
     omap.__ownerID = ownerID;
     omap.__hash = hash;
     omap.__altered = false;
     return omap;
   }
 
   var EMPTY_ORDERED_MAP;
   function emptyOrderedMap() {
     return (
       EMPTY_ORDERED_MAP ||
       (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))
     );
   }
 
   function updateOrderedMap(omap, k, v) {
     var map = omap._map;
     var list = omap._list;
     var i = map.get(k);
     var has = i !== undefined;
     var newMap;
     var newList;
     if (v === NOT_SET) {
       // removed
       if (!has) {
         return omap;
       }
       if (list.size >= SIZE && list.size >= map.size * 2) {
         newList = list.filter(function (entry, idx) { return entry !== undefined && i !== idx; });
         newMap = newList
           .toKeyedSeq()
           .map(function (entry) { return entry[0]; })
           .flip()
           .toMap();
         if (omap.__ownerID) {
           newMap.__ownerID = newList.__ownerID = omap.__ownerID;
         }
       } else {
         newMap = map.remove(k);
         newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
       }
     } else if (has) {
       if (v === list.get(i)[1]) {
         return omap;
       }
       newMap = map;
       newList = list.set(i, [k, v]);
     } else {
       newMap = map.set(k, list.size);
       newList = list.set(list.size, [k, v]);
     }
     if (omap.__ownerID) {
       omap.size = newMap.size;
       omap._map = newMap;
       omap._list = newList;
       omap.__hash = undefined;
       omap.__altered = true;
       return omap;
     }
     return makeOrderedMap(newMap, newList);
   }
 
   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 === undefined || value === null
         ? emptyStack()
         : isStack(value)
         ? value
         : emptyStack().pushAll(value);
     }
 
     if ( IndexedCollection ) Stack.__proto__ = IndexedCollection;
     Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );
     Stack.prototype.constructor = Stack;
 
     Stack.of = function of (/*...values*/) {
       return this(arguments);
     };
 
     Stack.prototype.toString = function toString () {
       return this.__toString('Stack [', ']');
     };
 
     // @pragma Access
 
     Stack.prototype.get = function get (index, notSetValue) {
       var head = this._head;
       index = wrapIndex(this, index);
       while (head && index--) {
         head = head.next;
       }
       return head ? head.value : notSetValue;
     };
 
     Stack.prototype.peek = function peek () {
       return this._head && this._head.value;
     };
 
     // @pragma Modification
 
     Stack.prototype.push = function push (/*...values*/) {
       var arguments$1 = arguments;
 
       if (arguments.length === 0) {
         return this;
       }
       var newSize = this.size + arguments.length;
       var head = this._head;
       for (var ii = arguments.length - 1; ii >= 0; ii--) {
         head = {
           value: arguments$1[ii],
           next: head,
         };
       }
       if (this.__ownerID) {
         this.size = newSize;
         this._head = head;
         this.__hash = undefined;
         this.__altered = true;
         return this;
       }
       return makeStack(newSize, head);
     };
 
     Stack.prototype.pushAll = function pushAll (iter) {
       iter = IndexedCollection(iter);
       if (iter.size === 0) {
         return this;
       }
       if (this.size === 0 && isStack(iter)) {
         return iter;
       }
       assertNotInfinite(iter.size);
       var newSize = this.size;
       var head = this._head;
       iter.__iterate(function (value) {
         newSize++;
         head = {
           value: value,
           next: head,
         };
       }, /* reverse */ true);
       if (this.__ownerID) {
         this.size = newSize;
         this._head = head;
         this.__hash = undefined;
         this.__altered = true;
         return this;
       }
       return makeStack(newSize, head);
     };
 
     Stack.prototype.pop = function pop () {
       return this.slice(1);
     };
 
     Stack.prototype.clear = function clear () {
       if (this.size === 0) {
         return this;
       }
       if (this.__ownerID) {
         this.size = 0;
         this._head = undefined;
         this.__hash = undefined;
         this.__altered = true;
         return this;
       }
       return emptyStack();
     };
 
     Stack.prototype.slice = function slice (begin, end) {
       if (wholeSlice(begin, end, this.size)) {
         return this;
       }
       var resolvedBegin = resolveBegin(begin, this.size);
       var resolvedEnd = resolveEnd(end, this.size);
       if (resolvedEnd !== this.size) {
         // super.slice(begin, end);
         return IndexedCollection.prototype.slice.call(this, begin, end);
       }
       var newSize = this.size - resolvedBegin;
       var head = this._head;
       while (resolvedBegin--) {
         head = head.next;
       }
       if (this.__ownerID) {
         this.size = newSize;
         this._head = head;
         this.__hash = undefined;
         this.__altered = true;
         return this;
       }
       return makeStack(newSize, head);
     };
 
     // @pragma Mutability
 
     Stack.prototype.__ensureOwner = function __ensureOwner (ownerID) {
       if (ownerID === this.__ownerID) {
         return this;
       }
       if (!ownerID) {
         if (this.size === 0) {
           return emptyStack();
         }
         this.__ownerID = ownerID;
         this.__altered = false;
         return this;
       }
       return makeStack(this.size, this._head, ownerID, this.__hash);
     };
 
     // @pragma Iteration
 
     Stack.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       if (reverse) {
         return new ArraySeq(this.toArray()).__iterate(
           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) === false) {
           break;
         }
         node = node.next;
       }
       return iterations;
     };
 
     Stack.prototype.__iterator = function __iterator (type, reverse) {
       if (reverse) {
         return new ArraySeq(this.toArray()).__iterator(type, reverse);
       }
       var iterations = 0;
       var node = this._head;
       return new Iterator(function () {
         if (node) {
           var value = node.value;
           node = node.next;
           return iteratorValue(type, iterations++, value);
         }
         return iteratorDone();
       });
     };
 
     return Stack;
   }(IndexedCollection));
 
   Stack.isStack = isStack;
 
   var StackPrototype = Stack.prototype;
   StackPrototype[IS_STACK_SYMBOL] = true;
   StackPrototype.shift = StackPrototype.pop;
   StackPrototype.unshift = StackPrototype.push;
   StackPrototype.unshiftAll = StackPrototype.pushAll;
   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'] = function (obj) {
     return obj.asImmutable();
   };
 
   function makeStack(size, head, ownerID, hash) {
     var map = Object.create(StackPrototype);
     map.size = size;
     map._head = head;
     map.__ownerID = ownerID;
     map.__hash = hash;
     map.__altered = false;
     return map;
   }
 
   var EMPTY_STACK;
   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;
     }
 
     if (
       !isCollection(b) ||
       (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
       (a.__hash !== undefined &&
         b.__hash !== undefined &&
         a.__hash !== b.__hash) ||
       isKeyed(a) !== isKeyed(b) ||
       isIndexed(a) !== isIndexed(b) ||
       isOrdered(a) !== isOrdered(b)
     ) {
       return false;
     }
 
     if (a.size === 0 && b.size === 0) {
       return true;
     }
 
     var notAssociative = !isAssociative(a);
 
     if (isOrdered(a)) {
       var entries = a.entries();
       return (
         b.every(function (v, k) {
           var entry = entries.next().value;
           return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
         }) && entries.next().done
       );
     }
 
     var flipped = false;
 
     if (a.size === undefined) {
       if (b.size === undefined) {
         if (typeof a.cacheResult === 'function') {
           a.cacheResult();
         }
       } else {
         flipped = true;
         var _ = a;
         a = b;
         b = _;
       }
     }
 
     var allEqual = true;
     var bSize = b.__iterate(function (v, k) {
       if (
         notAssociative
           ? !a.has(v)
           : flipped
           ? !is(v, a.get(k, NOT_SET))
           : !is(a.get(k, NOT_SET), v)
       ) {
         allEqual = false;
         return false;
       }
     });
 
     return allEqual && a.size === bSize;
   }
 
   function mixin(ctor, methods) {
     var keyCopier = function (key) {
       ctor.prototype[key] = methods[key];
     };
     Object.keys(methods).forEach(keyCopier);
     Object.getOwnPropertySymbols &&
       Object.getOwnPropertySymbols(methods).forEach(keyCopier);
     return ctor;
   }
 
   function 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 === undefined || value === null
         ? emptySet()
         : isSet(value) && !isOrdered(value)
         ? value
         : emptySet().withMutations(function (set) {
             var iter = SetCollection(value);
             assertNotInfinite(iter.size);
             iter.forEach(function (v) { return set.add(v); });
           });
     }
 
     if ( SetCollection ) Set.__proto__ = SetCollection;
     Set.prototype = Object.create( SetCollection && SetCollection.prototype );
     Set.prototype.constructor = Set;
 
     Set.of = function of (/*...values*/) {
       return this(arguments);
     };
 
     Set.fromKeys = function fromKeys (value) {
       return this(KeyedCollection(value).keySeq());
     };
 
     Set.intersect = function intersect (sets) {
       sets = Collection(sets).toArray();
       return sets.length
         ? SetPrototype.intersect.apply(Set(sets.pop()), sets)
         : emptySet();
     };
 
     Set.union = function union (sets) {
       sets = Collection(sets).toArray();
       return sets.length
         ? SetPrototype.union.apply(Set(sets.pop()), sets)
         : emptySet();
     };
 
     Set.prototype.toString = function toString () {
       return this.__toString('Set {', '}');
     };
 
     // @pragma Access
 
     Set.prototype.has = function has (value) {
       return this._map.has(value);
     };
 
     // @pragma Modification
 
     Set.prototype.add = function add (value) {
       return updateSet(this, this._map.set(value, value));
     };
 
     Set.prototype.remove = function remove (value) {
       return updateSet(this, this._map.remove(value));
     };
 
     Set.prototype.clear = function clear () {
       return updateSet(this, this._map.clear());
     };
 
     // @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 ];
 
       iters = iters.filter(function (x) { return x.size !== 0; });
       if (iters.length === 0) {
         return this;
       }
       if (this.size === 0 && !this.__ownerID && iters.length === 1) {
         return this.constructor(iters[0]);
       }
       return this.withMutations(function (set) {
         for (var ii = 0; ii < iters.length; ii++) {
           if (typeof iters[ii] === 'string') {
             set.add(iters[ii]);
           } else {
             SetCollection(iters[ii]).forEach(function (value) { return set.add(value); });
           }
         }
       });
     };
 
     Set.prototype.intersect = function intersect () {
       var iters = [], len = arguments.length;
       while ( len-- ) iters[ len ] = arguments[ len ];
 
       if (iters.length === 0) {
         return this;
       }
       iters = iters.map(function (iter) { return SetCollection(iter); });
       var toRemove = [];
       this.forEach(function (value) {
         if (!iters.every(function (iter) { return iter.includes(value); })) {
           toRemove.push(value);
         }
       });
       return this.withMutations(function (set) {
         toRemove.forEach(function (value) {
           set.remove(value);
         });
       });
     };
 
     Set.prototype.subtract = function subtract () {
       var iters = [], len = arguments.length;
       while ( len-- ) iters[ len ] = arguments[ len ];
 
       if (iters.length === 0) {
         return this;
       }
       iters = iters.map(function (iter) { return SetCollection(iter); });
       var toRemove = [];
       this.forEach(function (value) {
         if (iters.some(function (iter) { return iter.includes(value); })) {
           toRemove.push(value);
         }
       });
       return this.withMutations(function (set) {
         toRemove.forEach(function (value) {
           set.remove(value);
         });
       });
     };
 
     Set.prototype.sort = function sort (comparator) {
       // Late binding
       return OrderedSet(sortFactory(this, comparator));
     };
 
     Set.prototype.sortBy = function sortBy (mapper, comparator) {
       // Late binding
       return OrderedSet(sortFactory(this, comparator, mapper));
     };
 
     Set.prototype.wasAltered = function wasAltered () {
       return this._map.wasAltered();
     };
 
     Set.prototype.__iterate = function __iterate (fn, reverse) {
       var this$1$1 = this;
 
       return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse);
     };
 
     Set.prototype.__iterator = function __iterator (type, reverse) {
       return this._map.__iterator(type, reverse);
     };
 
     Set.prototype.__ensureOwner = function __ensureOwner (ownerID) {
       if (ownerID === this.__ownerID) {
         return this;
       }
       var newMap = this._map.__ensureOwner(ownerID);
       if (!ownerID) {
         if (this.size === 0) {
           return this.__empty();
         }
         this.__ownerID = ownerID;
         this._map = newMap;
         return this;
       }
       return this.__make(newMap, ownerID);
     };
 
     return Set;
   }(SetCollection));
 
   Set.isSet = isSet;
 
   var SetPrototype = Set.prototype;
   SetPrototype[IS_SET_SYMBOL] = true;
   SetPrototype[DELETE] = SetPrototype.remove;
   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'] = function (obj) {
     return obj.asImmutable();
   };
 
   SetPrototype.__empty = emptySet;
   SetPrototype.__make = makeSet;
 
   function updateSet(set, newMap) {
     if (set.__ownerID) {
       set.size = newMap.size;
       set._map = newMap;
       return set;
     }
     return newMap === set._map
       ? set
       : newMap.size === 0
       ? set.__empty()
       : set.__make(newMap);
   }
 
   function makeSet(map, ownerID) {
     var set = Object.create(SetPrototype);
     set.size = map ? map.size : 0;
     set._map = map;
     set.__ownerID = ownerID;
     return set;
   }
 
   var EMPTY_SET;
   function emptySet() {
     return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
   }
 
   /**
    * Returns a lazy seq of nums from start (inclusive) to end
    * (exclusive), by step, where start defaults to 0, step to 1, and end to
    * infinity. When start is equal to end, returns empty list.
    */
   var Range = /*@__PURE__*/(function (IndexedSeq) {
     function Range(start, end, step) {
       if (!(this instanceof Range)) {
         return new Range(start, end, step);
       }
       invariant(step !== 0, 'Cannot step a Range by 0');
       start = start || 0;
       if (end === undefined) {
         end = Infinity;
       }
       step = step === undefined ? 1 : Math.abs(step);
       if (end < start) {
         step = -step;
       }
       this._start = start;
       this._end = end;
       this._step = step;
       this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
       if (this.size === 0) {
         if (EMPTY_RANGE) {
           return EMPTY_RANGE;
         }
         EMPTY_RANGE = this;
       }
     }
 
     if ( IndexedSeq ) Range.__proto__ = IndexedSeq;
     Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
     Range.prototype.constructor = Range;
 
     Range.prototype.toString = function toString () {
       if (this.size === 0) {
         return 'Range []';
       }
       return (
         'Range [ ' +
         this._start +
         '...' +
         this._end +
         (this._step !== 1 ? ' by ' + this._step : '') +
         ' ]'
       );
     };
 
     Range.prototype.get = function get (index, notSetValue) {
       return this.has(index)
         ? this._start + wrapIndex(this, index) * this._step
         : notSetValue;
     };
 
     Range.prototype.includes = function includes (searchValue) {
       var possibleIndex = (searchValue - this._start) / this._step;
       return (
         possibleIndex >= 0 &&
         possibleIndex < this.size &&
         possibleIndex === Math.floor(possibleIndex)
       );
     };
 
     Range.prototype.slice = function slice (begin, end) {
       if (wholeSlice(begin, end, this.size)) {
         return this;
       }
       begin = resolveBegin(begin, this.size);
       end = resolveEnd(end, this.size);
       if (end <= begin) {
         return new Range(0, 0);
       }
       return new Range(
         this.get(begin, this._end),
         this.get(end, this._end),
         this._step
       );
     };
 
     Range.prototype.indexOf = function indexOf (searchValue) {
       var offsetValue = searchValue - this._start;
       if (offsetValue % this._step === 0) {
         var index = offsetValue / this._step;
         if (index >= 0 && index < this.size) {
           return index;
         }
       }
       return -1;
     };
 
     Range.prototype.lastIndexOf = function lastIndexOf (searchValue) {
       return this.indexOf(searchValue);
     };
 
     Range.prototype.__iterate = function __iterate (fn, reverse) {
       var size = this.size;
       var step = this._step;
       var value = reverse ? this._start + (size - 1) * step : this._start;
       var i = 0;
       while (i !== size) {
         if (fn(value, reverse ? size - ++i : i++, this) === false) {
           break;
         }
         value += reverse ? -step : step;
       }
       return i;
     };
 
     Range.prototype.__iterator = function __iterator (type, reverse) {
       var size = this.size;
       var step = this._step;
       var value = reverse ? this._start + (size - 1) * step : this._start;
       var i = 0;
       return new Iterator(function () {
         if (i === size) {
           return iteratorDone();
         }
         var v = value;
         value += reverse ? -step : step;
         return iteratorValue(type, reverse ? size - ++i : i++, v);
       });
     };
 
     Range.prototype.equals = function equals (other) {
       return other instanceof Range
         ? this._start === other._start &&
             this._end === other._end &&
             this._step === other._step
         : deepEqual(this, other);
     };
 
     return Range;
   }(IndexedSeq));
 
   var EMPTY_RANGE;
 
   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;
   Collection.isIndexed = isIndexed;
   Collection.isAssociative = isAssociative;
   Collection.isOrdered = isOrdered;
 
   Collection.Iterator = Iterator;
 
   mixin(Collection, {
     // ### Conversion to other types
 
     toArray: function toArray() {
       assertNotInfinite(this.size);
       var array = new Array(this.size || 0);
       var useTuples = isKeyed(this);
       var i = 0;
       this.__iterate(function (v, k) {
         // Keyed collections produce an array of tuples.
         array[i++] = useTuples ? [k, v] : v;
       });
       return array;
     },
 
     toIndexedSeq: function toIndexedSeq() {
       return new ToIndexedSequence(this);
     },
 
     toJS: function toJS$1() {
       return toJS(this);
     },
 
     toKeyedSeq: function toKeyedSeq() {
       return new ToKeyedSequence(this, true);
     },
 
     toMap: function toMap() {
       // Use Late Binding here to solve the circular dependency.
       return Map(this.toKeyedSeq());
     },
 
     toObject: toObject,
 
     toOrderedMap: function toOrderedMap() {
       // Use Late Binding here to solve the circular dependency.
       return OrderedMap(this.toKeyedSeq());
     },
 
     toOrderedSet: function toOrderedSet() {
       // Use Late Binding here to solve the circular dependency.
       return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
     },
 
     toSet: function toSet() {
       // Use Late Binding here to solve the circular dependency.
       return Set(isKeyed(this) ? this.valueSeq() : this);
     },
 
     toSetSeq: function toSetSeq() {
       return new ToSetSequence(this);
     },
 
     toSeq: function toSeq() {
       return isIndexed(this)
         ? this.toIndexedSeq()
         : isKeyed(this)
         ? this.toKeyedSeq()
         : this.toSetSeq();
     },
 
     toStack: function toStack() {
       // Use Late Binding here to solve the circular dependency.
       return Stack(isKeyed(this) ? this.valueSeq() : this);
     },
 
     toList: function toList() {
       // Use Late Binding here to solve the circular dependency.
       return List(isKeyed(this) ? this.valueSeq() : this);
     },
 
     // ### Common JavaScript methods and properties
 
     toString: function toString() {
       return '[Collection]';
     },
 
     __toString: function __toString(head, tail) {
       if (this.size === 0) {
         return head + tail;
       }
       return (
         head +
         ' ' +
         this.toSeq().map(this.__toStringMapper).join(', ') +
         ' ' +
         tail
       );
     },
 
     // ### ES6 Collection methods (ES6 Array and Map)
 
     concat: function concat() {
       var values = [], len = arguments.length;
       while ( len-- ) values[ len ] = arguments[ len ];
 
       return reify(this, concatFactory(this, values));
     },
 
     includes: function includes(searchValue) {
       return this.some(function (value) { return is(value, searchValue); });
     },
 
     entries: function entries() {
       return this.__iterator(ITERATE_ENTRIES);
     },
 
     every: function every(predicate, context) {
       assertNotInfinite(this.size);
       var returnValue = true;
       this.__iterate(function (v, k, c) {
         if (!predicate.call(context, v, k, c)) {
           returnValue = false;
           return false;
         }
       });
       return returnValue;
     },
 
     filter: function filter(predicate, context) {
       return reify(this, filterFactory(this, predicate, context, true));
     },
 
     partition: function partition(predicate, context) {
       return partitionFactory(this, predicate, context);
     },
 
     find: function find(predicate, context, notSetValue) {
       var entry = this.findEntry(predicate, context);
       return entry ? entry[1] : notSetValue;
     },
 
     forEach: function forEach(sideEffect, context) {
       assertNotInfinite(this.size);
       return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
     },
 
     join: function join(separator) {
       assertNotInfinite(this.size);
       separator = separator !== undefined ? '' + separator : ',';
       var joined = '';
       var isFirst = true;
       this.__iterate(function (v) {
         isFirst ? (isFirst = false) : (joined += separator);
         joined += v !== null && v !== undefined ? v.toString() : '';
       });
       return joined;
     },
 
     keys: function keys() {
       return this.__iterator(ITERATE_KEYS);
     },
 
     map: function map(mapper, context) {
       return reify(this, mapFactory(this, mapper, context));
     },
 
     reduce: function reduce$1(reducer, initialReduction, context) {
       return reduce(
         this,
         reducer,
         initialReduction,
         context,
         arguments.length < 2,
         false
       );
     },
 
     reduceRight: function reduceRight(reducer, initialReduction, context) {
       return reduce(
         this,
         reducer,
         initialReduction,
         context,
         arguments.length < 2,
         true
       );
     },
 
     reverse: function reverse() {
       return reify(this, reverseFactory(this, true));
     },
 
     slice: function slice(begin, end) {
       return reify(this, sliceFactory(this, begin, end, true));
     },
 
     some: function some(predicate, context) {
       assertNotInfinite(this.size);
       var returnValue = false;
       this.__iterate(function (v, k, c) {
         if (predicate.call(context, v, k, c)) {
           returnValue = true;
           return false;
         }
       });
       return returnValue;
     },
 
     sort: function sort(comparator) {
       return reify(this, sortFactory(this, comparator));
     },
 
     values: function values() {
       return this.__iterator(ITERATE_VALUES);
     },
 
     // ### More sequential methods
 
     butLast: function butLast() {
       return this.slice(0, -1);
     },
 
     isEmpty: function isEmpty() {
       return this.size !== undefined ? this.size === 0 : !this.some(function () { return true; });
     },
 
     count: function count(predicate, context) {
       return ensureSize(
         predicate ? this.toSeq().filter(predicate, context) : this
       );
     },
 
     countBy: function countBy(grouper, context) {
       return countByFactory(this, grouper, context);
     },
 
     equals: function equals(other) {
       return deepEqual(this, other);
     },
 
     entrySeq: function entrySeq() {
       var collection = this;
       if (collection._cache) {
         // 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();
       entriesSequence.fromEntrySeq = function () { return collection.toSeq(); };
       return entriesSequence;
     },
 
     filterNot: function filterNot(predicate, context) {
       return this.filter(not(predicate), context);
     },
 
     findEntry: function findEntry(predicate, context, notSetValue) {
       var found = notSetValue;
       this.__iterate(function (v, k, c) {
         if (predicate.call(context, v, k, c)) {
           found = [k, v];
           return false;
         }
       });
       return found;
     },
 
     findKey: function findKey(predicate, context) {
       var entry = this.findEntry(predicate, context);
       return entry && entry[0];
     },
 
     findLast: function findLast(predicate, context, notSetValue) {
       return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
     },
 
     findLastEntry: function findLastEntry(predicate, context, notSetValue) {
       return this.toKeyedSeq()
         .reverse()
         .findEntry(predicate, context, notSetValue);
     },
 
     findLastKey: function findLastKey(predicate, context) {
       return this.toKeyedSeq().reverse().findKey(predicate, context);
     },
 
     first: function first(notSetValue) {
       return this.find(returnTrue, null, notSetValue);
     },
 
     flatMap: function flatMap(mapper, context) {
       return reify(this, flatMapFactory(this, mapper, context));
     },
 
     flatten: function flatten(depth) {
       return reify(this, flattenFactory(this, depth, true));
     },
 
     fromEntrySeq: function fromEntrySeq() {
       return new FromEntriesSequence(this);
     },
 
     get: function get(searchKey, notSetValue) {
       return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue);
     },
 
     getIn: getIn,
 
     groupBy: function groupBy(grouper, context) {
       return groupByFactory(this, grouper, context);
     },
 
     has: function has(searchKey) {
       return this.get(searchKey, NOT_SET) !== NOT_SET;
     },
 
     hasIn: hasIn,
 
     isSubset: function isSubset(iter) {
       iter = typeof iter.includes === 'function' ? iter : Collection(iter);
       return this.every(function (value) { return iter.includes(value); });
     },
 
     isSuperset: function isSuperset(iter) {
       iter = typeof iter.isSubset === 'function' ? iter : Collection(iter);
       return iter.isSubset(this);
     },
 
     keyOf: function keyOf(searchValue) {
       return this.findKey(function (value) { return is(value, searchValue); });
     },
 
     keySeq: function keySeq() {
       return this.toSeq().map(keyMapper).toIndexedSeq();
     },
 
     last: function last(notSetValue) {
       return this.toSeq().reverse().first(notSetValue);
     },
 
     lastKeyOf: function lastKeyOf(searchValue) {
       return this.toKeyedSeq().reverse().keyOf(searchValue);
     },
 
     max: function max(comparator) {
       return maxFactory(this, comparator);
     },
 
     maxBy: function maxBy(mapper, comparator) {
       return maxFactory(this, comparator, mapper);
     },
 
     min: function min(comparator) {
       return maxFactory(
         this,
         comparator ? neg(comparator) : defaultNegComparator
       );
     },
 
     minBy: function minBy(mapper, comparator) {
       return maxFactory(
         this,
         comparator ? neg(comparator) : defaultNegComparator,
         mapper
       );
     },
 
     rest: function rest() {
       return this.slice(1);
     },
 
     skip: function skip(amount) {
       return amount === 0 ? this : this.slice(Math.max(0, amount));
     },
 
     skipLast: function skipLast(amount) {
       return amount === 0 ? this : this.slice(0, -Math.max(0, amount));
     },
 
     skipWhile: function skipWhile(predicate, context) {
       return reify(this, skipWhileFactory(this, predicate, context, true));
     },
 
     skipUntil: function skipUntil(predicate, context) {
       return this.skipWhile(not(predicate), context);
     },
 
     sortBy: function sortBy(mapper, comparator) {
       return reify(this, sortFactory(this, comparator, mapper));
     },
 
     take: function take(amount) {
       return this.slice(0, Math.max(0, amount));
     },
 
     takeLast: function takeLast(amount) {
       return this.slice(-Math.max(0, amount));
     },
 
     takeWhile: function takeWhile(predicate, context) {
       return reify(this, takeWhileFactory(this, predicate, context));
     },
 
     takeUntil: function takeUntil(predicate, context) {
       return this.takeWhile(not(predicate), context);
     },
 
     update: function update(fn) {
       return fn(this);
     },
 
     valueSeq: function valueSeq() {
       return this.toIndexedSeq();
     },
 
     // ### Hashable Object
 
     hashCode: function hashCode() {
       return this.__hash || (this.__hash = hashCollection(this));
     },
 
     // ### Internal
 
     // abstract __iterate(fn, reverse)
 
     // abstract __iterator(type, reverse)
   });
 
   var CollectionPrototype = Collection.prototype;
   CollectionPrototype[IS_COLLECTION_SYMBOL] = true;
   CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;
   CollectionPrototype.toJSON = CollectionPrototype.toArray;
   CollectionPrototype.__toStringMapper = quoteString;
   CollectionPrototype.inspect = CollectionPrototype.toSource = function () {
     return this.toString();
   };
   CollectionPrototype.chain = CollectionPrototype.flatMap;
   CollectionPrototype.contains = CollectionPrototype.includes;
 
   mixin(KeyedCollection, {
     // ### More sequential methods
 
     flip: function flip() {
       return reify(this, flipFactory(this));
     },
 
     mapEntries: function mapEntries(mapper, context) {
       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$1); })
           .fromEntrySeq()
       );
     },
 
     mapKeys: function mapKeys(mapper, context) {
       var this$1$1 = this;
 
       return reify(
         this,
         this.toSeq()
           .flip()
           .map(function (k, v) { return mapper.call(context, k, v, this$1$1); })
           .flip()
       );
     },
   });
 
   var KeyedCollectionPrototype = KeyedCollection.prototype;
   KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;
   KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;
   KeyedCollectionPrototype.toJSON = toObject;
   KeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); };
 
   mixin(IndexedCollection, {
     // ### Conversion to other types
 
     toKeyedSeq: function toKeyedSeq() {
       return new ToKeyedSequence(this, false);
     },
 
     // ### ES6 Collection methods (ES6 Array and Map)
 
     filter: function filter(predicate, context) {
       return reify(this, filterFactory(this, predicate, context, false));
     },
 
     findIndex: function findIndex(predicate, context) {
       var entry = this.findEntry(predicate, context);
       return entry ? entry[0] : -1;
     },
 
     indexOf: function indexOf(searchValue) {
       var key = this.keyOf(searchValue);
       return key === undefined ? -1 : key;
     },
 
     lastIndexOf: function lastIndexOf(searchValue) {
       var key = this.lastKeyOf(searchValue);
       return key === undefined ? -1 : key;
     },
 
     reverse: function reverse() {
       return reify(this, reverseFactory(this, false));
     },
 
     slice: function slice(begin, end) {
       return reify(this, sliceFactory(this, begin, end, false));
     },
 
     splice: function splice(index, removeNum /*, ...values*/) {
       var numArgs = arguments.length;
       removeNum = Math.max(removeNum || 0, 0);
       if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
         return this;
       }
       // If index is negative, it should resolve relative to the size of the
       // collection. However size may be expensive to compute if not cached, so
       // only call count() if the number is in fact negative.
       index = resolveBegin(index, index < 0 ? this.count() : this.size);
       var spliced = this.slice(0, index);
       return reify(
         this,
         numArgs === 1
           ? spliced
           : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))
       );
     },
 
     // ### More collection methods
 
     findLastIndex: function findLastIndex(predicate, context) {
       var entry = this.findLastEntry(predicate, context);
       return entry ? entry[0] : -1;
     },
 
     first: function first(notSetValue) {
       return this.get(0, notSetValue);
     },
 
     flatten: function flatten(depth) {
       return reify(this, flattenFactory(this, depth, false));
     },
 
     get: function get(index, notSetValue) {
       index = wrapIndex(this, index);
       return index < 0 ||
         this.size === Infinity ||
         (this.size !== undefined && index > this.size)
         ? notSetValue
         : this.find(function (_, key) { return key === index; }, undefined, notSetValue);
     },
 
     has: function has(index) {
       index = wrapIndex(this, index);
       return (
         index >= 0 &&
         (this.size !== undefined
           ? this.size === Infinity || index < this.size
           : this.indexOf(index) !== -1)
       );
     },
 
     interpose: function interpose(separator) {
       return reify(this, interposeFactory(this, separator));
     },
 
     interleave: function interleave(/*...collections*/) {
       var collections = [this].concat(arrCopy(arguments));
       var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections);
       var interleaved = zipped.flatten(true);
       if (zipped.size) {
         interleaved.size = zipped.size * collections.length;
       }
       return reify(this, interleaved);
     },
 
     keySeq: function keySeq() {
       return Range(0, this.size);
     },
 
     last: function last(notSetValue) {
       return this.get(-1, notSetValue);
     },
 
     skipWhile: function skipWhile(predicate, context) {
       return reify(this, skipWhileFactory(this, predicate, context, false));
     },
 
     zip: function zip(/*, ...collections */) {
       var collections = [this].concat(arrCopy(arguments));
       return reify(this, zipWithFactory(this, defaultZipper, collections));
     },
 
     zipAll: function zipAll(/*, ...collections */) {
       var collections = [this].concat(arrCopy(arguments));
       return reify(this, zipWithFactory(this, defaultZipper, collections, true));
     },
 
     zipWith: function zipWith(zipper /*, ...collections */) {
       var collections = arrCopy(arguments);
       collections[0] = this;
       return reify(this, zipWithFactory(this, zipper, collections));
     },
   });
 
   var IndexedCollectionPrototype = IndexedCollection.prototype;
   IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;
   IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;
 
   mixin(SetCollection, {
     // ### ES6 Collection methods (ES6 Array and Map)
 
     get: function get(value, notSetValue) {
       return this.has(value) ? value : notSetValue;
     },
 
     includes: function includes(value) {
       return this.has(value);
     },
 
     // ### More sequential methods
 
     keySeq: function keySeq() {
       return this.valueSeq();
     },
   });
 
   var SetCollectionPrototype = SetCollection.prototype;
   SetCollectionPrototype.has = CollectionPrototype.includes;
   SetCollectionPrototype.contains = SetCollectionPrototype.includes;
   SetCollectionPrototype.keys = SetCollectionPrototype.values;
 
   // Mixin subclasses
 
   mixin(KeyedSeq, KeyedCollectionPrototype);
   mixin(IndexedSeq, IndexedCollectionPrototype);
   mixin(SetSeq, SetCollectionPrototype);
 
   // #pragma Helper functions
 
   function reduce(collection, reducer, reduction, context, useFirst, reverse) {
     assertNotInfinite(collection.size);
     collection.__iterate(function (v, k, c) {
       if (useFirst) {
         useFirst = false;
         reduction = v;
       } else {
         reduction = reducer.call(context, reduction, v, k, c);
       }
     }, reverse);
     return reduction;
   }
 
   function keyMapper(v, k) {
     return k;
   }
 
   function entryMapper(v, k) {
     return [k, v];
   }
 
   function not(predicate) {
     return function () {
       return !predicate.apply(this, arguments);
     };
   }
 
   function neg(predicate) {
     return function () {
       return -predicate.apply(this, arguments);
     };
   }
 
   function defaultZipper() {
     return arrCopy(arguments);
   }
 
   function defaultNegComparator(a, b) {
     return a < b ? 1 : a > b ? -1 : 0;
   }
 
   function hashCollection(collection) {
     if (collection.size === Infinity) {
       return 0;
     }
     var ordered = isOrdered(collection);
     var keyed = isKeyed(collection);
     var h = ordered ? 1 : 0;
     var size = collection.__iterate(
       keyed
         ? ordered
           ? function (v, k) {
               h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
             }
           : function (v, k) {
               h = (h + hashMerge(hash(v), hash(k))) | 0;
             }
         : ordered
         ? function (v) {
             h = (31 * h + hash(v)) | 0;
           }
         : function (v) {
             h = (h + hash(v)) | 0;
           }
     );
     return murmurHashOfSize(size, h);
   }
 
   function murmurHashOfSize(size, h) {
     h = imul(h, 0xcc9e2d51);
     h = imul((h << 15) | (h >>> -15), 0x1b873593);
     h = imul((h << 13) | (h >>> -13), 5);
     h = ((h + 0xe6546b64) | 0) ^ size;
     h = imul(h ^ (h >>> 16), 0x85ebca6b);
     h = imul(h ^ (h >>> 13), 0xc2b2ae35);
     h = smi(h ^ (h >>> 16));
     return h;
   }
 
   function hashMerge(a, b) {
     return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
   }
 
   var OrderedSet = /*@__PURE__*/(function (Set) {
     function OrderedSet(value) {
       return value === undefined || value === null
         ? emptyOrderedSet()
         : isOrderedSet(value)
         ? value
         : emptyOrderedSet().withMutations(function (set) {
             var iter = SetCollection(value);
             assertNotInfinite(iter.size);
             iter.forEach(function (v) { return set.add(v); });
           });
     }
 
     if ( Set ) OrderedSet.__proto__ = Set;
     OrderedSet.prototype = Object.create( Set && Set.prototype );
     OrderedSet.prototype.constructor = OrderedSet;
 
     OrderedSet.of = function of (/*...values*/) {
       return this(arguments);
     };
 
     OrderedSet.fromKeys = function fromKeys (value) {
       return this(KeyedCollection(value).keySeq());
     };
 
     OrderedSet.prototype.toString = function toString () {
       return this.__toString('OrderedSet {', '}');
     };
 
     return OrderedSet;
   }(Set));
 
   OrderedSet.isOrderedSet = isOrderedSet;
 
   var OrderedSetPrototype = OrderedSet.prototype;
   OrderedSetPrototype[IS_ORDERED_SYMBOL] = true;
   OrderedSetPrototype.zip = IndexedCollectionPrototype.zip;
   OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;
   OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll;
 
   OrderedSetPrototype.__empty = emptyOrderedSet;
   OrderedSetPrototype.__make = makeOrderedSet;
 
   function makeOrderedSet(map, ownerID) {
     var set = Object.create(OrderedSetPrototype);
     set.size = map ? map.size : 0;
     set._map = map;
     set.__ownerID = ownerID;
     return set;
   }
 
   var EMPTY_ORDERED_SET;
   function emptyOrderedSet() {
     return (
       EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))
     );
   }
 
   var PairSorting = {
     LeftThenRight: -1,
     RightThenLeft: +1,
   };
 
   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$1 = this;
 
       if (values instanceof RecordType) {
         return values;
       }
       if (!(this instanceof RecordType)) {
         return new RecordType(values);
       }
       if (!hasInitialized) {
         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;
         for (var i = 0; i < keys.length; i++) {
           var propName = keys[i];
           indices[propName] = i;
           if (RecordTypePrototype[propName]) {
             /* eslint-disable no-console */
             typeof console === 'object' &&
               console.warn &&
               console.warn(
                 'Cannot define ' +
                   recordName(this) +
                   ' with property "' +
                   propName +
                   '" since that property name is part of the Record API.'
               );
             /* eslint-enable no-console */
           } else {
             setProp(RecordTypePrototype, propName);
           }
         }
       }
       this.__ownerID = undefined;
       this._values = List().withMutations(function (l) {
         l.setSize(this$1$1._keys.length);
         KeyedCollection(values).forEach(function (v, k) {
           l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v);
         });
       });
       return this;
     };
 
     var RecordTypePrototype = (RecordType.prototype =
       Object.create(RecordPrototype));
     RecordTypePrototype.constructor = RecordType;
 
     if (name) {
       RecordType.displayName = name;
     }
 
     return RecordType;
   };
 
   Record.prototype.toString = function toString () {
     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.get(k));
     }
     return str + ' }';
   };
 
   Record.prototype.equals = function equals (other) {
     return (
       this === other ||
       (isRecord(other) && recordSeq(this).equals(recordSeq(other)))
     );
   };
 
   Record.prototype.hashCode = function hashCode () {
     return recordSeq(this).hashCode();
   };
 
   // @pragma Access
 
   Record.prototype.has = function has (k) {
     return this._indices.hasOwnProperty(k);
   };
 
   Record.prototype.get = function get (k, notSetValue) {
     if (!this.has(k)) {
       return notSetValue;
     }
     var index = this._indices[k];
     var value = this._values.get(index);
     return value === undefined ? this._defaultValues[k] : value;
   };
 
   // @pragma Modification
 
   Record.prototype.set = function set (k, v) {
     if (this.has(k)) {
       var newValues = this._values.set(
         this._indices[k],
         v === this._defaultValues[k] ? undefined : v
       );
       if (newValues !== this._values && !this.__ownerID) {
         return makeRecord(this, newValues);
       }
     }
     return this;
   };
 
   Record.prototype.remove = function remove (k) {
     return this.set(k);
   };
 
   Record.prototype.clear = function clear () {
     var newValues = this._values.clear().setSize(this._keys.length);
 
     return this.__ownerID ? this : makeRecord(this, newValues);
   };
 
   Record.prototype.wasAltered = function wasAltered () {
     return this._values.wasAltered();
   };
 
   Record.prototype.toSeq = function toSeq () {
     return recordSeq(this);
   };
 
   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) {
     return recordSeq(this).__iterator(type, reverse);
   };
 
   Record.prototype.__iterate = function __iterate (fn, reverse) {
     return recordSeq(this).__iterate(fn, reverse);
   };
 
   Record.prototype.__ensureOwner = function __ensureOwner (ownerID) {
     if (ownerID === this.__ownerID) {
       return this;
     }
     var newValues = this._values.__ensureOwner(ownerID);
     if (!ownerID) {
       this.__ownerID = ownerID;
       this._values = newValues;
       return this;
     }
     return makeRecord(this, newValues, ownerID);
   };
 
   Record.isRecord = isRecord;
   Record.getDescriptiveName = recordName;
   var RecordPrototype = Record.prototype;
   RecordPrototype[IS_RECORD_SYMBOL] = true;
   RecordPrototype[DELETE] = RecordPrototype.remove;
   RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;
   RecordPrototype.getIn = getIn;
   RecordPrototype.hasIn = CollectionPrototype.hasIn;
   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 = function () {
     return this.toString();
   };
 
   function makeRecord(likeRecord, values, ownerID) {
     var record = Object.create(Object.getPrototypeOf(likeRecord));
     record._values = values;
     record.__ownerID = ownerID;
     return record;
   }
 
   function recordName(record) {
     return record.constructor.displayName || record.constructor.name || 'Record';
   }
 
   function recordSeq(record) {
     return keyedSeqFromValue(record._keys.map(function (k) { return [k, record.get(k)]; }));
   }
 
   function setProp(prototype, name) {
     try {
       Object.defineProperty(prototype, name, {
         get: function () {
           return this.get(name);
         },
         set: function (value) {
           invariant(this.__ownerID, 'Cannot set on an immutable record.');
           this.set(name, value);
         },
       });
     } catch (error) {
       // Object.defineProperty failed. Probably IE8.
     }
   }
 
   /**
    * Returns a lazy Seq of `value` repeated `times` times. When `times` is
    * undefined, returns an infinite sequence of `value`.
    */
   var Repeat = /*@__PURE__*/(function (IndexedSeq) {
     function Repeat(value, times) {
       if (!(this instanceof Repeat)) {
         return new Repeat(value, times);
       }
       this._value = value;
       this.size = times === undefined ? Infinity : Math.max(0, times);
       if (this.size === 0) {
         if (EMPTY_REPEAT) {
           return EMPTY_REPEAT;
         }
         EMPTY_REPEAT = this;
       }
     }
 
     if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq;
     Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
     Repeat.prototype.constructor = Repeat;
 
     Repeat.prototype.toString = function toString () {
       if (this.size === 0) {
         return 'Repeat []';
       }
       return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';
     };
 
     Repeat.prototype.get = function get (index, notSetValue) {
       return this.has(index) ? this._value : notSetValue;
     };
 
     Repeat.prototype.includes = function includes (searchValue) {
       return is(this._value, searchValue);
     };
 
     Repeat.prototype.slice = function slice (begin, end) {
       var size = this.size;
       return wholeSlice(begin, end, size)
         ? this
         : new Repeat(
             this._value,
             resolveEnd(end, size) - resolveBegin(begin, size)
           );
     };
 
     Repeat.prototype.reverse = function reverse () {
       return this;
     };
 
     Repeat.prototype.indexOf = function indexOf (searchValue) {
       if (is(this._value, searchValue)) {
         return 0;
       }
       return -1;
     };
 
     Repeat.prototype.lastIndexOf = function lastIndexOf (searchValue) {
       if (is(this._value, searchValue)) {
         return this.size;
       }
       return -1;
     };
 
     Repeat.prototype.__iterate = function __iterate (fn, reverse) {
       var size = this.size;
       var i = 0;
       while (i !== size) {
         if (fn(this._value, reverse ? size - ++i : i++, this) === false) {
           break;
         }
       }
       return i;
     };
 
     Repeat.prototype.__iterator = function __iterator (type, reverse) {
       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$1._value); }
       );
     };
 
     Repeat.prototype.equals = function equals (other) {
       return other instanceof Repeat
         ? is(this._value, other._value)
         : deepEqual(other);
     };
 
     return Repeat;
   }(IndexedSeq));
 
   var EMPTY_REPEAT;
 
   function fromJS(value, converter) {
     return fromJSWith(
       [],
       converter || defaultConverter,
       value,
       '',
       converter && converter.length > 2 ? [] : undefined,
       { '': value }
     );
   }
 
   function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
     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');
       }
       stack.push(value);
       keyPath && key !== '' && keyPath.push(key);
       var converted = converter.call(
         parentValue,
         key,
         Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
         ),
         keyPath && keyPath.slice()
       );
       stack.pop();
       keyPath && keyPath.pop();
       return converted;
     }
     return value;
   }
 
   function defaultConverter(k, v) {
     // Effectively the opposite of "Collection.toSeq()"
     return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
   }
 
   var version = "4.3.4";
 
   var Immutable = {
     version: version,
 
     Collection: Collection,
     // Note: Iterable is deprecated
     Iterable: Collection,
 
     Seq: Seq,
     Map: Map,
     OrderedMap: OrderedMap,
     List: List,
     Stack: Stack,
     Set: Set,
     OrderedSet: OrderedSet,
     PairSorting: PairSorting,
 
     Record: Record,
     Range: Range,
     Repeat: Repeat,
 
     is: is,
     fromJS: fromJS,
     hash: hash,
 
     isImmutable: isImmutable,
     isCollection: isCollection,
     isKeyed: isKeyed,
     isIndexed: isIndexed,
     isAssociative: isAssociative,
     isOrdered: isOrdered,
     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;
 
   exports.Collection = Collection;
   exports.Iterable = Iterable;
   exports.List = List;
   exports.Map = Map;
   exports.OrderedMap = OrderedMap;
   exports.OrderedSet = OrderedSet;
   exports.PairSorting = PairSorting;
   exports.Range = Range;
   exports.Record = Record;
   exports.Repeat = Repeat;
   exports.Seq = Seq;
   exports.Set = Set;
   exports.Stack = Stack;
   exports.default = Immutable;
   exports.fromJS = fromJS;
   exports.get = get;
   exports.getIn = getIn$1;
   exports.has = has;
   exports.hasIn = hasIn$1;
   exports.hash = hash;
   exports.is = is;
   exports.isAssociative = isAssociative;
   exports.isCollection = isCollection;
   exports.isImmutable = isImmutable;
   exports.isIndexed = isIndexed;
   exports.isKeyed = isKeyed;
   exports.isList = isList;
   exports.isMap = isMap;
   exports.isOrdered = isOrdered;
   exports.isOrderedMap = isOrderedMap;
   exports.isOrderedSet = isOrderedSet;
   exports.isPlainObject = isPlainObject;
   exports.isRecord = isRecord;
   exports.isSeq = isSeq;
   exports.isSet = isSet;
   exports.isStack = isStack;
   exports.isValueObject = isValueObject;
   exports.merge = merge;
   exports.mergeDeep = mergeDeep$1;
   exports.mergeDeepWith = mergeDeepWith$1;
   exports.mergeWith = mergeWith;
   exports.remove = remove;
   exports.removeIn = removeIn;
   exports.set = set;
   exports.setIn = setIn$1;
   exports.update = update$1;
   exports.updateIn = updateIn$1;
   exports.version = version;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
 })));