Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/immutable/dist/immutable.js
f646e1f695a7paginated-inlines

immutable.js
View Options

			/**
			* 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) {
			return !this.every(not(predicate), context);
			},

			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()))
			);
			}

			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.2.2";

			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,

			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.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 });

			})));