{"version":3,"sources":["webpack:///./node_modules/immutable/dist/immutable.js"],"names":["module","exports","SLICE$0","Array","prototype","slice","createClass","ctor","superClass","Object","create","constructor","Iterable","value","isIterable","Seq","KeyedIterable","isKeyed","KeyedSeq","IndexedIterable","isIndexed","IndexedSeq","SetIterable","isAssociative","SetSeq","maybeIterable","IS_ITERABLE_SENTINEL","maybeKeyed","IS_KEYED_SENTINEL","maybeIndexed","IS_INDEXED_SENTINEL","maybeAssociative","isOrdered","maybeOrdered","IS_ORDERED_SENTINEL","Keyed","Indexed","Set","NOT_SET","CHANGE_LENGTH","DID_ALTER","MakeRef","ref","SetRef","OwnerID","arrCopy","arr","offset","len","Math","max","length","newArr","ii","ensureSize","iter","undefined","size","__iterate","returnTrue","wrapIndex","index","uint32Index","NaN","wholeSlice","begin","end","resolveBegin","resolveIndex","resolveEnd","defaultIndex","min","EMPTY_SEQ","EMPTY_REPEAT","EMPTY_RANGE","REAL_ITERATOR_SYMBOL","Symbol","iterator","ITERATOR_SYMBOL","Iterator","next","this","iteratorValue","type","k","v","iteratorResult","done","iteratorDone","hasIterator","getIteratorFn","isIterator","maybeIterator","getIterator","iterable","iteratorFn","call","isArrayLike","emptySequence","toSeq","seqFromValue","seq","maybeIndexedSeqFromValue","ObjectSeq","TypeError","toKeyedSeq","fromEntrySeq","keyedSeqFromValue","entrySeq","toIndexedSeq","indexedSeqFromValue","toSetSeq","ArraySeq","array","_array","object","keys","_object","_keys","IterableSeq","_iterable","IteratorSeq","_iterator","_iteratorCache","isSeq","maybeSeq","isArray","seqIterate","fn","reverse","useKeys","cache","_cache","maxIndex","entry","__iterateUncached","seqIterator","__iteratorUncached","fromJS","json","converter","fromJSWith","key","parentJSON","map","isPlainObj","fromJSDefault","toList","toMap","is","valueA","valueB","valueOf","equals","deepEqual","a","b","__hash","notAssociative","entries","every","flipped","cacheResult","_","allEqual","bSize","has","get","Repeat","times","_value","Infinity","invariant","condition","error","Error","Range","start","step","abs","_start","_end","_step","ceil","Collection","KeyedCollection","IndexedCollection","SetCollection","toString","KEYS","VALUES","ENTRIES","inspect","toSource","of","arguments","__toString","toArray","__iterator","notSetValue","hasOwnProperty","iterations","val","includes","searchValue","indexOf","lastIndexOf","this$0","other","possibleIndex","floor","offsetValue","imul","c","d","smi","i32","hash","o","h","STRING_HASH_CACHE_MIN_STRLEN","cachedHashString","string","stringHashCache","hashString","STRING_HASH_CACHE_SIZE","STRING_HASH_CACHE_MAX_SIZE","hashCode","hashJSObj","obj","usingWeakMap","weakMap","UID_HASH_KEY","canDefineProperty","propertyIsEnumerable","getIENodeHash","node","nodeType","uniqueID","documentElement","objHashUID","set","isExtensible","defineProperty","apply","charCodeAt","e","WeakMap","assertNotInfinite","Map","emptyMap","isMap","withMutations","forEach","maybeMap","IS_MAP_SENTINEL","keyValues","i","_root","updateMap","setIn","keyPath","updateIn","remove","deleteIn","update","updater","updatedValue","updateInDeepMap","existing","keyPathIter","isNotSet","existingValue","newValue","nextExisting","nextUpdated","forceIterator","clear","__ownerID","__altered","merge","mergeIntoMapWith","mergeWith","merger","iters","mergeIn","m","mergeDeep","deepMerger","mergeDeepWith","deepMergerWith","mergeDeepIn","sort","comparator","OrderedMap","sortFactory","sortBy","mapper","mutable","asMutable","wasAltered","__ensureOwner","asImmutable","MapIterator","iterate","ownerID","makeMap","EMPTY_MAP","MapPrototype","ArrayMapNode","BitmapIndexedNode","bitmap","nodes","HashArrayMapNode","count","HashCollisionNode","keyHash","ValueNode","_type","_reverse","_stack","mapIteratorFrame","mapIteratorValue","prev","__prev","root","newRoot","newSize","didChangeSize","didAlter","updateNode","shift","isLeafNode","mergeIntoNode","newNode","idx1","SIZE","idx2","iterables","push","mergeIntoCollectionWith","nextValue","collection","filter","x","mergeIntoMap","popCount","idx","canEdit","newArray","removeIn","removed","exists","MAX_ARRAY_MAP_SIZE","createNodes","isEditable","newEntries","pop","bit","keyHashFrag","MAX_BITMAP_INDEXED_SIZE","expandNodes","including","expandedNodes","newBitmap","newNodes","spliceOut","newLen","after","spliceIn","newCount","MIN_HASH_ARRAY_MAP_SIZE","packNodes","excluding","packedII","packedNodes","keyMatch","stack","subNode","List","empty","emptyList","isList","makeList","VNode","list","setSize","maybeList","IS_LIST_SENTINEL","listNodeFor","_origin","updateList","setListBounds","newTail","_tail","getTailOffset","_capacity","updateVNode","_level","splice","insert","values","oldSize","unshift","mergeIntoListWith","iterateList","DONE","ListPrototype","removeBefore","level","originIndex","newChild","removingFirst","oldChild","editable","editableVNode","removeAfter","sizeIndex","EMPTY_LIST","EMPTY_ORDERED_MAP","left","right","tailPos","tail","iterateNodeOrLeaf","iterateLeaf","from","to","iterateNode","origin","capacity","nodeHas","lowerNode","newLowerNode","rawIndex","owner","oldOrigin","oldCapacity","newOrigin","newCapacity","newLevel","offsetShift","oldTailOffset","newTailOffset","oldTail","beginIndex","maxSize","emptyOrderedMap","isOrderedMap","maybeOrderedMap","makeOrderedMap","omap","_map","_list","updateOrderedMap","newMap","newList","flip","ToKeyedSequence","indexed","_iter","_useKeys","ToIndexedSequence","ToSetSequence","FromEntriesSequence","flipFactory","flipSequence","makeSequence","reversedSequence","cacheResultThrough","mapFactory","context","mappedSequence","reverseFactory","filterFactory","predicate","filterSequence","sliceFactory","originalSize","resolvedBegin","resolvedEnd","sliceSize","resolvedSize","sliceSeq","skipped","isSkipping","skipWhileFactory","skipSequence","skipping","concatFactory","isKeyedIterable","concat","singleton","concatSeq","flatten","reduce","sum","flattenFactory","depth","flatSequence","stopped","flatDeep","currentDepth","defaultComparator","maxFactory","maxCompare","comp","zipWithFactory","keyIter","zipper","zipSequence","iterators","isDone","steps","some","s","reify","validateEntry","resolveSize","iterableClass","Record","defaultValues","name","hasInitialized","RecordType","setProps","names","setProp","bind","RecordTypePrototype","_name","_defaultValues","RecordPrototype","valueSeq","indexedIterable","recordName","defaultVal","_empty","makeRecord","likeRecord","record","getPrototypeOf","emptySet","isSet","add","maybeSet","IS_SET_SENTINEL","fromKeys","keySeq","updateSet","union","intersect","originalSet","subtract","OrderedSet","__make","EMPTY_SET","SetPrototype","__empty","makeSet","emptyOrderedSet","isOrderedSet","maybeOrderedSet","EMPTY_ORDERED_SET","OrderedSetPrototype","makeOrderedSet","Stack","emptyStack","isStack","unshiftAll","maybeStack","IS_STACK_SENTINEL","head","_head","peek","makeStack","pushAll","EMPTY_STACK","StackPrototype","mixin","methods","keyCopier","getOwnPropertySymbols","toJS","__toJS","toJSON","toObject","toOrderedMap","toOrderedSet","toSet","toStack","__toStringMapper","join","returnValue","find","findEntry","sideEffect","separator","joined","isFirst","reducer","initialReduction","reduction","useFirst","reduceRight","reversed","not","butLast","isEmpty","countBy","grouper","countByFactory","groups","entriesSequence","entryMapper","filterNot","found","findKey","findLast","findLastEntry","findLastKey","first","flatMap","flatMapFactory","coerce","searchKey","getIn","searchKeyPath","nested","groupBy","groupByFactory","isKeyedIter","hasIn","isSubset","isSuperset","keyOf","keyMapper","last","lastKeyOf","maxBy","neg","defaultNegComparator","minBy","rest","skip","amount","skipLast","skipWhile","skipUntil","take","takeLast","takeWhile","takeWhileFactory","takeSequence","iterating","takeUntil","hashIterable","ordered","keyed","murmurHashOfSize","hashMerge","IterablePrototype","quoteString","chain","contains","mapEntries","mapKeys","KeyedIterablePrototype","JSON","stringify","String","defaultZipper","findIndex","removeNum","numArgs","spliced","findLastIndex","interpose","interposeFactory","interposedSequence","interleave","zipped","interleaved","zip","zipWith","factory"],"mappings":"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","file":"npm.immutable-9fe7b8b8fdeadd1cae46.js","sourcesContent":["/**\n *  Copyright (c) 2014-2015, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global.Immutable = factory());\n}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;\n\n  function createClass(ctor, superClass) {\n    if (superClass) {\n      ctor.prototype = Object.create(superClass.prototype);\n    }\n    ctor.prototype.constructor = ctor;\n  }\n\n  function Iterable(value) {\n      return isIterable(value) ? value : Seq(value);\n    }\n\n\n  createClass(KeyedIterable, Iterable);\n    function KeyedIterable(value) {\n      return isKeyed(value) ? value : KeyedSeq(value);\n    }\n\n\n  createClass(IndexedIterable, Iterable);\n    function IndexedIterable(value) {\n      return isIndexed(value) ? value : IndexedSeq(value);\n    }\n\n\n  createClass(SetIterable, Iterable);\n    function SetIterable(value) {\n      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);\n    }\n\n\n\n  function isIterable(maybeIterable) {\n    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);\n  }\n\n  function isKeyed(maybeKeyed) {\n    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);\n  }\n\n  function isIndexed(maybeIndexed) {\n    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);\n  }\n\n  function isAssociative(maybeAssociative) {\n    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n  }\n\n  function isOrdered(maybeOrdered) {\n    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);\n  }\n\n  Iterable.isIterable = isIterable;\n  Iterable.isKeyed = isKeyed;\n  Iterable.isIndexed = isIndexed;\n  Iterable.isAssociative = isAssociative;\n  Iterable.isOrdered = isOrdered;\n\n  Iterable.Keyed = KeyedIterable;\n  Iterable.Indexed = IndexedIterable;\n  Iterable.Set = SetIterable;\n\n\n  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  // Used for setting prototype methods that IE8 chokes on.\n  var DELETE = 'delete';\n\n  // Constants describing the size of trie nodes.\n  var SHIFT = 5; // Resulted in best performance after ______?\n  var SIZE = 1 << SHIFT;\n  var MASK = SIZE - 1;\n\n  // A consistent shared value representing \"not set\" which equals nothing other\n  // than itself, and nothing that could be provided externally.\n  var NOT_SET = {};\n\n  // Boolean references, Rough equivalent of `bool &`.\n  var CHANGE_LENGTH = { value: false };\n  var DID_ALTER = { value: false };\n\n  function MakeRef(ref) {\n    ref.value = false;\n    return ref;\n  }\n\n  function SetRef(ref) {\n    ref && (ref.value = true);\n  }\n\n  // A function which returns a value representing an \"owner\" for transient writes\n  // to tries. The return value will only ever equal itself, and will not equal\n  // the return of any subsequent call of this function.\n  function OwnerID() {}\n\n  // http://jsperf.com/copy-array-inline\n  function arrCopy(arr, offset) {\n    offset = offset || 0;\n    var len = Math.max(0, arr.length - offset);\n    var newArr = new Array(len);\n    for (var ii = 0; ii < len; ii++) {\n      newArr[ii] = arr[ii + offset];\n    }\n    return newArr;\n  }\n\n  function ensureSize(iter) {\n    if (iter.size === undefined) {\n      iter.size = iter.__iterate(returnTrue);\n    }\n    return iter.size;\n  }\n\n  function wrapIndex(iter, index) {\n    // This implements \"is array index\" which the ECMAString spec defines as:\n    //\n    //     A String property name P is an array index if and only if\n    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n    //     to 2^32−1.\n    //\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n    if (typeof index !== 'number') {\n      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n        return NaN;\n      }\n      index = uint32Index;\n    }\n    return index < 0 ? ensureSize(iter) + index : index;\n  }\n\n  function returnTrue() {\n    return true;\n  }\n\n  function wholeSlice(begin, end, size) {\n    return (begin === 0 || (size !== undefined && begin <= -size)) &&\n      (end === undefined || (size !== undefined && end >= size));\n  }\n\n  function resolveBegin(begin, size) {\n    return resolveIndex(begin, size, 0);\n  }\n\n  function resolveEnd(end, size) {\n    return resolveIndex(end, size, size);\n  }\n\n  function resolveIndex(index, size, defaultIndex) {\n    return index === undefined ?\n      defaultIndex :\n      index < 0 ?\n        Math.max(0, size + index) :\n        size === undefined ?\n          index :\n          Math.min(size, index);\n  }\n\n  /* global Symbol */\n\n  var ITERATE_KEYS = 0;\n  var ITERATE_VALUES = 1;\n  var ITERATE_ENTRIES = 2;\n\n  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\n\n  function Iterator(next) {\n      this.next = next;\n    }\n\n    Iterator.prototype.toString = function() {\n      return '[Iterator]';\n    };\n\n\n  Iterator.KEYS = ITERATE_KEYS;\n  Iterator.VALUES = ITERATE_VALUES;\n  Iterator.ENTRIES = ITERATE_ENTRIES;\n\n  Iterator.prototype.inspect =\n  Iterator.prototype.toSource = function () { return this.toString(); }\n  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n    return this;\n  };\n\n\n  function iteratorValue(type, k, v, iteratorResult) {\n    var value = type === 0 ? k : type === 1 ? v : [k, v];\n    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {\n      value: value, done: false\n    });\n    return iteratorResult;\n  }\n\n  function iteratorDone() {\n    return { value: undefined, done: true };\n  }\n\n  function hasIterator(maybeIterable) {\n    return !!getIteratorFn(maybeIterable);\n  }\n\n  function isIterator(maybeIterator) {\n    return maybeIterator && typeof maybeIterator.next === 'function';\n  }\n\n  function getIterator(iterable) {\n    var iteratorFn = getIteratorFn(iterable);\n    return iteratorFn && iteratorFn.call(iterable);\n  }\n\n  function getIteratorFn(iterable) {\n    var iteratorFn = iterable && (\n      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n      iterable[FAUX_ITERATOR_SYMBOL]\n    );\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  function isArrayLike(value) {\n    return value && typeof value.length === 'number';\n  }\n\n  createClass(Seq, Iterable);\n    function Seq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        isIterable(value) ? value.toSeq() : seqFromValue(value);\n    }\n\n    Seq.of = function(/*...values*/) {\n      return Seq(arguments);\n    };\n\n    Seq.prototype.toSeq = function() {\n      return this;\n    };\n\n    Seq.prototype.toString = function() {\n      return this.__toString('Seq {', '}');\n    };\n\n    Seq.prototype.cacheResult = function() {\n      if (!this._cache && this.__iterateUncached) {\n        this._cache = this.entrySeq().toArray();\n        this.size = this._cache.length;\n      }\n      return this;\n    };\n\n    // abstract __iterateUncached(fn, reverse)\n\n    Seq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, true);\n    };\n\n    // abstract __iteratorUncached(type, reverse)\n\n    Seq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, true);\n    };\n\n\n\n  createClass(KeyedSeq, Seq);\n    function KeyedSeq(value) {\n      return value === null || value === undefined ?\n        emptySequence().toKeyedSeq() :\n        isIterable(value) ?\n          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :\n          keyedSeqFromValue(value);\n    }\n\n    KeyedSeq.prototype.toKeyedSeq = function() {\n      return this;\n    };\n\n\n\n  createClass(IndexedSeq, Seq);\n    function IndexedSeq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();\n    }\n\n    IndexedSeq.of = function(/*...values*/) {\n      return IndexedSeq(arguments);\n    };\n\n    IndexedSeq.prototype.toIndexedSeq = function() {\n      return this;\n    };\n\n    IndexedSeq.prototype.toString = function() {\n      return this.__toString('Seq [', ']');\n    };\n\n    IndexedSeq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, false);\n    };\n\n    IndexedSeq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, false);\n    };\n\n\n\n  createClass(SetSeq, Seq);\n    function SetSeq(value) {\n      return (\n        value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value\n      ).toSetSeq();\n    }\n\n    SetSeq.of = function(/*...values*/) {\n      return SetSeq(arguments);\n    };\n\n    SetSeq.prototype.toSetSeq = function() {\n      return this;\n    };\n\n\n\n  Seq.isSeq = isSeq;\n  Seq.Keyed = KeyedSeq;\n  Seq.Set = SetSeq;\n  Seq.Indexed = IndexedSeq;\n\n  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';\n\n  Seq.prototype[IS_SEQ_SENTINEL] = true;\n\n\n\n  createClass(ArraySeq, IndexedSeq);\n    function ArraySeq(array) {\n      this._array = array;\n      this.size = array.length;\n    }\n\n    ArraySeq.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n    };\n\n    ArraySeq.prototype.__iterate = function(fn, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ArraySeq.prototype.__iterator = function(type, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}\n      );\n    };\n\n\n\n  createClass(ObjectSeq, KeyedSeq);\n    function ObjectSeq(object) {\n      var keys = Object.keys(object);\n      this._object = object;\n      this._keys = keys;\n      this.size = keys.length;\n    }\n\n    ObjectSeq.prototype.get = function(key, notSetValue) {\n      if (notSetValue !== undefined && !this.has(key)) {\n        return notSetValue;\n      }\n      return this._object[key];\n    };\n\n    ObjectSeq.prototype.has = function(key) {\n      return this._object.hasOwnProperty(key);\n    };\n\n    ObjectSeq.prototype.__iterate = function(fn, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        if (fn(object[key], key, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ObjectSeq.prototype.__iterator = function(type, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, key, object[key]);\n      });\n    };\n\n  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(IterableSeq, IndexedSeq);\n    function IterableSeq(iterable) {\n      this._iterable = iterable;\n      this.size = iterable.length || iterable.size;\n    }\n\n    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      var iterations = 0;\n      if (isIterator(iterator)) {\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (fn(step.value, iterations++, this) === false) {\n            break;\n          }\n        }\n      }\n      return iterations;\n    };\n\n    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      if (!isIterator(iterator)) {\n        return new Iterator(iteratorDone);\n      }\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step : iteratorValue(type, iterations++, step.value);\n      });\n    };\n\n\n\n  createClass(IteratorSeq, IndexedSeq);\n    function IteratorSeq(iterator) {\n      this._iterator = iterator;\n      this._iteratorCache = [];\n    }\n\n    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      while (iterations < cache.length) {\n        if (fn(cache[iterations], iterations++, this) === false) {\n          return iterations;\n        }\n      }\n      var step;\n      while (!(step = iterator.next()).done) {\n        var val = step.value;\n        cache[iterations] = val;\n        if (fn(val, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n\n    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      return new Iterator(function()  {\n        if (iterations >= cache.length) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          cache[iterations] = step.value;\n        }\n        return iteratorValue(type, iterations, cache[iterations++]);\n      });\n    };\n\n\n\n\n  // # pragma Helper functions\n\n  function isSeq(maybeSeq) {\n    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);\n  }\n\n  var EMPTY_SEQ;\n\n  function emptySequence() {\n    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n  }\n\n  function keyedSeqFromValue(value) {\n    var seq =\n      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :\n      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :\n      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :\n      typeof value === 'object' ? new ObjectSeq(value) :\n      undefined;\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of [k, v] entries, '+\n        'or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function indexedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function seqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value) ||\n      (typeof value === 'object' && new ObjectSeq(value));\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values, or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function maybeIndexedSeqFromValue(value) {\n    return (\n      isArrayLike(value) ? new ArraySeq(value) :\n      isIterator(value) ? new IteratorSeq(value) :\n      hasIterator(value) ? new IterableSeq(value) :\n      undefined\n    );\n  }\n\n  function seqIterate(seq, fn, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    }\n    return seq.__iterateUncached(fn, reverse);\n  }\n\n  function seqIterator(seq, type, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);\n      });\n    }\n    return seq.__iteratorUncached(type, reverse);\n  }\n\n  function fromJS(json, converter) {\n    return converter ?\n      fromJSWith(converter, json, '', {'': json}) :\n      fromJSDefault(json);\n  }\n\n  function fromJSWith(converter, json, key, parentJSON) {\n    if (Array.isArray(json)) {\n      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    if (isPlainObj(json)) {\n      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    return json;\n  }\n\n  function fromJSDefault(json) {\n    if (Array.isArray(json)) {\n      return IndexedSeq(json).map(fromJSDefault).toList();\n    }\n    if (isPlainObj(json)) {\n      return KeyedSeq(json).map(fromJSDefault).toMap();\n    }\n    return json;\n  }\n\n  function isPlainObj(value) {\n    return value && (value.constructor === Object || value.constructor === undefined);\n  }\n\n  /**\n   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n   *\n   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n   * value, which is different from the algorithm described by\n   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n   *\n   * This is extended further to allow Objects to describe the values they\n   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n   *\n   * Note: because of this extension, the key equality of Immutable.Map and the\n   * value equality of Immutable.Set will differ from ES6 Map and Set.\n   *\n   * ### Defining custom values\n   *\n   * The easiest way to describe the value an object represents is by implementing\n   * `valueOf`. For example, `Date` represents a value by returning a unix\n   * timestamp for `valueOf`:\n   *\n   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n   *     var date2 = new Date(1234567890000);\n   *     date1.valueOf(); // 1234567890000\n   *     assert( date1 !== date2 );\n   *     assert( Immutable.is( date1, date2 ) );\n   *\n   * Note: overriding `valueOf` may have other implications if you use this object\n   * where JavaScript expects a primitive, such as implicit string coercion.\n   *\n   * For more complex types, especially collections, implementing `valueOf` may\n   * not be performant. An alternative is to implement `equals` and `hashCode`.\n   *\n   * `equals` takes another object, presumably of similar type, and returns true\n   * if the it is equal. Equality is symmetrical, so the same result should be\n   * returned if this and the argument are flipped.\n   *\n   *     assert( a.equals(b) === b.equals(a) );\n   *\n   * `hashCode` returns a 32bit integer number representing the object which will\n   * be used to determine how to store the value object in a Map or Set. You must\n   * provide both or neither methods, one must not exist without the other.\n   *\n   * Also, an important relationship between these methods must be upheld: if two\n   * values are equal, they *must* return the same hashCode. If the values are not\n   * equal, they might have the same hashCode; this is called a hash collision,\n   * and while undesirable for performance reasons, it is acceptable.\n   *\n   *     if (a.equals(b)) {\n   *       assert( a.hashCode() === b.hashCode() );\n   *     }\n   *\n   * All Immutable collections implement `equals` and `hashCode`.\n   *\n   */\n  function is(valueA, valueB) {\n    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n      return true;\n    }\n    if (!valueA || !valueB) {\n      return false;\n    }\n    if (typeof valueA.valueOf === 'function' &&\n        typeof valueB.valueOf === 'function') {\n      valueA = valueA.valueOf();\n      valueB = valueB.valueOf();\n      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n        return true;\n      }\n      if (!valueA || !valueB) {\n        return false;\n      }\n    }\n    if (typeof valueA.equals === 'function' &&\n        typeof valueB.equals === 'function' &&\n        valueA.equals(valueB)) {\n      return true;\n    }\n    return false;\n  }\n\n  function deepEqual(a, b) {\n    if (a === b) {\n      return true;\n    }\n\n    if (\n      !isIterable(b) ||\n      a.size !== undefined && b.size !== undefined && a.size !== b.size ||\n      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||\n      isKeyed(a) !== isKeyed(b) ||\n      isIndexed(a) !== isIndexed(b) ||\n      isOrdered(a) !== isOrdered(b)\n    ) {\n      return false;\n    }\n\n    if (a.size === 0 && b.size === 0) {\n      return true;\n    }\n\n    var notAssociative = !isAssociative(a);\n\n    if (isOrdered(a)) {\n      var entries = a.entries();\n      return b.every(function(v, k)  {\n        var entry = entries.next().value;\n        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n      }) && entries.next().done;\n    }\n\n    var flipped = false;\n\n    if (a.size === undefined) {\n      if (b.size === undefined) {\n        if (typeof a.cacheResult === 'function') {\n          a.cacheResult();\n        }\n      } else {\n        flipped = true;\n        var _ = a;\n        a = b;\n        b = _;\n      }\n    }\n\n    var allEqual = true;\n    var bSize = b.__iterate(function(v, k)  {\n      if (notAssociative ? !a.has(v) :\n          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {\n        allEqual = false;\n        return false;\n      }\n    });\n\n    return allEqual && a.size === bSize;\n  }\n\n  createClass(Repeat, IndexedSeq);\n\n    function Repeat(value, times) {\n      if (!(this instanceof Repeat)) {\n        return new Repeat(value, times);\n      }\n      this._value = value;\n      this.size = times === undefined ? Infinity : Math.max(0, times);\n      if (this.size === 0) {\n        if (EMPTY_REPEAT) {\n          return EMPTY_REPEAT;\n        }\n        EMPTY_REPEAT = this;\n      }\n    }\n\n    Repeat.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Repeat []';\n      }\n      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n    };\n\n    Repeat.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._value : notSetValue;\n    };\n\n    Repeat.prototype.includes = function(searchValue) {\n      return is(this._value, searchValue);\n    };\n\n    Repeat.prototype.slice = function(begin, end) {\n      var size = this.size;\n      return wholeSlice(begin, end, size) ? this :\n        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));\n    };\n\n    Repeat.prototype.reverse = function() {\n      return this;\n    };\n\n    Repeat.prototype.indexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return 0;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.lastIndexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return this.size;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.__iterate = function(fn, reverse) {\n      for (var ii = 0; ii < this.size; ii++) {\n        if (fn(this._value, ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}\n      );\n    };\n\n    Repeat.prototype.equals = function(other) {\n      return other instanceof Repeat ?\n        is(this._value, other._value) :\n        deepEqual(other);\n    };\n\n\n  var EMPTY_REPEAT;\n\n  function invariant(condition, error) {\n    if (!condition) throw new Error(error);\n  }\n\n  createClass(Range, IndexedSeq);\n\n    function Range(start, end, step) {\n      if (!(this instanceof Range)) {\n        return new Range(start, end, step);\n      }\n      invariant(step !== 0, 'Cannot step a Range by 0');\n      start = start || 0;\n      if (end === undefined) {\n        end = Infinity;\n      }\n      step = step === undefined ? 1 : Math.abs(step);\n      if (end < start) {\n        step = -step;\n      }\n      this._start = start;\n      this._end = end;\n      this._step = step;\n      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n      if (this.size === 0) {\n        if (EMPTY_RANGE) {\n          return EMPTY_RANGE;\n        }\n        EMPTY_RANGE = this;\n      }\n    }\n\n    Range.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Range []';\n      }\n      return 'Range [ ' +\n        this._start + '...' + this._end +\n        (this._step !== 1 ? ' by ' + this._step : '') +\n      ' ]';\n    };\n\n    Range.prototype.get = function(index, notSetValue) {\n      return this.has(index) ?\n        this._start + wrapIndex(this, index) * this._step :\n        notSetValue;\n    };\n\n    Range.prototype.includes = function(searchValue) {\n      var possibleIndex = (searchValue - this._start) / this._step;\n      return possibleIndex >= 0 &&\n        possibleIndex < this.size &&\n        possibleIndex === Math.floor(possibleIndex);\n    };\n\n    Range.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      begin = resolveBegin(begin, this.size);\n      end = resolveEnd(end, this.size);\n      if (end <= begin) {\n        return new Range(0, 0);\n      }\n      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);\n    };\n\n    Range.prototype.indexOf = function(searchValue) {\n      var offsetValue = searchValue - this._start;\n      if (offsetValue % this._step === 0) {\n        var index = offsetValue / this._step;\n        if (index >= 0 && index < this.size) {\n          return index\n        }\n      }\n      return -1;\n    };\n\n    Range.prototype.lastIndexOf = function(searchValue) {\n      return this.indexOf(searchValue);\n    };\n\n    Range.prototype.__iterate = function(fn, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(value, ii, this) === false) {\n          return ii + 1;\n        }\n        value += reverse ? -step : step;\n      }\n      return ii;\n    };\n\n    Range.prototype.__iterator = function(type, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      var ii = 0;\n      return new Iterator(function()  {\n        var v = value;\n        value += reverse ? -step : step;\n        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);\n      });\n    };\n\n    Range.prototype.equals = function(other) {\n      return other instanceof Range ?\n        this._start === other._start &&\n        this._end === other._end &&\n        this._step === other._step :\n        deepEqual(this, other);\n    };\n\n\n  var EMPTY_RANGE;\n\n  createClass(Collection, Iterable);\n    function Collection() {\n      throw TypeError('Abstract');\n    }\n\n\n  createClass(KeyedCollection, Collection);function KeyedCollection() {}\n\n  createClass(IndexedCollection, Collection);function IndexedCollection() {}\n\n  createClass(SetCollection, Collection);function SetCollection() {}\n\n\n  Collection.Keyed = KeyedCollection;\n  Collection.Indexed = IndexedCollection;\n  Collection.Set = SetCollection;\n\n  var imul =\n    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?\n    Math.imul :\n    function imul(a, b) {\n      a = a | 0; // int\n      b = b | 0; // int\n      var c = a & 0xffff;\n      var d = b & 0xffff;\n      // Shift by 0 fixes the sign on the high part.\n      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int\n    };\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  function smi(i32) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);\n  }\n\n  function hash(o) {\n    if (o === false || o === null || o === undefined) {\n      return 0;\n    }\n    if (typeof o.valueOf === 'function') {\n      o = o.valueOf();\n      if (o === false || o === null || o === undefined) {\n        return 0;\n      }\n    }\n    if (o === true) {\n      return 1;\n    }\n    var type = typeof o;\n    if (type === 'number') {\n      if (o !== o || o === Infinity) {\n        return 0;\n      }\n      var h = o | 0;\n      if (h !== o) {\n        h ^= o * 0xFFFFFFFF;\n      }\n      while (o > 0xFFFFFFFF) {\n        o /= 0xFFFFFFFF;\n        h ^= o;\n      }\n      return smi(h);\n    }\n    if (type === 'string') {\n      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);\n    }\n    if (typeof o.hashCode === 'function') {\n      return o.hashCode();\n    }\n    if (type === 'object') {\n      return hashJSObj(o);\n    }\n    if (typeof o.toString === 'function') {\n      return hashString(o.toString());\n    }\n    throw new Error('Value type ' + type + ' cannot be hashed.');\n  }\n\n  function cachedHashString(string) {\n    var hash = stringHashCache[string];\n    if (hash === undefined) {\n      hash = hashString(string);\n      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n        STRING_HASH_CACHE_SIZE = 0;\n        stringHashCache = {};\n      }\n      STRING_HASH_CACHE_SIZE++;\n      stringHashCache[string] = hash;\n    }\n    return hash;\n  }\n\n  // http://jsperf.com/hashing-strings\n  function hashString(string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    var hash = 0;\n    for (var ii = 0; ii < string.length; ii++) {\n      hash = 31 * hash + string.charCodeAt(ii) | 0;\n    }\n    return smi(hash);\n  }\n\n  function hashJSObj(obj) {\n    var hash;\n    if (usingWeakMap) {\n      hash = weakMap.get(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = obj[UID_HASH_KEY];\n    if (hash !== undefined) {\n      return hash;\n    }\n\n    if (!canDefineProperty) {\n      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n      if (hash !== undefined) {\n        return hash;\n      }\n\n      hash = getIENodeHash(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = ++objHashUID;\n    if (objHashUID & 0x40000000) {\n      objHashUID = 0;\n    }\n\n    if (usingWeakMap) {\n      weakMap.set(obj, hash);\n    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n      throw new Error('Non-extensible objects are not allowed as keys.');\n    } else if (canDefineProperty) {\n      Object.defineProperty(obj, UID_HASH_KEY, {\n        'enumerable': false,\n        'configurable': false,\n        'writable': false,\n        'value': hash\n      });\n    } else if (obj.propertyIsEnumerable !== undefined &&\n               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {\n      // Since we can't define a non-enumerable property on the object\n      // we'll hijack one of the less-used non-enumerable properties to\n      // save our hash on it. Since this is a function it will not show up in\n      // `JSON.stringify` which is what we want.\n      obj.propertyIsEnumerable = function() {\n        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);\n      };\n      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;\n    } else if (obj.nodeType !== undefined) {\n      // At this point we couldn't get the IE `uniqueID` to use as a hash\n      // and we couldn't use a non-enumerable property to exploit the\n      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n      // itself.\n      obj[UID_HASH_KEY] = hash;\n    } else {\n      throw new Error('Unable to set a non-enumerable property on object.');\n    }\n\n    return hash;\n  }\n\n  // Get references to ES5 object methods.\n  var isExtensible = Object.isExtensible;\n\n  // True if Object.defineProperty works as expected. IE8 fails this test.\n  var canDefineProperty = (function() {\n    try {\n      Object.defineProperty({}, '@', {});\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }());\n\n  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n  // and avoid memory leaks from the IE cloneNode bug.\n  function getIENodeHash(node) {\n    if (node && node.nodeType > 0) {\n      switch (node.nodeType) {\n        case 1: // Element\n          return node.uniqueID;\n        case 9: // Document\n          return node.documentElement && node.documentElement.uniqueID;\n      }\n    }\n  }\n\n  // If possible, use a WeakMap.\n  var usingWeakMap = typeof WeakMap === 'function';\n  var weakMap;\n  if (usingWeakMap) {\n    weakMap = new WeakMap();\n  }\n\n  var objHashUID = 0;\n\n  var UID_HASH_KEY = '__immutablehash__';\n  if (typeof Symbol === 'function') {\n    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n  }\n\n  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n  var STRING_HASH_CACHE_MAX_SIZE = 255;\n  var STRING_HASH_CACHE_SIZE = 0;\n  var stringHashCache = {};\n\n  function assertNotInfinite(size) {\n    invariant(\n      size !== Infinity,\n      'Cannot perform this action with an infinite size.'\n    );\n  }\n\n  createClass(Map, KeyedCollection);\n\n    // @pragma Construction\n\n    function Map(value) {\n      return value === null || value === undefined ? emptyMap() :\n        isMap(value) && !isOrdered(value) ? value :\n        emptyMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    Map.of = function() {var keyValues = SLICE$0.call(arguments, 0);\n      return emptyMap().withMutations(function(map ) {\n        for (var i = 0; i < keyValues.length; i += 2) {\n          if (i + 1 >= keyValues.length) {\n            throw new Error('Missing value for key: ' + keyValues[i]);\n          }\n          map.set(keyValues[i], keyValues[i + 1]);\n        }\n      });\n    };\n\n    Map.prototype.toString = function() {\n      return this.__toString('Map {', '}');\n    };\n\n    // @pragma Access\n\n    Map.prototype.get = function(k, notSetValue) {\n      return this._root ?\n        this._root.get(0, undefined, k, notSetValue) :\n        notSetValue;\n    };\n\n    // @pragma Modification\n\n    Map.prototype.set = function(k, v) {\n      return updateMap(this, k, v);\n    };\n\n    Map.prototype.setIn = function(keyPath, v) {\n      return this.updateIn(keyPath, NOT_SET, function()  {return v});\n    };\n\n    Map.prototype.remove = function(k) {\n      return updateMap(this, k, NOT_SET);\n    };\n\n    Map.prototype.deleteIn = function(keyPath) {\n      return this.updateIn(keyPath, function()  {return NOT_SET});\n    };\n\n    Map.prototype.update = function(k, notSetValue, updater) {\n      return arguments.length === 1 ?\n        k(this) :\n        this.updateIn([k], notSetValue, updater);\n    };\n\n    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {\n      if (!updater) {\n        updater = notSetValue;\n        notSetValue = undefined;\n      }\n      var updatedValue = updateInDeepMap(\n        this,\n        forceIterator(keyPath),\n        notSetValue,\n        updater\n      );\n      return updatedValue === NOT_SET ? undefined : updatedValue;\n    };\n\n    Map.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._root = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyMap();\n    };\n\n    // @pragma Composition\n\n    Map.prototype.merge = function(/*...iters*/) {\n      return mergeIntoMapWith(this, undefined, arguments);\n    };\n\n    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, merger, iters);\n    };\n\n    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.merge === 'function' ?\n          m.merge.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoMapWith(this, deepMerger, arguments);\n    };\n\n    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, deepMergerWith(merger), iters);\n    };\n\n    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.mergeDeep === 'function' ?\n          m.mergeDeep.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator));\n    };\n\n    Map.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator, mapper));\n    };\n\n    // @pragma Mutability\n\n    Map.prototype.withMutations = function(fn) {\n      var mutable = this.asMutable();\n      fn(mutable);\n      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n    };\n\n    Map.prototype.asMutable = function() {\n      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n    };\n\n    Map.prototype.asImmutable = function() {\n      return this.__ensureOwner();\n    };\n\n    Map.prototype.wasAltered = function() {\n      return this.__altered;\n    };\n\n    Map.prototype.__iterator = function(type, reverse) {\n      return new MapIterator(this, type, reverse);\n    };\n\n    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      this._root && this._root.iterate(function(entry ) {\n        iterations++;\n        return fn(entry[1], entry[0], this$0);\n      }, reverse);\n      return iterations;\n    };\n\n    Map.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeMap(this.size, this._root, ownerID, this.__hash);\n    };\n\n\n  function isMap(maybeMap) {\n    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);\n  }\n\n  Map.isMap = isMap;\n\n  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';\n\n  var MapPrototype = Map.prototype;\n  MapPrototype[IS_MAP_SENTINEL] = true;\n  MapPrototype[DELETE] = MapPrototype.remove;\n  MapPrototype.removeIn = MapPrototype.deleteIn;\n\n\n  // #pragma Trie Nodes\n\n\n\n    function ArrayMapNode(ownerID, entries) {\n      this.ownerID = ownerID;\n      this.entries = entries;\n    }\n\n    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && entries.length === 1) {\n        return; // undefined\n      }\n\n      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n        return createNodes(ownerID, entries, key, value);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new ArrayMapNode(ownerID, newEntries);\n    };\n\n\n\n\n    function BitmapIndexedNode(ownerID, bitmap, nodes) {\n      this.ownerID = ownerID;\n      this.bitmap = bitmap;\n      this.nodes = nodes;\n    }\n\n    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));\n      var bitmap = this.bitmap;\n      return (bitmap & bit) === 0 ? notSetValue :\n        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);\n    };\n\n    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var bit = 1 << keyHashFrag;\n      var bitmap = this.bitmap;\n      var exists = (bitmap & bit) !== 0;\n\n      if (!exists && value === NOT_SET) {\n        return this;\n      }\n\n      var idx = popCount(bitmap & (bit - 1));\n      var nodes = this.nodes;\n      var node = exists ? nodes[idx] : undefined;\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\n      if (newNode === node) {\n        return this;\n      }\n\n      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n      }\n\n      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {\n        return nodes[idx ^ 1];\n      }\n\n      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n        return newNode;\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;\n      var newNodes = exists ? newNode ?\n        setIn(nodes, idx, newNode, isEditable) :\n        spliceOut(nodes, idx, isEditable) :\n        spliceIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.bitmap = newBitmap;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n    };\n\n\n\n\n    function HashArrayMapNode(ownerID, count, nodes) {\n      this.ownerID = ownerID;\n      this.count = count;\n      this.nodes = nodes;\n    }\n\n    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var node = this.nodes[idx];\n      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;\n    };\n\n    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var removed = value === NOT_SET;\n      var nodes = this.nodes;\n      var node = nodes[idx];\n\n      if (removed && !node) {\n        return this;\n      }\n\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n      if (newNode === node) {\n        return this;\n      }\n\n      var newCount = this.count;\n      if (!node) {\n        newCount++;\n      } else if (!newNode) {\n        newCount--;\n        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n          return packNodes(ownerID, nodes, newCount, idx);\n        }\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newNodes = setIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.count = newCount;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new HashArrayMapNode(ownerID, newCount, newNodes);\n    };\n\n\n\n\n    function HashCollisionNode(ownerID, keyHash, entries) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entries = entries;\n    }\n\n    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n\n      var removed = value === NOT_SET;\n\n      if (keyHash !== this.keyHash) {\n        if (removed) {\n          return this;\n        }\n        SetRef(didAlter);\n        SetRef(didChangeSize);\n        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n      }\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && len === 2) {\n        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n    };\n\n\n\n\n    function ValueNode(ownerID, keyHash, entry) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entry = entry;\n    }\n\n    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n    };\n\n    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n      var keyMatch = is(key, this.entry[0]);\n      if (keyMatch ? value === this.entry[1] : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n\n      if (removed) {\n        SetRef(didChangeSize);\n        return; // undefined\n      }\n\n      if (keyMatch) {\n        if (ownerID && ownerID === this.ownerID) {\n          this.entry[1] = value;\n          return this;\n        }\n        return new ValueNode(ownerID, this.keyHash, [key, value]);\n      }\n\n      SetRef(didChangeSize);\n      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n    };\n\n\n\n  // #pragma Iterators\n\n  ArrayMapNode.prototype.iterate =\n  HashCollisionNode.prototype.iterate = function (fn, reverse) {\n    var entries = this.entries;\n    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n        return false;\n      }\n    }\n  }\n\n  BitmapIndexedNode.prototype.iterate =\n  HashArrayMapNode.prototype.iterate = function (fn, reverse) {\n    var nodes = this.nodes;\n    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n      var node = nodes[reverse ? maxIndex - ii : ii];\n      if (node && node.iterate(fn, reverse) === false) {\n        return false;\n      }\n    }\n  }\n\n  ValueNode.prototype.iterate = function (fn, reverse) {\n    return fn(this.entry);\n  }\n\n  createClass(MapIterator, Iterator);\n\n    function MapIterator(map, type, reverse) {\n      this._type = type;\n      this._reverse = reverse;\n      this._stack = map._root && mapIteratorFrame(map._root);\n    }\n\n    MapIterator.prototype.next = function() {\n      var type = this._type;\n      var stack = this._stack;\n      while (stack) {\n        var node = stack.node;\n        var index = stack.index++;\n        var maxIndex;\n        if (node.entry) {\n          if (index === 0) {\n            return mapIteratorValue(type, node.entry);\n          }\n        } else if (node.entries) {\n          maxIndex = node.entries.length - 1;\n          if (index <= maxIndex) {\n            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);\n          }\n        } else {\n          maxIndex = node.nodes.length - 1;\n          if (index <= maxIndex) {\n            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n            if (subNode) {\n              if (subNode.entry) {\n                return mapIteratorValue(type, subNode.entry);\n              }\n              stack = this._stack = mapIteratorFrame(subNode, stack);\n            }\n            continue;\n          }\n        }\n        stack = this._stack = this._stack.__prev;\n      }\n      return iteratorDone();\n    };\n\n\n  function mapIteratorValue(type, entry) {\n    return iteratorValue(type, entry[0], entry[1]);\n  }\n\n  function mapIteratorFrame(node, prev) {\n    return {\n      node: node,\n      index: 0,\n      __prev: prev\n    };\n  }\n\n  function makeMap(size, root, ownerID, hash) {\n    var map = Object.create(MapPrototype);\n    map.size = size;\n    map._root = root;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_MAP;\n  function emptyMap() {\n    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n  }\n\n  function updateMap(map, k, v) {\n    var newRoot;\n    var newSize;\n    if (!map._root) {\n      if (v === NOT_SET) {\n        return map;\n      }\n      newSize = 1;\n      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n    } else {\n      var didChangeSize = MakeRef(CHANGE_LENGTH);\n      var didAlter = MakeRef(DID_ALTER);\n      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);\n      if (!didAlter.value) {\n        return map;\n      }\n      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);\n    }\n    if (map.__ownerID) {\n      map.size = newSize;\n      map._root = newRoot;\n      map.__hash = undefined;\n      map.__altered = true;\n      return map;\n    }\n    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n  }\n\n  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (!node) {\n      if (value === NOT_SET) {\n        return node;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return new ValueNode(ownerID, keyHash, [key, value]);\n    }\n    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);\n  }\n\n  function isLeafNode(node) {\n    return node.constructor === ValueNode || node.constructor === HashCollisionNode;\n  }\n\n  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n    if (node.keyHash === keyHash) {\n      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n    }\n\n    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n    var newNode;\n    var nodes = idx1 === idx2 ?\n      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :\n      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n  }\n\n  function createNodes(ownerID, entries, key, value) {\n    if (!ownerID) {\n      ownerID = new OwnerID();\n    }\n    var node = new ValueNode(ownerID, hash(key), [key, value]);\n    for (var ii = 0; ii < entries.length; ii++) {\n      var entry = entries[ii];\n      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n    }\n    return node;\n  }\n\n  function packNodes(ownerID, nodes, count, excluding) {\n    var bitmap = 0;\n    var packedII = 0;\n    var packedNodes = new Array(count);\n    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n      var node = nodes[ii];\n      if (node !== undefined && ii !== excluding) {\n        bitmap |= bit;\n        packedNodes[packedII++] = node;\n      }\n    }\n    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n  }\n\n  function expandNodes(ownerID, nodes, bitmap, including, node) {\n    var count = 0;\n    var expandedNodes = new Array(SIZE);\n    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n    }\n    expandedNodes[including] = node;\n    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n  }\n\n  function mergeIntoMapWith(map, merger, iterables) {\n    var iters = [];\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = KeyedIterable(value);\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    return mergeIntoCollectionWith(map, merger, iters);\n  }\n\n  function deepMerger(existing, value, key) {\n    return existing && existing.mergeDeep && isIterable(value) ?\n      existing.mergeDeep(value) :\n      is(existing, value) ? existing : value;\n  }\n\n  function deepMergerWith(merger) {\n    return function(existing, value, key)  {\n      if (existing && existing.mergeDeepWith && isIterable(value)) {\n        return existing.mergeDeepWith(merger, value);\n      }\n      var nextValue = merger(existing, value, key);\n      return is(existing, nextValue) ? existing : nextValue;\n    };\n  }\n\n  function mergeIntoCollectionWith(collection, merger, iters) {\n    iters = iters.filter(function(x ) {return x.size !== 0});\n    if (iters.length === 0) {\n      return collection;\n    }\n    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {\n      return collection.constructor(iters[0]);\n    }\n    return collection.withMutations(function(collection ) {\n      var mergeIntoMap = merger ?\n        function(value, key)  {\n          collection.update(key, NOT_SET, function(existing )\n            {return existing === NOT_SET ? value : merger(existing, value, key)}\n          );\n        } :\n        function(value, key)  {\n          collection.set(key, value);\n        }\n      for (var ii = 0; ii < iters.length; ii++) {\n        iters[ii].forEach(mergeIntoMap);\n      }\n    });\n  }\n\n  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {\n    var isNotSet = existing === NOT_SET;\n    var step = keyPathIter.next();\n    if (step.done) {\n      var existingValue = isNotSet ? notSetValue : existing;\n      var newValue = updater(existingValue);\n      return newValue === existingValue ? existing : newValue;\n    }\n    invariant(\n      isNotSet || (existing && existing.set),\n      'invalid keyPath'\n    );\n    var key = step.value;\n    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);\n    var nextUpdated = updateInDeepMap(\n      nextExisting,\n      keyPathIter,\n      notSetValue,\n      updater\n    );\n    return nextUpdated === nextExisting ? existing :\n      nextUpdated === NOT_SET ? existing.remove(key) :\n      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);\n  }\n\n  function popCount(x) {\n    x = x - ((x >> 1) & 0x55555555);\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x = x + (x >> 8);\n    x = x + (x >> 16);\n    return x & 0x7f;\n  }\n\n  function setIn(array, idx, val, canEdit) {\n    var newArray = canEdit ? array : arrCopy(array);\n    newArray[idx] = val;\n    return newArray;\n  }\n\n  function spliceIn(array, idx, val, canEdit) {\n    var newLen = array.length + 1;\n    if (canEdit && idx + 1 === newLen) {\n      array[idx] = val;\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        newArray[ii] = val;\n        after = -1;\n      } else {\n        newArray[ii] = array[ii + after];\n      }\n    }\n    return newArray;\n  }\n\n  function spliceOut(array, idx, canEdit) {\n    var newLen = array.length - 1;\n    if (canEdit && idx === newLen) {\n      array.pop();\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        after = 1;\n      }\n      newArray[ii] = array[ii + after];\n    }\n    return newArray;\n  }\n\n  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\n  createClass(List, IndexedCollection);\n\n    // @pragma Construction\n\n    function List(value) {\n      var empty = emptyList();\n      if (value === null || value === undefined) {\n        return empty;\n      }\n      if (isList(value)) {\n        return value;\n      }\n      var iter = IndexedIterable(value);\n      var size = iter.size;\n      if (size === 0) {\n        return empty;\n      }\n      assertNotInfinite(size);\n      if (size > 0 && size < SIZE) {\n        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n      }\n      return empty.withMutations(function(list ) {\n        list.setSize(size);\n        iter.forEach(function(v, i)  {return list.set(i, v)});\n      });\n    }\n\n    List.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    List.prototype.toString = function() {\n      return this.__toString('List [', ']');\n    };\n\n    // @pragma Access\n\n    List.prototype.get = function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      if (index >= 0 && index < this.size) {\n        index += this._origin;\n        var node = listNodeFor(this, index);\n        return node && node.array[index & MASK];\n      }\n      return notSetValue;\n    };\n\n    // @pragma Modification\n\n    List.prototype.set = function(index, value) {\n      return updateList(this, index, value);\n    };\n\n    List.prototype.remove = function(index) {\n      return !this.has(index) ? this :\n        index === 0 ? this.shift() :\n        index === this.size - 1 ? this.pop() :\n        this.splice(index, 1);\n    };\n\n    List.prototype.insert = function(index, value) {\n      return this.splice(index, 0, value);\n    };\n\n    List.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = this._origin = this._capacity = 0;\n        this._level = SHIFT;\n        this._root = this._tail = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyList();\n    };\n\n    List.prototype.push = function(/*...values*/) {\n      var values = arguments;\n      var oldSize = this.size;\n      return this.withMutations(function(list ) {\n        setListBounds(list, 0, oldSize + values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(oldSize + ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.pop = function() {\n      return setListBounds(this, 0, -1);\n    };\n\n    List.prototype.unshift = function(/*...values*/) {\n      var values = arguments;\n      return this.withMutations(function(list ) {\n        setListBounds(list, -values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.shift = function() {\n      return setListBounds(this, 1);\n    };\n\n    // @pragma Composition\n\n    List.prototype.merge = function(/*...iters*/) {\n      return mergeIntoListWith(this, undefined, arguments);\n    };\n\n    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, merger, iters);\n    };\n\n    List.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoListWith(this, deepMerger, arguments);\n    };\n\n    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, deepMergerWith(merger), iters);\n    };\n\n    List.prototype.setSize = function(size) {\n      return setListBounds(this, 0, size);\n    };\n\n    // @pragma Iteration\n\n    List.prototype.slice = function(begin, end) {\n      var size = this.size;\n      if (wholeSlice(begin, end, size)) {\n        return this;\n      }\n      return setListBounds(\n        this,\n        resolveBegin(begin, size),\n        resolveEnd(end, size)\n      );\n    };\n\n    List.prototype.__iterator = function(type, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      return new Iterator(function()  {\n        var value = values();\n        return value === DONE ?\n          iteratorDone() :\n          iteratorValue(type, index++, value);\n      });\n    };\n\n    List.prototype.__iterate = function(fn, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      var value;\n      while ((value = values()) !== DONE) {\n        if (fn(value, index++, this) === false) {\n          break;\n        }\n      }\n      return index;\n    };\n\n    List.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        return this;\n      }\n      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);\n    };\n\n\n  function isList(maybeList) {\n    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);\n  }\n\n  List.isList = isList;\n\n  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';\n\n  var ListPrototype = List.prototype;\n  ListPrototype[IS_LIST_SENTINEL] = true;\n  ListPrototype[DELETE] = ListPrototype.remove;\n  ListPrototype.setIn = MapPrototype.setIn;\n  ListPrototype.deleteIn =\n  ListPrototype.removeIn = MapPrototype.removeIn;\n  ListPrototype.update = MapPrototype.update;\n  ListPrototype.updateIn = MapPrototype.updateIn;\n  ListPrototype.mergeIn = MapPrototype.mergeIn;\n  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  ListPrototype.withMutations = MapPrototype.withMutations;\n  ListPrototype.asMutable = MapPrototype.asMutable;\n  ListPrototype.asImmutable = MapPrototype.asImmutable;\n  ListPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n\n    function VNode(array, ownerID) {\n      this.array = array;\n      this.ownerID = ownerID;\n    }\n\n    // TODO: seems like these methods are very similar\n\n    VNode.prototype.removeBefore = function(ownerID, level, index) {\n      if (index === level ? 1 << level : 0 || this.array.length === 0) {\n        return this;\n      }\n      var originIndex = (index >>> level) & MASK;\n      if (originIndex >= this.array.length) {\n        return new VNode([], ownerID);\n      }\n      var removingFirst = originIndex === 0;\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[originIndex];\n        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && removingFirst) {\n          return this;\n        }\n      }\n      if (removingFirst && !newChild) {\n        return this;\n      }\n      var editable = editableVNode(this, ownerID);\n      if (!removingFirst) {\n        for (var ii = 0; ii < originIndex; ii++) {\n          editable.array[ii] = undefined;\n        }\n      }\n      if (newChild) {\n        editable.array[originIndex] = newChild;\n      }\n      return editable;\n    };\n\n    VNode.prototype.removeAfter = function(ownerID, level, index) {\n      if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n        return this;\n      }\n      var sizeIndex = ((index - 1) >>> level) & MASK;\n      if (sizeIndex >= this.array.length) {\n        return this;\n      }\n\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[sizeIndex];\n        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n          return this;\n        }\n      }\n\n      var editable = editableVNode(this, ownerID);\n      editable.array.splice(sizeIndex + 1);\n      if (newChild) {\n        editable.array[sizeIndex] = newChild;\n      }\n      return editable;\n    };\n\n\n\n  var DONE = {};\n\n  function iterateList(list, reverse) {\n    var left = list._origin;\n    var right = list._capacity;\n    var tailPos = getTailOffset(right);\n    var tail = list._tail;\n\n    return iterateNodeOrLeaf(list._root, list._level, 0);\n\n    function iterateNodeOrLeaf(node, level, offset) {\n      return level === 0 ?\n        iterateLeaf(node, offset) :\n        iterateNode(node, level, offset);\n    }\n\n    function iterateLeaf(node, offset) {\n      var array = offset === tailPos ? tail && tail.array : node && node.array;\n      var from = offset > left ? 0 : left - offset;\n      var to = right - offset;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        if (from === to) {\n          return DONE;\n        }\n        var idx = reverse ? --to : from++;\n        return array && array[idx];\n      };\n    }\n\n    function iterateNode(node, level, offset) {\n      var values;\n      var array = node && node.array;\n      var from = offset > left ? 0 : (left - offset) >> level;\n      var to = ((right - offset) >> level) + 1;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        do {\n          if (values) {\n            var value = values();\n            if (value !== DONE) {\n              return value;\n            }\n            values = null;\n          }\n          if (from === to) {\n            return DONE;\n          }\n          var idx = reverse ? --to : from++;\n          values = iterateNodeOrLeaf(\n            array && array[idx], level - SHIFT, offset + (idx << level)\n          );\n        } while (true);\n      };\n    }\n  }\n\n  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n    var list = Object.create(ListPrototype);\n    list.size = capacity - origin;\n    list._origin = origin;\n    list._capacity = capacity;\n    list._level = level;\n    list._root = root;\n    list._tail = tail;\n    list.__ownerID = ownerID;\n    list.__hash = hash;\n    list.__altered = false;\n    return list;\n  }\n\n  var EMPTY_LIST;\n  function emptyList() {\n    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n  }\n\n  function updateList(list, index, value) {\n    index = wrapIndex(list, index);\n\n    if (index !== index) {\n      return list;\n    }\n\n    if (index >= list.size || index < 0) {\n      return list.withMutations(function(list ) {\n        index < 0 ?\n          setListBounds(list, index).set(0, value) :\n          setListBounds(list, 0, index + 1).set(index, value)\n      });\n    }\n\n    index += list._origin;\n\n    var newTail = list._tail;\n    var newRoot = list._root;\n    var didAlter = MakeRef(DID_ALTER);\n    if (index >= getTailOffset(list._capacity)) {\n      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n    } else {\n      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);\n    }\n\n    if (!didAlter.value) {\n      return list;\n    }\n\n    if (list.__ownerID) {\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n  }\n\n  function updateVNode(node, ownerID, level, index, value, didAlter) {\n    var idx = (index >>> level) & MASK;\n    var nodeHas = node && idx < node.array.length;\n    if (!nodeHas && value === undefined) {\n      return node;\n    }\n\n    var newNode;\n\n    if (level > 0) {\n      var lowerNode = node && node.array[idx];\n      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);\n      if (newLowerNode === lowerNode) {\n        return node;\n      }\n      newNode = editableVNode(node, ownerID);\n      newNode.array[idx] = newLowerNode;\n      return newNode;\n    }\n\n    if (nodeHas && node.array[idx] === value) {\n      return node;\n    }\n\n    SetRef(didAlter);\n\n    newNode = editableVNode(node, ownerID);\n    if (value === undefined && idx === newNode.array.length - 1) {\n      newNode.array.pop();\n    } else {\n      newNode.array[idx] = value;\n    }\n    return newNode;\n  }\n\n  function editableVNode(node, ownerID) {\n    if (ownerID && node && ownerID === node.ownerID) {\n      return node;\n    }\n    return new VNode(node ? node.array.slice() : [], ownerID);\n  }\n\n  function listNodeFor(list, rawIndex) {\n    if (rawIndex >= getTailOffset(list._capacity)) {\n      return list._tail;\n    }\n    if (rawIndex < 1 << (list._level + SHIFT)) {\n      var node = list._root;\n      var level = list._level;\n      while (node && level > 0) {\n        node = node.array[(rawIndex >>> level) & MASK];\n        level -= SHIFT;\n      }\n      return node;\n    }\n  }\n\n  function setListBounds(list, begin, end) {\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n    var owner = list.__ownerID || new OwnerID();\n    var oldOrigin = list._origin;\n    var oldCapacity = list._capacity;\n    var newOrigin = oldOrigin + begin;\n    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;\n    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n      return list;\n    }\n\n    // If it's going to end after it starts, it's empty.\n    if (newOrigin >= newCapacity) {\n      return list.clear();\n    }\n\n    var newLevel = list._level;\n    var newRoot = list._root;\n\n    // New origin might need creating a higher root.\n    var offsetShift = 0;\n    while (newOrigin + offsetShift < 0) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);\n      newLevel += SHIFT;\n      offsetShift += 1 << newLevel;\n    }\n    if (offsetShift) {\n      newOrigin += offsetShift;\n      oldOrigin += offsetShift;\n      newCapacity += offsetShift;\n      oldCapacity += offsetShift;\n    }\n\n    var oldTailOffset = getTailOffset(oldCapacity);\n    var newTailOffset = getTailOffset(newCapacity);\n\n    // New size might need creating a higher root.\n    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);\n      newLevel += SHIFT;\n    }\n\n    // Locate or create the new tail.\n    var oldTail = list._tail;\n    var newTail = newTailOffset < oldTailOffset ?\n      listNodeFor(list, newCapacity - 1) :\n      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;\n\n    // Merge Tail into tree.\n    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {\n      newRoot = editableVNode(newRoot, owner);\n      var node = newRoot;\n      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n        var idx = (oldTailOffset >>> level) & MASK;\n        node = node.array[idx] = editableVNode(node.array[idx], owner);\n      }\n      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n    }\n\n    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n    if (newCapacity < oldCapacity) {\n      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n    }\n\n    // If the new origin is within the tail, then we do not need a root.\n    if (newOrigin >= newTailOffset) {\n      newOrigin -= newTailOffset;\n      newCapacity -= newTailOffset;\n      newLevel = SHIFT;\n      newRoot = null;\n      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n    // Otherwise, if the root has been trimmed, garbage collect.\n    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n      offsetShift = 0;\n\n      // Identify the new top root node of the subtree of the old root.\n      while (newRoot) {\n        var beginIndex = (newOrigin >>> newLevel) & MASK;\n        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {\n          break;\n        }\n        if (beginIndex) {\n          offsetShift += (1 << newLevel) * beginIndex;\n        }\n        newLevel -= SHIFT;\n        newRoot = newRoot.array[beginIndex];\n      }\n\n      // Trim the new sides of the new root.\n      if (newRoot && newOrigin > oldOrigin) {\n        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n      }\n      if (newRoot && newTailOffset < oldTailOffset) {\n        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);\n      }\n      if (offsetShift) {\n        newOrigin -= offsetShift;\n        newCapacity -= offsetShift;\n      }\n    }\n\n    if (list.__ownerID) {\n      list.size = newCapacity - newOrigin;\n      list._origin = newOrigin;\n      list._capacity = newCapacity;\n      list._level = newLevel;\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n  }\n\n  function mergeIntoListWith(list, merger, iterables) {\n    var iters = [];\n    var maxSize = 0;\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = IndexedIterable(value);\n      if (iter.size > maxSize) {\n        maxSize = iter.size;\n      }\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    if (maxSize > list.size) {\n      list = list.setSize(maxSize);\n    }\n    return mergeIntoCollectionWith(list, merger, iters);\n  }\n\n  function getTailOffset(size) {\n    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);\n  }\n\n  createClass(OrderedMap, Map);\n\n    // @pragma Construction\n\n    function OrderedMap(value) {\n      return value === null || value === undefined ? emptyOrderedMap() :\n        isOrderedMap(value) ? value :\n        emptyOrderedMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    OrderedMap.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedMap.prototype.toString = function() {\n      return this.__toString('OrderedMap {', '}');\n    };\n\n    // @pragma Access\n\n    OrderedMap.prototype.get = function(k, notSetValue) {\n      var index = this._map.get(k);\n      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n    };\n\n    // @pragma Modification\n\n    OrderedMap.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._map.clear();\n        this._list.clear();\n        return this;\n      }\n      return emptyOrderedMap();\n    };\n\n    OrderedMap.prototype.set = function(k, v) {\n      return updateOrderedMap(this, k, v);\n    };\n\n    OrderedMap.prototype.remove = function(k) {\n      return updateOrderedMap(this, k, NOT_SET);\n    };\n\n    OrderedMap.prototype.wasAltered = function() {\n      return this._map.wasAltered() || this._list.wasAltered();\n    };\n\n    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._list.__iterate(\n        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},\n        reverse\n      );\n    };\n\n    OrderedMap.prototype.__iterator = function(type, reverse) {\n      return this._list.fromEntrySeq().__iterator(type, reverse);\n    };\n\n    OrderedMap.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      var newList = this._list.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        this._list = newList;\n        return this;\n      }\n      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n    };\n\n\n  function isOrderedMap(maybeOrderedMap) {\n    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n  }\n\n  OrderedMap.isOrderedMap = isOrderedMap;\n\n  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;\n  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\n\n\n  function makeOrderedMap(map, list, ownerID, hash) {\n    var omap = Object.create(OrderedMap.prototype);\n    omap.size = map ? map.size : 0;\n    omap._map = map;\n    omap._list = list;\n    omap.__ownerID = ownerID;\n    omap.__hash = hash;\n    return omap;\n  }\n\n  var EMPTY_ORDERED_MAP;\n  function emptyOrderedMap() {\n    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));\n  }\n\n  function updateOrderedMap(omap, k, v) {\n    var map = omap._map;\n    var list = omap._list;\n    var i = map.get(k);\n    var has = i !== undefined;\n    var newMap;\n    var newList;\n    if (v === NOT_SET) { // removed\n      if (!has) {\n        return omap;\n      }\n      if (list.size >= SIZE && list.size >= map.size * 2) {\n        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});\n        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();\n        if (omap.__ownerID) {\n          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n        }\n      } else {\n        newMap = map.remove(k);\n        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n      }\n    } else {\n      if (has) {\n        if (v === list.get(i)[1]) {\n          return omap;\n        }\n        newMap = map;\n        newList = list.set(i, [k, v]);\n      } else {\n        newMap = map.set(k, list.size);\n        newList = list.set(list.size, [k, v]);\n      }\n    }\n    if (omap.__ownerID) {\n      omap.size = newMap.size;\n      omap._map = newMap;\n      omap._list = newList;\n      omap.__hash = undefined;\n      return omap;\n    }\n    return makeOrderedMap(newMap, newList);\n  }\n\n  createClass(ToKeyedSequence, KeyedSeq);\n    function ToKeyedSequence(indexed, useKeys) {\n      this._iter = indexed;\n      this._useKeys = useKeys;\n      this.size = indexed.size;\n    }\n\n    ToKeyedSequence.prototype.get = function(key, notSetValue) {\n      return this._iter.get(key, notSetValue);\n    };\n\n    ToKeyedSequence.prototype.has = function(key) {\n      return this._iter.has(key);\n    };\n\n    ToKeyedSequence.prototype.valueSeq = function() {\n      return this._iter.valueSeq();\n    };\n\n    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;\n      var reversedSequence = reverseFactory(this, true);\n      if (!this._useKeys) {\n        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};\n      }\n      return reversedSequence;\n    };\n\n    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;\n      var mappedSequence = mapFactory(this, mapper, context);\n      if (!this._useKeys) {\n        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};\n      }\n      return mappedSequence;\n    };\n\n    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var ii;\n      return this._iter.__iterate(\n        this._useKeys ?\n          function(v, k)  {return fn(v, k, this$0)} :\n          ((ii = reverse ? resolveSize(this) : 0),\n            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),\n        reverse\n      );\n    };\n\n    ToKeyedSequence.prototype.__iterator = function(type, reverse) {\n      if (this._useKeys) {\n        return this._iter.__iterator(type, reverse);\n      }\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var ii = reverse ? resolveSize(this) : 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, reverse ? --ii : ii++, step.value, step);\n      });\n    };\n\n  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(ToIndexedSequence, IndexedSeq);\n    function ToIndexedSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToIndexedSequence.prototype.includes = function(value) {\n      return this._iter.includes(value);\n    };\n\n    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);\n    };\n\n    ToIndexedSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, iterations++, step.value, step)\n      });\n    };\n\n\n\n  createClass(ToSetSequence, SetSeq);\n    function ToSetSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToSetSequence.prototype.has = function(key) {\n      return this._iter.includes(key);\n    };\n\n    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);\n    };\n\n    ToSetSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, step.value, step.value, step);\n      });\n    };\n\n\n\n  createClass(FromEntriesSequence, KeyedSeq);\n    function FromEntriesSequence(entries) {\n      this._iter = entries;\n      this.size = entries.size;\n    }\n\n    FromEntriesSequence.prototype.entrySeq = function() {\n      return this._iter.toSeq();\n    };\n\n    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(entry ) {\n        // Check if entry exists first so array access doesn't throw for holes\n        // in the parent iteration.\n        if (entry) {\n          validateEntry(entry);\n          var indexedIterable = isIterable(entry);\n          return fn(\n            indexedIterable ? entry.get(1) : entry[1],\n            indexedIterable ? entry.get(0) : entry[0],\n            this$0\n          );\n        }\n      }, reverse);\n    };\n\n    FromEntriesSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          // Check if entry exists first so array access doesn't throw for holes\n          // in the parent iteration.\n          if (entry) {\n            validateEntry(entry);\n            var indexedIterable = isIterable(entry);\n            return iteratorValue(\n              type,\n              indexedIterable ? entry.get(0) : entry[0],\n              indexedIterable ? entry.get(1) : entry[1],\n              step\n            );\n          }\n        }\n      });\n    };\n\n\n  ToIndexedSequence.prototype.cacheResult =\n  ToKeyedSequence.prototype.cacheResult =\n  ToSetSequence.prototype.cacheResult =\n  FromEntriesSequence.prototype.cacheResult =\n    cacheResultThrough;\n\n\n  function flipFactory(iterable) {\n    var flipSequence = makeSequence(iterable);\n    flipSequence._iter = iterable;\n    flipSequence.size = iterable.size;\n    flipSequence.flip = function()  {return iterable};\n    flipSequence.reverse = function () {\n      var reversedSequence = iterable.reverse.apply(this); // super.reverse()\n      reversedSequence.flip = function()  {return iterable.reverse()};\n      return reversedSequence;\n    };\n    flipSequence.has = function(key ) {return iterable.includes(key)};\n    flipSequence.includes = function(key ) {return iterable.has(key)};\n    flipSequence.cacheResult = cacheResultThrough;\n    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);\n    }\n    flipSequence.__iteratorUncached = function(type, reverse) {\n      if (type === ITERATE_ENTRIES) {\n        var iterator = iterable.__iterator(type, reverse);\n        return new Iterator(function()  {\n          var step = iterator.next();\n          if (!step.done) {\n            var k = step.value[0];\n            step.value[0] = step.value[1];\n            step.value[1] = k;\n          }\n          return step;\n        });\n      }\n      return iterable.__iterator(\n        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n        reverse\n      );\n    }\n    return flipSequence;\n  }\n\n\n  function mapFactory(iterable, mapper, context) {\n    var mappedSequence = makeSequence(iterable);\n    mappedSequence.size = iterable.size;\n    mappedSequence.has = function(key ) {return iterable.has(key)};\n    mappedSequence.get = function(key, notSetValue)  {\n      var v = iterable.get(key, NOT_SET);\n      return v === NOT_SET ?\n        notSetValue :\n        mapper.call(context, v, key, iterable);\n    };\n    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(\n        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},\n        reverse\n      );\n    }\n    mappedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var key = entry[0];\n        return iteratorValue(\n          type,\n          key,\n          mapper.call(context, entry[1], key, iterable),\n          step\n        );\n      });\n    }\n    return mappedSequence;\n  }\n\n\n  function reverseFactory(iterable, useKeys) {\n    var reversedSequence = makeSequence(iterable);\n    reversedSequence._iter = iterable;\n    reversedSequence.size = iterable.size;\n    reversedSequence.reverse = function()  {return iterable};\n    if (iterable.flip) {\n      reversedSequence.flip = function () {\n        var flipSequence = flipFactory(iterable);\n        flipSequence.reverse = function()  {return iterable.flip()};\n        return flipSequence;\n      };\n    }\n    reversedSequence.get = function(key, notSetValue) \n      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};\n    reversedSequence.has = function(key )\n      {return iterable.has(useKeys ? key : -1 - key)};\n    reversedSequence.includes = function(value ) {return iterable.includes(value)};\n    reversedSequence.cacheResult = cacheResultThrough;\n    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);\n    };\n    reversedSequence.__iterator =\n      function(type, reverse)  {return iterable.__iterator(type, !reverse)};\n    return reversedSequence;\n  }\n\n\n  function filterFactory(iterable, predicate, context, useKeys) {\n    var filterSequence = makeSequence(iterable);\n    if (useKeys) {\n      filterSequence.has = function(key ) {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);\n      };\n      filterSequence.get = function(key, notSetValue)  {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?\n          v : notSetValue;\n      };\n    }\n    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      }, reverse);\n      return iterations;\n    };\n    filterSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          var key = entry[0];\n          var value = entry[1];\n          if (predicate.call(context, value, key, iterable)) {\n            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n          }\n        }\n      });\n    }\n    return filterSequence;\n  }\n\n\n  function countByFactory(iterable, grouper, context) {\n    var groups = Map().asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        0,\n        function(a ) {return a + 1}\n      );\n    });\n    return groups.asImmutable();\n  }\n\n\n  function groupByFactory(iterable, grouper, context) {\n    var isKeyedIter = isKeyed(iterable);\n    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}\n      );\n    });\n    var coerce = iterableClass(iterable);\n    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});\n  }\n\n\n  function sliceFactory(iterable, begin, end, useKeys) {\n    var originalSize = iterable.size;\n\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      if (end === Infinity) {\n        end = originalSize;\n      } else {\n        end = end | 0;\n      }\n    }\n\n    if (wholeSlice(begin, end, originalSize)) {\n      return iterable;\n    }\n\n    var resolvedBegin = resolveBegin(begin, originalSize);\n    var resolvedEnd = resolveEnd(end, originalSize);\n\n    // begin or end will be NaN if they were provided as negative numbers and\n    // this iterable's size is unknown. In that case, cache first so there is\n    // a known size and these do not resolve to NaN.\n    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);\n    }\n\n    // Note: resolvedEnd is undefined when the original sequence's length is\n    // unknown and this slice did not supply an end and should contain all\n    // elements after resolvedBegin.\n    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n    var resolvedSize = resolvedEnd - resolvedBegin;\n    var sliceSize;\n    if (resolvedSize === resolvedSize) {\n      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n    }\n\n    var sliceSeq = makeSequence(iterable);\n\n    // If iterable.size is undefined, the size of the realized sliceSeq is\n    // unknown at this point unless the number of items to slice is 0\n    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;\n\n    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {\n      sliceSeq.get = function (index, notSetValue) {\n        index = wrapIndex(this, index);\n        return index >= 0 && index < sliceSize ?\n          iterable.get(index + resolvedBegin, notSetValue) :\n          notSetValue;\n      }\n    }\n\n    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (sliceSize === 0) {\n        return 0;\n      }\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var skipped = 0;\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k)  {\n        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&\n                 iterations !== sliceSize;\n        }\n      });\n      return iterations;\n    };\n\n    sliceSeq.__iteratorUncached = function(type, reverse) {\n      if (sliceSize !== 0 && reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      // Don't bother instantiating parent iterator if taking 0.\n      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);\n      var skipped = 0;\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (skipped++ < resolvedBegin) {\n          iterator.next();\n        }\n        if (++iterations > sliceSize) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (useKeys || type === ITERATE_VALUES) {\n          return step;\n        } else if (type === ITERATE_KEYS) {\n          return iteratorValue(type, iterations - 1, undefined, step);\n        } else {\n          return iteratorValue(type, iterations - 1, step.value[1], step);\n        }\n      });\n    }\n\n    return sliceSeq;\n  }\n\n\n  function takeWhileFactory(iterable, predicate, context) {\n    var takeSequence = makeSequence(iterable);\n    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c) \n        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}\n      );\n      return iterations;\n    };\n    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterating = true;\n      return new Iterator(function()  {\n        if (!iterating) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var k = entry[0];\n        var v = entry[1];\n        if (!predicate.call(context, v, k, this$0)) {\n          iterating = false;\n          return iteratorDone();\n        }\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return takeSequence;\n  }\n\n\n  function skipWhileFactory(iterable, predicate, context, useKeys) {\n    var skipSequence = makeSequence(iterable);\n    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      });\n      return iterations;\n    };\n    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var skipping = true;\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step, k, v;\n        do {\n          step = iterator.next();\n          if (step.done) {\n            if (useKeys || type === ITERATE_VALUES) {\n              return step;\n            } else if (type === ITERATE_KEYS) {\n              return iteratorValue(type, iterations++, undefined, step);\n            } else {\n              return iteratorValue(type, iterations++, step.value[1], step);\n            }\n          }\n          var entry = step.value;\n          k = entry[0];\n          v = entry[1];\n          skipping && (skipping = predicate.call(context, v, k, this$0));\n        } while (skipping);\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return skipSequence;\n  }\n\n\n  function concatFactory(iterable, values) {\n    var isKeyedIterable = isKeyed(iterable);\n    var iters = [iterable].concat(values).map(function(v ) {\n      if (!isIterable(v)) {\n        v = isKeyedIterable ?\n          keyedSeqFromValue(v) :\n          indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n      } else if (isKeyedIterable) {\n        v = KeyedIterable(v);\n      }\n      return v;\n    }).filter(function(v ) {return v.size !== 0});\n\n    if (iters.length === 0) {\n      return iterable;\n    }\n\n    if (iters.length === 1) {\n      var singleton = iters[0];\n      if (singleton === iterable ||\n          isKeyedIterable && isKeyed(singleton) ||\n          isIndexed(iterable) && isIndexed(singleton)) {\n        return singleton;\n      }\n    }\n\n    var concatSeq = new ArraySeq(iters);\n    if (isKeyedIterable) {\n      concatSeq = concatSeq.toKeyedSeq();\n    } else if (!isIndexed(iterable)) {\n      concatSeq = concatSeq.toSetSeq();\n    }\n    concatSeq = concatSeq.flatten(true);\n    concatSeq.size = iters.reduce(\n      function(sum, seq)  {\n        if (sum !== undefined) {\n          var size = seq.size;\n          if (size !== undefined) {\n            return sum + size;\n          }\n        }\n      },\n      0\n    );\n    return concatSeq;\n  }\n\n\n  function flattenFactory(iterable, depth, useKeys) {\n    var flatSequence = makeSequence(iterable);\n    flatSequence.__iterateUncached = function(fn, reverse) {\n      var iterations = 0;\n      var stopped = false;\n      function flatDeep(iter, currentDepth) {var this$0 = this;\n        iter.__iterate(function(v, k)  {\n          if ((!depth || currentDepth < depth) && isIterable(v)) {\n            flatDeep(v, currentDepth + 1);\n          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {\n            stopped = true;\n          }\n          return !stopped;\n        }, reverse);\n      }\n      flatDeep(iterable, 0);\n      return iterations;\n    }\n    flatSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(type, reverse);\n      var stack = [];\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (iterator) {\n          var step = iterator.next();\n          if (step.done !== false) {\n            iterator = stack.pop();\n            continue;\n          }\n          var v = step.value;\n          if (type === ITERATE_ENTRIES) {\n            v = v[1];\n          }\n          if ((!depth || stack.length < depth) && isIterable(v)) {\n            stack.push(iterator);\n            iterator = v.__iterator(type, reverse);\n          } else {\n            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n          }\n        }\n        return iteratorDone();\n      });\n    }\n    return flatSequence;\n  }\n\n\n  function flatMapFactory(iterable, mapper, context) {\n    var coerce = iterableClass(iterable);\n    return iterable.toSeq().map(\n      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}\n    ).flatten(true);\n  }\n\n\n  function interposeFactory(iterable, separator) {\n    var interposedSequence = makeSequence(iterable);\n    interposedSequence.size = iterable.size && iterable.size * 2 -1;\n    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k) \n        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&\n        fn(v, iterations++, this$0) !== false},\n        reverse\n      );\n      return iterations;\n    };\n    interposedSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      var step;\n      return new Iterator(function()  {\n        if (!step || iterations % 2) {\n          step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n        }\n        return iterations % 2 ?\n          iteratorValue(type, iterations++, separator) :\n          iteratorValue(type, iterations++, step.value, step);\n      });\n    };\n    return interposedSequence;\n  }\n\n\n  function sortFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    var isKeyedIterable = isKeyed(iterable);\n    var index = 0;\n    var entries = iterable.toSeq().map(\n      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}\n    ).toArray();\n    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(\n      isKeyedIterable ?\n      function(v, i)  { entries[i].length = 2; } :\n      function(v, i)  { entries[i] = v[1]; }\n    );\n    return isKeyedIterable ? KeyedSeq(entries) :\n      isIndexed(iterable) ? IndexedSeq(entries) :\n      SetSeq(entries);\n  }\n\n\n  function maxFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    if (mapper) {\n      var entry = iterable.toSeq()\n        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})\n        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});\n      return entry && entry[0];\n    } else {\n      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});\n    }\n  }\n\n  function maxCompare(comparator, a, b) {\n    var comp = comparator(b, a);\n    // b is considered the new max if the comparator declares them equal, but\n    // they are not equal and b is in fact a nullish value.\n    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;\n  }\n\n\n  function zipWithFactory(keyIter, zipper, iters) {\n    var zipSequence = makeSequence(keyIter);\n    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();\n    // Note: this a generic base implementation of __iterate in terms of\n    // __iterator which may be more generically useful in the future.\n    zipSequence.__iterate = function(fn, reverse) {\n      /* generic:\n      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        iterations++;\n        if (fn(step.value[1], step.value[0], this) === false) {\n          break;\n        }\n      }\n      return iterations;\n      */\n      // indexed:\n      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        if (fn(step.value, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n    zipSequence.__iteratorUncached = function(type, reverse) {\n      var iterators = iters.map(function(i )\n        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}\n      );\n      var iterations = 0;\n      var isDone = false;\n      return new Iterator(function()  {\n        var steps;\n        if (!isDone) {\n          steps = iterators.map(function(i ) {return i.next()});\n          isDone = steps.some(function(s ) {return s.done});\n        }\n        if (isDone) {\n          return iteratorDone();\n        }\n        return iteratorValue(\n          type,\n          iterations++,\n          zipper.apply(null, steps.map(function(s ) {return s.value}))\n        );\n      });\n    };\n    return zipSequence\n  }\n\n\n  // #pragma Helper Functions\n\n  function reify(iter, seq) {\n    return isSeq(iter) ? seq : iter.constructor(seq);\n  }\n\n  function validateEntry(entry) {\n    if (entry !== Object(entry)) {\n      throw new TypeError('Expected [K, V] tuple: ' + entry);\n    }\n  }\n\n  function resolveSize(iter) {\n    assertNotInfinite(iter.size);\n    return ensureSize(iter);\n  }\n\n  function iterableClass(iterable) {\n    return isKeyed(iterable) ? KeyedIterable :\n      isIndexed(iterable) ? IndexedIterable :\n      SetIterable;\n  }\n\n  function makeSequence(iterable) {\n    return Object.create(\n      (\n        isKeyed(iterable) ? KeyedSeq :\n        isIndexed(iterable) ? IndexedSeq :\n        SetSeq\n      ).prototype\n    );\n  }\n\n  function cacheResultThrough() {\n    if (this._iter.cacheResult) {\n      this._iter.cacheResult();\n      this.size = this._iter.size;\n      return this;\n    } else {\n      return Seq.prototype.cacheResult.call(this);\n    }\n  }\n\n  function defaultComparator(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n  }\n\n  function forceIterator(keyPath) {\n    var iter = getIterator(keyPath);\n    if (!iter) {\n      // Array might not be iterable in this environment, so we need a fallback\n      // to our wrapped type.\n      if (!isArrayLike(keyPath)) {\n        throw new TypeError('Expected iterable or array-like: ' + keyPath);\n      }\n      iter = getIterator(Iterable(keyPath));\n    }\n    return iter;\n  }\n\n  createClass(Record, KeyedCollection);\n\n    function Record(defaultValues, name) {\n      var hasInitialized;\n\n      var RecordType = function Record(values) {\n        if (values instanceof RecordType) {\n          return values;\n        }\n        if (!(this instanceof RecordType)) {\n          return new RecordType(values);\n        }\n        if (!hasInitialized) {\n          hasInitialized = true;\n          var keys = Object.keys(defaultValues);\n          setProps(RecordTypePrototype, keys);\n          RecordTypePrototype.size = keys.length;\n          RecordTypePrototype._name = name;\n          RecordTypePrototype._keys = keys;\n          RecordTypePrototype._defaultValues = defaultValues;\n        }\n        this._map = Map(values);\n      };\n\n      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);\n      RecordTypePrototype.constructor = RecordType;\n\n      return RecordType;\n    }\n\n    Record.prototype.toString = function() {\n      return this.__toString(recordName(this) + ' {', '}');\n    };\n\n    // @pragma Access\n\n    Record.prototype.has = function(k) {\n      return this._defaultValues.hasOwnProperty(k);\n    };\n\n    Record.prototype.get = function(k, notSetValue) {\n      if (!this.has(k)) {\n        return notSetValue;\n      }\n      var defaultVal = this._defaultValues[k];\n      return this._map ? this._map.get(k, defaultVal) : defaultVal;\n    };\n\n    // @pragma Modification\n\n    Record.prototype.clear = function() {\n      if (this.__ownerID) {\n        this._map && this._map.clear();\n        return this;\n      }\n      var RecordType = this.constructor;\n      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));\n    };\n\n    Record.prototype.set = function(k, v) {\n      if (!this.has(k)) {\n        throw new Error('Cannot set unknown key \"' + k + '\" on ' + recordName(this));\n      }\n      if (this._map && !this._map.has(k)) {\n        var defaultVal = this._defaultValues[k];\n        if (v === defaultVal) {\n          return this;\n        }\n      }\n      var newMap = this._map && this._map.set(k, v);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.remove = function(k) {\n      if (!this.has(k)) {\n        return this;\n      }\n      var newMap = this._map && this._map.remove(k);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);\n    };\n\n    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);\n    };\n\n    Record.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map && this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return makeRecord(this, newMap, ownerID);\n    };\n\n\n  var RecordPrototype = Record.prototype;\n  RecordPrototype[DELETE] = RecordPrototype.remove;\n  RecordPrototype.deleteIn =\n  RecordPrototype.removeIn = MapPrototype.removeIn;\n  RecordPrototype.merge = MapPrototype.merge;\n  RecordPrototype.mergeWith = MapPrototype.mergeWith;\n  RecordPrototype.mergeIn = MapPrototype.mergeIn;\n  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;\n  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;\n  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  RecordPrototype.setIn = MapPrototype.setIn;\n  RecordPrototype.update = MapPrototype.update;\n  RecordPrototype.updateIn = MapPrototype.updateIn;\n  RecordPrototype.withMutations = MapPrototype.withMutations;\n  RecordPrototype.asMutable = MapPrototype.asMutable;\n  RecordPrototype.asImmutable = MapPrototype.asImmutable;\n\n\n  function makeRecord(likeRecord, map, ownerID) {\n    var record = Object.create(Object.getPrototypeOf(likeRecord));\n    record._map = map;\n    record.__ownerID = ownerID;\n    return record;\n  }\n\n  function recordName(record) {\n    return record._name || record.constructor.name || 'Record';\n  }\n\n  function setProps(prototype, names) {\n    try {\n      names.forEach(setProp.bind(undefined, prototype));\n    } catch (error) {\n      // Object.defineProperty failed. Probably IE8.\n    }\n  }\n\n  function setProp(prototype, name) {\n    Object.defineProperty(prototype, name, {\n      get: function() {\n        return this.get(name);\n      },\n      set: function(value) {\n        invariant(this.__ownerID, 'Cannot set on an immutable record.');\n        this.set(name, value);\n      }\n    });\n  }\n\n  createClass(Set, SetCollection);\n\n    // @pragma Construction\n\n    function Set(value) {\n      return value === null || value === undefined ? emptySet() :\n        isSet(value) && !isOrdered(value) ? value :\n        emptySet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    Set.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Set.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    Set.prototype.toString = function() {\n      return this.__toString('Set {', '}');\n    };\n\n    // @pragma Access\n\n    Set.prototype.has = function(value) {\n      return this._map.has(value);\n    };\n\n    // @pragma Modification\n\n    Set.prototype.add = function(value) {\n      return updateSet(this, this._map.set(value, true));\n    };\n\n    Set.prototype.remove = function(value) {\n      return updateSet(this, this._map.remove(value));\n    };\n\n    Set.prototype.clear = function() {\n      return updateSet(this, this._map.clear());\n    };\n\n    // @pragma Composition\n\n    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);\n      iters = iters.filter(function(x ) {return x.size !== 0});\n      if (iters.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n        return this.constructor(iters[0]);\n      }\n      return this.withMutations(function(set ) {\n        for (var ii = 0; ii < iters.length; ii++) {\n          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});\n        }\n      });\n    };\n\n    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (!iters.every(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (iters.some(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.merge = function() {\n      return this.union.apply(this, arguments);\n    };\n\n    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return this.union.apply(this, iters);\n    };\n\n    Set.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator));\n    };\n\n    Set.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator, mapper));\n    };\n\n    Set.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);\n    };\n\n    Set.prototype.__iterator = function(type, reverse) {\n      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);\n    };\n\n    Set.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return this.__make(newMap, ownerID);\n    };\n\n\n  function isSet(maybeSet) {\n    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);\n  }\n\n  Set.isSet = isSet;\n\n  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';\n\n  var SetPrototype = Set.prototype;\n  SetPrototype[IS_SET_SENTINEL] = true;\n  SetPrototype[DELETE] = SetPrototype.remove;\n  SetPrototype.mergeDeep = SetPrototype.merge;\n  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;\n  SetPrototype.withMutations = MapPrototype.withMutations;\n  SetPrototype.asMutable = MapPrototype.asMutable;\n  SetPrototype.asImmutable = MapPrototype.asImmutable;\n\n  SetPrototype.__empty = emptySet;\n  SetPrototype.__make = makeSet;\n\n  function updateSet(set, newMap) {\n    if (set.__ownerID) {\n      set.size = newMap.size;\n      set._map = newMap;\n      return set;\n    }\n    return newMap === set._map ? set :\n      newMap.size === 0 ? set.__empty() :\n      set.__make(newMap);\n  }\n\n  function makeSet(map, ownerID) {\n    var set = Object.create(SetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_SET;\n  function emptySet() {\n    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n  }\n\n  createClass(OrderedSet, Set);\n\n    // @pragma Construction\n\n    function OrderedSet(value) {\n      return value === null || value === undefined ? emptyOrderedSet() :\n        isOrderedSet(value) ? value :\n        emptyOrderedSet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    OrderedSet.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedSet.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    OrderedSet.prototype.toString = function() {\n      return this.__toString('OrderedSet {', '}');\n    };\n\n\n  function isOrderedSet(maybeOrderedSet) {\n    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n  }\n\n  OrderedSet.isOrderedSet = isOrderedSet;\n\n  var OrderedSetPrototype = OrderedSet.prototype;\n  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;\n\n  OrderedSetPrototype.__empty = emptyOrderedSet;\n  OrderedSetPrototype.__make = makeOrderedSet;\n\n  function makeOrderedSet(map, ownerID) {\n    var set = Object.create(OrderedSetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_ORDERED_SET;\n  function emptyOrderedSet() {\n    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));\n  }\n\n  createClass(Stack, IndexedCollection);\n\n    // @pragma Construction\n\n    function Stack(value) {\n      return value === null || value === undefined ? emptyStack() :\n        isStack(value) ? value :\n        emptyStack().unshiftAll(value);\n    }\n\n    Stack.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Stack.prototype.toString = function() {\n      return this.__toString('Stack [', ']');\n    };\n\n    // @pragma Access\n\n    Stack.prototype.get = function(index, notSetValue) {\n      var head = this._head;\n      index = wrapIndex(this, index);\n      while (head && index--) {\n        head = head.next;\n      }\n      return head ? head.value : notSetValue;\n    };\n\n    Stack.prototype.peek = function() {\n      return this._head && this._head.value;\n    };\n\n    // @pragma Modification\n\n    Stack.prototype.push = function(/*...values*/) {\n      if (arguments.length === 0) {\n        return this;\n      }\n      var newSize = this.size + arguments.length;\n      var head = this._head;\n      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n        head = {\n          value: arguments[ii],\n          next: head\n        };\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pushAll = function(iter) {\n      iter = IndexedIterable(iter);\n      if (iter.size === 0) {\n        return this;\n      }\n      assertNotInfinite(iter.size);\n      var newSize = this.size;\n      var head = this._head;\n      iter.reverse().forEach(function(value ) {\n        newSize++;\n        head = {\n          value: value,\n          next: head\n        };\n      });\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pop = function() {\n      return this.slice(1);\n    };\n\n    Stack.prototype.unshift = function(/*...values*/) {\n      return this.push.apply(this, arguments);\n    };\n\n    Stack.prototype.unshiftAll = function(iter) {\n      return this.pushAll(iter);\n    };\n\n    Stack.prototype.shift = function() {\n      return this.pop.apply(this, arguments);\n    };\n\n    Stack.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._head = undefined;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyStack();\n    };\n\n    Stack.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      var resolvedBegin = resolveBegin(begin, this.size);\n      var resolvedEnd = resolveEnd(end, this.size);\n      if (resolvedEnd !== this.size) {\n        // super.slice(begin, end);\n        return IndexedCollection.prototype.slice.call(this, begin, end);\n      }\n      var newSize = this.size - resolvedBegin;\n      var head = this._head;\n      while (resolvedBegin--) {\n        head = head.next;\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    // @pragma Mutability\n\n    Stack.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeStack(this.size, this._head, ownerID, this.__hash);\n    };\n\n    // @pragma Iteration\n\n    Stack.prototype.__iterate = function(fn, reverse) {\n      if (reverse) {\n        return this.reverse().__iterate(fn);\n      }\n      var iterations = 0;\n      var node = this._head;\n      while (node) {\n        if (fn(node.value, iterations++, this) === false) {\n          break;\n        }\n        node = node.next;\n      }\n      return iterations;\n    };\n\n    Stack.prototype.__iterator = function(type, reverse) {\n      if (reverse) {\n        return this.reverse().__iterator(type);\n      }\n      var iterations = 0;\n      var node = this._head;\n      return new Iterator(function()  {\n        if (node) {\n          var value = node.value;\n          node = node.next;\n          return iteratorValue(type, iterations++, value);\n        }\n        return iteratorDone();\n      });\n    };\n\n\n  function isStack(maybeStack) {\n    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);\n  }\n\n  Stack.isStack = isStack;\n\n  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';\n\n  var StackPrototype = Stack.prototype;\n  StackPrototype[IS_STACK_SENTINEL] = true;\n  StackPrototype.withMutations = MapPrototype.withMutations;\n  StackPrototype.asMutable = MapPrototype.asMutable;\n  StackPrototype.asImmutable = MapPrototype.asImmutable;\n  StackPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n  function makeStack(size, head, ownerID, hash) {\n    var map = Object.create(StackPrototype);\n    map.size = size;\n    map._head = head;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_STACK;\n  function emptyStack() {\n    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n  }\n\n  /**\n   * Contributes additional methods to a constructor\n   */\n  function mixin(ctor, methods) {\n    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };\n    Object.keys(methods).forEach(keyCopier);\n    Object.getOwnPropertySymbols &&\n      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n    return ctor;\n  }\n\n  Iterable.Iterator = Iterator;\n\n  mixin(Iterable, {\n\n    // ### Conversion to other types\n\n    toArray: function() {\n      assertNotInfinite(this.size);\n      var array = new Array(this.size || 0);\n      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });\n      return array;\n    },\n\n    toIndexedSeq: function() {\n      return new ToIndexedSequence(this);\n    },\n\n    toJS: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}\n      ).__toJS();\n    },\n\n    toJSON: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}\n      ).__toJS();\n    },\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, true);\n    },\n\n    toMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Map(this.toKeyedSeq());\n    },\n\n    toObject: function() {\n      assertNotInfinite(this.size);\n      var object = {};\n      this.__iterate(function(v, k)  { object[k] = v; });\n      return object;\n    },\n\n    toOrderedMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedMap(this.toKeyedSeq());\n    },\n\n    toOrderedSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Set(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSetSeq: function() {\n      return new ToSetSequence(this);\n    },\n\n    toSeq: function() {\n      return isIndexed(this) ? this.toIndexedSeq() :\n        isKeyed(this) ? this.toKeyedSeq() :\n        this.toSetSeq();\n    },\n\n    toStack: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Stack(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toList: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return List(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n\n    // ### Common JavaScript methods and properties\n\n    toString: function() {\n      return '[Iterable]';\n    },\n\n    __toString: function(head, tail) {\n      if (this.size === 0) {\n        return head + tail;\n      }\n      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    concat: function() {var values = SLICE$0.call(arguments, 0);\n      return reify(this, concatFactory(this, values));\n    },\n\n    includes: function(searchValue) {\n      return this.some(function(value ) {return is(value, searchValue)});\n    },\n\n    entries: function() {\n      return this.__iterator(ITERATE_ENTRIES);\n    },\n\n    every: function(predicate, context) {\n      assertNotInfinite(this.size);\n      var returnValue = true;\n      this.__iterate(function(v, k, c)  {\n        if (!predicate.call(context, v, k, c)) {\n          returnValue = false;\n          return false;\n        }\n      });\n      return returnValue;\n    },\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, true));\n    },\n\n    find: function(predicate, context, notSetValue) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[1] : notSetValue;\n    },\n\n    forEach: function(sideEffect, context) {\n      assertNotInfinite(this.size);\n      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n    },\n\n    join: function(separator) {\n      assertNotInfinite(this.size);\n      separator = separator !== undefined ? '' + separator : ',';\n      var joined = '';\n      var isFirst = true;\n      this.__iterate(function(v ) {\n        isFirst ? (isFirst = false) : (joined += separator);\n        joined += v !== null && v !== undefined ? v.toString() : '';\n      });\n      return joined;\n    },\n\n    keys: function() {\n      return this.__iterator(ITERATE_KEYS);\n    },\n\n    map: function(mapper, context) {\n      return reify(this, mapFactory(this, mapper, context));\n    },\n\n    reduce: function(reducer, initialReduction, context) {\n      assertNotInfinite(this.size);\n      var reduction;\n      var useFirst;\n      if (arguments.length < 2) {\n        useFirst = true;\n      } else {\n        reduction = initialReduction;\n      }\n      this.__iterate(function(v, k, c)  {\n        if (useFirst) {\n          useFirst = false;\n          reduction = v;\n        } else {\n          reduction = reducer.call(context, reduction, v, k, c);\n        }\n      });\n      return reduction;\n    },\n\n    reduceRight: function(reducer, initialReduction, context) {\n      var reversed = this.toKeyedSeq().reverse();\n      return reversed.reduce.apply(reversed, arguments);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, true));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, true));\n    },\n\n    some: function(predicate, context) {\n      return !this.every(not(predicate), context);\n    },\n\n    sort: function(comparator) {\n      return reify(this, sortFactory(this, comparator));\n    },\n\n    values: function() {\n      return this.__iterator(ITERATE_VALUES);\n    },\n\n\n    // ### More sequential methods\n\n    butLast: function() {\n      return this.slice(0, -1);\n    },\n\n    isEmpty: function() {\n      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});\n    },\n\n    count: function(predicate, context) {\n      return ensureSize(\n        predicate ? this.toSeq().filter(predicate, context) : this\n      );\n    },\n\n    countBy: function(grouper, context) {\n      return countByFactory(this, grouper, context);\n    },\n\n    equals: function(other) {\n      return deepEqual(this, other);\n    },\n\n    entrySeq: function() {\n      var iterable = this;\n      if (iterable._cache) {\n        // We cache as an entries array, so we can just return the cache!\n        return new ArraySeq(iterable._cache);\n      }\n      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();\n      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};\n      return entriesSequence;\n    },\n\n    filterNot: function(predicate, context) {\n      return this.filter(not(predicate), context);\n    },\n\n    findEntry: function(predicate, context, notSetValue) {\n      var found = notSetValue;\n      this.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          found = [k, v];\n          return false;\n        }\n      });\n      return found;\n    },\n\n    findKey: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLast: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n    },\n\n    findLastEntry: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().findEntry(predicate, context, notSetValue);\n    },\n\n    findLastKey: function(predicate, context) {\n      return this.toKeyedSeq().reverse().findKey(predicate, context);\n    },\n\n    first: function() {\n      return this.find(returnTrue);\n    },\n\n    flatMap: function(mapper, context) {\n      return reify(this, flatMapFactory(this, mapper, context));\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, true));\n    },\n\n    fromEntrySeq: function() {\n      return new FromEntriesSequence(this);\n    },\n\n    get: function(searchKey, notSetValue) {\n      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);\n    },\n\n    getIn: function(searchKeyPath, notSetValue) {\n      var nested = this;\n      // Note: in an ES6 environment, we would prefer:\n      // for (var key of searchKeyPath) {\n      var iter = forceIterator(searchKeyPath);\n      var step;\n      while (!(step = iter.next()).done) {\n        var key = step.value;\n        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;\n        if (nested === NOT_SET) {\n          return notSetValue;\n        }\n      }\n      return nested;\n    },\n\n    groupBy: function(grouper, context) {\n      return groupByFactory(this, grouper, context);\n    },\n\n    has: function(searchKey) {\n      return this.get(searchKey, NOT_SET) !== NOT_SET;\n    },\n\n    hasIn: function(searchKeyPath) {\n      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;\n    },\n\n    isSubset: function(iter) {\n      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);\n      return this.every(function(value ) {return iter.includes(value)});\n    },\n\n    isSuperset: function(iter) {\n      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);\n      return iter.isSubset(this);\n    },\n\n    keyOf: function(searchValue) {\n      return this.findKey(function(value ) {return is(value, searchValue)});\n    },\n\n    keySeq: function() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function() {\n      return this.toSeq().reverse().first();\n    },\n\n    lastKeyOf: function(searchValue) {\n      return this.toKeyedSeq().reverse().keyOf(searchValue);\n    },\n\n    max: function(comparator) {\n      return maxFactory(this, comparator);\n    },\n\n    maxBy: function(mapper, comparator) {\n      return maxFactory(this, comparator, mapper);\n    },\n\n    min: function(comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);\n    },\n\n    minBy: function(mapper, comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);\n    },\n\n    rest: function() {\n      return this.slice(1);\n    },\n\n    skip: function(amount) {\n      return this.slice(Math.max(0, amount));\n    },\n\n    skipLast: function(amount) {\n      return reify(this, this.toSeq().reverse().skip(amount).reverse());\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, true));\n    },\n\n    skipUntil: function(predicate, context) {\n      return this.skipWhile(not(predicate), context);\n    },\n\n    sortBy: function(mapper, comparator) {\n      return reify(this, sortFactory(this, comparator, mapper));\n    },\n\n    take: function(amount) {\n      return this.slice(0, Math.max(0, amount));\n    },\n\n    takeLast: function(amount) {\n      return reify(this, this.toSeq().reverse().take(amount).reverse());\n    },\n\n    takeWhile: function(predicate, context) {\n      return reify(this, takeWhileFactory(this, predicate, context));\n    },\n\n    takeUntil: function(predicate, context) {\n      return this.takeWhile(not(predicate), context);\n    },\n\n    valueSeq: function() {\n      return this.toIndexedSeq();\n    },\n\n\n    // ### Hashable Object\n\n    hashCode: function() {\n      return this.__hash || (this.__hash = hashIterable(this));\n    }\n\n\n    // ### Internal\n\n    // abstract __iterate(fn, reverse)\n\n    // abstract __iterator(type, reverse)\n  });\n\n  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  var IterablePrototype = Iterable.prototype;\n  IterablePrototype[IS_ITERABLE_SENTINEL] = true;\n  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;\n  IterablePrototype.__toJS = IterablePrototype.toArray;\n  IterablePrototype.__toStringMapper = quoteString;\n  IterablePrototype.inspect =\n  IterablePrototype.toSource = function() { return this.toString(); };\n  IterablePrototype.chain = IterablePrototype.flatMap;\n  IterablePrototype.contains = IterablePrototype.includes;\n\n  mixin(KeyedIterable, {\n\n    // ### More sequential methods\n\n    flip: function() {\n      return reify(this, flipFactory(this));\n    },\n\n    mapEntries: function(mapper, context) {var this$0 = this;\n      var iterations = 0;\n      return reify(this,\n        this.toSeq().map(\n          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}\n        ).fromEntrySeq()\n      );\n    },\n\n    mapKeys: function(mapper, context) {var this$0 = this;\n      return reify(this,\n        this.toSeq().flip().map(\n          function(k, v)  {return mapper.call(context, k, v, this$0)}\n        ).flip()\n      );\n    }\n\n  });\n\n  var KeyedIterablePrototype = KeyedIterable.prototype;\n  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;\n  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;\n  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;\n  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};\n\n\n\n  mixin(IndexedIterable, {\n\n    // ### Conversion to other types\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, false);\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, false));\n    },\n\n    findIndex: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    indexOf: function(searchValue) {\n      var key = this.keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function(searchValue) {\n      var key = this.lastKeyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, false));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, false));\n    },\n\n    splice: function(index, removeNum /*, ...values*/) {\n      var numArgs = arguments.length;\n      removeNum = Math.max(removeNum | 0, 0);\n      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n        return this;\n      }\n      // If index is negative, it should resolve relative to the size of the\n      // collection. However size may be expensive to compute if not cached, so\n      // only call count() if the number is in fact negative.\n      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n      var spliced = this.slice(0, index);\n      return reify(\n        this,\n        numArgs === 1 ?\n          spliced :\n          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n      );\n    },\n\n\n    // ### More collection methods\n\n    findLastIndex: function(predicate, context) {\n      var entry = this.findLastEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    first: function() {\n      return this.get(0);\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, false));\n    },\n\n    get: function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      return (index < 0 || (this.size === Infinity ||\n          (this.size !== undefined && index > this.size))) ?\n        notSetValue :\n        this.find(function(_, key)  {return key === index}, undefined, notSetValue);\n    },\n\n    has: function(index) {\n      index = wrapIndex(this, index);\n      return index >= 0 && (this.size !== undefined ?\n        this.size === Infinity || index < this.size :\n        this.indexOf(index) !== -1\n      );\n    },\n\n    interpose: function(separator) {\n      return reify(this, interposeFactory(this, separator));\n    },\n\n    interleave: function(/*...iterables*/) {\n      var iterables = [this].concat(arrCopy(arguments));\n      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);\n      var interleaved = zipped.flatten(true);\n      if (zipped.size) {\n        interleaved.size = zipped.size * iterables.length;\n      }\n      return reify(this, interleaved);\n    },\n\n    keySeq: function() {\n      return Range(0, this.size);\n    },\n\n    last: function() {\n      return this.get(-1);\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, false));\n    },\n\n    zip: function(/*, ...iterables */) {\n      var iterables = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, iterables));\n    },\n\n    zipWith: function(zipper/*, ...iterables */) {\n      var iterables = arrCopy(arguments);\n      iterables[0] = this;\n      return reify(this, zipWithFactory(this, zipper, iterables));\n    }\n\n  });\n\n  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;\n  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n\n  mixin(SetIterable, {\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    get: function(value, notSetValue) {\n      return this.has(value) ? value : notSetValue;\n    },\n\n    includes: function(value) {\n      return this.has(value);\n    },\n\n\n    // ### More sequential methods\n\n    keySeq: function() {\n      return this.valueSeq();\n    }\n\n  });\n\n  SetIterable.prototype.has = IterablePrototype.includes;\n  SetIterable.prototype.contains = SetIterable.prototype.includes;\n\n\n  // Mixin subclasses\n\n  mixin(KeyedSeq, KeyedIterable.prototype);\n  mixin(IndexedSeq, IndexedIterable.prototype);\n  mixin(SetSeq, SetIterable.prototype);\n\n  mixin(KeyedCollection, KeyedIterable.prototype);\n  mixin(IndexedCollection, IndexedIterable.prototype);\n  mixin(SetCollection, SetIterable.prototype);\n\n\n  // #pragma Helper functions\n\n  function keyMapper(v, k) {\n    return k;\n  }\n\n  function entryMapper(v, k) {\n    return [k, v];\n  }\n\n  function not(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    }\n  }\n\n  function neg(predicate) {\n    return function() {\n      return -predicate.apply(this, arguments);\n    }\n  }\n\n  function quoteString(value) {\n    return typeof value === 'string' ? JSON.stringify(value) : String(value);\n  }\n\n  function defaultZipper() {\n    return arrCopy(arguments);\n  }\n\n  function defaultNegComparator(a, b) {\n    return a < b ? 1 : a > b ? -1 : 0;\n  }\n\n  function hashIterable(iterable) {\n    if (iterable.size === Infinity) {\n      return 0;\n    }\n    var ordered = isOrdered(iterable);\n    var keyed = isKeyed(iterable);\n    var h = ordered ? 1 : 0;\n    var size = iterable.__iterate(\n      keyed ?\n        ordered ?\n          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :\n          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :\n        ordered ?\n          function(v ) { h = 31 * h + hash(v) | 0; } :\n          function(v ) { h = h + hash(v) | 0; }\n    );\n    return murmurHashOfSize(size, h);\n  }\n\n  function murmurHashOfSize(size, h) {\n    h = imul(h, 0xCC9E2D51);\n    h = imul(h << 15 | h >>> -15, 0x1B873593);\n    h = imul(h << 13 | h >>> -13, 5);\n    h = (h + 0xE6546B64 | 0) ^ size;\n    h = imul(h ^ h >>> 16, 0x85EBCA6B);\n    h = imul(h ^ h >>> 13, 0xC2B2AE35);\n    h = smi(h ^ h >>> 16);\n    return h;\n  }\n\n  function hashMerge(a, b) {\n    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int\n  }\n\n  var Immutable = {\n\n    Iterable: Iterable,\n\n    Seq: Seq,\n    Collection: Collection,\n    Map: Map,\n    OrderedMap: OrderedMap,\n    List: List,\n    Stack: Stack,\n    Set: Set,\n    OrderedSet: OrderedSet,\n\n    Record: Record,\n    Range: Range,\n    Repeat: Repeat,\n\n    is: is,\n    fromJS: fromJS\n\n  };\n\n  return Immutable;\n\n}));"],"sourceRoot":""}