nuclear.min.js.map

{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///dist/nuclear.min.js","webpack:///webpack/bootstrap 5101807446b00161d85d","webpack:///./src/main.js","webpack:///./src/console-polyfill.js","webpack:///./src/store.js","webpack:///./~/immutable/dist/immutable.js","webpack:///./src/utils.js","webpack:///./src/immutable-helpers.js","webpack:///./src/reactor.js","webpack:///./src/create-react-mixin.js","webpack:///./src/reactor/fns.js","webpack:///./src/reactor/cache.js","webpack:///./src/getter.js","webpack:///./src/key-path.js","webpack:///./src/logging.js","webpack:///./src/reactor/records.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","_interopRequireDefault","obj","__esModule","default","Object","defineProperty","value","_store","_store2","_reactor","_reactor2","_immutable","_immutable2","_immutableHelpers","_keyPath","_getter","_reactorCache","_createReactMixin","_createReactMixin2","Reactor","Store","Immutable","isKeyPath","isGetter","toJS","toImmutable","isImmutable","createReactMixin","LRUCache","window","console","log","debug","info","warn","error","e","_classCallCheck","instance","Constructor","TypeError","isStore","toTest","_createClass","defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","key","protoProps","staticProps","prototype","_utils","config","__handlers","Map","extend","initialize","state","type","payload","handler","get","getInitialState","actionType","set","toFactory","global","createClass","ctor","superClass","create","constructor","Iterable","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","MakeRef","ref","SetRef","OwnerID","arrCopy","arr","offset","len","Math","max","newArr","Array","ii","ensureSize","iter","undefined","size","__iterate","returnTrue","wrapIndex","index","uint32Index","NaN","wholeSlice","begin","end","resolveBegin","resolveIndex","resolveEnd","defaultIndex","min","Iterator","next","iteratorValue","k","v","iteratorResult","done","iteratorDone","hasIterator","getIteratorFn","isIterator","maybeIterator","getIterator","iterable","iteratorFn","REAL_ITERATOR_SYMBOL","FAUX_ITERATOR_SYMBOL","isArrayLike","emptySequence","toSeq","seqFromValue","toKeyedSeq","fromEntrySeq","keyedSeqFromValue","entrySeq","toIndexedSeq","indexedSeqFromValue","toSetSeq","ArraySeq","array","_array","ObjectSeq","object","keys","_object","_keys","IterableSeq","_iterable","IteratorSeq","iterator","_iterator","_iteratorCache","isSeq","maybeSeq","IS_SEQ_SENTINEL","EMPTY_SEQ","seq","isArray","maybeIndexedSeqFromValue","seqIterate","fn","reverse","useKeys","cache","_cache","maxIndex","entry","__iterateUncached","seqIterator","__iteratorUncached","fromJS","json","converter","fromJSWith","","fromJSDefault","parentJSON","map","isPlainObj","toList","toMap","is","valueA","valueB","valueOf","equals","deepEqual","a","b","__hash","notAssociative","entries","every","flipped","cacheResult","_","allEqual","bSize","has","NOT_SET","Repeat","times","_value","Infinity","EMPTY_REPEAT","invariant","condition","Error","Range","start","step","abs","_start","_end","_step","ceil","EMPTY_RANGE","Collection","KeyedCollection","IndexedCollection","SetCollection","smi","i32","hash","o","h","STRING_HASH_CACHE_MIN_STRLEN","cachedHashString","hashString","hashCode","hashJSObj","toString","string","stringHashCache","STRING_HASH_CACHE_SIZE","STRING_HASH_CACHE_MAX_SIZE","charCodeAt","usingWeakMap","weakMap","UID_HASH_KEY","canDefineProperty","propertyIsEnumerable","getIENodeHash","objHashUID","isExtensible","apply","arguments","nodeType","node","uniqueID","documentElement","assertNotInfinite","emptyMap","isMap","withMutations","forEach","maybeMap","IS_MAP_SENTINEL","ArrayMapNode","ownerID","BitmapIndexedNode","bitmap","nodes","HashArrayMapNode","count","HashCollisionNode","keyHash","ValueNode","MapIterator","_type","_reverse","_stack","_root","mapIteratorFrame","mapIteratorValue","prev","__prev","makeMap","MapPrototype","__ownerID","__altered","EMPTY_MAP","updateMap","newRoot","newSize","didChangeSize","CHANGE_LENGTH","didAlter","DID_ALTER","updateNode","shift","update","isLeafNode","mergeIntoNode","newNode","idx1","MASK","idx2","SHIFT","createNodes","packNodes","excluding","packedII","packedNodes","bit","expandNodes","including","expandedNodes","SIZE","mergeIntoMapWith","merger","iterables","iters","push","mergeIntoCollectionWith","deepMerger","existing","mergeDeep","deepMergerWith","mergeDeepWith","nextValue","collection","filter","x","mergeIntoMap","updateInDeepMap","keyPathIter","notSetValue","updater","isNotSet","existingValue","newValue","nextExisting","nextUpdated","remove","popCount","setIn","idx","val","canEdit","newArray","spliceIn","newLen","after","spliceOut","pop","List","empty","emptyList","isList","makeList","VNode","toArray","list","setSize","maybeList","IS_LIST_SENTINEL","iterateList","iterateNodeOrLeaf","level","iterateLeaf","iterateNode","tailPos","tail","from","left","to","right","DONE","values","_origin","_capacity","getTailOffset","_tail","_level","origin","capacity","ListPrototype","EMPTY_LIST","updateList","setListBounds","newTail","updateVNode","nodeHas","lowerNode","newLowerNode","editableVNode","slice","listNodeFor","rawIndex","owner","oldOrigin","oldCapacity","newOrigin","newCapacity","clear","newLevel","offsetShift","oldTailOffset","newTailOffset","oldTail","removeAfter","removeBefore","beginIndex","mergeIntoListWith","maxSize","OrderedMap","emptyOrderedMap","isOrderedMap","maybeOrderedMap","makeOrderedMap","omap","_map","_list","EMPTY_ORDERED_MAP","updateOrderedMap","newMap","newList","flip","ToKeyedSequence","indexed","_iter","_useKeys","ToIndexedSequence","ToSetSequence","FromEntriesSequence","flipFactory","flipSequence","makeSequence","reversedSequence","includes","cacheResultThrough","this$0","ITERATE_ENTRIES","__iterator","ITERATE_VALUES","ITERATE_KEYS","mapFactory","mapper","context","mappedSequence","reverseFactory","filterFactory","predicate","filterSequence","iterations","countByFactory","grouper","groups","asMutable","asImmutable","groupByFactory","isKeyedIter","coerce","iterableClass","reify","sliceFactory","originalSize","resolvedBegin","resolvedEnd","sliceSize","resolvedSize","sliceSeq","skipped","isSkipping","takeWhileFactory","takeSequence","iterating","skipWhileFactory","skipSequence","skipping","concatFactory","isKeyedIterable","concat","singleton","concatSeq","flatten","reduce","sum","flattenFactory","depth","flatSequence","flatDeep","currentDepth","stopped","stack","flatMapFactory","interposeFactory","separator","interposedSequence","sortFactory","comparator","defaultComparator","sort","maxFactory","maxCompare","comp","zipWithFactory","keyIter","zipper","zipSequence","iterators","isDone","steps","some","s","validateEntry","resolveSize","forceIterator","keyPath","Record","defaultValues","name","hasInitialized","RecordType","setProps","RecordTypePrototype","_name","_defaultValues","RecordPrototype","makeRecord","likeRecord","record","getPrototypeOf","recordName","names","setProp","bind","Set","emptySet","isSet","add","maybeSet","IS_SET_SENTINEL","updateSet","__empty","__make","makeSet","SetPrototype","EMPTY_SET","OrderedSet","emptyOrderedSet","isOrderedSet","maybeOrderedSet","makeOrderedSet","OrderedSetPrototype","EMPTY_ORDERED_SET","Stack","emptyStack","isStack","unshiftAll","maybeStack","IS_STACK_SENTINEL","makeStack","head","StackPrototype","_head","EMPTY_STACK","mixin","methods","keyCopier","getOwnPropertySymbols","keyMapper","entryMapper","not","neg","quoteString","JSON","stringify","String","defaultZipper","defaultNegComparator","hashIterable","ordered","keyed","hashMerge","murmurHashOfSize","imul","SLICE$0","Keyed","Indexed","DELETE","Symbol","ITERATOR_SYMBOL","KEYS","VALUES","ENTRIES","inspect","toSource","of","__toString","hasOwnProperty","searchValue","indexOf","lastIndexOf","other","possibleIndex","floor","offsetValue","d","WeakMap","keyValues","updateIn","deleteIn","updatedValue","merge","mergeWith","mergeIn","mergeDeepIn","sortBy","mutable","wasAltered","__ensureOwner","iterate","removeIn","removed","exists","MAX_ARRAY_MAP_SIZE","isEditable","newEntries","keyHashFrag","MAX_BITMAP_INDEXED_SIZE","newBitmap","newNodes","newCount","MIN_HASH_ARRAY_MAP_SIZE","keyMatch","subNode","splice","insert","oldSize","unshift","originIndex","newChild","removingFirst","oldChild","editable","sizeIndex","valueSeq","indexedIterable","defaultVal","_empty","fromKeys","keySeq","union","intersect","originalSet","subtract","peek","pushAll","__toJS","toJSON","toObject","toOrderedMap","toOrderedSet","toSet","toStack","__toStringMapper","join","returnValue","find","findEntry","sideEffect","joined","isFirst","reducer","initialReduction","reduction","useFirst","reduceRight","reversed","butLast","isEmpty","countBy","entriesSequence","filterNot","found","findKey","findLast","findLastEntry","findLastKey","first","flatMap","searchKey","getIn","searchKeyPath","nested","groupBy","hasIn","isSubset","isSuperset","keyOf","last","lastKeyOf","maxBy","minBy","rest","skip","amount","skipLast","skipWhile","skipUntil","take","takeLast","takeWhile","takeUntil","IterablePrototype","chain","contains","mapEntries","mapKeys","KeyedIterablePrototype","findIndex","removeNum","numArgs","spliced","findLastIndex","interpose","interleave","zipped","interleaved","zip","zipWith","objectToString","isLength","Number","MAX_VALUE","_bind","Function","isString","Int8Array","isFunction","isObject","source","l","clone","each","iteratee","origIteratee","innerCollection","partial","func","partialArgs","Klass","Factory","_len","args","_key","__proto__","isImmutableValue","arg","_interopRequireWildcard","newObj","_defineProperty","_reactorFns","fns","_logging","_reactorRecords","baseOptions","DEBUG_OPTIONS","PROD_OPTIONS","logger","NoopLogger","ConsoleGroupLogger","initialReactorState","ReactorState","DefaultCache","options","prevReactorState","reactorState","observerState","ObserverState","ReactMixin","__batchDepth","__isDispatching","keyPathOrGetter","_fns$evaluate","evaluate","result","getter","_this","_fns$addObserver","addObserver","removeObserverByEntry","removeObserver","getOption","dispatch","__notify","batchStart","batchEnd","store","registerStores","stores","replaceStores","serialize","loadState","newState","reset","_this2","dirtyStores","observerIdsToNotify","observerId","prevEvaluateResult","currEvaluateResult","prevValue","currValue","nextReactorState","resetDirtyStores","getState","reactor","data","getDataBindings","componentDidMount","__unwatchFns","unwatchFn","observe","setState","componentWillUnmount","evaluateResult","EvaluateResult","initialState","storeStates","incrementStoreStates","incrementId","logging","currState","nextState","dispatchStart","handle","dispatchError","message","errorMsg","dispatchEnd","stateToLoad","serializedStoreState","storeId","storeState","deserialize","dirtyStoresSet","getterKey","fromKeyPath","currId","storeDeps","getStoreDeps","updatedObserverState","observerIds","path","option","entriesToRemove","entryGetter","handlersMatch","isEqual","anyObsevers","observers","prevState","storeMap","storeIds","resetStoreState","handleReset","cacheEntry","lookup","isCacheMiss","isDirtyCacheEntry","createCacheEntry","miss","hit","serialized","serializedState","stateId","getDeps","dep","getComputeFn","CacheEntry","dispatchId","nextId","BasicCache","item","notFoundValue","existingEntry","DEFAULT_LRU_LIMIT","DEFAULT_LRU_EVICT_COUNT","limit","evictCount","lru","asMap","lruCache","evictItem","evict","getFlattenedDeps","toAdd","identity","__storeDeps","iA","iB","group","groupCollapsed","groupEnd","previousState","logDispatches","logAppState","logDirtyStores","throwOnUndefinedActionType","throwOnUndefinedStoreReturnValue","throwOnNonImmutableStore","throwOnDispatchInDispatch","any","observersMap"],"mappings":"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","file":"./dist/nuclear.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Nuclear\"] = factory();\n\telse\n\t\troot[\"Nuclear\"] = factory();\n})(this, function() {\nreturn \n\n\n/** WEBPACK FOOTER **\n ** webpack/universalModuleDefinition\n **/","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Nuclear\"] = factory();\n\telse\n\t\troot[\"Nuclear\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/*!*********************!*\\\n  !*** ./src/main.js ***!\n  \\*********************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\t__webpack_require__(/*! ./console-polyfill */ 1);\n\t\n\tvar _store = __webpack_require__(/*! ./store */ 2);\n\t\n\tvar _store2 = _interopRequireDefault(_store);\n\t\n\tvar _reactor = __webpack_require__(/*! ./reactor */ 6);\n\t\n\tvar _reactor2 = _interopRequireDefault(_reactor);\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _immutable2 = _interopRequireDefault(_immutable);\n\t\n\tvar _immutableHelpers = __webpack_require__(/*! ./immutable-helpers */ 5);\n\t\n\tvar _keyPath = __webpack_require__(/*! ./key-path */ 11);\n\t\n\tvar _getter = __webpack_require__(/*! ./getter */ 10);\n\t\n\tvar _reactorCache = __webpack_require__(/*! ./reactor/cache */ 9);\n\t\n\tvar _createReactMixin = __webpack_require__(/*! ./create-react-mixin */ 7);\n\t\n\tvar _createReactMixin2 = _interopRequireDefault(_createReactMixin);\n\t\n\texports['default'] = {\n\t  Reactor: _reactor2['default'],\n\t  Store: _store2['default'],\n\t  Immutable: _immutable2['default'],\n\t  isKeyPath: _keyPath.isKeyPath,\n\t  isGetter: _getter.isGetter,\n\t  toJS: _immutableHelpers.toJS,\n\t  toImmutable: _immutableHelpers.toImmutable,\n\t  isImmutable: _immutableHelpers.isImmutable,\n\t  createReactMixin: _createReactMixin2['default'],\n\t  LRUCache: _reactorCache.LRUCache\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 1 */\n/*!*********************************!*\\\n  !*** ./src/console-polyfill.js ***!\n  \\*********************************/\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\ttry {\n\t  /* eslint-disable no-console */\n\t  if (!(window.console && console.log)) {\n\t    /* eslint-enable no-console */\n\t    console = {\n\t      log: function log() {},\n\t      debug: function debug() {},\n\t      info: function info() {},\n\t      warn: function warn() {},\n\t      error: function error() {}\n\t    };\n\t  }\n\t} catch (e) {\n\t  // ignored\n\t}\n\n/***/ },\n/* 2 */\n/*!**********************!*\\\n  !*** ./src/store.js ***!\n  \\**********************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\texports.isStore = isStore;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _utils = __webpack_require__(/*! ./utils */ 4);\n\t\n\tvar _immutableHelpers = __webpack_require__(/*! ./immutable-helpers */ 5);\n\t\n\t/**\n\t * Stores define how a certain domain of the application should respond to actions\n\t * taken on the whole system.  They manage their own section of the entire app state\n\t * and have no knowledge about the other parts of the application state.\n\t */\n\t\n\tvar Store = (function () {\n\t  function Store(config) {\n\t    _classCallCheck(this, Store);\n\t\n\t    this.__handlers = (0, _immutable.Map)({});\n\t\n\t    if (config) {\n\t      // allow `MyStore extends Store` syntax without throwing error\n\t      (0, _utils.extend)(this, config);\n\t    }\n\t\n\t    this.initialize();\n\t  }\n\t\n\t  /**\n\t   * This method is overridden by extending classes to setup message handlers\n\t   * via `this.on` and to set up the initial state\n\t   *\n\t   * Anything returned from this function will be coerced into an ImmutableJS value\n\t   * and set as the initial state for the part of the ReactorCore\n\t   */\n\t\n\t  _createClass(Store, [{\n\t    key: 'initialize',\n\t    value: function initialize() {}\n\t    // extending classes implement to setup action handlers\n\t\n\t    /**\n\t     * Overridable method to get the initial state for this type of store\n\t     */\n\t\n\t  }, {\n\t    key: 'getInitialState',\n\t    value: function getInitialState() {\n\t      return (0, _immutable.Map)();\n\t    }\n\t\n\t    /**\n\t     * Takes a current reactor state, action type and payload\n\t     * does the reaction and returns the new state\n\t     */\n\t  }, {\n\t    key: 'handle',\n\t    value: function handle(state, type, payload) {\n\t      var handler = this.__handlers.get(type);\n\t\n\t      if (typeof handler === 'function') {\n\t        return handler.call(this, state, payload, type);\n\t      }\n\t\n\t      return state;\n\t    }\n\t\n\t    /**\n\t     * Pure function taking the current state of store and returning\n\t     * the new state after a NuclearJS reactor has been reset\n\t     *\n\t     * Overridable\n\t     */\n\t  }, {\n\t    key: 'handleReset',\n\t    value: function handleReset(state) {\n\t      return this.getInitialState();\n\t    }\n\t\n\t    /**\n\t     * Binds an action type => handler\n\t     */\n\t  }, {\n\t    key: 'on',\n\t    value: function on(actionType, handler) {\n\t      this.__handlers = this.__handlers.set(actionType, handler);\n\t    }\n\t\n\t    /**\n\t     * Serializes store state to plain JSON serializable JavaScript\n\t     * Overridable\n\t     * @param {*}\n\t     * @return {*}\n\t     */\n\t  }, {\n\t    key: 'serialize',\n\t    value: function serialize(state) {\n\t      return (0, _immutableHelpers.toJS)(state);\n\t    }\n\t\n\t    /**\n\t     * Deserializes plain JavaScript to store state\n\t     * Overridable\n\t     * @param {*}\n\t     * @return {*}\n\t     */\n\t  }, {\n\t    key: 'deserialize',\n\t    value: function deserialize(state) {\n\t      return (0, _immutableHelpers.toImmutable)(state);\n\t    }\n\t  }]);\n\t\n\t  return Store;\n\t})();\n\t\n\tfunction isStore(toTest) {\n\t  return toTest instanceof Store;\n\t}\n\t\n\texports['default'] = (0, _utils.toFactory)(Store);\n\n/***/ },\n/* 3 */\n/*!***************************************!*\\\n  !*** ./~/immutable/dist/immutable.js ***!\n  \\***************************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t/**\n\t *  Copyright (c) 2014-2015, Facebook, Inc.\n\t *  All rights reserved.\n\t *\n\t *  This source code is licensed under the BSD-style license found in the\n\t *  LICENSE file in the root directory of this source tree. An additional grant\n\t *  of patent rights can be found in the PATENTS file in the same directory.\n\t */\n\t\n\t(function (global, factory) {\n\t   true ? module.exports = factory() :\n\t  typeof define === 'function' && define.amd ? define(factory) :\n\t  (global.Immutable = factory());\n\t}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;\n\t\n\t  function createClass(ctor, superClass) {\n\t    if (superClass) {\n\t      ctor.prototype = Object.create(superClass.prototype);\n\t    }\n\t    ctor.prototype.constructor = ctor;\n\t  }\n\t\n\t  function Iterable(value) {\n\t      return isIterable(value) ? value : Seq(value);\n\t    }\n\t\n\t\n\t  createClass(KeyedIterable, Iterable);\n\t    function KeyedIterable(value) {\n\t      return isKeyed(value) ? value : KeyedSeq(value);\n\t    }\n\t\n\t\n\t  createClass(IndexedIterable, Iterable);\n\t    function IndexedIterable(value) {\n\t      return isIndexed(value) ? value : IndexedSeq(value);\n\t    }\n\t\n\t\n\t  createClass(SetIterable, Iterable);\n\t    function SetIterable(value) {\n\t      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);\n\t    }\n\t\n\t\n\t\n\t  function isIterable(maybeIterable) {\n\t    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);\n\t  }\n\t\n\t  function isKeyed(maybeKeyed) {\n\t    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);\n\t  }\n\t\n\t  function isIndexed(maybeIndexed) {\n\t    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);\n\t  }\n\t\n\t  function isAssociative(maybeAssociative) {\n\t    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n\t  }\n\t\n\t  function isOrdered(maybeOrdered) {\n\t    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);\n\t  }\n\t\n\t  Iterable.isIterable = isIterable;\n\t  Iterable.isKeyed = isKeyed;\n\t  Iterable.isIndexed = isIndexed;\n\t  Iterable.isAssociative = isAssociative;\n\t  Iterable.isOrdered = isOrdered;\n\t\n\t  Iterable.Keyed = KeyedIterable;\n\t  Iterable.Indexed = IndexedIterable;\n\t  Iterable.Set = SetIterable;\n\t\n\t\n\t  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n\t  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n\t  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n\t  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\t\n\t  // Used for setting prototype methods that IE8 chokes on.\n\t  var DELETE = 'delete';\n\t\n\t  // Constants describing the size of trie nodes.\n\t  var SHIFT = 5; // Resulted in best performance after ______?\n\t  var SIZE = 1 << SHIFT;\n\t  var MASK = SIZE - 1;\n\t\n\t  // A consistent shared value representing \"not set\" which equals nothing other\n\t  // than itself, and nothing that could be provided externally.\n\t  var NOT_SET = {};\n\t\n\t  // Boolean references, Rough equivalent of `bool &`.\n\t  var CHANGE_LENGTH = { value: false };\n\t  var DID_ALTER = { value: false };\n\t\n\t  function MakeRef(ref) {\n\t    ref.value = false;\n\t    return ref;\n\t  }\n\t\n\t  function SetRef(ref) {\n\t    ref && (ref.value = true);\n\t  }\n\t\n\t  // A function which returns a value representing an \"owner\" for transient writes\n\t  // to tries. The return value will only ever equal itself, and will not equal\n\t  // the return of any subsequent call of this function.\n\t  function OwnerID() {}\n\t\n\t  // http://jsperf.com/copy-array-inline\n\t  function arrCopy(arr, offset) {\n\t    offset = offset || 0;\n\t    var len = Math.max(0, arr.length - offset);\n\t    var newArr = new Array(len);\n\t    for (var ii = 0; ii < len; ii++) {\n\t      newArr[ii] = arr[ii + offset];\n\t    }\n\t    return newArr;\n\t  }\n\t\n\t  function ensureSize(iter) {\n\t    if (iter.size === undefined) {\n\t      iter.size = iter.__iterate(returnTrue);\n\t    }\n\t    return iter.size;\n\t  }\n\t\n\t  function wrapIndex(iter, index) {\n\t    // This implements \"is array index\" which the ECMAString spec defines as:\n\t    //\n\t    //     A String property name P is an array index if and only if\n\t    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n\t    //     to 2^32−1.\n\t    //\n\t    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n\t    if (typeof index !== 'number') {\n\t      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n\t      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n\t        return NaN;\n\t      }\n\t      index = uint32Index;\n\t    }\n\t    return index < 0 ? ensureSize(iter) + index : index;\n\t  }\n\t\n\t  function returnTrue() {\n\t    return true;\n\t  }\n\t\n\t  function wholeSlice(begin, end, size) {\n\t    return (begin === 0 || (size !== undefined && begin <= -size)) &&\n\t      (end === undefined || (size !== undefined && end >= size));\n\t  }\n\t\n\t  function resolveBegin(begin, size) {\n\t    return resolveIndex(begin, size, 0);\n\t  }\n\t\n\t  function resolveEnd(end, size) {\n\t    return resolveIndex(end, size, size);\n\t  }\n\t\n\t  function resolveIndex(index, size, defaultIndex) {\n\t    return index === undefined ?\n\t      defaultIndex :\n\t      index < 0 ?\n\t        Math.max(0, size + index) :\n\t        size === undefined ?\n\t          index :\n\t          Math.min(size, index);\n\t  }\n\t\n\t  /* global Symbol */\n\t\n\t  var ITERATE_KEYS = 0;\n\t  var ITERATE_VALUES = 1;\n\t  var ITERATE_ENTRIES = 2;\n\t\n\t  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n\t  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\t\n\t  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\t\n\t\n\t  function Iterator(next) {\n\t      this.next = next;\n\t    }\n\t\n\t    Iterator.prototype.toString = function() {\n\t      return '[Iterator]';\n\t    };\n\t\n\t\n\t  Iterator.KEYS = ITERATE_KEYS;\n\t  Iterator.VALUES = ITERATE_VALUES;\n\t  Iterator.ENTRIES = ITERATE_ENTRIES;\n\t\n\t  Iterator.prototype.inspect =\n\t  Iterator.prototype.toSource = function () { return this.toString(); }\n\t  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n\t    return this;\n\t  };\n\t\n\t\n\t  function iteratorValue(type, k, v, iteratorResult) {\n\t    var value = type === 0 ? k : type === 1 ? v : [k, v];\n\t    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {\n\t      value: value, done: false\n\t    });\n\t    return iteratorResult;\n\t  }\n\t\n\t  function iteratorDone() {\n\t    return { value: undefined, done: true };\n\t  }\n\t\n\t  function hasIterator(maybeIterable) {\n\t    return !!getIteratorFn(maybeIterable);\n\t  }\n\t\n\t  function isIterator(maybeIterator) {\n\t    return maybeIterator && typeof maybeIterator.next === 'function';\n\t  }\n\t\n\t  function getIterator(iterable) {\n\t    var iteratorFn = getIteratorFn(iterable);\n\t    return iteratorFn && iteratorFn.call(iterable);\n\t  }\n\t\n\t  function getIteratorFn(iterable) {\n\t    var iteratorFn = iterable && (\n\t      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n\t      iterable[FAUX_ITERATOR_SYMBOL]\n\t    );\n\t    if (typeof iteratorFn === 'function') {\n\t      return iteratorFn;\n\t    }\n\t  }\n\t\n\t  function isArrayLike(value) {\n\t    return value && typeof value.length === 'number';\n\t  }\n\t\n\t  createClass(Seq, Iterable);\n\t    function Seq(value) {\n\t      return value === null || value === undefined ? emptySequence() :\n\t        isIterable(value) ? value.toSeq() : seqFromValue(value);\n\t    }\n\t\n\t    Seq.of = function(/*...values*/) {\n\t      return Seq(arguments);\n\t    };\n\t\n\t    Seq.prototype.toSeq = function() {\n\t      return this;\n\t    };\n\t\n\t    Seq.prototype.toString = function() {\n\t      return this.__toString('Seq {', '}');\n\t    };\n\t\n\t    Seq.prototype.cacheResult = function() {\n\t      if (!this._cache && this.__iterateUncached) {\n\t        this._cache = this.entrySeq().toArray();\n\t        this.size = this._cache.length;\n\t      }\n\t      return this;\n\t    };\n\t\n\t    // abstract __iterateUncached(fn, reverse)\n\t\n\t    Seq.prototype.__iterate = function(fn, reverse) {\n\t      return seqIterate(this, fn, reverse, true);\n\t    };\n\t\n\t    // abstract __iteratorUncached(type, reverse)\n\t\n\t    Seq.prototype.__iterator = function(type, reverse) {\n\t      return seqIterator(this, type, reverse, true);\n\t    };\n\t\n\t\n\t\n\t  createClass(KeyedSeq, Seq);\n\t    function KeyedSeq(value) {\n\t      return value === null || value === undefined ?\n\t        emptySequence().toKeyedSeq() :\n\t        isIterable(value) ?\n\t          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :\n\t          keyedSeqFromValue(value);\n\t    }\n\t\n\t    KeyedSeq.prototype.toKeyedSeq = function() {\n\t      return this;\n\t    };\n\t\n\t\n\t\n\t  createClass(IndexedSeq, Seq);\n\t    function IndexedSeq(value) {\n\t      return value === null || value === undefined ? emptySequence() :\n\t        !isIterable(value) ? indexedSeqFromValue(value) :\n\t        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();\n\t    }\n\t\n\t    IndexedSeq.of = function(/*...values*/) {\n\t      return IndexedSeq(arguments);\n\t    };\n\t\n\t    IndexedSeq.prototype.toIndexedSeq = function() {\n\t      return this;\n\t    };\n\t\n\t    IndexedSeq.prototype.toString = function() {\n\t      return this.__toString('Seq [', ']');\n\t    };\n\t\n\t    IndexedSeq.prototype.__iterate = function(fn, reverse) {\n\t      return seqIterate(this, fn, reverse, false);\n\t    };\n\t\n\t    IndexedSeq.prototype.__iterator = function(type, reverse) {\n\t      return seqIterator(this, type, reverse, false);\n\t    };\n\t\n\t\n\t\n\t  createClass(SetSeq, Seq);\n\t    function SetSeq(value) {\n\t      return (\n\t        value === null || value === undefined ? emptySequence() :\n\t        !isIterable(value) ? indexedSeqFromValue(value) :\n\t        isKeyed(value) ? value.entrySeq() : value\n\t      ).toSetSeq();\n\t    }\n\t\n\t    SetSeq.of = function(/*...values*/) {\n\t      return SetSeq(arguments);\n\t    };\n\t\n\t    SetSeq.prototype.toSetSeq = function() {\n\t      return this;\n\t    };\n\t\n\t\n\t\n\t  Seq.isSeq = isSeq;\n\t  Seq.Keyed = KeyedSeq;\n\t  Seq.Set = SetSeq;\n\t  Seq.Indexed = IndexedSeq;\n\t\n\t  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';\n\t\n\t  Seq.prototype[IS_SEQ_SENTINEL] = true;\n\t\n\t\n\t\n\t  createClass(ArraySeq, IndexedSeq);\n\t    function ArraySeq(array) {\n\t      this._array = array;\n\t      this.size = array.length;\n\t    }\n\t\n\t    ArraySeq.prototype.get = function(index, notSetValue) {\n\t      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n\t    };\n\t\n\t    ArraySeq.prototype.__iterate = function(fn, reverse) {\n\t      var array = this._array;\n\t      var maxIndex = array.length - 1;\n\t      for (var ii = 0; ii <= maxIndex; ii++) {\n\t        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {\n\t          return ii + 1;\n\t        }\n\t      }\n\t      return ii;\n\t    };\n\t\n\t    ArraySeq.prototype.__iterator = function(type, reverse) {\n\t      var array = this._array;\n\t      var maxIndex = array.length - 1;\n\t      var ii = 0;\n\t      return new Iterator(function() \n\t        {return ii > maxIndex ?\n\t          iteratorDone() :\n\t          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}\n\t      );\n\t    };\n\t\n\t\n\t\n\t  createClass(ObjectSeq, KeyedSeq);\n\t    function ObjectSeq(object) {\n\t      var keys = Object.keys(object);\n\t      this._object = object;\n\t      this._keys = keys;\n\t      this.size = keys.length;\n\t    }\n\t\n\t    ObjectSeq.prototype.get = function(key, notSetValue) {\n\t      if (notSetValue !== undefined && !this.has(key)) {\n\t        return notSetValue;\n\t      }\n\t      return this._object[key];\n\t    };\n\t\n\t    ObjectSeq.prototype.has = function(key) {\n\t      return this._object.hasOwnProperty(key);\n\t    };\n\t\n\t    ObjectSeq.prototype.__iterate = function(fn, reverse) {\n\t      var object = this._object;\n\t      var keys = this._keys;\n\t      var maxIndex = keys.length - 1;\n\t      for (var ii = 0; ii <= maxIndex; ii++) {\n\t        var key = keys[reverse ? maxIndex - ii : ii];\n\t        if (fn(object[key], key, this) === false) {\n\t          return ii + 1;\n\t        }\n\t      }\n\t      return ii;\n\t    };\n\t\n\t    ObjectSeq.prototype.__iterator = function(type, reverse) {\n\t      var object = this._object;\n\t      var keys = this._keys;\n\t      var maxIndex = keys.length - 1;\n\t      var ii = 0;\n\t      return new Iterator(function()  {\n\t        var key = keys[reverse ? maxIndex - ii : ii];\n\t        return ii++ > maxIndex ?\n\t          iteratorDone() :\n\t          iteratorValue(type, key, object[key]);\n\t      });\n\t    };\n\t\n\t  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;\n\t\n\t\n\t  createClass(IterableSeq, IndexedSeq);\n\t    function IterableSeq(iterable) {\n\t      this._iterable = iterable;\n\t      this.size = iterable.length || iterable.size;\n\t    }\n\t\n\t    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {\n\t      if (reverse) {\n\t        return this.cacheResult().__iterate(fn, reverse);\n\t      }\n\t      var iterable = this._iterable;\n\t      var iterator = getIterator(iterable);\n\t      var iterations = 0;\n\t      if (isIterator(iterator)) {\n\t        var step;\n\t        while (!(step = iterator.next()).done) {\n\t          if (fn(step.value, iterations++, this) === false) {\n\t            break;\n\t          }\n\t        }\n\t      }\n\t      return iterations;\n\t    };\n\t\n\t    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {\n\t      if (reverse) {\n\t        return this.cacheResult().__iterator(type, reverse);\n\t      }\n\t      var iterable = this._iterable;\n\t      var iterator = getIterator(iterable);\n\t      if (!isIterator(iterator)) {\n\t        return new Iterator(iteratorDone);\n\t      }\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        var step = iterator.next();\n\t        return step.done ? step : iteratorValue(type, iterations++, step.value);\n\t      });\n\t    };\n\t\n\t\n\t\n\t  createClass(IteratorSeq, IndexedSeq);\n\t    function IteratorSeq(iterator) {\n\t      this._iterator = iterator;\n\t      this._iteratorCache = [];\n\t    }\n\t\n\t    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {\n\t      if (reverse) {\n\t        return this.cacheResult().__iterate(fn, reverse);\n\t      }\n\t      var iterator = this._iterator;\n\t      var cache = this._iteratorCache;\n\t      var iterations = 0;\n\t      while (iterations < cache.length) {\n\t        if (fn(cache[iterations], iterations++, this) === false) {\n\t          return iterations;\n\t        }\n\t      }\n\t      var step;\n\t      while (!(step = iterator.next()).done) {\n\t        var val = step.value;\n\t        cache[iterations] = val;\n\t        if (fn(val, iterations++, this) === false) {\n\t          break;\n\t        }\n\t      }\n\t      return iterations;\n\t    };\n\t\n\t    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {\n\t      if (reverse) {\n\t        return this.cacheResult().__iterator(type, reverse);\n\t      }\n\t      var iterator = this._iterator;\n\t      var cache = this._iteratorCache;\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        if (iterations >= cache.length) {\n\t          var step = iterator.next();\n\t          if (step.done) {\n\t            return step;\n\t          }\n\t          cache[iterations] = step.value;\n\t        }\n\t        return iteratorValue(type, iterations, cache[iterations++]);\n\t      });\n\t    };\n\t\n\t\n\t\n\t\n\t  // # pragma Helper functions\n\t\n\t  function isSeq(maybeSeq) {\n\t    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);\n\t  }\n\t\n\t  var EMPTY_SEQ;\n\t\n\t  function emptySequence() {\n\t    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n\t  }\n\t\n\t  function keyedSeqFromValue(value) {\n\t    var seq =\n\t      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :\n\t      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :\n\t      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :\n\t      typeof value === 'object' ? new ObjectSeq(value) :\n\t      undefined;\n\t    if (!seq) {\n\t      throw new TypeError(\n\t        'Expected Array or iterable object of [k, v] entries, '+\n\t        'or keyed object: ' + value\n\t      );\n\t    }\n\t    return seq;\n\t  }\n\t\n\t  function indexedSeqFromValue(value) {\n\t    var seq = maybeIndexedSeqFromValue(value);\n\t    if (!seq) {\n\t      throw new TypeError(\n\t        'Expected Array or iterable object of values: ' + value\n\t      );\n\t    }\n\t    return seq;\n\t  }\n\t\n\t  function seqFromValue(value) {\n\t    var seq = maybeIndexedSeqFromValue(value) ||\n\t      (typeof value === 'object' && new ObjectSeq(value));\n\t    if (!seq) {\n\t      throw new TypeError(\n\t        'Expected Array or iterable object of values, or keyed object: ' + value\n\t      );\n\t    }\n\t    return seq;\n\t  }\n\t\n\t  function maybeIndexedSeqFromValue(value) {\n\t    return (\n\t      isArrayLike(value) ? new ArraySeq(value) :\n\t      isIterator(value) ? new IteratorSeq(value) :\n\t      hasIterator(value) ? new IterableSeq(value) :\n\t      undefined\n\t    );\n\t  }\n\t\n\t  function seqIterate(seq, fn, reverse, useKeys) {\n\t    var cache = seq._cache;\n\t    if (cache) {\n\t      var maxIndex = cache.length - 1;\n\t      for (var ii = 0; ii <= maxIndex; ii++) {\n\t        var entry = cache[reverse ? maxIndex - ii : ii];\n\t        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {\n\t          return ii + 1;\n\t        }\n\t      }\n\t      return ii;\n\t    }\n\t    return seq.__iterateUncached(fn, reverse);\n\t  }\n\t\n\t  function seqIterator(seq, type, reverse, useKeys) {\n\t    var cache = seq._cache;\n\t    if (cache) {\n\t      var maxIndex = cache.length - 1;\n\t      var ii = 0;\n\t      return new Iterator(function()  {\n\t        var entry = cache[reverse ? maxIndex - ii : ii];\n\t        return ii++ > maxIndex ?\n\t          iteratorDone() :\n\t          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);\n\t      });\n\t    }\n\t    return seq.__iteratorUncached(type, reverse);\n\t  }\n\t\n\t  function fromJS(json, converter) {\n\t    return converter ?\n\t      fromJSWith(converter, json, '', {'': json}) :\n\t      fromJSDefault(json);\n\t  }\n\t\n\t  function fromJSWith(converter, json, key, parentJSON) {\n\t    if (Array.isArray(json)) {\n\t      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n\t    }\n\t    if (isPlainObj(json)) {\n\t      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n\t    }\n\t    return json;\n\t  }\n\t\n\t  function fromJSDefault(json) {\n\t    if (Array.isArray(json)) {\n\t      return IndexedSeq(json).map(fromJSDefault).toList();\n\t    }\n\t    if (isPlainObj(json)) {\n\t      return KeyedSeq(json).map(fromJSDefault).toMap();\n\t    }\n\t    return json;\n\t  }\n\t\n\t  function isPlainObj(value) {\n\t    return value && (value.constructor === Object || value.constructor === undefined);\n\t  }\n\t\n\t  /**\n\t   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n\t   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n\t   *\n\t   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n\t   * value, which is different from the algorithm described by\n\t   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n\t   *\n\t   * This is extended further to allow Objects to describe the values they\n\t   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n\t   *\n\t   * Note: because of this extension, the key equality of Immutable.Map and the\n\t   * value equality of Immutable.Set will differ from ES6 Map and Set.\n\t   *\n\t   * ### Defining custom values\n\t   *\n\t   * The easiest way to describe the value an object represents is by implementing\n\t   * `valueOf`. For example, `Date` represents a value by returning a unix\n\t   * timestamp for `valueOf`:\n\t   *\n\t   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n\t   *     var date2 = new Date(1234567890000);\n\t   *     date1.valueOf(); // 1234567890000\n\t   *     assert( date1 !== date2 );\n\t   *     assert( Immutable.is( date1, date2 ) );\n\t   *\n\t   * Note: overriding `valueOf` may have other implications if you use this object\n\t   * where JavaScript expects a primitive, such as implicit string coercion.\n\t   *\n\t   * For more complex types, especially collections, implementing `valueOf` may\n\t   * not be performant. An alternative is to implement `equals` and `hashCode`.\n\t   *\n\t   * `equals` takes another object, presumably of similar type, and returns true\n\t   * if the it is equal. Equality is symmetrical, so the same result should be\n\t   * returned if this and the argument are flipped.\n\t   *\n\t   *     assert( a.equals(b) === b.equals(a) );\n\t   *\n\t   * `hashCode` returns a 32bit integer number representing the object which will\n\t   * be used to determine how to store the value object in a Map or Set. You must\n\t   * provide both or neither methods, one must not exist without the other.\n\t   *\n\t   * Also, an important relationship between these methods must be upheld: if two\n\t   * values are equal, they *must* return the same hashCode. If the values are not\n\t   * equal, they might have the same hashCode; this is called a hash collision,\n\t   * and while undesirable for performance reasons, it is acceptable.\n\t   *\n\t   *     if (a.equals(b)) {\n\t   *       assert( a.hashCode() === b.hashCode() );\n\t   *     }\n\t   *\n\t   * All Immutable collections implement `equals` and `hashCode`.\n\t   *\n\t   */\n\t  function is(valueA, valueB) {\n\t    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n\t      return true;\n\t    }\n\t    if (!valueA || !valueB) {\n\t      return false;\n\t    }\n\t    if (typeof valueA.valueOf === 'function' &&\n\t        typeof valueB.valueOf === 'function') {\n\t      valueA = valueA.valueOf();\n\t      valueB = valueB.valueOf();\n\t      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n\t        return true;\n\t      }\n\t      if (!valueA || !valueB) {\n\t        return false;\n\t      }\n\t    }\n\t    if (typeof valueA.equals === 'function' &&\n\t        typeof valueB.equals === 'function' &&\n\t        valueA.equals(valueB)) {\n\t      return true;\n\t    }\n\t    return false;\n\t  }\n\t\n\t  function deepEqual(a, b) {\n\t    if (a === b) {\n\t      return true;\n\t    }\n\t\n\t    if (\n\t      !isIterable(b) ||\n\t      a.size !== undefined && b.size !== undefined && a.size !== b.size ||\n\t      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||\n\t      isKeyed(a) !== isKeyed(b) ||\n\t      isIndexed(a) !== isIndexed(b) ||\n\t      isOrdered(a) !== isOrdered(b)\n\t    ) {\n\t      return false;\n\t    }\n\t\n\t    if (a.size === 0 && b.size === 0) {\n\t      return true;\n\t    }\n\t\n\t    var notAssociative = !isAssociative(a);\n\t\n\t    if (isOrdered(a)) {\n\t      var entries = a.entries();\n\t      return b.every(function(v, k)  {\n\t        var entry = entries.next().value;\n\t        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n\t      }) && entries.next().done;\n\t    }\n\t\n\t    var flipped = false;\n\t\n\t    if (a.size === undefined) {\n\t      if (b.size === undefined) {\n\t        if (typeof a.cacheResult === 'function') {\n\t          a.cacheResult();\n\t        }\n\t      } else {\n\t        flipped = true;\n\t        var _ = a;\n\t        a = b;\n\t        b = _;\n\t      }\n\t    }\n\t\n\t    var allEqual = true;\n\t    var bSize = b.__iterate(function(v, k)  {\n\t      if (notAssociative ? !a.has(v) :\n\t          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {\n\t        allEqual = false;\n\t        return false;\n\t      }\n\t    });\n\t\n\t    return allEqual && a.size === bSize;\n\t  }\n\t\n\t  createClass(Repeat, IndexedSeq);\n\t\n\t    function Repeat(value, times) {\n\t      if (!(this instanceof Repeat)) {\n\t        return new Repeat(value, times);\n\t      }\n\t      this._value = value;\n\t      this.size = times === undefined ? Infinity : Math.max(0, times);\n\t      if (this.size === 0) {\n\t        if (EMPTY_REPEAT) {\n\t          return EMPTY_REPEAT;\n\t        }\n\t        EMPTY_REPEAT = this;\n\t      }\n\t    }\n\t\n\t    Repeat.prototype.toString = function() {\n\t      if (this.size === 0) {\n\t        return 'Repeat []';\n\t      }\n\t      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n\t    };\n\t\n\t    Repeat.prototype.get = function(index, notSetValue) {\n\t      return this.has(index) ? this._value : notSetValue;\n\t    };\n\t\n\t    Repeat.prototype.includes = function(searchValue) {\n\t      return is(this._value, searchValue);\n\t    };\n\t\n\t    Repeat.prototype.slice = function(begin, end) {\n\t      var size = this.size;\n\t      return wholeSlice(begin, end, size) ? this :\n\t        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));\n\t    };\n\t\n\t    Repeat.prototype.reverse = function() {\n\t      return this;\n\t    };\n\t\n\t    Repeat.prototype.indexOf = function(searchValue) {\n\t      if (is(this._value, searchValue)) {\n\t        return 0;\n\t      }\n\t      return -1;\n\t    };\n\t\n\t    Repeat.prototype.lastIndexOf = function(searchValue) {\n\t      if (is(this._value, searchValue)) {\n\t        return this.size;\n\t      }\n\t      return -1;\n\t    };\n\t\n\t    Repeat.prototype.__iterate = function(fn, reverse) {\n\t      for (var ii = 0; ii < this.size; ii++) {\n\t        if (fn(this._value, ii, this) === false) {\n\t          return ii + 1;\n\t        }\n\t      }\n\t      return ii;\n\t    };\n\t\n\t    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;\n\t      var ii = 0;\n\t      return new Iterator(function() \n\t        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}\n\t      );\n\t    };\n\t\n\t    Repeat.prototype.equals = function(other) {\n\t      return other instanceof Repeat ?\n\t        is(this._value, other._value) :\n\t        deepEqual(other);\n\t    };\n\t\n\t\n\t  var EMPTY_REPEAT;\n\t\n\t  function invariant(condition, error) {\n\t    if (!condition) throw new Error(error);\n\t  }\n\t\n\t  createClass(Range, IndexedSeq);\n\t\n\t    function Range(start, end, step) {\n\t      if (!(this instanceof Range)) {\n\t        return new Range(start, end, step);\n\t      }\n\t      invariant(step !== 0, 'Cannot step a Range by 0');\n\t      start = start || 0;\n\t      if (end === undefined) {\n\t        end = Infinity;\n\t      }\n\t      step = step === undefined ? 1 : Math.abs(step);\n\t      if (end < start) {\n\t        step = -step;\n\t      }\n\t      this._start = start;\n\t      this._end = end;\n\t      this._step = step;\n\t      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n\t      if (this.size === 0) {\n\t        if (EMPTY_RANGE) {\n\t          return EMPTY_RANGE;\n\t        }\n\t        EMPTY_RANGE = this;\n\t      }\n\t    }\n\t\n\t    Range.prototype.toString = function() {\n\t      if (this.size === 0) {\n\t        return 'Range []';\n\t      }\n\t      return 'Range [ ' +\n\t        this._start + '...' + this._end +\n\t        (this._step !== 1 ? ' by ' + this._step : '') +\n\t      ' ]';\n\t    };\n\t\n\t    Range.prototype.get = function(index, notSetValue) {\n\t      return this.has(index) ?\n\t        this._start + wrapIndex(this, index) * this._step :\n\t        notSetValue;\n\t    };\n\t\n\t    Range.prototype.includes = function(searchValue) {\n\t      var possibleIndex = (searchValue - this._start) / this._step;\n\t      return possibleIndex >= 0 &&\n\t        possibleIndex < this.size &&\n\t        possibleIndex === Math.floor(possibleIndex);\n\t    };\n\t\n\t    Range.prototype.slice = function(begin, end) {\n\t      if (wholeSlice(begin, end, this.size)) {\n\t        return this;\n\t      }\n\t      begin = resolveBegin(begin, this.size);\n\t      end = resolveEnd(end, this.size);\n\t      if (end <= begin) {\n\t        return new Range(0, 0);\n\t      }\n\t      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);\n\t    };\n\t\n\t    Range.prototype.indexOf = function(searchValue) {\n\t      var offsetValue = searchValue - this._start;\n\t      if (offsetValue % this._step === 0) {\n\t        var index = offsetValue / this._step;\n\t        if (index >= 0 && index < this.size) {\n\t          return index\n\t        }\n\t      }\n\t      return -1;\n\t    };\n\t\n\t    Range.prototype.lastIndexOf = function(searchValue) {\n\t      return this.indexOf(searchValue);\n\t    };\n\t\n\t    Range.prototype.__iterate = function(fn, reverse) {\n\t      var maxIndex = this.size - 1;\n\t      var step = this._step;\n\t      var value = reverse ? this._start + maxIndex * step : this._start;\n\t      for (var ii = 0; ii <= maxIndex; ii++) {\n\t        if (fn(value, ii, this) === false) {\n\t          return ii + 1;\n\t        }\n\t        value += reverse ? -step : step;\n\t      }\n\t      return ii;\n\t    };\n\t\n\t    Range.prototype.__iterator = function(type, reverse) {\n\t      var maxIndex = this.size - 1;\n\t      var step = this._step;\n\t      var value = reverse ? this._start + maxIndex * step : this._start;\n\t      var ii = 0;\n\t      return new Iterator(function()  {\n\t        var v = value;\n\t        value += reverse ? -step : step;\n\t        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);\n\t      });\n\t    };\n\t\n\t    Range.prototype.equals = function(other) {\n\t      return other instanceof Range ?\n\t        this._start === other._start &&\n\t        this._end === other._end &&\n\t        this._step === other._step :\n\t        deepEqual(this, other);\n\t    };\n\t\n\t\n\t  var EMPTY_RANGE;\n\t\n\t  createClass(Collection, Iterable);\n\t    function Collection() {\n\t      throw TypeError('Abstract');\n\t    }\n\t\n\t\n\t  createClass(KeyedCollection, Collection);function KeyedCollection() {}\n\t\n\t  createClass(IndexedCollection, Collection);function IndexedCollection() {}\n\t\n\t  createClass(SetCollection, Collection);function SetCollection() {}\n\t\n\t\n\t  Collection.Keyed = KeyedCollection;\n\t  Collection.Indexed = IndexedCollection;\n\t  Collection.Set = SetCollection;\n\t\n\t  var imul =\n\t    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?\n\t    Math.imul :\n\t    function imul(a, b) {\n\t      a = a | 0; // int\n\t      b = b | 0; // int\n\t      var c = a & 0xffff;\n\t      var d = b & 0xffff;\n\t      // Shift by 0 fixes the sign on the high part.\n\t      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int\n\t    };\n\t\n\t  // v8 has an optimization for storing 31-bit signed numbers.\n\t  // Values which have either 00 or 11 as the high order bits qualify.\n\t  // This function drops the highest order bit in a signed number, maintaining\n\t  // the sign bit.\n\t  function smi(i32) {\n\t    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);\n\t  }\n\t\n\t  function hash(o) {\n\t    if (o === false || o === null || o === undefined) {\n\t      return 0;\n\t    }\n\t    if (typeof o.valueOf === 'function') {\n\t      o = o.valueOf();\n\t      if (o === false || o === null || o === undefined) {\n\t        return 0;\n\t      }\n\t    }\n\t    if (o === true) {\n\t      return 1;\n\t    }\n\t    var type = typeof o;\n\t    if (type === 'number') {\n\t      if (o !== o || o === Infinity) {\n\t        return 0;\n\t      }\n\t      var h = o | 0;\n\t      if (h !== o) {\n\t        h ^= o * 0xFFFFFFFF;\n\t      }\n\t      while (o > 0xFFFFFFFF) {\n\t        o /= 0xFFFFFFFF;\n\t        h ^= o;\n\t      }\n\t      return smi(h);\n\t    }\n\t    if (type === 'string') {\n\t      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);\n\t    }\n\t    if (typeof o.hashCode === 'function') {\n\t      return o.hashCode();\n\t    }\n\t    if (type === 'object') {\n\t      return hashJSObj(o);\n\t    }\n\t    if (typeof o.toString === 'function') {\n\t      return hashString(o.toString());\n\t    }\n\t    throw new Error('Value type ' + type + ' cannot be hashed.');\n\t  }\n\t\n\t  function cachedHashString(string) {\n\t    var hash = stringHashCache[string];\n\t    if (hash === undefined) {\n\t      hash = hashString(string);\n\t      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n\t        STRING_HASH_CACHE_SIZE = 0;\n\t        stringHashCache = {};\n\t      }\n\t      STRING_HASH_CACHE_SIZE++;\n\t      stringHashCache[string] = hash;\n\t    }\n\t    return hash;\n\t  }\n\t\n\t  // http://jsperf.com/hashing-strings\n\t  function hashString(string) {\n\t    // This is the hash from JVM\n\t    // The hash code for a string is computed as\n\t    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n\t    // where s[i] is the ith character of the string and n is the length of\n\t    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n\t    // (exclusive) by dropping high bits.\n\t    var hash = 0;\n\t    for (var ii = 0; ii < string.length; ii++) {\n\t      hash = 31 * hash + string.charCodeAt(ii) | 0;\n\t    }\n\t    return smi(hash);\n\t  }\n\t\n\t  function hashJSObj(obj) {\n\t    var hash;\n\t    if (usingWeakMap) {\n\t      hash = weakMap.get(obj);\n\t      if (hash !== undefined) {\n\t        return hash;\n\t      }\n\t    }\n\t\n\t    hash = obj[UID_HASH_KEY];\n\t    if (hash !== undefined) {\n\t      return hash;\n\t    }\n\t\n\t    if (!canDefineProperty) {\n\t      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n\t      if (hash !== undefined) {\n\t        return hash;\n\t      }\n\t\n\t      hash = getIENodeHash(obj);\n\t      if (hash !== undefined) {\n\t        return hash;\n\t      }\n\t    }\n\t\n\t    hash = ++objHashUID;\n\t    if (objHashUID & 0x40000000) {\n\t      objHashUID = 0;\n\t    }\n\t\n\t    if (usingWeakMap) {\n\t      weakMap.set(obj, hash);\n\t    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n\t      throw new Error('Non-extensible objects are not allowed as keys.');\n\t    } else if (canDefineProperty) {\n\t      Object.defineProperty(obj, UID_HASH_KEY, {\n\t        'enumerable': false,\n\t        'configurable': false,\n\t        'writable': false,\n\t        'value': hash\n\t      });\n\t    } else if (obj.propertyIsEnumerable !== undefined &&\n\t               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {\n\t      // Since we can't define a non-enumerable property on the object\n\t      // we'll hijack one of the less-used non-enumerable properties to\n\t      // save our hash on it. Since this is a function it will not show up in\n\t      // `JSON.stringify` which is what we want.\n\t      obj.propertyIsEnumerable = function() {\n\t        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);\n\t      };\n\t      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;\n\t    } else if (obj.nodeType !== undefined) {\n\t      // At this point we couldn't get the IE `uniqueID` to use as a hash\n\t      // and we couldn't use a non-enumerable property to exploit the\n\t      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n\t      // itself.\n\t      obj[UID_HASH_KEY] = hash;\n\t    } else {\n\t      throw new Error('Unable to set a non-enumerable property on object.');\n\t    }\n\t\n\t    return hash;\n\t  }\n\t\n\t  // Get references to ES5 object methods.\n\t  var isExtensible = Object.isExtensible;\n\t\n\t  // True if Object.defineProperty works as expected. IE8 fails this test.\n\t  var canDefineProperty = (function() {\n\t    try {\n\t      Object.defineProperty({}, '@', {});\n\t      return true;\n\t    } catch (e) {\n\t      return false;\n\t    }\n\t  }());\n\t\n\t  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n\t  // and avoid memory leaks from the IE cloneNode bug.\n\t  function getIENodeHash(node) {\n\t    if (node && node.nodeType > 0) {\n\t      switch (node.nodeType) {\n\t        case 1: // Element\n\t          return node.uniqueID;\n\t        case 9: // Document\n\t          return node.documentElement && node.documentElement.uniqueID;\n\t      }\n\t    }\n\t  }\n\t\n\t  // If possible, use a WeakMap.\n\t  var usingWeakMap = typeof WeakMap === 'function';\n\t  var weakMap;\n\t  if (usingWeakMap) {\n\t    weakMap = new WeakMap();\n\t  }\n\t\n\t  var objHashUID = 0;\n\t\n\t  var UID_HASH_KEY = '__immutablehash__';\n\t  if (typeof Symbol === 'function') {\n\t    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n\t  }\n\t\n\t  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n\t  var STRING_HASH_CACHE_MAX_SIZE = 255;\n\t  var STRING_HASH_CACHE_SIZE = 0;\n\t  var stringHashCache = {};\n\t\n\t  function assertNotInfinite(size) {\n\t    invariant(\n\t      size !== Infinity,\n\t      'Cannot perform this action with an infinite size.'\n\t    );\n\t  }\n\t\n\t  createClass(Map, KeyedCollection);\n\t\n\t    // @pragma Construction\n\t\n\t    function Map(value) {\n\t      return value === null || value === undefined ? emptyMap() :\n\t        isMap(value) && !isOrdered(value) ? value :\n\t        emptyMap().withMutations(function(map ) {\n\t          var iter = KeyedIterable(value);\n\t          assertNotInfinite(iter.size);\n\t          iter.forEach(function(v, k)  {return map.set(k, v)});\n\t        });\n\t    }\n\t\n\t    Map.of = function() {var keyValues = SLICE$0.call(arguments, 0);\n\t      return emptyMap().withMutations(function(map ) {\n\t        for (var i = 0; i < keyValues.length; i += 2) {\n\t          if (i + 1 >= keyValues.length) {\n\t            throw new Error('Missing value for key: ' + keyValues[i]);\n\t          }\n\t          map.set(keyValues[i], keyValues[i + 1]);\n\t        }\n\t      });\n\t    };\n\t\n\t    Map.prototype.toString = function() {\n\t      return this.__toString('Map {', '}');\n\t    };\n\t\n\t    // @pragma Access\n\t\n\t    Map.prototype.get = function(k, notSetValue) {\n\t      return this._root ?\n\t        this._root.get(0, undefined, k, notSetValue) :\n\t        notSetValue;\n\t    };\n\t\n\t    // @pragma Modification\n\t\n\t    Map.prototype.set = function(k, v) {\n\t      return updateMap(this, k, v);\n\t    };\n\t\n\t    Map.prototype.setIn = function(keyPath, v) {\n\t      return this.updateIn(keyPath, NOT_SET, function()  {return v});\n\t    };\n\t\n\t    Map.prototype.remove = function(k) {\n\t      return updateMap(this, k, NOT_SET);\n\t    };\n\t\n\t    Map.prototype.deleteIn = function(keyPath) {\n\t      return this.updateIn(keyPath, function()  {return NOT_SET});\n\t    };\n\t\n\t    Map.prototype.update = function(k, notSetValue, updater) {\n\t      return arguments.length === 1 ?\n\t        k(this) :\n\t        this.updateIn([k], notSetValue, updater);\n\t    };\n\t\n\t    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {\n\t      if (!updater) {\n\t        updater = notSetValue;\n\t        notSetValue = undefined;\n\t      }\n\t      var updatedValue = updateInDeepMap(\n\t        this,\n\t        forceIterator(keyPath),\n\t        notSetValue,\n\t        updater\n\t      );\n\t      return updatedValue === NOT_SET ? undefined : updatedValue;\n\t    };\n\t\n\t    Map.prototype.clear = function() {\n\t      if (this.size === 0) {\n\t        return this;\n\t      }\n\t      if (this.__ownerID) {\n\t        this.size = 0;\n\t        this._root = null;\n\t        this.__hash = undefined;\n\t        this.__altered = true;\n\t        return this;\n\t      }\n\t      return emptyMap();\n\t    };\n\t\n\t    // @pragma Composition\n\t\n\t    Map.prototype.merge = function(/*...iters*/) {\n\t      return mergeIntoMapWith(this, undefined, arguments);\n\t    };\n\t\n\t    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n\t      return mergeIntoMapWith(this, merger, iters);\n\t    };\n\t\n\t    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n\t      return this.updateIn(\n\t        keyPath,\n\t        emptyMap(),\n\t        function(m ) {return typeof m.merge === 'function' ?\n\t          m.merge.apply(m, iters) :\n\t          iters[iters.length - 1]}\n\t      );\n\t    };\n\t\n\t    Map.prototype.mergeDeep = function(/*...iters*/) {\n\t      return mergeIntoMapWith(this, deepMerger, arguments);\n\t    };\n\t\n\t    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n\t      return mergeIntoMapWith(this, deepMergerWith(merger), iters);\n\t    };\n\t\n\t    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n\t      return this.updateIn(\n\t        keyPath,\n\t        emptyMap(),\n\t        function(m ) {return typeof m.mergeDeep === 'function' ?\n\t          m.mergeDeep.apply(m, iters) :\n\t          iters[iters.length - 1]}\n\t      );\n\t    };\n\t\n\t    Map.prototype.sort = function(comparator) {\n\t      // Late binding\n\t      return OrderedMap(sortFactory(this, comparator));\n\t    };\n\t\n\t    Map.prototype.sortBy = function(mapper, comparator) {\n\t      // Late binding\n\t      return OrderedMap(sortFactory(this, comparator, mapper));\n\t    };\n\t\n\t    // @pragma Mutability\n\t\n\t    Map.prototype.withMutations = function(fn) {\n\t      var mutable = this.asMutable();\n\t      fn(mutable);\n\t      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n\t    };\n\t\n\t    Map.prototype.asMutable = function() {\n\t      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n\t    };\n\t\n\t    Map.prototype.asImmutable = function() {\n\t      return this.__ensureOwner();\n\t    };\n\t\n\t    Map.prototype.wasAltered = function() {\n\t      return this.__altered;\n\t    };\n\t\n\t    Map.prototype.__iterator = function(type, reverse) {\n\t      return new MapIterator(this, type, reverse);\n\t    };\n\t\n\t    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      var iterations = 0;\n\t      this._root && this._root.iterate(function(entry ) {\n\t        iterations++;\n\t        return fn(entry[1], entry[0], this$0);\n\t      }, reverse);\n\t      return iterations;\n\t    };\n\t\n\t    Map.prototype.__ensureOwner = function(ownerID) {\n\t      if (ownerID === this.__ownerID) {\n\t        return this;\n\t      }\n\t      if (!ownerID) {\n\t        this.__ownerID = ownerID;\n\t        this.__altered = false;\n\t        return this;\n\t      }\n\t      return makeMap(this.size, this._root, ownerID, this.__hash);\n\t    };\n\t\n\t\n\t  function isMap(maybeMap) {\n\t    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);\n\t  }\n\t\n\t  Map.isMap = isMap;\n\t\n\t  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';\n\t\n\t  var MapPrototype = Map.prototype;\n\t  MapPrototype[IS_MAP_SENTINEL] = true;\n\t  MapPrototype[DELETE] = MapPrototype.remove;\n\t  MapPrototype.removeIn = MapPrototype.deleteIn;\n\t\n\t\n\t  // #pragma Trie Nodes\n\t\n\t\n\t\n\t    function ArrayMapNode(ownerID, entries) {\n\t      this.ownerID = ownerID;\n\t      this.entries = entries;\n\t    }\n\t\n\t    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n\t      var entries = this.entries;\n\t      for (var ii = 0, len = entries.length; ii < len; ii++) {\n\t        if (is(key, entries[ii][0])) {\n\t          return entries[ii][1];\n\t        }\n\t      }\n\t      return notSetValue;\n\t    };\n\t\n\t    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n\t      var removed = value === NOT_SET;\n\t\n\t      var entries = this.entries;\n\t      var idx = 0;\n\t      for (var len = entries.length; idx < len; idx++) {\n\t        if (is(key, entries[idx][0])) {\n\t          break;\n\t        }\n\t      }\n\t      var exists = idx < len;\n\t\n\t      if (exists ? entries[idx][1] === value : removed) {\n\t        return this;\n\t      }\n\t\n\t      SetRef(didAlter);\n\t      (removed || !exists) && SetRef(didChangeSize);\n\t\n\t      if (removed && entries.length === 1) {\n\t        return; // undefined\n\t      }\n\t\n\t      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n\t        return createNodes(ownerID, entries, key, value);\n\t      }\n\t\n\t      var isEditable = ownerID && ownerID === this.ownerID;\n\t      var newEntries = isEditable ? entries : arrCopy(entries);\n\t\n\t      if (exists) {\n\t        if (removed) {\n\t          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n\t        } else {\n\t          newEntries[idx] = [key, value];\n\t        }\n\t      } else {\n\t        newEntries.push([key, value]);\n\t      }\n\t\n\t      if (isEditable) {\n\t        this.entries = newEntries;\n\t        return this;\n\t      }\n\t\n\t      return new ArrayMapNode(ownerID, newEntries);\n\t    };\n\t\n\t\n\t\n\t\n\t    function BitmapIndexedNode(ownerID, bitmap, nodes) {\n\t      this.ownerID = ownerID;\n\t      this.bitmap = bitmap;\n\t      this.nodes = nodes;\n\t    }\n\t\n\t    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n\t      if (keyHash === undefined) {\n\t        keyHash = hash(key);\n\t      }\n\t      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));\n\t      var bitmap = this.bitmap;\n\t      return (bitmap & bit) === 0 ? notSetValue :\n\t        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);\n\t    };\n\t\n\t    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n\t      if (keyHash === undefined) {\n\t        keyHash = hash(key);\n\t      }\n\t      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\t      var bit = 1 << keyHashFrag;\n\t      var bitmap = this.bitmap;\n\t      var exists = (bitmap & bit) !== 0;\n\t\n\t      if (!exists && value === NOT_SET) {\n\t        return this;\n\t      }\n\t\n\t      var idx = popCount(bitmap & (bit - 1));\n\t      var nodes = this.nodes;\n\t      var node = exists ? nodes[idx] : undefined;\n\t      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\t\n\t      if (newNode === node) {\n\t        return this;\n\t      }\n\t\n\t      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n\t        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n\t      }\n\t\n\t      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {\n\t        return nodes[idx ^ 1];\n\t      }\n\t\n\t      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n\t        return newNode;\n\t      }\n\t\n\t      var isEditable = ownerID && ownerID === this.ownerID;\n\t      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;\n\t      var newNodes = exists ? newNode ?\n\t        setIn(nodes, idx, newNode, isEditable) :\n\t        spliceOut(nodes, idx, isEditable) :\n\t        spliceIn(nodes, idx, newNode, isEditable);\n\t\n\t      if (isEditable) {\n\t        this.bitmap = newBitmap;\n\t        this.nodes = newNodes;\n\t        return this;\n\t      }\n\t\n\t      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n\t    };\n\t\n\t\n\t\n\t\n\t    function HashArrayMapNode(ownerID, count, nodes) {\n\t      this.ownerID = ownerID;\n\t      this.count = count;\n\t      this.nodes = nodes;\n\t    }\n\t\n\t    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n\t      if (keyHash === undefined) {\n\t        keyHash = hash(key);\n\t      }\n\t      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\t      var node = this.nodes[idx];\n\t      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;\n\t    };\n\t\n\t    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n\t      if (keyHash === undefined) {\n\t        keyHash = hash(key);\n\t      }\n\t      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\t      var removed = value === NOT_SET;\n\t      var nodes = this.nodes;\n\t      var node = nodes[idx];\n\t\n\t      if (removed && !node) {\n\t        return this;\n\t      }\n\t\n\t      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\t      if (newNode === node) {\n\t        return this;\n\t      }\n\t\n\t      var newCount = this.count;\n\t      if (!node) {\n\t        newCount++;\n\t      } else if (!newNode) {\n\t        newCount--;\n\t        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n\t          return packNodes(ownerID, nodes, newCount, idx);\n\t        }\n\t      }\n\t\n\t      var isEditable = ownerID && ownerID === this.ownerID;\n\t      var newNodes = setIn(nodes, idx, newNode, isEditable);\n\t\n\t      if (isEditable) {\n\t        this.count = newCount;\n\t        this.nodes = newNodes;\n\t        return this;\n\t      }\n\t\n\t      return new HashArrayMapNode(ownerID, newCount, newNodes);\n\t    };\n\t\n\t\n\t\n\t\n\t    function HashCollisionNode(ownerID, keyHash, entries) {\n\t      this.ownerID = ownerID;\n\t      this.keyHash = keyHash;\n\t      this.entries = entries;\n\t    }\n\t\n\t    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n\t      var entries = this.entries;\n\t      for (var ii = 0, len = entries.length; ii < len; ii++) {\n\t        if (is(key, entries[ii][0])) {\n\t          return entries[ii][1];\n\t        }\n\t      }\n\t      return notSetValue;\n\t    };\n\t\n\t    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n\t      if (keyHash === undefined) {\n\t        keyHash = hash(key);\n\t      }\n\t\n\t      var removed = value === NOT_SET;\n\t\n\t      if (keyHash !== this.keyHash) {\n\t        if (removed) {\n\t          return this;\n\t        }\n\t        SetRef(didAlter);\n\t        SetRef(didChangeSize);\n\t        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n\t      }\n\t\n\t      var entries = this.entries;\n\t      var idx = 0;\n\t      for (var len = entries.length; idx < len; idx++) {\n\t        if (is(key, entries[idx][0])) {\n\t          break;\n\t        }\n\t      }\n\t      var exists = idx < len;\n\t\n\t      if (exists ? entries[idx][1] === value : removed) {\n\t        return this;\n\t      }\n\t\n\t      SetRef(didAlter);\n\t      (removed || !exists) && SetRef(didChangeSize);\n\t\n\t      if (removed && len === 2) {\n\t        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n\t      }\n\t\n\t      var isEditable = ownerID && ownerID === this.ownerID;\n\t      var newEntries = isEditable ? entries : arrCopy(entries);\n\t\n\t      if (exists) {\n\t        if (removed) {\n\t          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n\t        } else {\n\t          newEntries[idx] = [key, value];\n\t        }\n\t      } else {\n\t        newEntries.push([key, value]);\n\t      }\n\t\n\t      if (isEditable) {\n\t        this.entries = newEntries;\n\t        return this;\n\t      }\n\t\n\t      return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n\t    };\n\t\n\t\n\t\n\t\n\t    function ValueNode(ownerID, keyHash, entry) {\n\t      this.ownerID = ownerID;\n\t      this.keyHash = keyHash;\n\t      this.entry = entry;\n\t    }\n\t\n\t    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n\t      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n\t    };\n\t\n\t    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n\t      var removed = value === NOT_SET;\n\t      var keyMatch = is(key, this.entry[0]);\n\t      if (keyMatch ? value === this.entry[1] : removed) {\n\t        return this;\n\t      }\n\t\n\t      SetRef(didAlter);\n\t\n\t      if (removed) {\n\t        SetRef(didChangeSize);\n\t        return; // undefined\n\t      }\n\t\n\t      if (keyMatch) {\n\t        if (ownerID && ownerID === this.ownerID) {\n\t          this.entry[1] = value;\n\t          return this;\n\t        }\n\t        return new ValueNode(ownerID, this.keyHash, [key, value]);\n\t      }\n\t\n\t      SetRef(didChangeSize);\n\t      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n\t    };\n\t\n\t\n\t\n\t  // #pragma Iterators\n\t\n\t  ArrayMapNode.prototype.iterate =\n\t  HashCollisionNode.prototype.iterate = function (fn, reverse) {\n\t    var entries = this.entries;\n\t    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n\t      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n\t        return false;\n\t      }\n\t    }\n\t  }\n\t\n\t  BitmapIndexedNode.prototype.iterate =\n\t  HashArrayMapNode.prototype.iterate = function (fn, reverse) {\n\t    var nodes = this.nodes;\n\t    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n\t      var node = nodes[reverse ? maxIndex - ii : ii];\n\t      if (node && node.iterate(fn, reverse) === false) {\n\t        return false;\n\t      }\n\t    }\n\t  }\n\t\n\t  ValueNode.prototype.iterate = function (fn, reverse) {\n\t    return fn(this.entry);\n\t  }\n\t\n\t  createClass(MapIterator, Iterator);\n\t\n\t    function MapIterator(map, type, reverse) {\n\t      this._type = type;\n\t      this._reverse = reverse;\n\t      this._stack = map._root && mapIteratorFrame(map._root);\n\t    }\n\t\n\t    MapIterator.prototype.next = function() {\n\t      var type = this._type;\n\t      var stack = this._stack;\n\t      while (stack) {\n\t        var node = stack.node;\n\t        var index = stack.index++;\n\t        var maxIndex;\n\t        if (node.entry) {\n\t          if (index === 0) {\n\t            return mapIteratorValue(type, node.entry);\n\t          }\n\t        } else if (node.entries) {\n\t          maxIndex = node.entries.length - 1;\n\t          if (index <= maxIndex) {\n\t            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);\n\t          }\n\t        } else {\n\t          maxIndex = node.nodes.length - 1;\n\t          if (index <= maxIndex) {\n\t            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n\t            if (subNode) {\n\t              if (subNode.entry) {\n\t                return mapIteratorValue(type, subNode.entry);\n\t              }\n\t              stack = this._stack = mapIteratorFrame(subNode, stack);\n\t            }\n\t            continue;\n\t          }\n\t        }\n\t        stack = this._stack = this._stack.__prev;\n\t      }\n\t      return iteratorDone();\n\t    };\n\t\n\t\n\t  function mapIteratorValue(type, entry) {\n\t    return iteratorValue(type, entry[0], entry[1]);\n\t  }\n\t\n\t  function mapIteratorFrame(node, prev) {\n\t    return {\n\t      node: node,\n\t      index: 0,\n\t      __prev: prev\n\t    };\n\t  }\n\t\n\t  function makeMap(size, root, ownerID, hash) {\n\t    var map = Object.create(MapPrototype);\n\t    map.size = size;\n\t    map._root = root;\n\t    map.__ownerID = ownerID;\n\t    map.__hash = hash;\n\t    map.__altered = false;\n\t    return map;\n\t  }\n\t\n\t  var EMPTY_MAP;\n\t  function emptyMap() {\n\t    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n\t  }\n\t\n\t  function updateMap(map, k, v) {\n\t    var newRoot;\n\t    var newSize;\n\t    if (!map._root) {\n\t      if (v === NOT_SET) {\n\t        return map;\n\t      }\n\t      newSize = 1;\n\t      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n\t    } else {\n\t      var didChangeSize = MakeRef(CHANGE_LENGTH);\n\t      var didAlter = MakeRef(DID_ALTER);\n\t      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);\n\t      if (!didAlter.value) {\n\t        return map;\n\t      }\n\t      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);\n\t    }\n\t    if (map.__ownerID) {\n\t      map.size = newSize;\n\t      map._root = newRoot;\n\t      map.__hash = undefined;\n\t      map.__altered = true;\n\t      return map;\n\t    }\n\t    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n\t  }\n\t\n\t  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n\t    if (!node) {\n\t      if (value === NOT_SET) {\n\t        return node;\n\t      }\n\t      SetRef(didAlter);\n\t      SetRef(didChangeSize);\n\t      return new ValueNode(ownerID, keyHash, [key, value]);\n\t    }\n\t    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);\n\t  }\n\t\n\t  function isLeafNode(node) {\n\t    return node.constructor === ValueNode || node.constructor === HashCollisionNode;\n\t  }\n\t\n\t  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n\t    if (node.keyHash === keyHash) {\n\t      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n\t    }\n\t\n\t    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n\t    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\t\n\t    var newNode;\n\t    var nodes = idx1 === idx2 ?\n\t      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :\n\t      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\t\n\t    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n\t  }\n\t\n\t  function createNodes(ownerID, entries, key, value) {\n\t    if (!ownerID) {\n\t      ownerID = new OwnerID();\n\t    }\n\t    var node = new ValueNode(ownerID, hash(key), [key, value]);\n\t    for (var ii = 0; ii < entries.length; ii++) {\n\t      var entry = entries[ii];\n\t      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n\t    }\n\t    return node;\n\t  }\n\t\n\t  function packNodes(ownerID, nodes, count, excluding) {\n\t    var bitmap = 0;\n\t    var packedII = 0;\n\t    var packedNodes = new Array(count);\n\t    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n\t      var node = nodes[ii];\n\t      if (node !== undefined && ii !== excluding) {\n\t        bitmap |= bit;\n\t        packedNodes[packedII++] = node;\n\t      }\n\t    }\n\t    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n\t  }\n\t\n\t  function expandNodes(ownerID, nodes, bitmap, including, node) {\n\t    var count = 0;\n\t    var expandedNodes = new Array(SIZE);\n\t    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n\t      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n\t    }\n\t    expandedNodes[including] = node;\n\t    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n\t  }\n\t\n\t  function mergeIntoMapWith(map, merger, iterables) {\n\t    var iters = [];\n\t    for (var ii = 0; ii < iterables.length; ii++) {\n\t      var value = iterables[ii];\n\t      var iter = KeyedIterable(value);\n\t      if (!isIterable(value)) {\n\t        iter = iter.map(function(v ) {return fromJS(v)});\n\t      }\n\t      iters.push(iter);\n\t    }\n\t    return mergeIntoCollectionWith(map, merger, iters);\n\t  }\n\t\n\t  function deepMerger(existing, value, key) {\n\t    return existing && existing.mergeDeep && isIterable(value) ?\n\t      existing.mergeDeep(value) :\n\t      is(existing, value) ? existing : value;\n\t  }\n\t\n\t  function deepMergerWith(merger) {\n\t    return function(existing, value, key)  {\n\t      if (existing && existing.mergeDeepWith && isIterable(value)) {\n\t        return existing.mergeDeepWith(merger, value);\n\t      }\n\t      var nextValue = merger(existing, value, key);\n\t      return is(existing, nextValue) ? existing : nextValue;\n\t    };\n\t  }\n\t\n\t  function mergeIntoCollectionWith(collection, merger, iters) {\n\t    iters = iters.filter(function(x ) {return x.size !== 0});\n\t    if (iters.length === 0) {\n\t      return collection;\n\t    }\n\t    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {\n\t      return collection.constructor(iters[0]);\n\t    }\n\t    return collection.withMutations(function(collection ) {\n\t      var mergeIntoMap = merger ?\n\t        function(value, key)  {\n\t          collection.update(key, NOT_SET, function(existing )\n\t            {return existing === NOT_SET ? value : merger(existing, value, key)}\n\t          );\n\t        } :\n\t        function(value, key)  {\n\t          collection.set(key, value);\n\t        }\n\t      for (var ii = 0; ii < iters.length; ii++) {\n\t        iters[ii].forEach(mergeIntoMap);\n\t      }\n\t    });\n\t  }\n\t\n\t  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {\n\t    var isNotSet = existing === NOT_SET;\n\t    var step = keyPathIter.next();\n\t    if (step.done) {\n\t      var existingValue = isNotSet ? notSetValue : existing;\n\t      var newValue = updater(existingValue);\n\t      return newValue === existingValue ? existing : newValue;\n\t    }\n\t    invariant(\n\t      isNotSet || (existing && existing.set),\n\t      'invalid keyPath'\n\t    );\n\t    var key = step.value;\n\t    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);\n\t    var nextUpdated = updateInDeepMap(\n\t      nextExisting,\n\t      keyPathIter,\n\t      notSetValue,\n\t      updater\n\t    );\n\t    return nextUpdated === nextExisting ? existing :\n\t      nextUpdated === NOT_SET ? existing.remove(key) :\n\t      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);\n\t  }\n\t\n\t  function popCount(x) {\n\t    x = x - ((x >> 1) & 0x55555555);\n\t    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n\t    x = (x + (x >> 4)) & 0x0f0f0f0f;\n\t    x = x + (x >> 8);\n\t    x = x + (x >> 16);\n\t    return x & 0x7f;\n\t  }\n\t\n\t  function setIn(array, idx, val, canEdit) {\n\t    var newArray = canEdit ? array : arrCopy(array);\n\t    newArray[idx] = val;\n\t    return newArray;\n\t  }\n\t\n\t  function spliceIn(array, idx, val, canEdit) {\n\t    var newLen = array.length + 1;\n\t    if (canEdit && idx + 1 === newLen) {\n\t      array[idx] = val;\n\t      return array;\n\t    }\n\t    var newArray = new Array(newLen);\n\t    var after = 0;\n\t    for (var ii = 0; ii < newLen; ii++) {\n\t      if (ii === idx) {\n\t        newArray[ii] = val;\n\t        after = -1;\n\t      } else {\n\t        newArray[ii] = array[ii + after];\n\t      }\n\t    }\n\t    return newArray;\n\t  }\n\t\n\t  function spliceOut(array, idx, canEdit) {\n\t    var newLen = array.length - 1;\n\t    if (canEdit && idx === newLen) {\n\t      array.pop();\n\t      return array;\n\t    }\n\t    var newArray = new Array(newLen);\n\t    var after = 0;\n\t    for (var ii = 0; ii < newLen; ii++) {\n\t      if (ii === idx) {\n\t        after = 1;\n\t      }\n\t      newArray[ii] = array[ii + after];\n\t    }\n\t    return newArray;\n\t  }\n\t\n\t  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n\t  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n\t  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\t\n\t  createClass(List, IndexedCollection);\n\t\n\t    // @pragma Construction\n\t\n\t    function List(value) {\n\t      var empty = emptyList();\n\t      if (value === null || value === undefined) {\n\t        return empty;\n\t      }\n\t      if (isList(value)) {\n\t        return value;\n\t      }\n\t      var iter = IndexedIterable(value);\n\t      var size = iter.size;\n\t      if (size === 0) {\n\t        return empty;\n\t      }\n\t      assertNotInfinite(size);\n\t      if (size > 0 && size < SIZE) {\n\t        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n\t      }\n\t      return empty.withMutations(function(list ) {\n\t        list.setSize(size);\n\t        iter.forEach(function(v, i)  {return list.set(i, v)});\n\t      });\n\t    }\n\t\n\t    List.of = function(/*...values*/) {\n\t      return this(arguments);\n\t    };\n\t\n\t    List.prototype.toString = function() {\n\t      return this.__toString('List [', ']');\n\t    };\n\t\n\t    // @pragma Access\n\t\n\t    List.prototype.get = function(index, notSetValue) {\n\t      index = wrapIndex(this, index);\n\t      if (index >= 0 && index < this.size) {\n\t        index += this._origin;\n\t        var node = listNodeFor(this, index);\n\t        return node && node.array[index & MASK];\n\t      }\n\t      return notSetValue;\n\t    };\n\t\n\t    // @pragma Modification\n\t\n\t    List.prototype.set = function(index, value) {\n\t      return updateList(this, index, value);\n\t    };\n\t\n\t    List.prototype.remove = function(index) {\n\t      return !this.has(index) ? this :\n\t        index === 0 ? this.shift() :\n\t        index === this.size - 1 ? this.pop() :\n\t        this.splice(index, 1);\n\t    };\n\t\n\t    List.prototype.insert = function(index, value) {\n\t      return this.splice(index, 0, value);\n\t    };\n\t\n\t    List.prototype.clear = function() {\n\t      if (this.size === 0) {\n\t        return this;\n\t      }\n\t      if (this.__ownerID) {\n\t        this.size = this._origin = this._capacity = 0;\n\t        this._level = SHIFT;\n\t        this._root = this._tail = null;\n\t        this.__hash = undefined;\n\t        this.__altered = true;\n\t        return this;\n\t      }\n\t      return emptyList();\n\t    };\n\t\n\t    List.prototype.push = function(/*...values*/) {\n\t      var values = arguments;\n\t      var oldSize = this.size;\n\t      return this.withMutations(function(list ) {\n\t        setListBounds(list, 0, oldSize + values.length);\n\t        for (var ii = 0; ii < values.length; ii++) {\n\t          list.set(oldSize + ii, values[ii]);\n\t        }\n\t      });\n\t    };\n\t\n\t    List.prototype.pop = function() {\n\t      return setListBounds(this, 0, -1);\n\t    };\n\t\n\t    List.prototype.unshift = function(/*...values*/) {\n\t      var values = arguments;\n\t      return this.withMutations(function(list ) {\n\t        setListBounds(list, -values.length);\n\t        for (var ii = 0; ii < values.length; ii++) {\n\t          list.set(ii, values[ii]);\n\t        }\n\t      });\n\t    };\n\t\n\t    List.prototype.shift = function() {\n\t      return setListBounds(this, 1);\n\t    };\n\t\n\t    // @pragma Composition\n\t\n\t    List.prototype.merge = function(/*...iters*/) {\n\t      return mergeIntoListWith(this, undefined, arguments);\n\t    };\n\t\n\t    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n\t      return mergeIntoListWith(this, merger, iters);\n\t    };\n\t\n\t    List.prototype.mergeDeep = function(/*...iters*/) {\n\t      return mergeIntoListWith(this, deepMerger, arguments);\n\t    };\n\t\n\t    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n\t      return mergeIntoListWith(this, deepMergerWith(merger), iters);\n\t    };\n\t\n\t    List.prototype.setSize = function(size) {\n\t      return setListBounds(this, 0, size);\n\t    };\n\t\n\t    // @pragma Iteration\n\t\n\t    List.prototype.slice = function(begin, end) {\n\t      var size = this.size;\n\t      if (wholeSlice(begin, end, size)) {\n\t        return this;\n\t      }\n\t      return setListBounds(\n\t        this,\n\t        resolveBegin(begin, size),\n\t        resolveEnd(end, size)\n\t      );\n\t    };\n\t\n\t    List.prototype.__iterator = function(type, reverse) {\n\t      var index = 0;\n\t      var values = iterateList(this, reverse);\n\t      return new Iterator(function()  {\n\t        var value = values();\n\t        return value === DONE ?\n\t          iteratorDone() :\n\t          iteratorValue(type, index++, value);\n\t      });\n\t    };\n\t\n\t    List.prototype.__iterate = function(fn, reverse) {\n\t      var index = 0;\n\t      var values = iterateList(this, reverse);\n\t      var value;\n\t      while ((value = values()) !== DONE) {\n\t        if (fn(value, index++, this) === false) {\n\t          break;\n\t        }\n\t      }\n\t      return index;\n\t    };\n\t\n\t    List.prototype.__ensureOwner = function(ownerID) {\n\t      if (ownerID === this.__ownerID) {\n\t        return this;\n\t      }\n\t      if (!ownerID) {\n\t        this.__ownerID = ownerID;\n\t        return this;\n\t      }\n\t      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);\n\t    };\n\t\n\t\n\t  function isList(maybeList) {\n\t    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);\n\t  }\n\t\n\t  List.isList = isList;\n\t\n\t  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';\n\t\n\t  var ListPrototype = List.prototype;\n\t  ListPrototype[IS_LIST_SENTINEL] = true;\n\t  ListPrototype[DELETE] = ListPrototype.remove;\n\t  ListPrototype.setIn = MapPrototype.setIn;\n\t  ListPrototype.deleteIn =\n\t  ListPrototype.removeIn = MapPrototype.removeIn;\n\t  ListPrototype.update = MapPrototype.update;\n\t  ListPrototype.updateIn = MapPrototype.updateIn;\n\t  ListPrototype.mergeIn = MapPrototype.mergeIn;\n\t  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n\t  ListPrototype.withMutations = MapPrototype.withMutations;\n\t  ListPrototype.asMutable = MapPrototype.asMutable;\n\t  ListPrototype.asImmutable = MapPrototype.asImmutable;\n\t  ListPrototype.wasAltered = MapPrototype.wasAltered;\n\t\n\t\n\t\n\t    function VNode(array, ownerID) {\n\t      this.array = array;\n\t      this.ownerID = ownerID;\n\t    }\n\t\n\t    // TODO: seems like these methods are very similar\n\t\n\t    VNode.prototype.removeBefore = function(ownerID, level, index) {\n\t      if (index === level ? 1 << level : 0 || this.array.length === 0) {\n\t        return this;\n\t      }\n\t      var originIndex = (index >>> level) & MASK;\n\t      if (originIndex >= this.array.length) {\n\t        return new VNode([], ownerID);\n\t      }\n\t      var removingFirst = originIndex === 0;\n\t      var newChild;\n\t      if (level > 0) {\n\t        var oldChild = this.array[originIndex];\n\t        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n\t        if (newChild === oldChild && removingFirst) {\n\t          return this;\n\t        }\n\t      }\n\t      if (removingFirst && !newChild) {\n\t        return this;\n\t      }\n\t      var editable = editableVNode(this, ownerID);\n\t      if (!removingFirst) {\n\t        for (var ii = 0; ii < originIndex; ii++) {\n\t          editable.array[ii] = undefined;\n\t        }\n\t      }\n\t      if (newChild) {\n\t        editable.array[originIndex] = newChild;\n\t      }\n\t      return editable;\n\t    };\n\t\n\t    VNode.prototype.removeAfter = function(ownerID, level, index) {\n\t      if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n\t        return this;\n\t      }\n\t      var sizeIndex = ((index - 1) >>> level) & MASK;\n\t      if (sizeIndex >= this.array.length) {\n\t        return this;\n\t      }\n\t\n\t      var newChild;\n\t      if (level > 0) {\n\t        var oldChild = this.array[sizeIndex];\n\t        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n\t        if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n\t          return this;\n\t        }\n\t      }\n\t\n\t      var editable = editableVNode(this, ownerID);\n\t      editable.array.splice(sizeIndex + 1);\n\t      if (newChild) {\n\t        editable.array[sizeIndex] = newChild;\n\t      }\n\t      return editable;\n\t    };\n\t\n\t\n\t\n\t  var DONE = {};\n\t\n\t  function iterateList(list, reverse) {\n\t    var left = list._origin;\n\t    var right = list._capacity;\n\t    var tailPos = getTailOffset(right);\n\t    var tail = list._tail;\n\t\n\t    return iterateNodeOrLeaf(list._root, list._level, 0);\n\t\n\t    function iterateNodeOrLeaf(node, level, offset) {\n\t      return level === 0 ?\n\t        iterateLeaf(node, offset) :\n\t        iterateNode(node, level, offset);\n\t    }\n\t\n\t    function iterateLeaf(node, offset) {\n\t      var array = offset === tailPos ? tail && tail.array : node && node.array;\n\t      var from = offset > left ? 0 : left - offset;\n\t      var to = right - offset;\n\t      if (to > SIZE) {\n\t        to = SIZE;\n\t      }\n\t      return function()  {\n\t        if (from === to) {\n\t          return DONE;\n\t        }\n\t        var idx = reverse ? --to : from++;\n\t        return array && array[idx];\n\t      };\n\t    }\n\t\n\t    function iterateNode(node, level, offset) {\n\t      var values;\n\t      var array = node && node.array;\n\t      var from = offset > left ? 0 : (left - offset) >> level;\n\t      var to = ((right - offset) >> level) + 1;\n\t      if (to > SIZE) {\n\t        to = SIZE;\n\t      }\n\t      return function()  {\n\t        do {\n\t          if (values) {\n\t            var value = values();\n\t            if (value !== DONE) {\n\t              return value;\n\t            }\n\t            values = null;\n\t          }\n\t          if (from === to) {\n\t            return DONE;\n\t          }\n\t          var idx = reverse ? --to : from++;\n\t          values = iterateNodeOrLeaf(\n\t            array && array[idx], level - SHIFT, offset + (idx << level)\n\t          );\n\t        } while (true);\n\t      };\n\t    }\n\t  }\n\t\n\t  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n\t    var list = Object.create(ListPrototype);\n\t    list.size = capacity - origin;\n\t    list._origin = origin;\n\t    list._capacity = capacity;\n\t    list._level = level;\n\t    list._root = root;\n\t    list._tail = tail;\n\t    list.__ownerID = ownerID;\n\t    list.__hash = hash;\n\t    list.__altered = false;\n\t    return list;\n\t  }\n\t\n\t  var EMPTY_LIST;\n\t  function emptyList() {\n\t    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n\t  }\n\t\n\t  function updateList(list, index, value) {\n\t    index = wrapIndex(list, index);\n\t\n\t    if (index !== index) {\n\t      return list;\n\t    }\n\t\n\t    if (index >= list.size || index < 0) {\n\t      return list.withMutations(function(list ) {\n\t        index < 0 ?\n\t          setListBounds(list, index).set(0, value) :\n\t          setListBounds(list, 0, index + 1).set(index, value)\n\t      });\n\t    }\n\t\n\t    index += list._origin;\n\t\n\t    var newTail = list._tail;\n\t    var newRoot = list._root;\n\t    var didAlter = MakeRef(DID_ALTER);\n\t    if (index >= getTailOffset(list._capacity)) {\n\t      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n\t    } else {\n\t      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);\n\t    }\n\t\n\t    if (!didAlter.value) {\n\t      return list;\n\t    }\n\t\n\t    if (list.__ownerID) {\n\t      list._root = newRoot;\n\t      list._tail = newTail;\n\t      list.__hash = undefined;\n\t      list.__altered = true;\n\t      return list;\n\t    }\n\t    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n\t  }\n\t\n\t  function updateVNode(node, ownerID, level, index, value, didAlter) {\n\t    var idx = (index >>> level) & MASK;\n\t    var nodeHas = node && idx < node.array.length;\n\t    if (!nodeHas && value === undefined) {\n\t      return node;\n\t    }\n\t\n\t    var newNode;\n\t\n\t    if (level > 0) {\n\t      var lowerNode = node && node.array[idx];\n\t      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);\n\t      if (newLowerNode === lowerNode) {\n\t        return node;\n\t      }\n\t      newNode = editableVNode(node, ownerID);\n\t      newNode.array[idx] = newLowerNode;\n\t      return newNode;\n\t    }\n\t\n\t    if (nodeHas && node.array[idx] === value) {\n\t      return node;\n\t    }\n\t\n\t    SetRef(didAlter);\n\t\n\t    newNode = editableVNode(node, ownerID);\n\t    if (value === undefined && idx === newNode.array.length - 1) {\n\t      newNode.array.pop();\n\t    } else {\n\t      newNode.array[idx] = value;\n\t    }\n\t    return newNode;\n\t  }\n\t\n\t  function editableVNode(node, ownerID) {\n\t    if (ownerID && node && ownerID === node.ownerID) {\n\t      return node;\n\t    }\n\t    return new VNode(node ? node.array.slice() : [], ownerID);\n\t  }\n\t\n\t  function listNodeFor(list, rawIndex) {\n\t    if (rawIndex >= getTailOffset(list._capacity)) {\n\t      return list._tail;\n\t    }\n\t    if (rawIndex < 1 << (list._level + SHIFT)) {\n\t      var node = list._root;\n\t      var level = list._level;\n\t      while (node && level > 0) {\n\t        node = node.array[(rawIndex >>> level) & MASK];\n\t        level -= SHIFT;\n\t      }\n\t      return node;\n\t    }\n\t  }\n\t\n\t  function setListBounds(list, begin, end) {\n\t    // Sanitize begin & end using this shorthand for ToInt32(argument)\n\t    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n\t    if (begin !== undefined) {\n\t      begin = begin | 0;\n\t    }\n\t    if (end !== undefined) {\n\t      end = end | 0;\n\t    }\n\t    var owner = list.__ownerID || new OwnerID();\n\t    var oldOrigin = list._origin;\n\t    var oldCapacity = list._capacity;\n\t    var newOrigin = oldOrigin + begin;\n\t    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;\n\t    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n\t      return list;\n\t    }\n\t\n\t    // If it's going to end after it starts, it's empty.\n\t    if (newOrigin >= newCapacity) {\n\t      return list.clear();\n\t    }\n\t\n\t    var newLevel = list._level;\n\t    var newRoot = list._root;\n\t\n\t    // New origin might need creating a higher root.\n\t    var offsetShift = 0;\n\t    while (newOrigin + offsetShift < 0) {\n\t      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);\n\t      newLevel += SHIFT;\n\t      offsetShift += 1 << newLevel;\n\t    }\n\t    if (offsetShift) {\n\t      newOrigin += offsetShift;\n\t      oldOrigin += offsetShift;\n\t      newCapacity += offsetShift;\n\t      oldCapacity += offsetShift;\n\t    }\n\t\n\t    var oldTailOffset = getTailOffset(oldCapacity);\n\t    var newTailOffset = getTailOffset(newCapacity);\n\t\n\t    // New size might need creating a higher root.\n\t    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n\t      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);\n\t      newLevel += SHIFT;\n\t    }\n\t\n\t    // Locate or create the new tail.\n\t    var oldTail = list._tail;\n\t    var newTail = newTailOffset < oldTailOffset ?\n\t      listNodeFor(list, newCapacity - 1) :\n\t      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;\n\t\n\t    // Merge Tail into tree.\n\t    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {\n\t      newRoot = editableVNode(newRoot, owner);\n\t      var node = newRoot;\n\t      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n\t        var idx = (oldTailOffset >>> level) & MASK;\n\t        node = node.array[idx] = editableVNode(node.array[idx], owner);\n\t      }\n\t      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n\t    }\n\t\n\t    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n\t    if (newCapacity < oldCapacity) {\n\t      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n\t    }\n\t\n\t    // If the new origin is within the tail, then we do not need a root.\n\t    if (newOrigin >= newTailOffset) {\n\t      newOrigin -= newTailOffset;\n\t      newCapacity -= newTailOffset;\n\t      newLevel = SHIFT;\n\t      newRoot = null;\n\t      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\t\n\t    // Otherwise, if the root has been trimmed, garbage collect.\n\t    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n\t      offsetShift = 0;\n\t\n\t      // Identify the new top root node of the subtree of the old root.\n\t      while (newRoot) {\n\t        var beginIndex = (newOrigin >>> newLevel) & MASK;\n\t        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {\n\t          break;\n\t        }\n\t        if (beginIndex) {\n\t          offsetShift += (1 << newLevel) * beginIndex;\n\t        }\n\t        newLevel -= SHIFT;\n\t        newRoot = newRoot.array[beginIndex];\n\t      }\n\t\n\t      // Trim the new sides of the new root.\n\t      if (newRoot && newOrigin > oldOrigin) {\n\t        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n\t      }\n\t      if (newRoot && newTailOffset < oldTailOffset) {\n\t        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);\n\t      }\n\t      if (offsetShift) {\n\t        newOrigin -= offsetShift;\n\t        newCapacity -= offsetShift;\n\t      }\n\t    }\n\t\n\t    if (list.__ownerID) {\n\t      list.size = newCapacity - newOrigin;\n\t      list._origin = newOrigin;\n\t      list._capacity = newCapacity;\n\t      list._level = newLevel;\n\t      list._root = newRoot;\n\t      list._tail = newTail;\n\t      list.__hash = undefined;\n\t      list.__altered = true;\n\t      return list;\n\t    }\n\t    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n\t  }\n\t\n\t  function mergeIntoListWith(list, merger, iterables) {\n\t    var iters = [];\n\t    var maxSize = 0;\n\t    for (var ii = 0; ii < iterables.length; ii++) {\n\t      var value = iterables[ii];\n\t      var iter = IndexedIterable(value);\n\t      if (iter.size > maxSize) {\n\t        maxSize = iter.size;\n\t      }\n\t      if (!isIterable(value)) {\n\t        iter = iter.map(function(v ) {return fromJS(v)});\n\t      }\n\t      iters.push(iter);\n\t    }\n\t    if (maxSize > list.size) {\n\t      list = list.setSize(maxSize);\n\t    }\n\t    return mergeIntoCollectionWith(list, merger, iters);\n\t  }\n\t\n\t  function getTailOffset(size) {\n\t    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);\n\t  }\n\t\n\t  createClass(OrderedMap, Map);\n\t\n\t    // @pragma Construction\n\t\n\t    function OrderedMap(value) {\n\t      return value === null || value === undefined ? emptyOrderedMap() :\n\t        isOrderedMap(value) ? value :\n\t        emptyOrderedMap().withMutations(function(map ) {\n\t          var iter = KeyedIterable(value);\n\t          assertNotInfinite(iter.size);\n\t          iter.forEach(function(v, k)  {return map.set(k, v)});\n\t        });\n\t    }\n\t\n\t    OrderedMap.of = function(/*...values*/) {\n\t      return this(arguments);\n\t    };\n\t\n\t    OrderedMap.prototype.toString = function() {\n\t      return this.__toString('OrderedMap {', '}');\n\t    };\n\t\n\t    // @pragma Access\n\t\n\t    OrderedMap.prototype.get = function(k, notSetValue) {\n\t      var index = this._map.get(k);\n\t      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n\t    };\n\t\n\t    // @pragma Modification\n\t\n\t    OrderedMap.prototype.clear = function() {\n\t      if (this.size === 0) {\n\t        return this;\n\t      }\n\t      if (this.__ownerID) {\n\t        this.size = 0;\n\t        this._map.clear();\n\t        this._list.clear();\n\t        return this;\n\t      }\n\t      return emptyOrderedMap();\n\t    };\n\t\n\t    OrderedMap.prototype.set = function(k, v) {\n\t      return updateOrderedMap(this, k, v);\n\t    };\n\t\n\t    OrderedMap.prototype.remove = function(k) {\n\t      return updateOrderedMap(this, k, NOT_SET);\n\t    };\n\t\n\t    OrderedMap.prototype.wasAltered = function() {\n\t      return this._map.wasAltered() || this._list.wasAltered();\n\t    };\n\t\n\t    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      return this._list.__iterate(\n\t        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},\n\t        reverse\n\t      );\n\t    };\n\t\n\t    OrderedMap.prototype.__iterator = function(type, reverse) {\n\t      return this._list.fromEntrySeq().__iterator(type, reverse);\n\t    };\n\t\n\t    OrderedMap.prototype.__ensureOwner = function(ownerID) {\n\t      if (ownerID === this.__ownerID) {\n\t        return this;\n\t      }\n\t      var newMap = this._map.__ensureOwner(ownerID);\n\t      var newList = this._list.__ensureOwner(ownerID);\n\t      if (!ownerID) {\n\t        this.__ownerID = ownerID;\n\t        this._map = newMap;\n\t        this._list = newList;\n\t        return this;\n\t      }\n\t      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n\t    };\n\t\n\t\n\t  function isOrderedMap(maybeOrderedMap) {\n\t    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n\t  }\n\t\n\t  OrderedMap.isOrderedMap = isOrderedMap;\n\t\n\t  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;\n\t  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\t\n\t\n\t\n\t  function makeOrderedMap(map, list, ownerID, hash) {\n\t    var omap = Object.create(OrderedMap.prototype);\n\t    omap.size = map ? map.size : 0;\n\t    omap._map = map;\n\t    omap._list = list;\n\t    omap.__ownerID = ownerID;\n\t    omap.__hash = hash;\n\t    return omap;\n\t  }\n\t\n\t  var EMPTY_ORDERED_MAP;\n\t  function emptyOrderedMap() {\n\t    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));\n\t  }\n\t\n\t  function updateOrderedMap(omap, k, v) {\n\t    var map = omap._map;\n\t    var list = omap._list;\n\t    var i = map.get(k);\n\t    var has = i !== undefined;\n\t    var newMap;\n\t    var newList;\n\t    if (v === NOT_SET) { // removed\n\t      if (!has) {\n\t        return omap;\n\t      }\n\t      if (list.size >= SIZE && list.size >= map.size * 2) {\n\t        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});\n\t        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();\n\t        if (omap.__ownerID) {\n\t          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n\t        }\n\t      } else {\n\t        newMap = map.remove(k);\n\t        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n\t      }\n\t    } else {\n\t      if (has) {\n\t        if (v === list.get(i)[1]) {\n\t          return omap;\n\t        }\n\t        newMap = map;\n\t        newList = list.set(i, [k, v]);\n\t      } else {\n\t        newMap = map.set(k, list.size);\n\t        newList = list.set(list.size, [k, v]);\n\t      }\n\t    }\n\t    if (omap.__ownerID) {\n\t      omap.size = newMap.size;\n\t      omap._map = newMap;\n\t      omap._list = newList;\n\t      omap.__hash = undefined;\n\t      return omap;\n\t    }\n\t    return makeOrderedMap(newMap, newList);\n\t  }\n\t\n\t  createClass(ToKeyedSequence, KeyedSeq);\n\t    function ToKeyedSequence(indexed, useKeys) {\n\t      this._iter = indexed;\n\t      this._useKeys = useKeys;\n\t      this.size = indexed.size;\n\t    }\n\t\n\t    ToKeyedSequence.prototype.get = function(key, notSetValue) {\n\t      return this._iter.get(key, notSetValue);\n\t    };\n\t\n\t    ToKeyedSequence.prototype.has = function(key) {\n\t      return this._iter.has(key);\n\t    };\n\t\n\t    ToKeyedSequence.prototype.valueSeq = function() {\n\t      return this._iter.valueSeq();\n\t    };\n\t\n\t    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;\n\t      var reversedSequence = reverseFactory(this, true);\n\t      if (!this._useKeys) {\n\t        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};\n\t      }\n\t      return reversedSequence;\n\t    };\n\t\n\t    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;\n\t      var mappedSequence = mapFactory(this, mapper, context);\n\t      if (!this._useKeys) {\n\t        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};\n\t      }\n\t      return mappedSequence;\n\t    };\n\t\n\t    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      var ii;\n\t      return this._iter.__iterate(\n\t        this._useKeys ?\n\t          function(v, k)  {return fn(v, k, this$0)} :\n\t          ((ii = reverse ? resolveSize(this) : 0),\n\t            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),\n\t        reverse\n\t      );\n\t    };\n\t\n\t    ToKeyedSequence.prototype.__iterator = function(type, reverse) {\n\t      if (this._useKeys) {\n\t        return this._iter.__iterator(type, reverse);\n\t      }\n\t      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n\t      var ii = reverse ? resolveSize(this) : 0;\n\t      return new Iterator(function()  {\n\t        var step = iterator.next();\n\t        return step.done ? step :\n\t          iteratorValue(type, reverse ? --ii : ii++, step.value, step);\n\t      });\n\t    };\n\t\n\t  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;\n\t\n\t\n\t  createClass(ToIndexedSequence, IndexedSeq);\n\t    function ToIndexedSequence(iter) {\n\t      this._iter = iter;\n\t      this.size = iter.size;\n\t    }\n\t\n\t    ToIndexedSequence.prototype.includes = function(value) {\n\t      return this._iter.includes(value);\n\t    };\n\t\n\t    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      var iterations = 0;\n\t      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);\n\t    };\n\t\n\t    ToIndexedSequence.prototype.__iterator = function(type, reverse) {\n\t      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        var step = iterator.next();\n\t        return step.done ? step :\n\t          iteratorValue(type, iterations++, step.value, step)\n\t      });\n\t    };\n\t\n\t\n\t\n\t  createClass(ToSetSequence, SetSeq);\n\t    function ToSetSequence(iter) {\n\t      this._iter = iter;\n\t      this.size = iter.size;\n\t    }\n\t\n\t    ToSetSequence.prototype.has = function(key) {\n\t      return this._iter.includes(key);\n\t    };\n\t\n\t    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);\n\t    };\n\t\n\t    ToSetSequence.prototype.__iterator = function(type, reverse) {\n\t      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n\t      return new Iterator(function()  {\n\t        var step = iterator.next();\n\t        return step.done ? step :\n\t          iteratorValue(type, step.value, step.value, step);\n\t      });\n\t    };\n\t\n\t\n\t\n\t  createClass(FromEntriesSequence, KeyedSeq);\n\t    function FromEntriesSequence(entries) {\n\t      this._iter = entries;\n\t      this.size = entries.size;\n\t    }\n\t\n\t    FromEntriesSequence.prototype.entrySeq = function() {\n\t      return this._iter.toSeq();\n\t    };\n\t\n\t    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      return this._iter.__iterate(function(entry ) {\n\t        // Check if entry exists first so array access doesn't throw for holes\n\t        // in the parent iteration.\n\t        if (entry) {\n\t          validateEntry(entry);\n\t          var indexedIterable = isIterable(entry);\n\t          return fn(\n\t            indexedIterable ? entry.get(1) : entry[1],\n\t            indexedIterable ? entry.get(0) : entry[0],\n\t            this$0\n\t          );\n\t        }\n\t      }, reverse);\n\t    };\n\t\n\t    FromEntriesSequence.prototype.__iterator = function(type, reverse) {\n\t      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n\t      return new Iterator(function()  {\n\t        while (true) {\n\t          var step = iterator.next();\n\t          if (step.done) {\n\t            return step;\n\t          }\n\t          var entry = step.value;\n\t          // Check if entry exists first so array access doesn't throw for holes\n\t          // in the parent iteration.\n\t          if (entry) {\n\t            validateEntry(entry);\n\t            var indexedIterable = isIterable(entry);\n\t            return iteratorValue(\n\t              type,\n\t              indexedIterable ? entry.get(0) : entry[0],\n\t              indexedIterable ? entry.get(1) : entry[1],\n\t              step\n\t            );\n\t          }\n\t        }\n\t      });\n\t    };\n\t\n\t\n\t  ToIndexedSequence.prototype.cacheResult =\n\t  ToKeyedSequence.prototype.cacheResult =\n\t  ToSetSequence.prototype.cacheResult =\n\t  FromEntriesSequence.prototype.cacheResult =\n\t    cacheResultThrough;\n\t\n\t\n\t  function flipFactory(iterable) {\n\t    var flipSequence = makeSequence(iterable);\n\t    flipSequence._iter = iterable;\n\t    flipSequence.size = iterable.size;\n\t    flipSequence.flip = function()  {return iterable};\n\t    flipSequence.reverse = function () {\n\t      var reversedSequence = iterable.reverse.apply(this); // super.reverse()\n\t      reversedSequence.flip = function()  {return iterable.reverse()};\n\t      return reversedSequence;\n\t    };\n\t    flipSequence.has = function(key ) {return iterable.includes(key)};\n\t    flipSequence.includes = function(key ) {return iterable.has(key)};\n\t    flipSequence.cacheResult = cacheResultThrough;\n\t    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n\t      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);\n\t    }\n\t    flipSequence.__iteratorUncached = function(type, reverse) {\n\t      if (type === ITERATE_ENTRIES) {\n\t        var iterator = iterable.__iterator(type, reverse);\n\t        return new Iterator(function()  {\n\t          var step = iterator.next();\n\t          if (!step.done) {\n\t            var k = step.value[0];\n\t            step.value[0] = step.value[1];\n\t            step.value[1] = k;\n\t          }\n\t          return step;\n\t        });\n\t      }\n\t      return iterable.__iterator(\n\t        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n\t        reverse\n\t      );\n\t    }\n\t    return flipSequence;\n\t  }\n\t\n\t\n\t  function mapFactory(iterable, mapper, context) {\n\t    var mappedSequence = makeSequence(iterable);\n\t    mappedSequence.size = iterable.size;\n\t    mappedSequence.has = function(key ) {return iterable.has(key)};\n\t    mappedSequence.get = function(key, notSetValue)  {\n\t      var v = iterable.get(key, NOT_SET);\n\t      return v === NOT_SET ?\n\t        notSetValue :\n\t        mapper.call(context, v, key, iterable);\n\t    };\n\t    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n\t      return iterable.__iterate(\n\t        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},\n\t        reverse\n\t      );\n\t    }\n\t    mappedSequence.__iteratorUncached = function (type, reverse) {\n\t      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n\t      return new Iterator(function()  {\n\t        var step = iterator.next();\n\t        if (step.done) {\n\t          return step;\n\t        }\n\t        var entry = step.value;\n\t        var key = entry[0];\n\t        return iteratorValue(\n\t          type,\n\t          key,\n\t          mapper.call(context, entry[1], key, iterable),\n\t          step\n\t        );\n\t      });\n\t    }\n\t    return mappedSequence;\n\t  }\n\t\n\t\n\t  function reverseFactory(iterable, useKeys) {\n\t    var reversedSequence = makeSequence(iterable);\n\t    reversedSequence._iter = iterable;\n\t    reversedSequence.size = iterable.size;\n\t    reversedSequence.reverse = function()  {return iterable};\n\t    if (iterable.flip) {\n\t      reversedSequence.flip = function () {\n\t        var flipSequence = flipFactory(iterable);\n\t        flipSequence.reverse = function()  {return iterable.flip()};\n\t        return flipSequence;\n\t      };\n\t    }\n\t    reversedSequence.get = function(key, notSetValue) \n\t      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};\n\t    reversedSequence.has = function(key )\n\t      {return iterable.has(useKeys ? key : -1 - key)};\n\t    reversedSequence.includes = function(value ) {return iterable.includes(value)};\n\t    reversedSequence.cacheResult = cacheResultThrough;\n\t    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;\n\t      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);\n\t    };\n\t    reversedSequence.__iterator =\n\t      function(type, reverse)  {return iterable.__iterator(type, !reverse)};\n\t    return reversedSequence;\n\t  }\n\t\n\t\n\t  function filterFactory(iterable, predicate, context, useKeys) {\n\t    var filterSequence = makeSequence(iterable);\n\t    if (useKeys) {\n\t      filterSequence.has = function(key ) {\n\t        var v = iterable.get(key, NOT_SET);\n\t        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);\n\t      };\n\t      filterSequence.get = function(key, notSetValue)  {\n\t        var v = iterable.get(key, NOT_SET);\n\t        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?\n\t          v : notSetValue;\n\t      };\n\t    }\n\t    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n\t      var iterations = 0;\n\t      iterable.__iterate(function(v, k, c)  {\n\t        if (predicate.call(context, v, k, c)) {\n\t          iterations++;\n\t          return fn(v, useKeys ? k : iterations - 1, this$0);\n\t        }\n\t      }, reverse);\n\t      return iterations;\n\t    };\n\t    filterSequence.__iteratorUncached = function (type, reverse) {\n\t      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        while (true) {\n\t          var step = iterator.next();\n\t          if (step.done) {\n\t            return step;\n\t          }\n\t          var entry = step.value;\n\t          var key = entry[0];\n\t          var value = entry[1];\n\t          if (predicate.call(context, value, key, iterable)) {\n\t            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n\t          }\n\t        }\n\t      });\n\t    }\n\t    return filterSequence;\n\t  }\n\t\n\t\n\t  function countByFactory(iterable, grouper, context) {\n\t    var groups = Map().asMutable();\n\t    iterable.__iterate(function(v, k)  {\n\t      groups.update(\n\t        grouper.call(context, v, k, iterable),\n\t        0,\n\t        function(a ) {return a + 1}\n\t      );\n\t    });\n\t    return groups.asImmutable();\n\t  }\n\t\n\t\n\t  function groupByFactory(iterable, grouper, context) {\n\t    var isKeyedIter = isKeyed(iterable);\n\t    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();\n\t    iterable.__iterate(function(v, k)  {\n\t      groups.update(\n\t        grouper.call(context, v, k, iterable),\n\t        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}\n\t      );\n\t    });\n\t    var coerce = iterableClass(iterable);\n\t    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});\n\t  }\n\t\n\t\n\t  function sliceFactory(iterable, begin, end, useKeys) {\n\t    var originalSize = iterable.size;\n\t\n\t    // Sanitize begin & end using this shorthand for ToInt32(argument)\n\t    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n\t    if (begin !== undefined) {\n\t      begin = begin | 0;\n\t    }\n\t    if (end !== undefined) {\n\t      if (end === Infinity) {\n\t        end = originalSize;\n\t      } else {\n\t        end = end | 0;\n\t      }\n\t    }\n\t\n\t    if (wholeSlice(begin, end, originalSize)) {\n\t      return iterable;\n\t    }\n\t\n\t    var resolvedBegin = resolveBegin(begin, originalSize);\n\t    var resolvedEnd = resolveEnd(end, originalSize);\n\t\n\t    // begin or end will be NaN if they were provided as negative numbers and\n\t    // this iterable's size is unknown. In that case, cache first so there is\n\t    // a known size and these do not resolve to NaN.\n\t    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n\t      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);\n\t    }\n\t\n\t    // Note: resolvedEnd is undefined when the original sequence's length is\n\t    // unknown and this slice did not supply an end and should contain all\n\t    // elements after resolvedBegin.\n\t    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n\t    var resolvedSize = resolvedEnd - resolvedBegin;\n\t    var sliceSize;\n\t    if (resolvedSize === resolvedSize) {\n\t      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n\t    }\n\t\n\t    var sliceSeq = makeSequence(iterable);\n\t\n\t    // If iterable.size is undefined, the size of the realized sliceSeq is\n\t    // unknown at this point unless the number of items to slice is 0\n\t    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;\n\t\n\t    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {\n\t      sliceSeq.get = function (index, notSetValue) {\n\t        index = wrapIndex(this, index);\n\t        return index >= 0 && index < sliceSize ?\n\t          iterable.get(index + resolvedBegin, notSetValue) :\n\t          notSetValue;\n\t      }\n\t    }\n\t\n\t    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;\n\t      if (sliceSize === 0) {\n\t        return 0;\n\t      }\n\t      if (reverse) {\n\t        return this.cacheResult().__iterate(fn, reverse);\n\t      }\n\t      var skipped = 0;\n\t      var isSkipping = true;\n\t      var iterations = 0;\n\t      iterable.__iterate(function(v, k)  {\n\t        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n\t          iterations++;\n\t          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&\n\t                 iterations !== sliceSize;\n\t        }\n\t      });\n\t      return iterations;\n\t    };\n\t\n\t    sliceSeq.__iteratorUncached = function(type, reverse) {\n\t      if (sliceSize !== 0 && reverse) {\n\t        return this.cacheResult().__iterator(type, reverse);\n\t      }\n\t      // Don't bother instantiating parent iterator if taking 0.\n\t      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);\n\t      var skipped = 0;\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        while (skipped++ < resolvedBegin) {\n\t          iterator.next();\n\t        }\n\t        if (++iterations > sliceSize) {\n\t          return iteratorDone();\n\t        }\n\t        var step = iterator.next();\n\t        if (useKeys || type === ITERATE_VALUES) {\n\t          return step;\n\t        } else if (type === ITERATE_KEYS) {\n\t          return iteratorValue(type, iterations - 1, undefined, step);\n\t        } else {\n\t          return iteratorValue(type, iterations - 1, step.value[1], step);\n\t        }\n\t      });\n\t    }\n\t\n\t    return sliceSeq;\n\t  }\n\t\n\t\n\t  function takeWhileFactory(iterable, predicate, context) {\n\t    var takeSequence = makeSequence(iterable);\n\t    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n\t      if (reverse) {\n\t        return this.cacheResult().__iterate(fn, reverse);\n\t      }\n\t      var iterations = 0;\n\t      iterable.__iterate(function(v, k, c) \n\t        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}\n\t      );\n\t      return iterations;\n\t    };\n\t    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n\t      if (reverse) {\n\t        return this.cacheResult().__iterator(type, reverse);\n\t      }\n\t      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n\t      var iterating = true;\n\t      return new Iterator(function()  {\n\t        if (!iterating) {\n\t          return iteratorDone();\n\t        }\n\t        var step = iterator.next();\n\t        if (step.done) {\n\t          return step;\n\t        }\n\t        var entry = step.value;\n\t        var k = entry[0];\n\t        var v = entry[1];\n\t        if (!predicate.call(context, v, k, this$0)) {\n\t          iterating = false;\n\t          return iteratorDone();\n\t        }\n\t        return type === ITERATE_ENTRIES ? step :\n\t          iteratorValue(type, k, v, step);\n\t      });\n\t    };\n\t    return takeSequence;\n\t  }\n\t\n\t\n\t  function skipWhileFactory(iterable, predicate, context, useKeys) {\n\t    var skipSequence = makeSequence(iterable);\n\t    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n\t      if (reverse) {\n\t        return this.cacheResult().__iterate(fn, reverse);\n\t      }\n\t      var isSkipping = true;\n\t      var iterations = 0;\n\t      iterable.__iterate(function(v, k, c)  {\n\t        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n\t          iterations++;\n\t          return fn(v, useKeys ? k : iterations - 1, this$0);\n\t        }\n\t      });\n\t      return iterations;\n\t    };\n\t    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n\t      if (reverse) {\n\t        return this.cacheResult().__iterator(type, reverse);\n\t      }\n\t      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n\t      var skipping = true;\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        var step, k, v;\n\t        do {\n\t          step = iterator.next();\n\t          if (step.done) {\n\t            if (useKeys || type === ITERATE_VALUES) {\n\t              return step;\n\t            } else if (type === ITERATE_KEYS) {\n\t              return iteratorValue(type, iterations++, undefined, step);\n\t            } else {\n\t              return iteratorValue(type, iterations++, step.value[1], step);\n\t            }\n\t          }\n\t          var entry = step.value;\n\t          k = entry[0];\n\t          v = entry[1];\n\t          skipping && (skipping = predicate.call(context, v, k, this$0));\n\t        } while (skipping);\n\t        return type === ITERATE_ENTRIES ? step :\n\t          iteratorValue(type, k, v, step);\n\t      });\n\t    };\n\t    return skipSequence;\n\t  }\n\t\n\t\n\t  function concatFactory(iterable, values) {\n\t    var isKeyedIterable = isKeyed(iterable);\n\t    var iters = [iterable].concat(values).map(function(v ) {\n\t      if (!isIterable(v)) {\n\t        v = isKeyedIterable ?\n\t          keyedSeqFromValue(v) :\n\t          indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n\t      } else if (isKeyedIterable) {\n\t        v = KeyedIterable(v);\n\t      }\n\t      return v;\n\t    }).filter(function(v ) {return v.size !== 0});\n\t\n\t    if (iters.length === 0) {\n\t      return iterable;\n\t    }\n\t\n\t    if (iters.length === 1) {\n\t      var singleton = iters[0];\n\t      if (singleton === iterable ||\n\t          isKeyedIterable && isKeyed(singleton) ||\n\t          isIndexed(iterable) && isIndexed(singleton)) {\n\t        return singleton;\n\t      }\n\t    }\n\t\n\t    var concatSeq = new ArraySeq(iters);\n\t    if (isKeyedIterable) {\n\t      concatSeq = concatSeq.toKeyedSeq();\n\t    } else if (!isIndexed(iterable)) {\n\t      concatSeq = concatSeq.toSetSeq();\n\t    }\n\t    concatSeq = concatSeq.flatten(true);\n\t    concatSeq.size = iters.reduce(\n\t      function(sum, seq)  {\n\t        if (sum !== undefined) {\n\t          var size = seq.size;\n\t          if (size !== undefined) {\n\t            return sum + size;\n\t          }\n\t        }\n\t      },\n\t      0\n\t    );\n\t    return concatSeq;\n\t  }\n\t\n\t\n\t  function flattenFactory(iterable, depth, useKeys) {\n\t    var flatSequence = makeSequence(iterable);\n\t    flatSequence.__iterateUncached = function(fn, reverse) {\n\t      var iterations = 0;\n\t      var stopped = false;\n\t      function flatDeep(iter, currentDepth) {var this$0 = this;\n\t        iter.__iterate(function(v, k)  {\n\t          if ((!depth || currentDepth < depth) && isIterable(v)) {\n\t            flatDeep(v, currentDepth + 1);\n\t          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {\n\t            stopped = true;\n\t          }\n\t          return !stopped;\n\t        }, reverse);\n\t      }\n\t      flatDeep(iterable, 0);\n\t      return iterations;\n\t    }\n\t    flatSequence.__iteratorUncached = function(type, reverse) {\n\t      var iterator = iterable.__iterator(type, reverse);\n\t      var stack = [];\n\t      var iterations = 0;\n\t      return new Iterator(function()  {\n\t        while (iterator) {\n\t          var step = iterator.next();\n\t          if (step.done !== false) {\n\t            iterator = stack.pop();\n\t            continue;\n\t          }\n\t          var v = step.value;\n\t          if (type === ITERATE_ENTRIES) {\n\t            v = v[1];\n\t          }\n\t          if ((!depth || stack.length < depth) && isIterable(v)) {\n\t            stack.push(iterator);\n\t            iterator = v.__iterator(type, reverse);\n\t          } else {\n\t            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n\t          }\n\t        }\n\t        return iteratorDone();\n\t      });\n\t    }\n\t    return flatSequence;\n\t  }\n\t\n\t\n\t  function flatMapFactory(iterable, mapper, context) {\n\t    var coerce = iterableClass(iterable);\n\t    return iterable.toSeq().map(\n\t      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}\n\t    ).flatten(true);\n\t  }\n\t\n\t\n\t  function interposeFactory(iterable, separator) {\n\t    var interposedSequence = makeSequence(iterable);\n\t    interposedSequence.size = iterable.size && iterable.size * 2 -1;\n\t    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n\t      var iterations = 0;\n\t      iterable.__iterate(function(v, k) \n\t        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&\n\t        fn(v, iterations++, this$0) !== false},\n\t        reverse\n\t      );\n\t      return iterations;\n\t    };\n\t    interposedSequence.__iteratorUncached = function(type, reverse) {\n\t      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);\n\t      var iterations = 0;\n\t      var step;\n\t      return new Iterator(function()  {\n\t        if (!step || iterations % 2) {\n\t          step = iterator.next();\n\t          if (step.done) {\n\t            return step;\n\t          }\n\t        }\n\t        return iterations % 2 ?\n\t          iteratorValue(type, iterations++, separator) :\n\t          iteratorValue(type, iterations++, step.value, step);\n\t      });\n\t    };\n\t    return interposedSequence;\n\t  }\n\t\n\t\n\t  function sortFactory(iterable, comparator, mapper) {\n\t    if (!comparator) {\n\t      comparator = defaultComparator;\n\t    }\n\t    var isKeyedIterable = isKeyed(iterable);\n\t    var index = 0;\n\t    var entries = iterable.toSeq().map(\n\t      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}\n\t    ).toArray();\n\t    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(\n\t      isKeyedIterable ?\n\t      function(v, i)  { entries[i].length = 2; } :\n\t      function(v, i)  { entries[i] = v[1]; }\n\t    );\n\t    return isKeyedIterable ? KeyedSeq(entries) :\n\t      isIndexed(iterable) ? IndexedSeq(entries) :\n\t      SetSeq(entries);\n\t  }\n\t\n\t\n\t  function maxFactory(iterable, comparator, mapper) {\n\t    if (!comparator) {\n\t      comparator = defaultComparator;\n\t    }\n\t    if (mapper) {\n\t      var entry = iterable.toSeq()\n\t        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})\n\t        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});\n\t      return entry && entry[0];\n\t    } else {\n\t      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});\n\t    }\n\t  }\n\t\n\t  function maxCompare(comparator, a, b) {\n\t    var comp = comparator(b, a);\n\t    // b is considered the new max if the comparator declares them equal, but\n\t    // they are not equal and b is in fact a nullish value.\n\t    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;\n\t  }\n\t\n\t\n\t  function zipWithFactory(keyIter, zipper, iters) {\n\t    var zipSequence = makeSequence(keyIter);\n\t    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();\n\t    // Note: this a generic base implementation of __iterate in terms of\n\t    // __iterator which may be more generically useful in the future.\n\t    zipSequence.__iterate = function(fn, reverse) {\n\t      /* generic:\n\t      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n\t      var step;\n\t      var iterations = 0;\n\t      while (!(step = iterator.next()).done) {\n\t        iterations++;\n\t        if (fn(step.value[1], step.value[0], this) === false) {\n\t          break;\n\t        }\n\t      }\n\t      return iterations;\n\t      */\n\t      // indexed:\n\t      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n\t      var step;\n\t      var iterations = 0;\n\t      while (!(step = iterator.next()).done) {\n\t        if (fn(step.value, iterations++, this) === false) {\n\t          break;\n\t        }\n\t      }\n\t      return iterations;\n\t    };\n\t    zipSequence.__iteratorUncached = function(type, reverse) {\n\t      var iterators = iters.map(function(i )\n\t        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}\n\t      );\n\t      var iterations = 0;\n\t      var isDone = false;\n\t      return new Iterator(function()  {\n\t        var steps;\n\t        if (!isDone) {\n\t          steps = iterators.map(function(i ) {return i.next()});\n\t          isDone = steps.some(function(s ) {return s.done});\n\t        }\n\t        if (isDone) {\n\t          return iteratorDone();\n\t        }\n\t        return iteratorValue(\n\t          type,\n\t          iterations++,\n\t          zipper.apply(null, steps.map(function(s ) {return s.value}))\n\t        );\n\t      });\n\t    };\n\t    return zipSequence\n\t  }\n\t\n\t\n\t  // #pragma Helper Functions\n\t\n\t  function reify(iter, seq) {\n\t    return isSeq(iter) ? seq : iter.constructor(seq);\n\t  }\n\t\n\t  function validateEntry(entry) {\n\t    if (entry !== Object(entry)) {\n\t      throw new TypeError('Expected [K, V] tuple: ' + entry);\n\t    }\n\t  }\n\t\n\t  function resolveSize(iter) {\n\t    assertNotInfinite(iter.size);\n\t    return ensureSize(iter);\n\t  }\n\t\n\t  function iterableClass(iterable) {\n\t    return isKeyed(iterable) ? KeyedIterable :\n\t      isIndexed(iterable) ? IndexedIterable :\n\t      SetIterable;\n\t  }\n\t\n\t  function makeSequence(iterable) {\n\t    return Object.create(\n\t      (\n\t        isKeyed(iterable) ? KeyedSeq :\n\t        isIndexed(iterable) ? IndexedSeq :\n\t        SetSeq\n\t      ).prototype\n\t    );\n\t  }\n\t\n\t  function cacheResultThrough() {\n\t    if (this._iter.cacheResult) {\n\t      this._iter.cacheResult();\n\t      this.size = this._iter.size;\n\t      return this;\n\t    } else {\n\t      return Seq.prototype.cacheResult.call(this);\n\t    }\n\t  }\n\t\n\t  function defaultComparator(a, b) {\n\t    return a > b ? 1 : a < b ? -1 : 0;\n\t  }\n\t\n\t  function forceIterator(keyPath) {\n\t    var iter = getIterator(keyPath);\n\t    if (!iter) {\n\t      // Array might not be iterable in this environment, so we need a fallback\n\t      // to our wrapped type.\n\t      if (!isArrayLike(keyPath)) {\n\t        throw new TypeError('Expected iterable or array-like: ' + keyPath);\n\t      }\n\t      iter = getIterator(Iterable(keyPath));\n\t    }\n\t    return iter;\n\t  }\n\t\n\t  createClass(Record, KeyedCollection);\n\t\n\t    function Record(defaultValues, name) {\n\t      var hasInitialized;\n\t\n\t      var RecordType = function Record(values) {\n\t        if (values instanceof RecordType) {\n\t          return values;\n\t        }\n\t        if (!(this instanceof RecordType)) {\n\t          return new RecordType(values);\n\t        }\n\t        if (!hasInitialized) {\n\t          hasInitialized = true;\n\t          var keys = Object.keys(defaultValues);\n\t          setProps(RecordTypePrototype, keys);\n\t          RecordTypePrototype.size = keys.length;\n\t          RecordTypePrototype._name = name;\n\t          RecordTypePrototype._keys = keys;\n\t          RecordTypePrototype._defaultValues = defaultValues;\n\t        }\n\t        this._map = Map(values);\n\t      };\n\t\n\t      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);\n\t      RecordTypePrototype.constructor = RecordType;\n\t\n\t      return RecordType;\n\t    }\n\t\n\t    Record.prototype.toString = function() {\n\t      return this.__toString(recordName(this) + ' {', '}');\n\t    };\n\t\n\t    // @pragma Access\n\t\n\t    Record.prototype.has = function(k) {\n\t      return this._defaultValues.hasOwnProperty(k);\n\t    };\n\t\n\t    Record.prototype.get = function(k, notSetValue) {\n\t      if (!this.has(k)) {\n\t        return notSetValue;\n\t      }\n\t      var defaultVal = this._defaultValues[k];\n\t      return this._map ? this._map.get(k, defaultVal) : defaultVal;\n\t    };\n\t\n\t    // @pragma Modification\n\t\n\t    Record.prototype.clear = function() {\n\t      if (this.__ownerID) {\n\t        this._map && this._map.clear();\n\t        return this;\n\t      }\n\t      var RecordType = this.constructor;\n\t      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));\n\t    };\n\t\n\t    Record.prototype.set = function(k, v) {\n\t      if (!this.has(k)) {\n\t        throw new Error('Cannot set unknown key \"' + k + '\" on ' + recordName(this));\n\t      }\n\t      if (this._map && !this._map.has(k)) {\n\t        var defaultVal = this._defaultValues[k];\n\t        if (v === defaultVal) {\n\t          return this;\n\t        }\n\t      }\n\t      var newMap = this._map && this._map.set(k, v);\n\t      if (this.__ownerID || newMap === this._map) {\n\t        return this;\n\t      }\n\t      return makeRecord(this, newMap);\n\t    };\n\t\n\t    Record.prototype.remove = function(k) {\n\t      if (!this.has(k)) {\n\t        return this;\n\t      }\n\t      var newMap = this._map && this._map.remove(k);\n\t      if (this.__ownerID || newMap === this._map) {\n\t        return this;\n\t      }\n\t      return makeRecord(this, newMap);\n\t    };\n\t\n\t    Record.prototype.wasAltered = function() {\n\t      return this._map.wasAltered();\n\t    };\n\t\n\t    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;\n\t      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);\n\t    };\n\t\n\t    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);\n\t    };\n\t\n\t    Record.prototype.__ensureOwner = function(ownerID) {\n\t      if (ownerID === this.__ownerID) {\n\t        return this;\n\t      }\n\t      var newMap = this._map && this._map.__ensureOwner(ownerID);\n\t      if (!ownerID) {\n\t        this.__ownerID = ownerID;\n\t        this._map = newMap;\n\t        return this;\n\t      }\n\t      return makeRecord(this, newMap, ownerID);\n\t    };\n\t\n\t\n\t  var RecordPrototype = Record.prototype;\n\t  RecordPrototype[DELETE] = RecordPrototype.remove;\n\t  RecordPrototype.deleteIn =\n\t  RecordPrototype.removeIn = MapPrototype.removeIn;\n\t  RecordPrototype.merge = MapPrototype.merge;\n\t  RecordPrototype.mergeWith = MapPrototype.mergeWith;\n\t  RecordPrototype.mergeIn = MapPrototype.mergeIn;\n\t  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;\n\t  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;\n\t  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n\t  RecordPrototype.setIn = MapPrototype.setIn;\n\t  RecordPrototype.update = MapPrototype.update;\n\t  RecordPrototype.updateIn = MapPrototype.updateIn;\n\t  RecordPrototype.withMutations = MapPrototype.withMutations;\n\t  RecordPrototype.asMutable = MapPrototype.asMutable;\n\t  RecordPrototype.asImmutable = MapPrototype.asImmutable;\n\t\n\t\n\t  function makeRecord(likeRecord, map, ownerID) {\n\t    var record = Object.create(Object.getPrototypeOf(likeRecord));\n\t    record._map = map;\n\t    record.__ownerID = ownerID;\n\t    return record;\n\t  }\n\t\n\t  function recordName(record) {\n\t    return record._name || record.constructor.name || 'Record';\n\t  }\n\t\n\t  function setProps(prototype, names) {\n\t    try {\n\t      names.forEach(setProp.bind(undefined, prototype));\n\t    } catch (error) {\n\t      // Object.defineProperty failed. Probably IE8.\n\t    }\n\t  }\n\t\n\t  function setProp(prototype, name) {\n\t    Object.defineProperty(prototype, name, {\n\t      get: function() {\n\t        return this.get(name);\n\t      },\n\t      set: function(value) {\n\t        invariant(this.__ownerID, 'Cannot set on an immutable record.');\n\t        this.set(name, value);\n\t      }\n\t    });\n\t  }\n\t\n\t  createClass(Set, SetCollection);\n\t\n\t    // @pragma Construction\n\t\n\t    function Set(value) {\n\t      return value === null || value === undefined ? emptySet() :\n\t        isSet(value) && !isOrdered(value) ? value :\n\t        emptySet().withMutations(function(set ) {\n\t          var iter = SetIterable(value);\n\t          assertNotInfinite(iter.size);\n\t          iter.forEach(function(v ) {return set.add(v)});\n\t        });\n\t    }\n\t\n\t    Set.of = function(/*...values*/) {\n\t      return this(arguments);\n\t    };\n\t\n\t    Set.fromKeys = function(value) {\n\t      return this(KeyedIterable(value).keySeq());\n\t    };\n\t\n\t    Set.prototype.toString = function() {\n\t      return this.__toString('Set {', '}');\n\t    };\n\t\n\t    // @pragma Access\n\t\n\t    Set.prototype.has = function(value) {\n\t      return this._map.has(value);\n\t    };\n\t\n\t    // @pragma Modification\n\t\n\t    Set.prototype.add = function(value) {\n\t      return updateSet(this, this._map.set(value, true));\n\t    };\n\t\n\t    Set.prototype.remove = function(value) {\n\t      return updateSet(this, this._map.remove(value));\n\t    };\n\t\n\t    Set.prototype.clear = function() {\n\t      return updateSet(this, this._map.clear());\n\t    };\n\t\n\t    // @pragma Composition\n\t\n\t    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);\n\t      iters = iters.filter(function(x ) {return x.size !== 0});\n\t      if (iters.length === 0) {\n\t        return this;\n\t      }\n\t      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n\t        return this.constructor(iters[0]);\n\t      }\n\t      return this.withMutations(function(set ) {\n\t        for (var ii = 0; ii < iters.length; ii++) {\n\t          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});\n\t        }\n\t      });\n\t    };\n\t\n\t    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);\n\t      if (iters.length === 0) {\n\t        return this;\n\t      }\n\t      iters = iters.map(function(iter ) {return SetIterable(iter)});\n\t      var originalSet = this;\n\t      return this.withMutations(function(set ) {\n\t        originalSet.forEach(function(value ) {\n\t          if (!iters.every(function(iter ) {return iter.includes(value)})) {\n\t            set.remove(value);\n\t          }\n\t        });\n\t      });\n\t    };\n\t\n\t    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);\n\t      if (iters.length === 0) {\n\t        return this;\n\t      }\n\t      iters = iters.map(function(iter ) {return SetIterable(iter)});\n\t      var originalSet = this;\n\t      return this.withMutations(function(set ) {\n\t        originalSet.forEach(function(value ) {\n\t          if (iters.some(function(iter ) {return iter.includes(value)})) {\n\t            set.remove(value);\n\t          }\n\t        });\n\t      });\n\t    };\n\t\n\t    Set.prototype.merge = function() {\n\t      return this.union.apply(this, arguments);\n\t    };\n\t\n\t    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n\t      return this.union.apply(this, iters);\n\t    };\n\t\n\t    Set.prototype.sort = function(comparator) {\n\t      // Late binding\n\t      return OrderedSet(sortFactory(this, comparator));\n\t    };\n\t\n\t    Set.prototype.sortBy = function(mapper, comparator) {\n\t      // Late binding\n\t      return OrderedSet(sortFactory(this, comparator, mapper));\n\t    };\n\t\n\t    Set.prototype.wasAltered = function() {\n\t      return this._map.wasAltered();\n\t    };\n\t\n\t    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n\t      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);\n\t    };\n\t\n\t    Set.prototype.__iterator = function(type, reverse) {\n\t      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);\n\t    };\n\t\n\t    Set.prototype.__ensureOwner = function(ownerID) {\n\t      if (ownerID === this.__ownerID) {\n\t        return this;\n\t      }\n\t      var newMap = this._map.__ensureOwner(ownerID);\n\t      if (!ownerID) {\n\t        this.__ownerID = ownerID;\n\t        this._map = newMap;\n\t        return this;\n\t      }\n\t      return this.__make(newMap, ownerID);\n\t    };\n\t\n\t\n\t  function isSet(maybeSet) {\n\t    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);\n\t  }\n\t\n\t  Set.isSet = isSet;\n\t\n\t  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';\n\t\n\t  var SetPrototype = Set.prototype;\n\t  SetPrototype[IS_SET_SENTINEL] = true;\n\t  SetPrototype[DELETE] = SetPrototype.remove;\n\t  SetPrototype.mergeDeep = SetPrototype.merge;\n\t  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;\n\t  SetPrototype.withMutations = MapPrototype.withMutations;\n\t  SetPrototype.asMutable = MapPrototype.asMutable;\n\t  SetPrototype.asImmutable = MapPrototype.asImmutable;\n\t\n\t  SetPrototype.__empty = emptySet;\n\t  SetPrototype.__make = makeSet;\n\t\n\t  function updateSet(set, newMap) {\n\t    if (set.__ownerID) {\n\t      set.size = newMap.size;\n\t      set._map = newMap;\n\t      return set;\n\t    }\n\t    return newMap === set._map ? set :\n\t      newMap.size === 0 ? set.__empty() :\n\t      set.__make(newMap);\n\t  }\n\t\n\t  function makeSet(map, ownerID) {\n\t    var set = Object.create(SetPrototype);\n\t    set.size = map ? map.size : 0;\n\t    set._map = map;\n\t    set.__ownerID = ownerID;\n\t    return set;\n\t  }\n\t\n\t  var EMPTY_SET;\n\t  function emptySet() {\n\t    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n\t  }\n\t\n\t  createClass(OrderedSet, Set);\n\t\n\t    // @pragma Construction\n\t\n\t    function OrderedSet(value) {\n\t      return value === null || value === undefined ? emptyOrderedSet() :\n\t        isOrderedSet(value) ? value :\n\t        emptyOrderedSet().withMutations(function(set ) {\n\t          var iter = SetIterable(value);\n\t          assertNotInfinite(iter.size);\n\t          iter.forEach(function(v ) {return set.add(v)});\n\t        });\n\t    }\n\t\n\t    OrderedSet.of = function(/*...values*/) {\n\t      return this(arguments);\n\t    };\n\t\n\t    OrderedSet.fromKeys = function(value) {\n\t      return this(KeyedIterable(value).keySeq());\n\t    };\n\t\n\t    OrderedSet.prototype.toString = function() {\n\t      return this.__toString('OrderedSet {', '}');\n\t    };\n\t\n\t\n\t  function isOrderedSet(maybeOrderedSet) {\n\t    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n\t  }\n\t\n\t  OrderedSet.isOrderedSet = isOrderedSet;\n\t\n\t  var OrderedSetPrototype = OrderedSet.prototype;\n\t  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;\n\t\n\t  OrderedSetPrototype.__empty = emptyOrderedSet;\n\t  OrderedSetPrototype.__make = makeOrderedSet;\n\t\n\t  function makeOrderedSet(map, ownerID) {\n\t    var set = Object.create(OrderedSetPrototype);\n\t    set.size = map ? map.size : 0;\n\t    set._map = map;\n\t    set.__ownerID = ownerID;\n\t    return set;\n\t  }\n\t\n\t  var EMPTY_ORDERED_SET;\n\t  function emptyOrderedSet() {\n\t    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));\n\t  }\n\t\n\t  createClass(Stack, IndexedCollection);\n\t\n\t    // @pragma Construction\n\t\n\t    function Stack(value) {\n\t      return value === null || value === undefined ? emptyStack() :\n\t        isStack(value) ? value :\n\t        emptyStack().unshiftAll(value);\n\t    }\n\t\n\t    Stack.of = function(/*...values*/) {\n\t      return this(arguments);\n\t    };\n\t\n\t    Stack.prototype.toString = function() {\n\t      return this.__toString('Stack [', ']');\n\t    };\n\t\n\t    // @pragma Access\n\t\n\t    Stack.prototype.get = function(index, notSetValue) {\n\t      var head = this._head;\n\t      index = wrapIndex(this, index);\n\t      while (head && index--) {\n\t        head = head.next;\n\t      }\n\t      return head ? head.value : notSetValue;\n\t    };\n\t\n\t    Stack.prototype.peek = function() {\n\t      return this._head && this._head.value;\n\t    };\n\t\n\t    // @pragma Modification\n\t\n\t    Stack.prototype.push = function(/*...values*/) {\n\t      if (arguments.length === 0) {\n\t        return this;\n\t      }\n\t      var newSize = this.size + arguments.length;\n\t      var head = this._head;\n\t      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n\t        head = {\n\t          value: arguments[ii],\n\t          next: head\n\t        };\n\t      }\n\t      if (this.__ownerID) {\n\t        this.size = newSize;\n\t        this._head = head;\n\t        this.__hash = undefined;\n\t        this.__altered = true;\n\t        return this;\n\t      }\n\t      return makeStack(newSize, head);\n\t    };\n\t\n\t    Stack.prototype.pushAll = function(iter) {\n\t      iter = IndexedIterable(iter);\n\t      if (iter.size === 0) {\n\t        return this;\n\t      }\n\t      assertNotInfinite(iter.size);\n\t      var newSize = this.size;\n\t      var head = this._head;\n\t      iter.reverse().forEach(function(value ) {\n\t        newSize++;\n\t        head = {\n\t          value: value,\n\t          next: head\n\t        };\n\t      });\n\t      if (this.__ownerID) {\n\t        this.size = newSize;\n\t        this._head = head;\n\t        this.__hash = undefined;\n\t        this.__altered = true;\n\t        return this;\n\t      }\n\t      return makeStack(newSize, head);\n\t    };\n\t\n\t    Stack.prototype.pop = function() {\n\t      return this.slice(1);\n\t    };\n\t\n\t    Stack.prototype.unshift = function(/*...values*/) {\n\t      return this.push.apply(this, arguments);\n\t    };\n\t\n\t    Stack.prototype.unshiftAll = function(iter) {\n\t      return this.pushAll(iter);\n\t    };\n\t\n\t    Stack.prototype.shift = function() {\n\t      return this.pop.apply(this, arguments);\n\t    };\n\t\n\t    Stack.prototype.clear = function() {\n\t      if (this.size === 0) {\n\t        return this;\n\t      }\n\t      if (this.__ownerID) {\n\t        this.size = 0;\n\t        this._head = undefined;\n\t        this.__hash = undefined;\n\t        this.__altered = true;\n\t        return this;\n\t      }\n\t      return emptyStack();\n\t    };\n\t\n\t    Stack.prototype.slice = function(begin, end) {\n\t      if (wholeSlice(begin, end, this.size)) {\n\t        return this;\n\t      }\n\t      var resolvedBegin = resolveBegin(begin, this.size);\n\t      var resolvedEnd = resolveEnd(end, this.size);\n\t      if (resolvedEnd !== this.size) {\n\t        // super.slice(begin, end);\n\t        return IndexedCollection.prototype.slice.call(this, begin, end);\n\t      }\n\t      var newSize = this.size - resolvedBegin;\n\t      var head = this._head;\n\t      while (resolvedBegin--) {\n\t        head = head.next;\n\t      }\n\t      if (this.__ownerID) {\n\t        this.size = newSize;\n\t        this._head = head;\n\t        this.__hash = undefined;\n\t        this.__altered = true;\n\t        return this;\n\t      }\n\t      return makeStack(newSize, head);\n\t    };\n\t\n\t    // @pragma Mutability\n\t\n\t    Stack.prototype.__ensureOwner = function(ownerID) {\n\t      if (ownerID === this.__ownerID) {\n\t        return this;\n\t      }\n\t      if (!ownerID) {\n\t        this.__ownerID = ownerID;\n\t        this.__altered = false;\n\t        return this;\n\t      }\n\t      return makeStack(this.size, this._head, ownerID, this.__hash);\n\t    };\n\t\n\t    // @pragma Iteration\n\t\n\t    Stack.prototype.__iterate = function(fn, reverse) {\n\t      if (reverse) {\n\t        return this.reverse().__iterate(fn);\n\t      }\n\t      var iterations = 0;\n\t      var node = this._head;\n\t      while (node) {\n\t        if (fn(node.value, iterations++, this) === false) {\n\t          break;\n\t        }\n\t        node = node.next;\n\t      }\n\t      return iterations;\n\t    };\n\t\n\t    Stack.prototype.__iterator = function(type, reverse) {\n\t      if (reverse) {\n\t        return this.reverse().__iterator(type);\n\t      }\n\t      var iterations = 0;\n\t      var node = this._head;\n\t      return new Iterator(function()  {\n\t        if (node) {\n\t          var value = node.value;\n\t          node = node.next;\n\t          return iteratorValue(type, iterations++, value);\n\t        }\n\t        return iteratorDone();\n\t      });\n\t    };\n\t\n\t\n\t  function isStack(maybeStack) {\n\t    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);\n\t  }\n\t\n\t  Stack.isStack = isStack;\n\t\n\t  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';\n\t\n\t  var StackPrototype = Stack.prototype;\n\t  StackPrototype[IS_STACK_SENTINEL] = true;\n\t  StackPrototype.withMutations = MapPrototype.withMutations;\n\t  StackPrototype.asMutable = MapPrototype.asMutable;\n\t  StackPrototype.asImmutable = MapPrototype.asImmutable;\n\t  StackPrototype.wasAltered = MapPrototype.wasAltered;\n\t\n\t\n\t  function makeStack(size, head, ownerID, hash) {\n\t    var map = Object.create(StackPrototype);\n\t    map.size = size;\n\t    map._head = head;\n\t    map.__ownerID = ownerID;\n\t    map.__hash = hash;\n\t    map.__altered = false;\n\t    return map;\n\t  }\n\t\n\t  var EMPTY_STACK;\n\t  function emptyStack() {\n\t    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n\t  }\n\t\n\t  /**\n\t   * Contributes additional methods to a constructor\n\t   */\n\t  function mixin(ctor, methods) {\n\t    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };\n\t    Object.keys(methods).forEach(keyCopier);\n\t    Object.getOwnPropertySymbols &&\n\t      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n\t    return ctor;\n\t  }\n\t\n\t  Iterable.Iterator = Iterator;\n\t\n\t  mixin(Iterable, {\n\t\n\t    // ### Conversion to other types\n\t\n\t    toArray: function() {\n\t      assertNotInfinite(this.size);\n\t      var array = new Array(this.size || 0);\n\t      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });\n\t      return array;\n\t    },\n\t\n\t    toIndexedSeq: function() {\n\t      return new ToIndexedSequence(this);\n\t    },\n\t\n\t    toJS: function() {\n\t      return this.toSeq().map(\n\t        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}\n\t      ).__toJS();\n\t    },\n\t\n\t    toJSON: function() {\n\t      return this.toSeq().map(\n\t        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}\n\t      ).__toJS();\n\t    },\n\t\n\t    toKeyedSeq: function() {\n\t      return new ToKeyedSequence(this, true);\n\t    },\n\t\n\t    toMap: function() {\n\t      // Use Late Binding here to solve the circular dependency.\n\t      return Map(this.toKeyedSeq());\n\t    },\n\t\n\t    toObject: function() {\n\t      assertNotInfinite(this.size);\n\t      var object = {};\n\t      this.__iterate(function(v, k)  { object[k] = v; });\n\t      return object;\n\t    },\n\t\n\t    toOrderedMap: function() {\n\t      // Use Late Binding here to solve the circular dependency.\n\t      return OrderedMap(this.toKeyedSeq());\n\t    },\n\t\n\t    toOrderedSet: function() {\n\t      // Use Late Binding here to solve the circular dependency.\n\t      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n\t    },\n\t\n\t    toSet: function() {\n\t      // Use Late Binding here to solve the circular dependency.\n\t      return Set(isKeyed(this) ? this.valueSeq() : this);\n\t    },\n\t\n\t    toSetSeq: function() {\n\t      return new ToSetSequence(this);\n\t    },\n\t\n\t    toSeq: function() {\n\t      return isIndexed(this) ? this.toIndexedSeq() :\n\t        isKeyed(this) ? this.toKeyedSeq() :\n\t        this.toSetSeq();\n\t    },\n\t\n\t    toStack: function() {\n\t      // Use Late Binding here to solve the circular dependency.\n\t      return Stack(isKeyed(this) ? this.valueSeq() : this);\n\t    },\n\t\n\t    toList: function() {\n\t      // Use Late Binding here to solve the circular dependency.\n\t      return List(isKeyed(this) ? this.valueSeq() : this);\n\t    },\n\t\n\t\n\t    // ### Common JavaScript methods and properties\n\t\n\t    toString: function() {\n\t      return '[Iterable]';\n\t    },\n\t\n\t    __toString: function(head, tail) {\n\t      if (this.size === 0) {\n\t        return head + tail;\n\t      }\n\t      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;\n\t    },\n\t\n\t\n\t    // ### ES6 Collection methods (ES6 Array and Map)\n\t\n\t    concat: function() {var values = SLICE$0.call(arguments, 0);\n\t      return reify(this, concatFactory(this, values));\n\t    },\n\t\n\t    includes: function(searchValue) {\n\t      return this.some(function(value ) {return is(value, searchValue)});\n\t    },\n\t\n\t    entries: function() {\n\t      return this.__iterator(ITERATE_ENTRIES);\n\t    },\n\t\n\t    every: function(predicate, context) {\n\t      assertNotInfinite(this.size);\n\t      var returnValue = true;\n\t      this.__iterate(function(v, k, c)  {\n\t        if (!predicate.call(context, v, k, c)) {\n\t          returnValue = false;\n\t          return false;\n\t        }\n\t      });\n\t      return returnValue;\n\t    },\n\t\n\t    filter: function(predicate, context) {\n\t      return reify(this, filterFactory(this, predicate, context, true));\n\t    },\n\t\n\t    find: function(predicate, context, notSetValue) {\n\t      var entry = this.findEntry(predicate, context);\n\t      return entry ? entry[1] : notSetValue;\n\t    },\n\t\n\t    forEach: function(sideEffect, context) {\n\t      assertNotInfinite(this.size);\n\t      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n\t    },\n\t\n\t    join: function(separator) {\n\t      assertNotInfinite(this.size);\n\t      separator = separator !== undefined ? '' + separator : ',';\n\t      var joined = '';\n\t      var isFirst = true;\n\t      this.__iterate(function(v ) {\n\t        isFirst ? (isFirst = false) : (joined += separator);\n\t        joined += v !== null && v !== undefined ? v.toString() : '';\n\t      });\n\t      return joined;\n\t    },\n\t\n\t    keys: function() {\n\t      return this.__iterator(ITERATE_KEYS);\n\t    },\n\t\n\t    map: function(mapper, context) {\n\t      return reify(this, mapFactory(this, mapper, context));\n\t    },\n\t\n\t    reduce: function(reducer, initialReduction, context) {\n\t      assertNotInfinite(this.size);\n\t      var reduction;\n\t      var useFirst;\n\t      if (arguments.length < 2) {\n\t        useFirst = true;\n\t      } else {\n\t        reduction = initialReduction;\n\t      }\n\t      this.__iterate(function(v, k, c)  {\n\t        if (useFirst) {\n\t          useFirst = false;\n\t          reduction = v;\n\t        } else {\n\t          reduction = reducer.call(context, reduction, v, k, c);\n\t        }\n\t      });\n\t      return reduction;\n\t    },\n\t\n\t    reduceRight: function(reducer, initialReduction, context) {\n\t      var reversed = this.toKeyedSeq().reverse();\n\t      return reversed.reduce.apply(reversed, arguments);\n\t    },\n\t\n\t    reverse: function() {\n\t      return reify(this, reverseFactory(this, true));\n\t    },\n\t\n\t    slice: function(begin, end) {\n\t      return reify(this, sliceFactory(this, begin, end, true));\n\t    },\n\t\n\t    some: function(predicate, context) {\n\t      return !this.every(not(predicate), context);\n\t    },\n\t\n\t    sort: function(comparator) {\n\t      return reify(this, sortFactory(this, comparator));\n\t    },\n\t\n\t    values: function() {\n\t      return this.__iterator(ITERATE_VALUES);\n\t    },\n\t\n\t\n\t    // ### More sequential methods\n\t\n\t    butLast: function() {\n\t      return this.slice(0, -1);\n\t    },\n\t\n\t    isEmpty: function() {\n\t      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});\n\t    },\n\t\n\t    count: function(predicate, context) {\n\t      return ensureSize(\n\t        predicate ? this.toSeq().filter(predicate, context) : this\n\t      );\n\t    },\n\t\n\t    countBy: function(grouper, context) {\n\t      return countByFactory(this, grouper, context);\n\t    },\n\t\n\t    equals: function(other) {\n\t      return deepEqual(this, other);\n\t    },\n\t\n\t    entrySeq: function() {\n\t      var iterable = this;\n\t      if (iterable._cache) {\n\t        // We cache as an entries array, so we can just return the cache!\n\t        return new ArraySeq(iterable._cache);\n\t      }\n\t      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();\n\t      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};\n\t      return entriesSequence;\n\t    },\n\t\n\t    filterNot: function(predicate, context) {\n\t      return this.filter(not(predicate), context);\n\t    },\n\t\n\t    findEntry: function(predicate, context, notSetValue) {\n\t      var found = notSetValue;\n\t      this.__iterate(function(v, k, c)  {\n\t        if (predicate.call(context, v, k, c)) {\n\t          found = [k, v];\n\t          return false;\n\t        }\n\t      });\n\t      return found;\n\t    },\n\t\n\t    findKey: function(predicate, context) {\n\t      var entry = this.findEntry(predicate, context);\n\t      return entry && entry[0];\n\t    },\n\t\n\t    findLast: function(predicate, context, notSetValue) {\n\t      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n\t    },\n\t\n\t    findLastEntry: function(predicate, context, notSetValue) {\n\t      return this.toKeyedSeq().reverse().findEntry(predicate, context, notSetValue);\n\t    },\n\t\n\t    findLastKey: function(predicate, context) {\n\t      return this.toKeyedSeq().reverse().findKey(predicate, context);\n\t    },\n\t\n\t    first: function() {\n\t      return this.find(returnTrue);\n\t    },\n\t\n\t    flatMap: function(mapper, context) {\n\t      return reify(this, flatMapFactory(this, mapper, context));\n\t    },\n\t\n\t    flatten: function(depth) {\n\t      return reify(this, flattenFactory(this, depth, true));\n\t    },\n\t\n\t    fromEntrySeq: function() {\n\t      return new FromEntriesSequence(this);\n\t    },\n\t\n\t    get: function(searchKey, notSetValue) {\n\t      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);\n\t    },\n\t\n\t    getIn: function(searchKeyPath, notSetValue) {\n\t      var nested = this;\n\t      // Note: in an ES6 environment, we would prefer:\n\t      // for (var key of searchKeyPath) {\n\t      var iter = forceIterator(searchKeyPath);\n\t      var step;\n\t      while (!(step = iter.next()).done) {\n\t        var key = step.value;\n\t        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;\n\t        if (nested === NOT_SET) {\n\t          return notSetValue;\n\t        }\n\t      }\n\t      return nested;\n\t    },\n\t\n\t    groupBy: function(grouper, context) {\n\t      return groupByFactory(this, grouper, context);\n\t    },\n\t\n\t    has: function(searchKey) {\n\t      return this.get(searchKey, NOT_SET) !== NOT_SET;\n\t    },\n\t\n\t    hasIn: function(searchKeyPath) {\n\t      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;\n\t    },\n\t\n\t    isSubset: function(iter) {\n\t      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);\n\t      return this.every(function(value ) {return iter.includes(value)});\n\t    },\n\t\n\t    isSuperset: function(iter) {\n\t      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);\n\t      return iter.isSubset(this);\n\t    },\n\t\n\t    keyOf: function(searchValue) {\n\t      return this.findKey(function(value ) {return is(value, searchValue)});\n\t    },\n\t\n\t    keySeq: function() {\n\t      return this.toSeq().map(keyMapper).toIndexedSeq();\n\t    },\n\t\n\t    last: function() {\n\t      return this.toSeq().reverse().first();\n\t    },\n\t\n\t    lastKeyOf: function(searchValue) {\n\t      return this.toKeyedSeq().reverse().keyOf(searchValue);\n\t    },\n\t\n\t    max: function(comparator) {\n\t      return maxFactory(this, comparator);\n\t    },\n\t\n\t    maxBy: function(mapper, comparator) {\n\t      return maxFactory(this, comparator, mapper);\n\t    },\n\t\n\t    min: function(comparator) {\n\t      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);\n\t    },\n\t\n\t    minBy: function(mapper, comparator) {\n\t      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);\n\t    },\n\t\n\t    rest: function() {\n\t      return this.slice(1);\n\t    },\n\t\n\t    skip: function(amount) {\n\t      return this.slice(Math.max(0, amount));\n\t    },\n\t\n\t    skipLast: function(amount) {\n\t      return reify(this, this.toSeq().reverse().skip(amount).reverse());\n\t    },\n\t\n\t    skipWhile: function(predicate, context) {\n\t      return reify(this, skipWhileFactory(this, predicate, context, true));\n\t    },\n\t\n\t    skipUntil: function(predicate, context) {\n\t      return this.skipWhile(not(predicate), context);\n\t    },\n\t\n\t    sortBy: function(mapper, comparator) {\n\t      return reify(this, sortFactory(this, comparator, mapper));\n\t    },\n\t\n\t    take: function(amount) {\n\t      return this.slice(0, Math.max(0, amount));\n\t    },\n\t\n\t    takeLast: function(amount) {\n\t      return reify(this, this.toSeq().reverse().take(amount).reverse());\n\t    },\n\t\n\t    takeWhile: function(predicate, context) {\n\t      return reify(this, takeWhileFactory(this, predicate, context));\n\t    },\n\t\n\t    takeUntil: function(predicate, context) {\n\t      return this.takeWhile(not(predicate), context);\n\t    },\n\t\n\t    valueSeq: function() {\n\t      return this.toIndexedSeq();\n\t    },\n\t\n\t\n\t    // ### Hashable Object\n\t\n\t    hashCode: function() {\n\t      return this.__hash || (this.__hash = hashIterable(this));\n\t    }\n\t\n\t\n\t    // ### Internal\n\t\n\t    // abstract __iterate(fn, reverse)\n\t\n\t    // abstract __iterator(type, reverse)\n\t  });\n\t\n\t  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n\t  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n\t  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n\t  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\t\n\t  var IterablePrototype = Iterable.prototype;\n\t  IterablePrototype[IS_ITERABLE_SENTINEL] = true;\n\t  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;\n\t  IterablePrototype.__toJS = IterablePrototype.toArray;\n\t  IterablePrototype.__toStringMapper = quoteString;\n\t  IterablePrototype.inspect =\n\t  IterablePrototype.toSource = function() { return this.toString(); };\n\t  IterablePrototype.chain = IterablePrototype.flatMap;\n\t  IterablePrototype.contains = IterablePrototype.includes;\n\t\n\t  mixin(KeyedIterable, {\n\t\n\t    // ### More sequential methods\n\t\n\t    flip: function() {\n\t      return reify(this, flipFactory(this));\n\t    },\n\t\n\t    mapEntries: function(mapper, context) {var this$0 = this;\n\t      var iterations = 0;\n\t      return reify(this,\n\t        this.toSeq().map(\n\t          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}\n\t        ).fromEntrySeq()\n\t      );\n\t    },\n\t\n\t    mapKeys: function(mapper, context) {var this$0 = this;\n\t      return reify(this,\n\t        this.toSeq().flip().map(\n\t          function(k, v)  {return mapper.call(context, k, v, this$0)}\n\t        ).flip()\n\t      );\n\t    }\n\t\n\t  });\n\t\n\t  var KeyedIterablePrototype = KeyedIterable.prototype;\n\t  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;\n\t  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;\n\t  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;\n\t  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};\n\t\n\t\n\t\n\t  mixin(IndexedIterable, {\n\t\n\t    // ### Conversion to other types\n\t\n\t    toKeyedSeq: function() {\n\t      return new ToKeyedSequence(this, false);\n\t    },\n\t\n\t\n\t    // ### ES6 Collection methods (ES6 Array and Map)\n\t\n\t    filter: function(predicate, context) {\n\t      return reify(this, filterFactory(this, predicate, context, false));\n\t    },\n\t\n\t    findIndex: function(predicate, context) {\n\t      var entry = this.findEntry(predicate, context);\n\t      return entry ? entry[0] : -1;\n\t    },\n\t\n\t    indexOf: function(searchValue) {\n\t      var key = this.keyOf(searchValue);\n\t      return key === undefined ? -1 : key;\n\t    },\n\t\n\t    lastIndexOf: function(searchValue) {\n\t      var key = this.lastKeyOf(searchValue);\n\t      return key === undefined ? -1 : key;\n\t    },\n\t\n\t    reverse: function() {\n\t      return reify(this, reverseFactory(this, false));\n\t    },\n\t\n\t    slice: function(begin, end) {\n\t      return reify(this, sliceFactory(this, begin, end, false));\n\t    },\n\t\n\t    splice: function(index, removeNum /*, ...values*/) {\n\t      var numArgs = arguments.length;\n\t      removeNum = Math.max(removeNum | 0, 0);\n\t      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n\t        return this;\n\t      }\n\t      // If index is negative, it should resolve relative to the size of the\n\t      // collection. However size may be expensive to compute if not cached, so\n\t      // only call count() if the number is in fact negative.\n\t      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n\t      var spliced = this.slice(0, index);\n\t      return reify(\n\t        this,\n\t        numArgs === 1 ?\n\t          spliced :\n\t          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n\t      );\n\t    },\n\t\n\t\n\t    // ### More collection methods\n\t\n\t    findLastIndex: function(predicate, context) {\n\t      var entry = this.findLastEntry(predicate, context);\n\t      return entry ? entry[0] : -1;\n\t    },\n\t\n\t    first: function() {\n\t      return this.get(0);\n\t    },\n\t\n\t    flatten: function(depth) {\n\t      return reify(this, flattenFactory(this, depth, false));\n\t    },\n\t\n\t    get: function(index, notSetValue) {\n\t      index = wrapIndex(this, index);\n\t      return (index < 0 || (this.size === Infinity ||\n\t          (this.size !== undefined && index > this.size))) ?\n\t        notSetValue :\n\t        this.find(function(_, key)  {return key === index}, undefined, notSetValue);\n\t    },\n\t\n\t    has: function(index) {\n\t      index = wrapIndex(this, index);\n\t      return index >= 0 && (this.size !== undefined ?\n\t        this.size === Infinity || index < this.size :\n\t        this.indexOf(index) !== -1\n\t      );\n\t    },\n\t\n\t    interpose: function(separator) {\n\t      return reify(this, interposeFactory(this, separator));\n\t    },\n\t\n\t    interleave: function(/*...iterables*/) {\n\t      var iterables = [this].concat(arrCopy(arguments));\n\t      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);\n\t      var interleaved = zipped.flatten(true);\n\t      if (zipped.size) {\n\t        interleaved.size = zipped.size * iterables.length;\n\t      }\n\t      return reify(this, interleaved);\n\t    },\n\t\n\t    keySeq: function() {\n\t      return Range(0, this.size);\n\t    },\n\t\n\t    last: function() {\n\t      return this.get(-1);\n\t    },\n\t\n\t    skipWhile: function(predicate, context) {\n\t      return reify(this, skipWhileFactory(this, predicate, context, false));\n\t    },\n\t\n\t    zip: function(/*, ...iterables */) {\n\t      var iterables = [this].concat(arrCopy(arguments));\n\t      return reify(this, zipWithFactory(this, defaultZipper, iterables));\n\t    },\n\t\n\t    zipWith: function(zipper/*, ...iterables */) {\n\t      var iterables = arrCopy(arguments);\n\t      iterables[0] = this;\n\t      return reify(this, zipWithFactory(this, zipper, iterables));\n\t    }\n\t\n\t  });\n\t\n\t  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;\n\t  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;\n\t\n\t\n\t\n\t  mixin(SetIterable, {\n\t\n\t    // ### ES6 Collection methods (ES6 Array and Map)\n\t\n\t    get: function(value, notSetValue) {\n\t      return this.has(value) ? value : notSetValue;\n\t    },\n\t\n\t    includes: function(value) {\n\t      return this.has(value);\n\t    },\n\t\n\t\n\t    // ### More sequential methods\n\t\n\t    keySeq: function() {\n\t      return this.valueSeq();\n\t    }\n\t\n\t  });\n\t\n\t  SetIterable.prototype.has = IterablePrototype.includes;\n\t  SetIterable.prototype.contains = SetIterable.prototype.includes;\n\t\n\t\n\t  // Mixin subclasses\n\t\n\t  mixin(KeyedSeq, KeyedIterable.prototype);\n\t  mixin(IndexedSeq, IndexedIterable.prototype);\n\t  mixin(SetSeq, SetIterable.prototype);\n\t\n\t  mixin(KeyedCollection, KeyedIterable.prototype);\n\t  mixin(IndexedCollection, IndexedIterable.prototype);\n\t  mixin(SetCollection, SetIterable.prototype);\n\t\n\t\n\t  // #pragma Helper functions\n\t\n\t  function keyMapper(v, k) {\n\t    return k;\n\t  }\n\t\n\t  function entryMapper(v, k) {\n\t    return [k, v];\n\t  }\n\t\n\t  function not(predicate) {\n\t    return function() {\n\t      return !predicate.apply(this, arguments);\n\t    }\n\t  }\n\t\n\t  function neg(predicate) {\n\t    return function() {\n\t      return -predicate.apply(this, arguments);\n\t    }\n\t  }\n\t\n\t  function quoteString(value) {\n\t    return typeof value === 'string' ? JSON.stringify(value) : String(value);\n\t  }\n\t\n\t  function defaultZipper() {\n\t    return arrCopy(arguments);\n\t  }\n\t\n\t  function defaultNegComparator(a, b) {\n\t    return a < b ? 1 : a > b ? -1 : 0;\n\t  }\n\t\n\t  function hashIterable(iterable) {\n\t    if (iterable.size === Infinity) {\n\t      return 0;\n\t    }\n\t    var ordered = isOrdered(iterable);\n\t    var keyed = isKeyed(iterable);\n\t    var h = ordered ? 1 : 0;\n\t    var size = iterable.__iterate(\n\t      keyed ?\n\t        ordered ?\n\t          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :\n\t          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :\n\t        ordered ?\n\t          function(v ) { h = 31 * h + hash(v) | 0; } :\n\t          function(v ) { h = h + hash(v) | 0; }\n\t    );\n\t    return murmurHashOfSize(size, h);\n\t  }\n\t\n\t  function murmurHashOfSize(size, h) {\n\t    h = imul(h, 0xCC9E2D51);\n\t    h = imul(h << 15 | h >>> -15, 0x1B873593);\n\t    h = imul(h << 13 | h >>> -13, 5);\n\t    h = (h + 0xE6546B64 | 0) ^ size;\n\t    h = imul(h ^ h >>> 16, 0x85EBCA6B);\n\t    h = imul(h ^ h >>> 13, 0xC2B2AE35);\n\t    h = smi(h ^ h >>> 16);\n\t    return h;\n\t  }\n\t\n\t  function hashMerge(a, b) {\n\t    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int\n\t  }\n\t\n\t  var Immutable = {\n\t\n\t    Iterable: Iterable,\n\t\n\t    Seq: Seq,\n\t    Collection: Collection,\n\t    Map: Map,\n\t    OrderedMap: OrderedMap,\n\t    List: List,\n\t    Stack: Stack,\n\t    Set: Set,\n\t    OrderedSet: OrderedSet,\n\t\n\t    Record: Record,\n\t    Range: Range,\n\t    Repeat: Repeat,\n\t\n\t    is: is,\n\t    fromJS: fromJS\n\t\n\t  };\n\t\n\t  return Immutable;\n\t\n\t}));\n\n/***/ },\n/* 4 */\n/*!**********************!*\\\n  !*** ./src/utils.js ***!\n  \\**********************/\n/***/ function(module, exports) {\n\n\t/**\n\t * Checks if the passed in value is a string\n\t * @param {*} val\n\t * @return {boolean}\n\t */\n\t'use strict';\n\t\n\tvar _bind = Function.prototype.bind;\n\texports.isString = function (val) {\n\t  return typeof val === 'string' || objectToString(val) === '[object String]';\n\t};\n\t\n\t/**\n\t * Checks if the passed in value is an array\n\t * @param {*} val\n\t * @return {boolean}\n\t */\n\texports.isArray = Array.isArray /* istanbul ignore next */ || function (val) {\n\t  return objectToString(val) === '[object Array]';\n\t};\n\t\n\t// taken from underscore source to account for browser discrepancy\n\t/* istanbul ignore if  */\n\tif (typeof /./ !== 'function' && typeof Int8Array !== 'object') {\n\t  /**\n\t   * Checks if the passed in value is a function\n\t   * @param {*} val\n\t   * @return {boolean}\n\t   */\n\t  exports.isFunction = function (obj) {\n\t    return typeof obj === 'function' || false;\n\t  };\n\t} else {\n\t  /**\n\t   * Checks if the passed in value is a function\n\t   * @param {*} val\n\t   * @return {boolean}\n\t   */\n\t  exports.isFunction = function (val) {\n\t    return toString.call(val) === '[object Function]';\n\t  };\n\t}\n\t\n\t/**\n\t * Checks if the passed in value is of type Object\n\t * @param {*} val\n\t * @return {boolean}\n\t */\n\texports.isObject = function (obj) {\n\t  var type = typeof obj;\n\t  return type === 'function' || type === 'object' && !!obj;\n\t};\n\t\n\t/**\n\t * Extends an object with the properties of additional objects\n\t * @param {object} obj\n\t * @param {object} objects\n\t * @return {object}\n\t */\n\texports.extend = function (obj) {\n\t  var length = arguments.length;\n\t\n\t  if (!obj || length < 2) {\n\t    return obj || {};\n\t  }\n\t\n\t  for (var index = 1; index < length; index++) {\n\t    var source = arguments[index];\n\t    var keys = Object.keys(source);\n\t    var l = keys.length;\n\t\n\t    for (var i = 0; i < l; i++) {\n\t      var key = keys[i];\n\t      obj[key] = source[key];\n\t    }\n\t  }\n\t\n\t  return obj;\n\t};\n\t\n\t/**\n\t * Creates a shallow clone of an object\n\t * @param {object} obj\n\t * @return {object}\n\t */\n\texports.clone = function (obj) {\n\t  if (!exports.isObject(obj)) {\n\t    return obj;\n\t  }\n\t  return exports.isArray(obj) ? obj.slice() : exports.extend({}, obj);\n\t};\n\t\n\t/**\n\t * Iterates over a collection of elements yielding each iteration to an\n\t * iteratee. The iteratee may be bound to the context argument and is invoked\n\t * each time with three arguments (value, index|key, collection). Iteration may\n\t * be exited early by explicitly returning false.\n\t * @param {array|object|string} collection\n\t * @param {function} iteratee\n\t * @param {*} context\n\t * @return {array|object|string}\n\t */\n\texports.each = function (collection, iteratee, context) {\n\t  var length = collection ? collection.length : 0;\n\t  var i = -1;\n\t  var keys;\n\t  var origIteratee;\n\t\n\t  if (context) {\n\t    origIteratee = iteratee;\n\t    iteratee = function (value, index, innerCollection) {\n\t      return origIteratee.call(context, value, index, innerCollection);\n\t    };\n\t  }\n\t\n\t  if (isLength(length)) {\n\t    while (++i < length) {\n\t      if (iteratee(collection[i], i, collection) === false) {\n\t        break;\n\t      }\n\t    }\n\t  } else {\n\t    keys = Object.keys(collection);\n\t    length = keys.length;\n\t    while (++i < length) {\n\t      if (iteratee(collection[keys[i]], keys[i], collection) === false) {\n\t        break;\n\t      }\n\t    }\n\t  }\n\t\n\t  return collection;\n\t};\n\t\n\t/**\n\t * Returns a new function the invokes `func` with `partialArgs` prepended to\n\t * any passed into the new function. Acts like `Array.prototype.bind`, except\n\t * it does not alter `this` context.\n\t * @param {function} func\n\t * @param {*} partialArgs\n\t * @return {function}\n\t */\n\texports.partial = function (func) {\n\t  var slice = Array.prototype.slice;\n\t  var partialArgs = slice.call(arguments, 1);\n\t\n\t  return function () {\n\t    return func.apply(this, partialArgs.concat(slice.call(arguments)));\n\t  };\n\t};\n\t\n\t/**\n\t * Returns a factory method that allows construction with or without `new`\n\t */\n\texports.toFactory = function (Klass) {\n\t  var Factory = function Factory() {\n\t    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n\t      args[_key] = arguments[_key];\n\t    }\n\t\n\t    return new (_bind.apply(Klass, [null].concat(args)))();\n\t  };\n\t\n\t  Factory.__proto__ = Klass; // eslint-disable-line no-proto\n\t  Factory.prototype = Klass.prototype;\n\t  return Factory;\n\t};\n\t\n\t/**\n\t * Returns the text value representation of an object\n\t * @private\n\t * @param {*} obj\n\t * @return {string}\n\t */\n\tfunction objectToString(obj) {\n\t  return obj && typeof obj === 'object' && toString.call(obj);\n\t}\n\t\n\t/**\n\t * Checks if the value is a valid array-like length.\n\t * @private\n\t * @param {*} val\n\t * @return {bool}\n\t */\n\tfunction isLength(val) {\n\t  return typeof val === 'number' && val > -1 && val % 1 === 0 && val <= Number.MAX_VALUE;\n\t}\n\n/***/ },\n/* 5 */\n/*!**********************************!*\\\n  !*** ./src/immutable-helpers.js ***!\n  \\**********************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\texports.isImmutable = isImmutable;\n\texports.isImmutableValue = isImmutableValue;\n\texports.toJS = toJS;\n\texports.toImmutable = toImmutable;\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _immutable2 = _interopRequireDefault(_immutable);\n\t\n\tvar _utils = __webpack_require__(/*! ./utils */ 4);\n\t\n\t/**\n\t * A collection of helpers for the ImmutableJS library\n\t */\n\t\n\t/**\n\t * @param {*} obj\n\t * @return {boolean}\n\t */\n\t\n\tfunction isImmutable(obj) {\n\t  return _immutable2['default'].Iterable.isIterable(obj);\n\t}\n\t\n\t/**\n\t * Returns true if the value is an ImmutableJS data structure\n\t * or a JavaScript primitive that is immutable (string, number, etc)\n\t * @param {*} obj\n\t * @return {boolean}\n\t */\n\t\n\tfunction isImmutableValue(obj) {\n\t  return isImmutable(obj) || !(0, _utils.isObject)(obj);\n\t}\n\t\n\t/**\n\t * Converts an Immutable Sequence to JS object\n\t * Can be called on any type\n\t */\n\t\n\tfunction toJS(arg) {\n\t  // arg instanceof Immutable.Sequence is unreliable\n\t  return isImmutable(arg) ? arg.toJS() : arg;\n\t}\n\t\n\t/**\n\t * Converts a JS object to an Immutable object, if it's\n\t * already Immutable its a no-op\n\t */\n\t\n\tfunction toImmutable(arg) {\n\t  return isImmutable(arg) ? arg : _immutable2['default'].fromJS(arg);\n\t}\n\n/***/ },\n/* 6 */\n/*!************************!*\\\n  !*** ./src/reactor.js ***!\n  \\************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\tfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _immutable2 = _interopRequireDefault(_immutable);\n\t\n\tvar _createReactMixin = __webpack_require__(/*! ./create-react-mixin */ 7);\n\t\n\tvar _createReactMixin2 = _interopRequireDefault(_createReactMixin);\n\t\n\tvar _reactorFns = __webpack_require__(/*! ./reactor/fns */ 8);\n\t\n\tvar fns = _interopRequireWildcard(_reactorFns);\n\t\n\tvar _reactorCache = __webpack_require__(/*! ./reactor/cache */ 9);\n\t\n\tvar _logging = __webpack_require__(/*! ./logging */ 12);\n\t\n\tvar _keyPath = __webpack_require__(/*! ./key-path */ 11);\n\t\n\tvar _getter = __webpack_require__(/*! ./getter */ 10);\n\t\n\tvar _immutableHelpers = __webpack_require__(/*! ./immutable-helpers */ 5);\n\t\n\tvar _utils = __webpack_require__(/*! ./utils */ 4);\n\t\n\tvar _reactorRecords = __webpack_require__(/*! ./reactor/records */ 13);\n\t\n\t/**\n\t * State is stored in NuclearJS Reactors.  Reactors\n\t * contain a 'state' object which is an Immutable.Map\n\t *\n\t * The only way Reactors can change state is by reacting to\n\t * messages.  To update state, Reactor's dispatch messages to\n\t * all registered cores, and the core returns it's new\n\t * state based on the message\n\t */\n\t\n\tvar Reactor = (function () {\n\t  function Reactor() {\n\t    var config = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\t\n\t    _classCallCheck(this, Reactor);\n\t\n\t    var debug = !!config.debug;\n\t    var baseOptions = debug ? _reactorRecords.DEBUG_OPTIONS : _reactorRecords.PROD_OPTIONS;\n\t    // if defined, merge the custom implementation over the noop logger to avoid undefined lookups,\n\t    // otherwise, just use the built-in console group logger\n\t    var logger = config.logger ? (0, _utils.extend)({}, _logging.NoopLogger, config.logger) : _logging.NoopLogger;\n\t    if (!config.logger && debug) {\n\t      logger = _logging.ConsoleGroupLogger;\n\t    }\n\t    var initialReactorState = new _reactorRecords.ReactorState({\n\t      debug: debug,\n\t      cache: config.cache || (0, _reactorCache.DefaultCache)(),\n\t      logger: logger,\n\t      // merge config options with the defaults\n\t      options: baseOptions.merge(config.options || {})\n\t    });\n\t\n\t    this.prevReactorState = initialReactorState;\n\t    this.reactorState = initialReactorState;\n\t    this.observerState = new _reactorRecords.ObserverState();\n\t\n\t    this.ReactMixin = (0, _createReactMixin2['default'])(this);\n\t\n\t    // keep track of the depth of batch nesting\n\t    this.__batchDepth = 0;\n\t\n\t    // keep track if we are currently dispatching\n\t    this.__isDispatching = false;\n\t  }\n\t\n\t  /**\n\t   * Evaluates a KeyPath or Getter in context of the reactor state\n\t   * @param {KeyPath|Getter} keyPathOrGetter\n\t   * @return {*}\n\t   */\n\t\n\t  _createClass(Reactor, [{\n\t    key: 'evaluate',\n\t    value: function evaluate(keyPathOrGetter) {\n\t      var _fns$evaluate = fns.evaluate(this.reactorState, keyPathOrGetter);\n\t\n\t      var result = _fns$evaluate.result;\n\t      var reactorState = _fns$evaluate.reactorState;\n\t\n\t      this.reactorState = reactorState;\n\t      return result;\n\t    }\n\t\n\t    /**\n\t     * Gets the coerced state (to JS object) of the reactor.evaluate\n\t     * @param {KeyPath|Getter} keyPathOrGetter\n\t     * @return {*}\n\t     */\n\t  }, {\n\t    key: 'evaluateToJS',\n\t    value: function evaluateToJS(keyPathOrGetter) {\n\t      return (0, _immutableHelpers.toJS)(this.evaluate(keyPathOrGetter));\n\t    }\n\t\n\t    /**\n\t     * Adds a change observer whenever a certain part of the reactor state changes\n\t     *\n\t     * 1. observe(handlerFn) - 1 argument, called anytime reactor.state changes\n\t     * 2. observe(keyPath, handlerFn) same as above\n\t     * 3. observe(getter, handlerFn) called whenever any getter dependencies change with\n\t     *    the value of the getter\n\t     *\n\t     * Adds a change handler whenever certain deps change\n\t     * If only one argument is passed invoked the handler whenever\n\t     * the reactor state changes\n\t     *\n\t     * @param {KeyPath|Getter} getter\n\t     * @param {function} handler\n\t     * @return {function} unwatch function\n\t     */\n\t  }, {\n\t    key: 'observe',\n\t    value: function observe(getter, handler) {\n\t      var _this = this;\n\t\n\t      if (arguments.length === 1) {\n\t        handler = getter;\n\t        getter = [];\n\t      }\n\t\n\t      var _fns$addObserver = fns.addObserver(this.observerState, getter, handler);\n\t\n\t      var observerState = _fns$addObserver.observerState;\n\t      var entry = _fns$addObserver.entry;\n\t\n\t      this.observerState = observerState;\n\t      return function () {\n\t        _this.observerState = fns.removeObserverByEntry(_this.observerState, entry);\n\t      };\n\t    }\n\t  }, {\n\t    key: 'unobserve',\n\t    value: function unobserve(getter, handler) {\n\t      if (arguments.length === 0) {\n\t        throw new Error('Must call unobserve with a Getter');\n\t      }\n\t      if (!(0, _getter.isGetter)(getter) && !(0, _keyPath.isKeyPath)(getter)) {\n\t        throw new Error('Must call unobserve with a Getter');\n\t      }\n\t\n\t      this.observerState = fns.removeObserver(this.observerState, getter, handler);\n\t    }\n\t\n\t    /**\n\t     * Dispatches a single message\n\t     * @param {string} actionType\n\t     * @param {object|undefined} payload\n\t     */\n\t  }, {\n\t    key: 'dispatch',\n\t    value: function dispatch(actionType, payload) {\n\t      if (this.__batchDepth === 0) {\n\t        if (fns.getOption(this.reactorState, 'throwOnDispatchInDispatch')) {\n\t          if (this.__isDispatching) {\n\t            this.__isDispatching = false;\n\t            throw new Error('Dispatch may not be called while a dispatch is in progress');\n\t          }\n\t        }\n\t        this.__isDispatching = true;\n\t      }\n\t\n\t      try {\n\t        this.reactorState = fns.dispatch(this.reactorState, actionType, payload);\n\t      } catch (e) {\n\t        this.__isDispatching = false;\n\t        throw e;\n\t      }\n\t\n\t      try {\n\t        this.__notify();\n\t      } finally {\n\t        this.__isDispatching = false;\n\t      }\n\t    }\n\t\n\t    /**\n\t     * Allows batching of dispatches before notifying change observers\n\t     * @param {Function} fn\n\t     */\n\t  }, {\n\t    key: 'batch',\n\t    value: function batch(fn) {\n\t      this.batchStart();\n\t      fn();\n\t      this.batchEnd();\n\t    }\n\t\n\t    /**\n\t     * @deprecated\n\t     * @param {String} id\n\t     * @param {Store} store\n\t     */\n\t  }, {\n\t    key: 'registerStore',\n\t    value: function registerStore(id, store) {\n\t      /* eslint-disable no-console */\n\t      console.warn('Deprecation warning: `registerStore` will no longer be supported in 1.1, use `registerStores` instead');\n\t      /* eslint-enable no-console */\n\t      this.registerStores(_defineProperty({}, id, store));\n\t    }\n\t\n\t    /**\n\t     * @param {Object} stores\n\t     */\n\t  }, {\n\t    key: 'registerStores',\n\t    value: function registerStores(stores) {\n\t      this.reactorState = fns.registerStores(this.reactorState, stores);\n\t      this.__notify();\n\t    }\n\t\n\t    /**\n\t     * Replace store implementation (handlers) without modifying the app state or calling getInitialState\n\t     * Useful for hot reloading\n\t     * @param {Object} stores\n\t     */\n\t  }, {\n\t    key: 'replaceStores',\n\t    value: function replaceStores(stores) {\n\t      this.reactorState = fns.replaceStores(this.reactorState, stores);\n\t    }\n\t\n\t    /**\n\t     * Returns a plain object representing the application state\n\t     * @return {Object}\n\t     */\n\t  }, {\n\t    key: 'serialize',\n\t    value: function serialize() {\n\t      return fns.serialize(this.reactorState);\n\t    }\n\t\n\t    /**\n\t     * @param {Object} state\n\t     */\n\t  }, {\n\t    key: 'loadState',\n\t    value: function loadState(state) {\n\t      this.reactorState = fns.loadState(this.reactorState, state);\n\t      this.__notify();\n\t    }\n\t\n\t    /**\n\t     * Resets the state of a reactor and returns back to initial state\n\t     */\n\t  }, {\n\t    key: 'reset',\n\t    value: function reset() {\n\t      var newState = fns.reset(this.reactorState);\n\t      this.reactorState = newState;\n\t      this.prevReactorState = newState;\n\t      this.observerState = new _reactorRecords.ObserverState();\n\t    }\n\t\n\t    /**\n\t     * Notifies all change observers with the current state\n\t     * @private\n\t     */\n\t  }, {\n\t    key: '__notify',\n\t    value: function __notify() {\n\t      var _this2 = this;\n\t\n\t      if (this.__batchDepth > 0) {\n\t        // in the middle of batch, dont notify\n\t        return;\n\t      }\n\t\n\t      var dirtyStores = this.reactorState.get('dirtyStores');\n\t      if (dirtyStores.size === 0) {\n\t        return;\n\t      }\n\t\n\t      var observerIdsToNotify = _immutable2['default'].Set().withMutations(function (set) {\n\t        // notify all observers\n\t        set.union(_this2.observerState.get('any'));\n\t\n\t        dirtyStores.forEach(function (id) {\n\t          var entries = _this2.observerState.getIn(['stores', id]);\n\t          if (!entries) {\n\t            return;\n\t          }\n\t          set.union(entries);\n\t        });\n\t      });\n\t\n\t      observerIdsToNotify.forEach(function (observerId) {\n\t        var entry = _this2.observerState.getIn(['observersMap', observerId]);\n\t        if (!entry) {\n\t          // don't notify here in the case a handler called unobserve on another observer\n\t          return;\n\t        }\n\t\n\t        var getter = entry.get('getter');\n\t        var handler = entry.get('handler');\n\t\n\t        var prevEvaluateResult = fns.evaluate(_this2.prevReactorState, getter);\n\t        var currEvaluateResult = fns.evaluate(_this2.reactorState, getter);\n\t\n\t        _this2.prevReactorState = prevEvaluateResult.reactorState;\n\t        _this2.reactorState = currEvaluateResult.reactorState;\n\t\n\t        var prevValue = prevEvaluateResult.result;\n\t        var currValue = currEvaluateResult.result;\n\t\n\t        if (!_immutable2['default'].is(prevValue, currValue)) {\n\t          handler.call(null, currValue);\n\t        }\n\t      });\n\t\n\t      var nextReactorState = fns.resetDirtyStores(this.reactorState);\n\t\n\t      this.prevReactorState = nextReactorState;\n\t      this.reactorState = nextReactorState;\n\t    }\n\t\n\t    /**\n\t     * Starts batching, ie pausing notifies and batching up changes\n\t     * to be notified when batchEnd() is called\n\t     */\n\t  }, {\n\t    key: 'batchStart',\n\t    value: function batchStart() {\n\t      this.__batchDepth++;\n\t    }\n\t\n\t    /**\n\t     * Ends a batch cycle and will notify obsevers of all changes if\n\t     * the batch depth is back to 0 (outer most batch completed)\n\t     */\n\t  }, {\n\t    key: 'batchEnd',\n\t    value: function batchEnd() {\n\t      this.__batchDepth--;\n\t\n\t      if (this.__batchDepth <= 0) {\n\t        // set to true to catch if dispatch called from observer\n\t        this.__isDispatching = true;\n\t        try {\n\t          this.__notify();\n\t        } catch (e) {\n\t          this.__isDispatching = false;\n\t          throw e;\n\t        }\n\t        this.__isDispatching = false;\n\t      }\n\t    }\n\t  }]);\n\t\n\t  return Reactor;\n\t})();\n\t\n\texports['default'] = (0, _utils.toFactory)(Reactor);\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 7 */\n/*!***********************************!*\\\n  !*** ./src/create-react-mixin.js ***!\n  \\***********************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\t\n\tvar _utils = __webpack_require__(/*! ./utils */ 4);\n\t\n\t/**\n\t * Returns a mapping of the getDataBinding keys to\n\t * the reactor values\n\t */\n\tfunction getState(reactor, data) {\n\t  var state = {};\n\t  (0, _utils.each)(data, function (value, key) {\n\t    state[key] = reactor.evaluate(value);\n\t  });\n\t  return state;\n\t}\n\t\n\t/**\n\t * @param {Reactor} reactor\n\t */\n\t\n\texports['default'] = function (reactor) {\n\t  return {\n\t    getInitialState: function getInitialState() {\n\t      return getState(reactor, this.getDataBindings());\n\t    },\n\t\n\t    componentDidMount: function componentDidMount() {\n\t      var _this = this;\n\t\n\t      this.__unwatchFns = [];\n\t      (0, _utils.each)(this.getDataBindings(), function (getter, key) {\n\t        var unwatchFn = reactor.observe(getter, function (val) {\n\t          _this.setState(_defineProperty({}, key, val));\n\t        });\n\t\n\t        _this.__unwatchFns.push(unwatchFn);\n\t      });\n\t    },\n\t\n\t    componentWillUnmount: function componentWillUnmount() {\n\t      while (this.__unwatchFns.length) {\n\t        this.__unwatchFns.shift()();\n\t      }\n\t    }\n\t  };\n\t};\n\t\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 8 */\n/*!****************************!*\\\n  !*** ./src/reactor/fns.js ***!\n  \\****************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\texports.registerStores = registerStores;\n\texports.replaceStores = replaceStores;\n\texports.dispatch = dispatch;\n\texports.loadState = loadState;\n\texports.addObserver = addObserver;\n\texports.getOption = getOption;\n\texports.removeObserver = removeObserver;\n\texports.removeObserverByEntry = removeObserverByEntry;\n\texports.reset = reset;\n\texports.evaluate = evaluate;\n\texports.serialize = serialize;\n\texports.resetDirtyStores = resetDirtyStores;\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _immutable2 = _interopRequireDefault(_immutable);\n\t\n\tvar _cache = __webpack_require__(/*! ./cache */ 9);\n\t\n\tvar _immutableHelpers = __webpack_require__(/*! ../immutable-helpers */ 5);\n\t\n\tvar _getter = __webpack_require__(/*! ../getter */ 10);\n\t\n\tvar _keyPath = __webpack_require__(/*! ../key-path */ 11);\n\t\n\tvar _utils = __webpack_require__(/*! ../utils */ 4);\n\t\n\t/**\n\t * Immutable Types\n\t */\n\tvar EvaluateResult = _immutable2['default'].Record({ result: null, reactorState: null });\n\t\n\tfunction evaluateResult(result, reactorState) {\n\t  return new EvaluateResult({\n\t    result: result,\n\t    reactorState: reactorState\n\t  });\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @param {Object<String, Store>} stores\n\t * @return {ReactorState}\n\t */\n\t\n\tfunction registerStores(reactorState, stores) {\n\t  return reactorState.withMutations(function (reactorState) {\n\t    (0, _utils.each)(stores, function (store, id) {\n\t      if (reactorState.getIn(['stores', id])) {\n\t        /* eslint-disable no-console */\n\t        console.warn('Store already defined for id = ' + id);\n\t        /* eslint-enable no-console */\n\t      }\n\t\n\t      var initialState = store.getInitialState();\n\t\n\t      if (initialState === undefined && getOption(reactorState, 'throwOnUndefinedStoreReturnValue')) {\n\t        throw new Error('Store getInitialState() must return a value, did you forget a return statement');\n\t      }\n\t      if (getOption(reactorState, 'throwOnNonImmutableStore') && !(0, _immutableHelpers.isImmutableValue)(initialState)) {\n\t        throw new Error('Store getInitialState() must return an immutable value, did you forget to call toImmutable');\n\t      }\n\t\n\t      reactorState.update('stores', function (stores) {\n\t        return stores.set(id, store);\n\t      }).update('state', function (state) {\n\t        return state.set(id, initialState);\n\t      }).update('dirtyStores', function (state) {\n\t        return state.add(id);\n\t      }).update('storeStates', function (storeStates) {\n\t        return incrementStoreStates(storeStates, [id]);\n\t      });\n\t    });\n\t    incrementId(reactorState);\n\t  });\n\t}\n\t\n\t/**\n\t * Overrides the store implementation without resetting the value of that particular part of the app state\n\t * this is useful when doing hot reloading of stores.\n\t * @param {ReactorState} reactorState\n\t * @param {Object<String, Store>} stores\n\t * @return {ReactorState}\n\t */\n\t\n\tfunction replaceStores(reactorState, stores) {\n\t  return reactorState.withMutations(function (reactorState) {\n\t    (0, _utils.each)(stores, function (store, id) {\n\t      reactorState.update('stores', function (stores) {\n\t        return stores.set(id, store);\n\t      });\n\t    });\n\t  });\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @param {String} actionType\n\t * @param {*} payload\n\t * @return {ReactorState}\n\t */\n\t\n\tfunction dispatch(reactorState, actionType, payload) {\n\t  var logging = reactorState.get('logger');\n\t\n\t  if (actionType === undefined && getOption(reactorState, 'throwOnUndefinedActionType')) {\n\t    throw new Error('`dispatch` cannot be called with an `undefined` action type.');\n\t  }\n\t\n\t  var currState = reactorState.get('state');\n\t  var dirtyStores = reactorState.get('dirtyStores');\n\t\n\t  var nextState = currState.withMutations(function (state) {\n\t    logging.dispatchStart(reactorState, actionType, payload);\n\t\n\t    // let each store handle the message\n\t    reactorState.get('stores').forEach(function (store, id) {\n\t      var currState = state.get(id);\n\t      var newState = undefined;\n\t\n\t      try {\n\t        newState = store.handle(currState, actionType, payload);\n\t      } catch (e) {\n\t        // ensure console.group is properly closed\n\t        logging.dispatchError(reactorState, e.message);\n\t        throw e;\n\t      }\n\t\n\t      if (newState === undefined && getOption(reactorState, 'throwOnUndefinedStoreReturnValue')) {\n\t        var errorMsg = 'Store handler must return a value, did you forget a return statement';\n\t        logging.dispatchError(reactorState, errorMsg);\n\t        throw new Error(errorMsg);\n\t      }\n\t\n\t      state.set(id, newState);\n\t\n\t      if (currState !== newState) {\n\t        // if the store state changed add store to list of dirty stores\n\t        dirtyStores = dirtyStores.add(id);\n\t      }\n\t    });\n\t\n\t    logging.dispatchEnd(reactorState, state, dirtyStores, currState);\n\t  });\n\t\n\t  var nextReactorState = reactorState.set('state', nextState).set('dirtyStores', dirtyStores).update('storeStates', function (storeStates) {\n\t    return incrementStoreStates(storeStates, dirtyStores);\n\t  });\n\t\n\t  return incrementId(nextReactorState);\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @param {Immutable.Map} state\n\t * @return {ReactorState}\n\t */\n\t\n\tfunction loadState(reactorState, state) {\n\t  var dirtyStores = [];\n\t  var stateToLoad = (0, _immutableHelpers.toImmutable)({}).withMutations(function (stateToLoad) {\n\t    (0, _utils.each)(state, function (serializedStoreState, storeId) {\n\t      var store = reactorState.getIn(['stores', storeId]);\n\t      if (store) {\n\t        var storeState = store.deserialize(serializedStoreState);\n\t        if (storeState !== undefined) {\n\t          stateToLoad.set(storeId, storeState);\n\t          dirtyStores.push(storeId);\n\t        }\n\t      }\n\t    });\n\t  });\n\t\n\t  var dirtyStoresSet = _immutable2['default'].Set(dirtyStores);\n\t  return reactorState.update('state', function (state) {\n\t    return state.merge(stateToLoad);\n\t  }).update('dirtyStores', function (stores) {\n\t    return stores.union(dirtyStoresSet);\n\t  }).update('storeStates', function (storeStates) {\n\t    return incrementStoreStates(storeStates, dirtyStores);\n\t  });\n\t}\n\t\n\t/**\n\t * Adds a change observer whenever a certain part of the reactor state changes\n\t *\n\t * 1. observe(handlerFn) - 1 argument, called anytime reactor.state changes\n\t * 2. observe(keyPath, handlerFn) same as above\n\t * 3. observe(getter, handlerFn) called whenever any getter dependencies change with\n\t *    the value of the getter\n\t *\n\t * Adds a change handler whenever certain deps change\n\t * If only one argument is passed invoked the handler whenever\n\t * the reactor state changes\n\t *\n\t * @param {ObserverState} observerState\n\t * @param {KeyPath|Getter} getter\n\t * @param {function} handler\n\t * @return {ObserveResult}\n\t */\n\t\n\tfunction addObserver(observerState, getter, handler) {\n\t  // use the passed in getter as the key so we can rely on a byreference call for unobserve\n\t  var getterKey = getter;\n\t  if ((0, _keyPath.isKeyPath)(getter)) {\n\t    getter = (0, _getter.fromKeyPath)(getter);\n\t  }\n\t\n\t  var currId = observerState.get('nextId');\n\t  var storeDeps = (0, _getter.getStoreDeps)(getter);\n\t  var entry = _immutable2['default'].Map({\n\t    id: currId,\n\t    storeDeps: storeDeps,\n\t    getterKey: getterKey,\n\t    getter: getter,\n\t    handler: handler\n\t  });\n\t\n\t  var updatedObserverState = undefined;\n\t  if (storeDeps.size === 0) {\n\t    // no storeDeps means the observer is dependent on any of the state changing\n\t    updatedObserverState = observerState.update('any', function (observerIds) {\n\t      return observerIds.add(currId);\n\t    });\n\t  } else {\n\t    updatedObserverState = observerState.withMutations(function (map) {\n\t      storeDeps.forEach(function (storeId) {\n\t        var path = ['stores', storeId];\n\t        if (!map.hasIn(path)) {\n\t          map.setIn(path, _immutable2['default'].Set());\n\t        }\n\t        map.updateIn(['stores', storeId], function (observerIds) {\n\t          return observerIds.add(currId);\n\t        });\n\t      });\n\t    });\n\t  }\n\t\n\t  updatedObserverState = updatedObserverState.set('nextId', currId + 1).setIn(['observersMap', currId], entry);\n\t\n\t  return {\n\t    observerState: updatedObserverState,\n\t    entry: entry\n\t  };\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @param {String} option\n\t * @return {Boolean}\n\t */\n\t\n\tfunction getOption(reactorState, option) {\n\t  var value = reactorState.getIn(['options', option]);\n\t  if (value === undefined) {\n\t    throw new Error('Invalid option: ' + option);\n\t  }\n\t  return value;\n\t}\n\t\n\t/**\n\t * Use cases\n\t * removeObserver(observerState, [])\n\t * removeObserver(observerState, [], handler)\n\t * removeObserver(observerState, ['keyPath'])\n\t * removeObserver(observerState, ['keyPath'], handler)\n\t * removeObserver(observerState, getter)\n\t * removeObserver(observerState, getter, handler)\n\t * @param {ObserverState} observerState\n\t * @param {KeyPath|Getter} getter\n\t * @param {Function} handler\n\t * @return {ObserverState}\n\t */\n\t\n\tfunction removeObserver(observerState, getter, handler) {\n\t  var entriesToRemove = observerState.get('observersMap').filter(function (entry) {\n\t    // use the getterKey in the case of a keyPath is transformed to a getter in addObserver\n\t    var entryGetter = entry.get('getterKey');\n\t    var handlersMatch = !handler || entry.get('handler') === handler;\n\t    if (!handlersMatch) {\n\t      return false;\n\t    }\n\t    // check for a by-value equality of keypaths\n\t    if ((0, _keyPath.isKeyPath)(getter) && (0, _keyPath.isKeyPath)(entryGetter)) {\n\t      return (0, _keyPath.isEqual)(getter, entryGetter);\n\t    }\n\t    // we are comparing two getters do it by reference\n\t    return getter === entryGetter;\n\t  });\n\t\n\t  return observerState.withMutations(function (map) {\n\t    entriesToRemove.forEach(function (entry) {\n\t      return removeObserverByEntry(map, entry);\n\t    });\n\t  });\n\t}\n\t\n\t/**\n\t * Removes an observer entry by id from the observerState\n\t * @param {ObserverState} observerState\n\t * @param {Immutable.Map} entry\n\t * @return {ObserverState}\n\t */\n\t\n\tfunction removeObserverByEntry(observerState, entry) {\n\t  return observerState.withMutations(function (map) {\n\t    var id = entry.get('id');\n\t    var storeDeps = entry.get('storeDeps');\n\t\n\t    if (storeDeps.size === 0) {\n\t      map.update('any', function (anyObsevers) {\n\t        return anyObsevers.remove(id);\n\t      });\n\t    } else {\n\t      storeDeps.forEach(function (storeId) {\n\t        map.updateIn(['stores', storeId], function (observers) {\n\t          if (observers) {\n\t            // check for observers being present because reactor.reset() can be called before an unwatch fn\n\t            return observers.remove(id);\n\t          }\n\t          return observers;\n\t        });\n\t      });\n\t    }\n\t\n\t    map.removeIn(['observersMap', id]);\n\t  });\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @return {ReactorState}\n\t */\n\t\n\tfunction reset(reactorState) {\n\t  var prevState = reactorState.get('state');\n\t\n\t  return reactorState.withMutations(function (reactorState) {\n\t    var storeMap = reactorState.get('stores');\n\t    var storeIds = storeMap.keySeq().toJS();\n\t    storeMap.forEach(function (store, id) {\n\t      var storeState = prevState.get(id);\n\t      var resetStoreState = store.handleReset(storeState);\n\t      if (resetStoreState === undefined && getOption(reactorState, 'throwOnUndefinedStoreReturnValue')) {\n\t        throw new Error('Store handleReset() must return a value, did you forget a return statement');\n\t      }\n\t      if (getOption(reactorState, 'throwOnNonImmutableStore') && !(0, _immutableHelpers.isImmutableValue)(resetStoreState)) {\n\t        throw new Error('Store reset state must be an immutable value, did you forget to call toImmutable');\n\t      }\n\t      reactorState.setIn(['state', id], resetStoreState);\n\t    });\n\t\n\t    reactorState.update('storeStates', function (storeStates) {\n\t      return incrementStoreStates(storeStates, storeIds);\n\t    });\n\t    resetDirtyStores(reactorState);\n\t  });\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @param {KeyPath|Gettter} keyPathOrGetter\n\t * @return {EvaluateResult}\n\t */\n\t\n\tfunction evaluate(reactorState, keyPathOrGetter) {\n\t  var state = reactorState.get('state');\n\t\n\t  if ((0, _keyPath.isKeyPath)(keyPathOrGetter)) {\n\t    // if its a keyPath simply return\n\t    return evaluateResult(state.getIn(keyPathOrGetter), reactorState);\n\t  } else if (!(0, _getter.isGetter)(keyPathOrGetter)) {\n\t    throw new Error('evaluate must be passed a keyPath or Getter');\n\t  }\n\t\n\t  // Must be a Getter\n\t\n\t  var cache = reactorState.get('cache');\n\t  var cacheEntry = cache.lookup(keyPathOrGetter);\n\t  var isCacheMiss = !cacheEntry || isDirtyCacheEntry(reactorState, cacheEntry);\n\t  if (isCacheMiss) {\n\t    cacheEntry = createCacheEntry(reactorState, keyPathOrGetter);\n\t  }\n\t\n\t  return evaluateResult(cacheEntry.get('value'), reactorState.update('cache', function (cache) {\n\t    return isCacheMiss ? cache.miss(keyPathOrGetter, cacheEntry) : cache.hit(keyPathOrGetter);\n\t  }));\n\t}\n\t\n\t/**\n\t * Returns serialized state for all stores\n\t * @param {ReactorState} reactorState\n\t * @return {Object}\n\t */\n\t\n\tfunction serialize(reactorState) {\n\t  var serialized = {};\n\t  reactorState.get('stores').forEach(function (store, id) {\n\t    var storeState = reactorState.getIn(['state', id]);\n\t    var serializedState = store.serialize(storeState);\n\t    if (serializedState !== undefined) {\n\t      serialized[id] = serializedState;\n\t    }\n\t  });\n\t  return serialized;\n\t}\n\t\n\t/**\n\t * Returns serialized state for all stores\n\t * @param {ReactorState} reactorState\n\t * @return {ReactorState}\n\t */\n\t\n\tfunction resetDirtyStores(reactorState) {\n\t  return reactorState.set('dirtyStores', _immutable2['default'].Set());\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @param {CacheEntry} cacheEntry\n\t * @return {boolean}\n\t */\n\tfunction isDirtyCacheEntry(reactorState, cacheEntry) {\n\t  var storeStates = cacheEntry.get('storeStates');\n\t\n\t  // if there are no store states for this entry then it was never cached before\n\t  return !storeStates.size || storeStates.some(function (stateId, storeId) {\n\t    return reactorState.getIn(['storeStates', storeId]) !== stateId;\n\t  });\n\t}\n\t\n\t/**\n\t * Evaluates getter for given reactorState and returns CacheEntry\n\t * @param {ReactorState} reactorState\n\t * @param {Getter} getter\n\t * @return {CacheEntry}\n\t */\n\tfunction createCacheEntry(reactorState, getter) {\n\t  // evaluate dependencies\n\t  var args = (0, _getter.getDeps)(getter).map(function (dep) {\n\t    return evaluate(reactorState, dep).result;\n\t  });\n\t  var value = (0, _getter.getComputeFn)(getter).apply(null, args);\n\t\n\t  var storeDeps = (0, _getter.getStoreDeps)(getter);\n\t  var storeStates = (0, _immutableHelpers.toImmutable)({}).withMutations(function (map) {\n\t    storeDeps.forEach(function (storeId) {\n\t      var stateId = reactorState.getIn(['storeStates', storeId]);\n\t      map.set(storeId, stateId);\n\t    });\n\t  });\n\t\n\t  return (0, _cache.CacheEntry)({\n\t    value: value,\n\t    storeStates: storeStates,\n\t    dispatchId: reactorState.get('dispatchId')\n\t  });\n\t}\n\t\n\t/**\n\t * @param {ReactorState} reactorState\n\t * @return {ReactorState}\n\t */\n\tfunction incrementId(reactorState) {\n\t  return reactorState.update('dispatchId', function (id) {\n\t    return id + 1;\n\t  });\n\t}\n\t\n\t/**\n\t * @param {Immutable.Map} storeStates\n\t * @param {Array} storeIds\n\t * @return {Immutable.Map}\n\t */\n\tfunction incrementStoreStates(storeStates, storeIds) {\n\t  return storeStates.withMutations(function (map) {\n\t    storeIds.forEach(function (id) {\n\t      var nextId = map.has(id) ? map.get(id) + 1 : 1;\n\t      map.set(id, nextId);\n\t    });\n\t  });\n\t}\n\n/***/ },\n/* 9 */\n/*!******************************!*\\\n  !*** ./src/reactor/cache.js ***!\n  \\******************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();\n\t\n\texports.DefaultCache = DefaultCache;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar CacheEntry = (0, _immutable.Record)({\n\t  value: null,\n\t  storeStates: (0, _immutable.Map)(),\n\t  dispatchId: null\n\t});\n\t\n\texports.CacheEntry = CacheEntry;\n\t/*******************************************************************************\n\t * interface PersistentCache {\n\t *    has(item)\n\t *    lookup(item, notFoundValue)\n\t *    hit(item)\n\t *    miss(item, entry)\n\t *    evict(item)\n\t *    asMap()\n\t * }\n\t *\n\t * Inspired by clojure.core.cache/CacheProtocol\n\t *******************************************************************************/\n\t\n\t/**\n\t * Plain map-based cache\n\t */\n\t\n\tvar BasicCache = (function () {\n\t\n\t  /**\n\t   * @param {Immutable.Map} cache\n\t   */\n\t\n\t  function BasicCache() {\n\t    var cache = arguments.length <= 0 || arguments[0] === undefined ? (0, _immutable.Map)() : arguments[0];\n\t\n\t    _classCallCheck(this, BasicCache);\n\t\n\t    this.cache = cache;\n\t  }\n\t\n\t  /**\n\t   * Retrieve the associated value, if it exists in this cache, otherwise\n\t   * returns notFoundValue (or undefined if not provided)\n\t   * @param {Object} item\n\t   * @param {Object?} notFoundValue\n\t   * @return {CacheEntry?}\n\t   */\n\t\n\t  _createClass(BasicCache, [{\n\t    key: 'lookup',\n\t    value: function lookup(item, notFoundValue) {\n\t      return this.cache.get(item, notFoundValue);\n\t    }\n\t\n\t    /**\n\t     * Checks if this cache contains an associated value\n\t     * @param {Object} item\n\t     * @return {boolean}\n\t     */\n\t  }, {\n\t    key: 'has',\n\t    value: function has(item) {\n\t      return this.cache.has(item);\n\t    }\n\t\n\t    /**\n\t     * Return cached items as map\n\t     * @return {Immutable.Map}\n\t     */\n\t  }, {\n\t    key: 'asMap',\n\t    value: function asMap() {\n\t      return this.cache;\n\t    }\n\t\n\t    /**\n\t     * Updates this cache when it is determined to contain the associated value\n\t     * @param {Object} item\n\t     * @return {BasicCache}\n\t     */\n\t  }, {\n\t    key: 'hit',\n\t    value: function hit(item) {\n\t      return this;\n\t    }\n\t\n\t    /**\n\t     * Updates this cache when it is determined to **not** contain the associated value\n\t     * @param {Object} item\n\t     * @param {CacheEntry} entry\n\t     * @return {BasicCache}\n\t     */\n\t  }, {\n\t    key: 'miss',\n\t    value: function miss(item, entry) {\n\t      return new BasicCache(this.cache.update(item, function (existingEntry) {\n\t        if (existingEntry && existingEntry.dispatchId > entry.dispatchId) {\n\t          throw new Error('Refusing to cache older value');\n\t        }\n\t        return entry;\n\t      }));\n\t    }\n\t\n\t    /**\n\t     * Removes entry from cache\n\t     * @param {Object} item\n\t     * @return {BasicCache}\n\t     */\n\t  }, {\n\t    key: 'evict',\n\t    value: function evict(item) {\n\t      return new BasicCache(this.cache.remove(item));\n\t    }\n\t  }]);\n\t\n\t  return BasicCache;\n\t})();\n\t\n\texports.BasicCache = BasicCache;\n\t\n\tvar DEFAULT_LRU_LIMIT = 1000;\n\tvar DEFAULT_LRU_EVICT_COUNT = 1;\n\t\n\t/**\n\t * Implements caching strategy that evicts least-recently-used items in cache\n\t * when an item is being added to a cache that has reached a configured size\n\t * limit.\n\t */\n\t\n\tvar LRUCache = (function () {\n\t  function LRUCache() {\n\t    var limit = arguments.length <= 0 || arguments[0] === undefined ? DEFAULT_LRU_LIMIT : arguments[0];\n\t    var evictCount = arguments.length <= 1 || arguments[1] === undefined ? DEFAULT_LRU_EVICT_COUNT : arguments[1];\n\t    var cache = arguments.length <= 2 || arguments[2] === undefined ? new BasicCache() : arguments[2];\n\t    var lru = arguments.length <= 3 || arguments[3] === undefined ? (0, _immutable.OrderedSet)() : arguments[3];\n\t\n\t    _classCallCheck(this, LRUCache);\n\t\n\t    console.log(\"using LRU\");\n\t    this.limit = limit;\n\t    this.evictCount = evictCount;\n\t    this.cache = cache;\n\t    this.lru = lru;\n\t  }\n\t\n\t  /**\n\t   * Returns default cache strategy\n\t   * @return {BasicCache}\n\t   */\n\t\n\t  /**\n\t   * Retrieve the associated value, if it exists in this cache, otherwise\n\t   * returns notFoundValue (or undefined if not provided)\n\t   * @param {Object} item\n\t   * @param {Object?} notFoundValue\n\t   * @return {CacheEntry}\n\t   */\n\t\n\t  _createClass(LRUCache, [{\n\t    key: 'lookup',\n\t    value: function lookup(item, notFoundValue) {\n\t      return this.cache.lookup(item, notFoundValue);\n\t    }\n\t\n\t    /**\n\t     * Checks if this cache contains an associated value\n\t     * @param {Object} item\n\t     * @return {boolean}\n\t     */\n\t  }, {\n\t    key: 'has',\n\t    value: function has(item) {\n\t      return this.cache.has(item);\n\t    }\n\t\n\t    /**\n\t     * Return cached items as map\n\t     * @return {Immutable.Map}\n\t     */\n\t  }, {\n\t    key: 'asMap',\n\t    value: function asMap() {\n\t      return this.cache.asMap();\n\t    }\n\t\n\t    /**\n\t     * Updates this cache when it is determined to contain the associated value\n\t     * @param {Object} item\n\t     * @return {LRUCache}\n\t     */\n\t  }, {\n\t    key: 'hit',\n\t    value: function hit(item) {\n\t      if (!this.cache.has(item)) {\n\t        return this;\n\t      }\n\t\n\t      // remove it first to reorder in lru OrderedSet\n\t      return new LRUCache(this.limit, this.evictCount, this.cache, this.lru.remove(item).add(item));\n\t    }\n\t\n\t    /**\n\t     * Updates this cache when it is determined to **not** contain the associated value\n\t     * If cache has reached size limit, the LRU item is evicted.\n\t     * @param {Object} item\n\t     * @param {CacheEntry} entry\n\t     * @return {LRUCache}\n\t     */\n\t  }, {\n\t    key: 'miss',\n\t    value: function miss(item, entry) {\n\t      var lruCache;\n\t      if (this.lru.size >= this.limit) {\n\t        if (this.has(item)) {\n\t          return new LRUCache(this.limit, this.evictCount, this.cache.miss(item, entry), this.lru.remove(item).add(item));\n\t        }\n\t\n\t        var cache = this.lru.take(this.evictCount).reduce(function (c, evictItem) {\n\t          return c.evict(evictItem);\n\t        }, this.cache).miss(item, entry);\n\t\n\t        lruCache = new LRUCache(this.limit, this.evictCount, cache, this.lru.skip(this.evictCount).add(item));\n\t      } else {\n\t        lruCache = new LRUCache(this.limit, this.evictCount, this.cache.miss(item, entry), this.lru.add(item));\n\t      }\n\t      return lruCache;\n\t    }\n\t\n\t    /**\n\t     * Removes entry from cache\n\t     * @param {Object} item\n\t     * @return {LRUCache}\n\t     */\n\t  }, {\n\t    key: 'evict',\n\t    value: function evict(item) {\n\t      if (!this.cache.has(item)) {\n\t        return this;\n\t      }\n\t\n\t      return new LRUCache(this.limit, this.evictCount, this.cache.evict(item), this.lru.remove(item));\n\t    }\n\t  }]);\n\t\n\t  return LRUCache;\n\t})();\n\t\n\texports.LRUCache = LRUCache;\n\t\n\tfunction DefaultCache() {\n\t  return new BasicCache();\n\t}\n\n/***/ },\n/* 10 */\n/*!***********************!*\\\n  !*** ./src/getter.js ***!\n  \\***********************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _immutable2 = _interopRequireDefault(_immutable);\n\t\n\tvar _utils = __webpack_require__(/*! ./utils */ 4);\n\t\n\tvar _keyPath = __webpack_require__(/*! ./key-path */ 11);\n\t\n\t/**\n\t * Getter helper functions\n\t * A getter is an array with the form:\n\t * [<KeyPath>, ...<KeyPath>, <function>]\n\t */\n\tvar identity = function identity(x) {\n\t  return x;\n\t};\n\t\n\t/**\n\t * Checks if something is a getter literal, ex: ['dep1', 'dep2', function(dep1, dep2) {...}]\n\t * @param {*} toTest\n\t * @return {boolean}\n\t */\n\tfunction isGetter(toTest) {\n\t  return (0, _utils.isArray)(toTest) && (0, _utils.isFunction)(toTest[toTest.length - 1]);\n\t}\n\t\n\t/**\n\t * Returns the compute function from a getter\n\t * @param {Getter} getter\n\t * @return {function}\n\t */\n\tfunction getComputeFn(getter) {\n\t  return getter[getter.length - 1];\n\t}\n\t\n\t/**\n\t * Returns an array of deps from a getter\n\t * @param {Getter} getter\n\t * @return {function}\n\t */\n\tfunction getDeps(getter) {\n\t  return getter.slice(0, getter.length - 1);\n\t}\n\t\n\t/**\n\t * Returns an array of deps from a getter and all its deps\n\t * @param {Getter} getter\n\t * @param {Immutable.Set} existing\n\t * @return {Immutable.Set}\n\t */\n\tfunction getFlattenedDeps(getter, existing) {\n\t  if (!existing) {\n\t    existing = _immutable2['default'].Set();\n\t  }\n\t\n\t  var toAdd = _immutable2['default'].Set().withMutations(function (set) {\n\t    if (!isGetter(getter)) {\n\t      throw new Error('getFlattenedDeps must be passed a Getter');\n\t    }\n\t\n\t    getDeps(getter).forEach(function (dep) {\n\t      if ((0, _keyPath.isKeyPath)(dep)) {\n\t        set.add((0, _immutable.List)(dep));\n\t      } else if (isGetter(dep)) {\n\t        set.union(getFlattenedDeps(dep));\n\t      } else {\n\t        throw new Error('Invalid getter, each dependency must be a KeyPath or Getter');\n\t      }\n\t    });\n\t  });\n\t\n\t  return existing.union(toAdd);\n\t}\n\t\n\t/**\n\t * @param {KeyPath}\n\t * @return {Getter}\n\t */\n\tfunction fromKeyPath(keyPath) {\n\t  if (!(0, _keyPath.isKeyPath)(keyPath)) {\n\t    throw new Error('Cannot create Getter from KeyPath: ' + keyPath);\n\t  }\n\t\n\t  return [keyPath, identity];\n\t}\n\t\n\t/**\n\t * Adds non enumerated __storeDeps property\n\t * @param {Getter}\n\t */\n\tfunction getStoreDeps(getter) {\n\t  if (getter.hasOwnProperty('__storeDeps')) {\n\t    return getter.__storeDeps;\n\t  }\n\t\n\t  var storeDeps = getFlattenedDeps(getter).map(function (keyPath) {\n\t    return keyPath.first();\n\t  }).filter(function (x) {\n\t    return !!x;\n\t  });\n\t\n\t  Object.defineProperty(getter, '__storeDeps', {\n\t    enumerable: false,\n\t    configurable: false,\n\t    writable: false,\n\t    value: storeDeps\n\t  });\n\t\n\t  return storeDeps;\n\t}\n\t\n\texports['default'] = {\n\t  isGetter: isGetter,\n\t  getComputeFn: getComputeFn,\n\t  getFlattenedDeps: getFlattenedDeps,\n\t  getStoreDeps: getStoreDeps,\n\t  getDeps: getDeps,\n\t  fromKeyPath: fromKeyPath\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 11 */\n/*!*************************!*\\\n  !*** ./src/key-path.js ***!\n  \\*************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\texports.isKeyPath = isKeyPath;\n\texports.isEqual = isEqual;\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _immutable2 = _interopRequireDefault(_immutable);\n\t\n\tvar _utils = __webpack_require__(/*! ./utils */ 4);\n\t\n\t/**\n\t * Checks if something is simply a keyPath and not a getter\n\t * @param {*} toTest\n\t * @return {boolean}\n\t */\n\t\n\tfunction isKeyPath(toTest) {\n\t  return (0, _utils.isArray)(toTest) && !(0, _utils.isFunction)(toTest[toTest.length - 1]);\n\t}\n\t\n\t/**\n\t * Checks if two keypaths are equal by value\n\t * @param {KeyPath} a\n\t * @param {KeyPath} a\n\t * @return {Boolean}\n\t */\n\t\n\tfunction isEqual(a, b) {\n\t  var iA = _immutable2['default'].List(a);\n\t  var iB = _immutable2['default'].List(b);\n\t\n\t  return _immutable2['default'].is(iA, iB);\n\t}\n\n/***/ },\n/* 12 */\n/*!************************!*\\\n  !*** ./src/logging.js ***!\n  \\************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _reactorFns = __webpack_require__(/*! ./reactor/fns */ 8);\n\t\n\t/* eslint-disable no-console */\n\t/**\n\t * Wraps a Reactor.react invocation in a console.group\n\t */\n\tvar ConsoleGroupLogger = {\n\t  /**\n\t   * @param {ReactorState} reactorState\n\t   * @param {String} type\n\t   * @param {*} payload\n\t   */\n\t  dispatchStart: function dispatchStart(reactorState, type, payload) {\n\t    if (!(0, _reactorFns.getOption)(reactorState, 'logDispatches')) {\n\t      return;\n\t    }\n\t\n\t    if (console.group) {\n\t      console.groupCollapsed('Dispatch: %s', type);\n\t      console.group('payload');\n\t      console.debug(payload);\n\t      console.groupEnd();\n\t    }\n\t  },\n\t  /**\n\t   * @param {ReactorState} reactorState\n\t   * @param {Error} error\n\t   */\n\t  dispatchError: function dispatchError(reactorState, error) {\n\t    if (!(0, _reactorFns.getOption)(reactorState, 'logDispatches')) {\n\t      return;\n\t    }\n\t\n\t    if (console.group) {\n\t      console.debug('Dispatch error: ' + error);\n\t      console.groupEnd();\n\t    }\n\t  },\n\t  /**\n\t   * @param {ReactorState} reactorState\n\t   * @param {Map} state\n\t   * @param {Set} dirtyStores\n\t   */\n\t  dispatchEnd: function dispatchEnd(reactorState, state, dirtyStores, previousState) {\n\t    if (!(0, _reactorFns.getOption)(reactorState, 'logDispatches')) {\n\t      return;\n\t    }\n\t\n\t    if (console.group) {\n\t      if ((0, _reactorFns.getOption)(reactorState, 'logDirtyStores')) {\n\t        console.log('Stores updated:', dirtyStores.toList().toJS());\n\t      }\n\t\n\t      if ((0, _reactorFns.getOption)(reactorState, 'logAppState')) {\n\t        console.debug('Dispatch done, new state: ', state.toJS());\n\t      }\n\t      console.groupEnd();\n\t    }\n\t  }\n\t};\n\t\n\texports.ConsoleGroupLogger = ConsoleGroupLogger;\n\t/* eslint-enable no-console */\n\t\n\tvar NoopLogger = {\n\t  /**\n\t   * @param {ReactorState} reactorState\n\t   * @param {String} type\n\t   * @param {*} payload\n\t   */\n\t  dispatchStart: function dispatchStart(reactorState, type, payload) {},\n\t  /**\n\t   * @param {ReactorState} reactorState\n\t   * @param {Error} error\n\t   */\n\t  dispatchError: function dispatchError(reactorState, error) {},\n\t  /**\n\t   * @param {ReactorState} reactorState\n\t   * @param {Map} state\n\t   * @param {Set} dirtyStores\n\t   */\n\t  dispatchEnd: function dispatchEnd(reactorState, state, dirtyStores) {}\n\t};\n\texports.NoopLogger = NoopLogger;\n\n/***/ },\n/* 13 */\n/*!********************************!*\\\n  !*** ./src/reactor/records.js ***!\n  \\********************************/\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\t\n\tvar _immutable = __webpack_require__(/*! immutable */ 3);\n\t\n\tvar _cache = __webpack_require__(/*! ./cache */ 9);\n\t\n\tvar _logging = __webpack_require__(/*! ../logging */ 12);\n\t\n\tvar PROD_OPTIONS = (0, _immutable.Map)({\n\t  // logs information for each dispatch\n\t  logDispatches: false,\n\t  // log the entire app state after each dispatch\n\t  logAppState: false,\n\t  // logs what stores changed after a dispatch\n\t  logDirtyStores: false,\n\t  // if true, throws an error when dispatching an `undefined` actionType\n\t  throwOnUndefinedActionType: false,\n\t  // if true, throws an error if a store returns undefined\n\t  throwOnUndefinedStoreReturnValue: false,\n\t  // if true, throws an error if a store.getInitialState() returns a non immutable value\n\t  throwOnNonImmutableStore: false,\n\t  // if true, throws when dispatching in dispatch\n\t  throwOnDispatchInDispatch: false\n\t});\n\t\n\texports.PROD_OPTIONS = PROD_OPTIONS;\n\tvar DEBUG_OPTIONS = (0, _immutable.Map)({\n\t  // logs information for each dispatch\n\t  logDispatches: true,\n\t  // log the entire app state after each dispatch\n\t  logAppState: true,\n\t  // logs what stores changed after a dispatch\n\t  logDirtyStores: true,\n\t  // if true, throws an error when dispatching an `undefined` actionType\n\t  throwOnUndefinedActionType: true,\n\t  // if true, throws an error if a store returns undefined\n\t  throwOnUndefinedStoreReturnValue: true,\n\t  // if true, throws an error if a store.getInitialState() returns a non immutable value\n\t  throwOnNonImmutableStore: true,\n\t  // if true, throws when dispatching in dispatch\n\t  throwOnDispatchInDispatch: true\n\t});\n\t\n\texports.DEBUG_OPTIONS = DEBUG_OPTIONS;\n\tvar ReactorState = (0, _immutable.Record)({\n\t  dispatchId: 0,\n\t  state: (0, _immutable.Map)(),\n\t  stores: (0, _immutable.Map)(),\n\t  cache: (0, _cache.DefaultCache)(),\n\t  logger: _logging.NoopLogger,\n\t  // maintains a mapping of storeId => state id (monotomically increasing integer whenever store state changes)\n\t  storeStates: (0, _immutable.Map)(),\n\t  dirtyStores: (0, _immutable.Set)(),\n\t  debug: false,\n\t  // production defaults\n\t  options: PROD_OPTIONS\n\t});\n\t\n\texports.ReactorState = ReactorState;\n\tvar ObserverState = (0, _immutable.Record)({\n\t  // observers registered to any store change\n\t  any: (0, _immutable.Set)(),\n\t  // observers registered to specific store changes\n\t  stores: (0, _immutable.Map)({}),\n\t\n\t  observersMap: (0, _immutable.Map)({}),\n\t\n\t  nextId: 1\n\t});\n\texports.ObserverState = ObserverState;\n\n/***/ }\n/******/ ])\n});\n;\n\n\n/** WEBPACK FOOTER **\n ** dist/nuclear.min.js\n **/"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 5101807446b00161d85d\n **/","import './console-polyfill'\nimport Store from './store'\nimport Reactor from './reactor'\nimport Immutable from 'immutable'\nimport { toJS, toImmutable, isImmutable } from './immutable-helpers'\nimport { isKeyPath } from './key-path'\nimport { isGetter } from './getter'\nimport { LRUCache } from './reactor/cache'\nimport createReactMixin from './create-react-mixin'\n\nexport default {\n  Reactor,\n  Store,\n  Immutable,\n  isKeyPath,\n  isGetter,\n  toJS,\n  toImmutable,\n  isImmutable,\n  createReactMixin,\n  LRUCache,\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/main.js\n **/","try {\n  /* eslint-disable no-console */\n  if (!(window.console && console.log)) {\n  /* eslint-enable no-console */\n    console = {\n      log: function() {},\n      debug: function() {},\n      info: function() {},\n      warn: function() {},\n      error: function() {},\n    }\n  }\n} catch(e) {\n  // ignored\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/console-polyfill.js\n **/","import { Map } from 'immutable'\nimport { toFactory, extend } from './utils'\nimport { toJS, toImmutable } from './immutable-helpers'\n\n/**\n * Stores define how a certain domain of the application should respond to actions\n * taken on the whole system.  They manage their own section of the entire app state\n * and have no knowledge about the other parts of the application state.\n */\nclass Store {\n  constructor(config) {\n    this.__handlers = Map({})\n\n    if (config) {\n      // allow `MyStore extends Store` syntax without throwing error\n      extend(this, config)\n    }\n\n    this.initialize()\n  }\n\n  /**\n   * This method is overridden by extending classes to setup message handlers\n   * via `this.on` and to set up the initial state\n   *\n   * Anything returned from this function will be coerced into an ImmutableJS value\n   * and set as the initial state for the part of the ReactorCore\n   */\n  initialize() {\n    // extending classes implement to setup action handlers\n  }\n\n  /**\n   * Overridable method to get the initial state for this type of store\n   */\n  getInitialState() {\n    return Map()\n  }\n\n  /**\n   * Takes a current reactor state, action type and payload\n   * does the reaction and returns the new state\n   */\n  handle(state, type, payload) {\n    const handler = this.__handlers.get(type)\n\n    if (typeof handler === 'function') {\n      return handler.call(this, state, payload, type)\n    }\n\n    return state\n  }\n\n  /**\n   * Pure function taking the current state of store and returning\n   * the new state after a NuclearJS reactor has been reset\n   *\n   * Overridable\n   */\n  handleReset(state) {\n    return this.getInitialState()\n  }\n\n  /**\n   * Binds an action type => handler\n   */\n  on(actionType, handler) {\n    this.__handlers = this.__handlers.set(actionType, handler)\n  }\n\n  /**\n   * Serializes store state to plain JSON serializable JavaScript\n   * Overridable\n   * @param {*}\n   * @return {*}\n   */\n  serialize(state) {\n    return toJS(state)\n  }\n\n  /**\n   * Deserializes plain JavaScript to store state\n   * Overridable\n   * @param {*}\n   * @return {*}\n   */\n  deserialize(state) {\n    return toImmutable(state)\n  }\n}\n\nexport function isStore(toTest) {\n  return (toTest instanceof Store)\n}\n\nexport default toFactory(Store)\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/store.js\n **/","/**\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}));\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/immutable/dist/immutable.js\n ** module id = 3\n ** module chunks = 0\n **/","/**\n * Checks if the passed in value is a string\n * @param {*} val\n * @return {boolean}\n */\nexports.isString = function(val) {\n  return typeof val === 'string' || objectToString(val) === '[object String]'\n}\n\n/**\n * Checks if the passed in value is an array\n * @param {*} val\n * @return {boolean}\n */\nexports.isArray = Array.isArray /* istanbul ignore next */|| function(val) {\n  return objectToString(val) === '[object Array]'\n}\n\n// taken from underscore source to account for browser discrepancy\n/* istanbul ignore if  */\nif (typeof /./ !== 'function' && typeof Int8Array !== 'object') {\n  /**\n   * Checks if the passed in value is a function\n   * @param {*} val\n   * @return {boolean}\n   */\n  exports.isFunction = function(obj) {\n    return typeof obj === 'function' || false\n  }\n} else {\n  /**\n   * Checks if the passed in value is a function\n   * @param {*} val\n   * @return {boolean}\n   */\n  exports.isFunction = function(val) {\n    return toString.call(val) === '[object Function]'\n  }\n}\n\n/**\n * Checks if the passed in value is of type Object\n * @param {*} val\n * @return {boolean}\n */\nexports.isObject = function(obj) {\n  var type = typeof obj\n  return type === 'function' || type === 'object' && !!obj\n}\n\n/**\n * Extends an object with the properties of additional objects\n * @param {object} obj\n * @param {object} objects\n * @return {object}\n */\nexports.extend = function(obj) {\n  var length = arguments.length\n\n  if (!obj || length < 2) {\n    return obj || {}\n  }\n\n  for (var index = 1; index < length; index++) {\n    var source = arguments[index]\n    var keys = Object.keys(source)\n    var l = keys.length\n\n    for (var i = 0; i < l; i++) {\n      var key = keys[i]\n      obj[key] = source[key]\n    }\n  }\n\n  return obj\n}\n\n/**\n * Creates a shallow clone of an object\n * @param {object} obj\n * @return {object}\n */\nexports.clone = function(obj) {\n  if (!exports.isObject(obj)) {\n    return obj\n  }\n  return exports.isArray(obj) ? obj.slice() : exports.extend({}, obj)\n}\n\n/**\n * Iterates over a collection of elements yielding each iteration to an\n * iteratee. The iteratee may be bound to the context argument and is invoked\n * each time with three arguments (value, index|key, collection). Iteration may\n * be exited early by explicitly returning false.\n * @param {array|object|string} collection\n * @param {function} iteratee\n * @param {*} context\n * @return {array|object|string}\n */\nexports.each = function(collection, iteratee, context) {\n  var length = collection ? collection.length : 0\n  var i = -1\n  var keys\n  var origIteratee\n\n  if (context) {\n    origIteratee = iteratee\n    iteratee = function(value, index, innerCollection) {\n      return origIteratee.call(context, value, index, innerCollection)\n    }\n  }\n\n  if (isLength(length)) {\n    while (++i < length) {\n      if (iteratee(collection[i], i, collection) === false) {\n        break\n      }\n    }\n  } else {\n    keys = Object.keys(collection)\n    length = keys.length\n    while (++i < length) {\n      if (iteratee(collection[keys[i]], keys[i], collection) === false) {\n        break\n      }\n    }\n  }\n\n  return collection\n}\n\n/**\n * Returns a new function the invokes `func` with `partialArgs` prepended to\n * any passed into the new function. Acts like `Array.prototype.bind`, except\n * it does not alter `this` context.\n * @param {function} func\n * @param {*} partialArgs\n * @return {function}\n */\nexports.partial = function(func) {\n  var slice = Array.prototype.slice\n  var partialArgs = slice.call(arguments, 1)\n\n  return function() {\n    return func.apply(this, partialArgs.concat(slice.call(arguments)))\n  }\n}\n\n/**\n * Returns a factory method that allows construction with or without `new`\n */\nexports.toFactory = function(Klass) {\n  var Factory = function(...args) {\n    return new Klass(...args)\n  }\n\n  Factory.__proto__ = Klass // eslint-disable-line no-proto\n  Factory.prototype = Klass.prototype\n  return Factory\n}\n\n/**\n * Returns the text value representation of an object\n * @private\n * @param {*} obj\n * @return {string}\n */\nfunction objectToString(obj) {\n  return obj && typeof obj === 'object' && toString.call(obj)\n}\n\n/**\n * Checks if the value is a valid array-like length.\n * @private\n * @param {*} val\n * @return {bool}\n */\nfunction isLength(val) {\n  return typeof val === 'number'\n    && val > -1\n    && val % 1 === 0\n    && val <= Number.MAX_VALUE\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/utils.js\n **/","import Immutable from 'immutable'\nimport { isObject } from './utils'\n\n/**\n * A collection of helpers for the ImmutableJS library\n */\n\n/**\n * @param {*} obj\n * @return {boolean}\n */\nexport function isImmutable(obj) {\n  return Immutable.Iterable.isIterable(obj)\n}\n\n/**\n * Returns true if the value is an ImmutableJS data structure\n * or a JavaScript primitive that is immutable (string, number, etc)\n * @param {*} obj\n * @return {boolean}\n */\nexport function isImmutableValue(obj) {\n  return (\n    isImmutable(obj) ||\n    !isObject(obj)\n  )\n}\n\n/**\n * Converts an Immutable Sequence to JS object\n * Can be called on any type\n */\nexport function toJS(arg) {\n  // arg instanceof Immutable.Sequence is unreliable\n  return (isImmutable(arg))\n    ? arg.toJS()\n    : arg\n}\n\n/**\n * Converts a JS object to an Immutable object, if it's\n * already Immutable its a no-op\n */\nexport function toImmutable(arg) {\n  return (isImmutable(arg))\n    ? arg\n    : Immutable.fromJS(arg)\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/immutable-helpers.js\n **/","import Immutable from 'immutable'\nimport createReactMixin from './create-react-mixin'\nimport * as fns from './reactor/fns'\nimport { DefaultCache } from './reactor/cache'\nimport { NoopLogger, ConsoleGroupLogger } from './logging'\nimport { isKeyPath } from './key-path'\nimport { isGetter } from './getter'\nimport { toJS } from './immutable-helpers'\nimport { extend, toFactory } from './utils'\nimport {\n  ReactorState,\n  ObserverState,\n  DEBUG_OPTIONS,\n  PROD_OPTIONS,\n} from './reactor/records'\n\n/**\n * State is stored in NuclearJS Reactors.  Reactors\n * contain a 'state' object which is an Immutable.Map\n *\n * The only way Reactors can change state is by reacting to\n * messages.  To update state, Reactor's dispatch messages to\n * all registered cores, and the core returns it's new\n * state based on the message\n */\nclass Reactor {\n  constructor(config = {}) {\n    const debug = !!config.debug\n    const baseOptions = debug ? DEBUG_OPTIONS : PROD_OPTIONS\n    // if defined, merge the custom implementation over the noop logger to avoid undefined lookups,\n    // otherwise, just use the built-in console group logger\n    let logger = config.logger ? extend({}, NoopLogger, config.logger) : NoopLogger\n    if (!config.logger && debug) {\n      logger = ConsoleGroupLogger\n    }\n    const initialReactorState = new ReactorState({\n      debug: debug,\n      cache: config.cache || DefaultCache(),\n      logger: logger,\n      // merge config options with the defaults\n      options: baseOptions.merge(config.options || {}),\n    })\n\n    this.prevReactorState = initialReactorState\n    this.reactorState = initialReactorState\n    this.observerState = new ObserverState()\n\n    this.ReactMixin = createReactMixin(this)\n\n    // keep track of the depth of batch nesting\n    this.__batchDepth = 0\n\n    // keep track if we are currently dispatching\n    this.__isDispatching = false\n  }\n\n  /**\n   * Evaluates a KeyPath or Getter in context of the reactor state\n   * @param {KeyPath|Getter} keyPathOrGetter\n   * @return {*}\n   */\n  evaluate(keyPathOrGetter) {\n    let { result, reactorState } = fns.evaluate(this.reactorState, keyPathOrGetter)\n    this.reactorState = reactorState\n    return result\n  }\n\n  /**\n   * Gets the coerced state (to JS object) of the reactor.evaluate\n   * @param {KeyPath|Getter} keyPathOrGetter\n   * @return {*}\n   */\n  evaluateToJS(keyPathOrGetter) {\n    return toJS(this.evaluate(keyPathOrGetter))\n  }\n\n  /**\n   * Adds a change observer whenever a certain part of the reactor state changes\n   *\n   * 1. observe(handlerFn) - 1 argument, called anytime reactor.state changes\n   * 2. observe(keyPath, handlerFn) same as above\n   * 3. observe(getter, handlerFn) called whenever any getter dependencies change with\n   *    the value of the getter\n   *\n   * Adds a change handler whenever certain deps change\n   * If only one argument is passed invoked the handler whenever\n   * the reactor state changes\n   *\n   * @param {KeyPath|Getter} getter\n   * @param {function} handler\n   * @return {function} unwatch function\n   */\n  observe(getter, handler) {\n    if (arguments.length === 1) {\n      handler = getter\n      getter = []\n    }\n    let { observerState, entry } = fns.addObserver(this.observerState, getter, handler)\n    this.observerState = observerState\n    return () => {\n      this.observerState = fns.removeObserverByEntry(this.observerState, entry)\n    }\n  }\n\n  unobserve(getter, handler) {\n    if (arguments.length === 0) {\n      throw new Error('Must call unobserve with a Getter')\n    }\n    if (!isGetter(getter) && !isKeyPath(getter)) {\n      throw new Error('Must call unobserve with a Getter')\n    }\n\n    this.observerState = fns.removeObserver(this.observerState, getter, handler)\n  }\n\n  /**\n   * Dispatches a single message\n   * @param {string} actionType\n   * @param {object|undefined} payload\n   */\n  dispatch(actionType, payload) {\n    if (this.__batchDepth === 0) {\n      if (fns.getOption(this.reactorState, 'throwOnDispatchInDispatch')) {\n        if (this.__isDispatching) {\n          this.__isDispatching = false\n          throw new Error('Dispatch may not be called while a dispatch is in progress')\n        }\n      }\n      this.__isDispatching = true\n    }\n\n    try {\n      this.reactorState = fns.dispatch(this.reactorState, actionType, payload)\n    } catch (e) {\n      this.__isDispatching = false\n      throw e\n    }\n\n    try {\n      this.__notify()\n    } finally {\n      this.__isDispatching = false\n    }\n  }\n\n  /**\n   * Allows batching of dispatches before notifying change observers\n   * @param {Function} fn\n   */\n  batch(fn) {\n    this.batchStart()\n    fn()\n    this.batchEnd()\n  }\n\n  /**\n   * @deprecated\n   * @param {String} id\n   * @param {Store} store\n   */\n  registerStore(id, store) {\n    /* eslint-disable no-console */\n    console.warn('Deprecation warning: `registerStore` will no longer be supported in 1.1, use `registerStores` instead')\n    /* eslint-enable no-console */\n    this.registerStores({\n      [id]: store,\n    })\n  }\n\n  /**\n   * @param {Object} stores\n   */\n  registerStores(stores) {\n    this.reactorState = fns.registerStores(this.reactorState, stores)\n    this.__notify()\n  }\n\n  /**\n   * Replace store implementation (handlers) without modifying the app state or calling getInitialState\n   * Useful for hot reloading\n   * @param {Object} stores\n   */\n  replaceStores(stores) {\n    this.reactorState = fns.replaceStores(this.reactorState, stores)\n  }\n\n  /**\n   * Returns a plain object representing the application state\n   * @return {Object}\n   */\n  serialize() {\n    return fns.serialize(this.reactorState)\n  }\n\n  /**\n   * @param {Object} state\n   */\n  loadState(state) {\n    this.reactorState = fns.loadState(this.reactorState, state)\n    this.__notify()\n  }\n\n  /**\n   * Resets the state of a reactor and returns back to initial state\n   */\n  reset() {\n    const newState = fns.reset(this.reactorState)\n    this.reactorState = newState\n    this.prevReactorState = newState\n    this.observerState = new ObserverState()\n  }\n\n  /**\n   * Notifies all change observers with the current state\n   * @private\n   */\n  __notify() {\n    if (this.__batchDepth > 0) {\n      // in the middle of batch, dont notify\n      return\n    }\n\n    const dirtyStores = this.reactorState.get('dirtyStores')\n    if (dirtyStores.size === 0) {\n      return\n    }\n\n    let observerIdsToNotify = Immutable.Set().withMutations(set => {\n      // notify all observers\n      set.union(this.observerState.get('any'))\n\n      dirtyStores.forEach(id => {\n        const entries = this.observerState.getIn(['stores', id])\n        if (!entries) {\n          return\n        }\n        set.union(entries)\n      })\n    })\n\n    observerIdsToNotify.forEach((observerId) => {\n      const entry = this.observerState.getIn(['observersMap', observerId])\n      if (!entry) {\n        // don't notify here in the case a handler called unobserve on another observer\n        return\n      }\n\n      const getter = entry.get('getter')\n      const handler = entry.get('handler')\n\n      const prevEvaluateResult = fns.evaluate(this.prevReactorState, getter)\n      const currEvaluateResult = fns.evaluate(this.reactorState, getter)\n\n      this.prevReactorState = prevEvaluateResult.reactorState\n      this.reactorState = currEvaluateResult.reactorState\n\n      const prevValue = prevEvaluateResult.result\n      const currValue = currEvaluateResult.result\n\n      if (!Immutable.is(prevValue, currValue)) {\n        handler.call(null, currValue)\n      }\n    })\n\n    const nextReactorState = fns.resetDirtyStores(this.reactorState)\n\n    this.prevReactorState = nextReactorState\n    this.reactorState = nextReactorState\n  }\n\n  /**\n   * Starts batching, ie pausing notifies and batching up changes\n   * to be notified when batchEnd() is called\n   */\n  batchStart() {\n    this.__batchDepth++\n  }\n\n  /**\n   * Ends a batch cycle and will notify obsevers of all changes if\n   * the batch depth is back to 0 (outer most batch completed)\n   */\n  batchEnd() {\n    this.__batchDepth--\n\n    if (this.__batchDepth <= 0) {\n      // set to true to catch if dispatch called from observer\n      this.__isDispatching = true\n      try {\n        this.__notify()\n      } catch (e) {\n        this.__isDispatching = false\n        throw e\n      }\n      this.__isDispatching = false\n    }\n  }\n}\n\nexport default toFactory(Reactor)\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/reactor.js\n **/","import { each } from './utils'\n\n/**\n * Returns a mapping of the getDataBinding keys to\n * the reactor values\n */\nfunction getState(reactor, data) {\n  let state = {}\n  each(data, (value, key) => {\n    state[key] = reactor.evaluate(value)\n  })\n  return state\n}\n\n/**\n * @param {Reactor} reactor\n */\nexport default function(reactor) {\n  return {\n    getInitialState() {\n      return getState(reactor, this.getDataBindings())\n    },\n\n    componentDidMount() {\n      this.__unwatchFns = []\n      each(this.getDataBindings(), (getter, key) => {\n        const unwatchFn = reactor.observe(getter, (val) => {\n          this.setState({\n            [key]: val,\n          })\n        })\n\n        this.__unwatchFns.push(unwatchFn)\n      })\n    },\n\n    componentWillUnmount() {\n      while (this.__unwatchFns.length) {\n        this.__unwatchFns.shift()()\n      }\n    },\n  }\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/create-react-mixin.js\n **/","import Immutable from 'immutable'\nimport { CacheEntry } from './cache'\nimport { isImmutableValue } from '../immutable-helpers'\nimport { toImmutable } from '../immutable-helpers'\nimport { fromKeyPath, getStoreDeps, getComputeFn, getDeps, isGetter } from '../getter'\nimport { isEqual, isKeyPath } from '../key-path'\nimport { each } from '../utils'\n\n/**\n * Immutable Types\n */\nconst EvaluateResult = Immutable.Record({ result: null, reactorState: null})\n\nfunction evaluateResult(result, reactorState) {\n  return new EvaluateResult({\n    result: result,\n    reactorState: reactorState,\n  })\n}\n\n/**\n * @param {ReactorState} reactorState\n * @param {Object<String, Store>} stores\n * @return {ReactorState}\n */\nexport function registerStores(reactorState, stores) {\n  return reactorState.withMutations((reactorState) => {\n    each(stores, (store, id) => {\n      if (reactorState.getIn(['stores', id])) {\n        /* eslint-disable no-console */\n        console.warn('Store already defined for id = ' + id)\n        /* eslint-enable no-console */\n      }\n\n      const initialState = store.getInitialState()\n\n      if (initialState === undefined && getOption(reactorState, 'throwOnUndefinedStoreReturnValue')) {\n        throw new Error('Store getInitialState() must return a value, did you forget a return statement')\n      }\n      if (getOption(reactorState, 'throwOnNonImmutableStore') && !isImmutableValue(initialState)) {\n        throw new Error('Store getInitialState() must return an immutable value, did you forget to call toImmutable')\n      }\n\n      reactorState\n        .update('stores', stores => stores.set(id, store))\n        .update('state', state => state.set(id, initialState))\n        .update('dirtyStores', state => state.add(id))\n        .update('storeStates', storeStates => incrementStoreStates(storeStates, [id]))\n    })\n    incrementId(reactorState)\n  })\n}\n\n/**\n * Overrides the store implementation without resetting the value of that particular part of the app state\n * this is useful when doing hot reloading of stores.\n * @param {ReactorState} reactorState\n * @param {Object<String, Store>} stores\n * @return {ReactorState}\n */\nexport function replaceStores(reactorState, stores) {\n  return reactorState.withMutations((reactorState) => {\n    each(stores, (store, id) => {\n      reactorState.update('stores', stores => stores.set(id, store))\n    })\n  })\n}\n\n/**\n * @param {ReactorState} reactorState\n * @param {String} actionType\n * @param {*} payload\n * @return {ReactorState}\n */\nexport function dispatch(reactorState, actionType, payload) {\n  let logging = reactorState.get('logger')\n\n  if (actionType === undefined && getOption(reactorState, 'throwOnUndefinedActionType')) {\n    throw new Error('`dispatch` cannot be called with an `undefined` action type.')\n  }\n\n  const currState = reactorState.get('state')\n  let dirtyStores = reactorState.get('dirtyStores')\n\n  const nextState = currState.withMutations(state => {\n    logging.dispatchStart(reactorState, actionType, payload)\n\n    // let each store handle the message\n    reactorState.get('stores').forEach((store, id) => {\n      const currState = state.get(id)\n      let newState\n\n      try {\n        newState = store.handle(currState, actionType, payload)\n      } catch(e) {\n        // ensure console.group is properly closed\n        logging.dispatchError(reactorState, e.message)\n        throw e\n      }\n\n      if (newState === undefined && getOption(reactorState, 'throwOnUndefinedStoreReturnValue')) {\n        const errorMsg = 'Store handler must return a value, did you forget a return statement'\n        logging.dispatchError(reactorState, errorMsg)\n        throw new Error(errorMsg)\n      }\n\n      state.set(id, newState)\n\n      if (currState !== newState) {\n        // if the store state changed add store to list of dirty stores\n        dirtyStores = dirtyStores.add(id)\n      }\n    })\n\n    logging.dispatchEnd(reactorState, state, dirtyStores, currState)\n  })\n\n  const nextReactorState = reactorState\n    .set('state', nextState)\n    .set('dirtyStores', dirtyStores)\n    .update('storeStates', storeStates => incrementStoreStates(storeStates, dirtyStores))\n\n  return incrementId(nextReactorState)\n}\n\n/**\n * @param {ReactorState} reactorState\n * @param {Immutable.Map} state\n * @return {ReactorState}\n */\nexport function loadState(reactorState, state) {\n  let dirtyStores = []\n  const stateToLoad = toImmutable({}).withMutations(stateToLoad => {\n    each(state, (serializedStoreState, storeId) => {\n      const store = reactorState.getIn(['stores', storeId])\n      if (store) {\n        const storeState = store.deserialize(serializedStoreState)\n        if (storeState !== undefined) {\n          stateToLoad.set(storeId, storeState)\n          dirtyStores.push(storeId)\n        }\n      }\n    })\n  })\n\n  const dirtyStoresSet = Immutable.Set(dirtyStores)\n  return reactorState\n    .update('state', state => state.merge(stateToLoad))\n    .update('dirtyStores', stores => stores.union(dirtyStoresSet))\n    .update('storeStates', storeStates => incrementStoreStates(storeStates, dirtyStores))\n}\n\n/**\n * Adds a change observer whenever a certain part of the reactor state changes\n *\n * 1. observe(handlerFn) - 1 argument, called anytime reactor.state changes\n * 2. observe(keyPath, handlerFn) same as above\n * 3. observe(getter, handlerFn) called whenever any getter dependencies change with\n *    the value of the getter\n *\n * Adds a change handler whenever certain deps change\n * If only one argument is passed invoked the handler whenever\n * the reactor state changes\n *\n * @param {ObserverState} observerState\n * @param {KeyPath|Getter} getter\n * @param {function} handler\n * @return {ObserveResult}\n */\nexport function addObserver(observerState, getter, handler) {\n  // use the passed in getter as the key so we can rely on a byreference call for unobserve\n  const getterKey = getter\n  if (isKeyPath(getter)) {\n    getter = fromKeyPath(getter)\n  }\n\n  const currId = observerState.get('nextId')\n  const storeDeps = getStoreDeps(getter)\n  const entry = Immutable.Map({\n    id: currId,\n    storeDeps: storeDeps,\n    getterKey: getterKey,\n    getter: getter,\n    handler: handler,\n  })\n\n  let updatedObserverState\n  if (storeDeps.size === 0) {\n    // no storeDeps means the observer is dependent on any of the state changing\n    updatedObserverState = observerState.update('any', observerIds => observerIds.add(currId))\n  } else {\n    updatedObserverState = observerState.withMutations(map => {\n      storeDeps.forEach(storeId => {\n        let path = ['stores', storeId]\n        if (!map.hasIn(path)) {\n          map.setIn(path, Immutable.Set())\n        }\n        map.updateIn(['stores', storeId], observerIds => observerIds.add(currId))\n      })\n    })\n  }\n\n  updatedObserverState = updatedObserverState\n    .set('nextId', currId + 1)\n    .setIn(['observersMap', currId], entry)\n\n  return {\n    observerState: updatedObserverState,\n    entry: entry,\n  }\n}\n\n/**\n * @param {ReactorState} reactorState\n * @param {String} option\n * @return {Boolean}\n */\nexport function getOption(reactorState, option) {\n  const value = reactorState.getIn(['options', option])\n  if (value === undefined) {\n    throw new Error('Invalid option: ' + option)\n  }\n  return value\n}\n\n/**\n * Use cases\n * removeObserver(observerState, [])\n * removeObserver(observerState, [], handler)\n * removeObserver(observerState, ['keyPath'])\n * removeObserver(observerState, ['keyPath'], handler)\n * removeObserver(observerState, getter)\n * removeObserver(observerState, getter, handler)\n * @param {ObserverState} observerState\n * @param {KeyPath|Getter} getter\n * @param {Function} handler\n * @return {ObserverState}\n */\nexport function removeObserver(observerState, getter, handler) {\n  const entriesToRemove = observerState.get('observersMap').filter(entry => {\n    // use the getterKey in the case of a keyPath is transformed to a getter in addObserver\n    let entryGetter = entry.get('getterKey')\n    let handlersMatch = (!handler || entry.get('handler') === handler)\n    if (!handlersMatch) {\n      return false\n    }\n    // check for a by-value equality of keypaths\n    if (isKeyPath(getter) && isKeyPath(entryGetter)) {\n      return isEqual(getter, entryGetter)\n    }\n    // we are comparing two getters do it by reference\n    return (getter === entryGetter)\n  })\n\n  return observerState.withMutations(map => {\n    entriesToRemove.forEach(entry => removeObserverByEntry(map, entry))\n  })\n}\n\n/**\n * Removes an observer entry by id from the observerState\n * @param {ObserverState} observerState\n * @param {Immutable.Map} entry\n * @return {ObserverState}\n */\nexport function removeObserverByEntry(observerState, entry) {\n  return observerState.withMutations(map => {\n    const id = entry.get('id')\n    const storeDeps = entry.get('storeDeps')\n\n    if (storeDeps.size === 0) {\n      map.update('any', anyObsevers => anyObsevers.remove(id))\n    } else {\n      storeDeps.forEach(storeId => {\n        map.updateIn(['stores', storeId], observers => {\n          if (observers) {\n            // check for observers being present because reactor.reset() can be called before an unwatch fn\n            return observers.remove(id)\n          }\n          return observers\n        })\n      })\n    }\n\n    map.removeIn(['observersMap', id])\n  })\n}\n\n/**\n * @param {ReactorState} reactorState\n * @return {ReactorState}\n */\nexport function reset(reactorState) {\n  const prevState = reactorState.get('state')\n\n  return reactorState.withMutations(reactorState => {\n    const storeMap = reactorState.get('stores')\n    const storeIds = storeMap.keySeq().toJS()\n    storeMap.forEach((store, id) => {\n      const storeState = prevState.get(id)\n      const resetStoreState = store.handleReset(storeState)\n      if (resetStoreState === undefined && getOption(reactorState, 'throwOnUndefinedStoreReturnValue')) {\n        throw new Error('Store handleReset() must return a value, did you forget a return statement')\n      }\n      if (getOption(reactorState, 'throwOnNonImmutableStore') && !isImmutableValue(resetStoreState)) {\n        throw new Error('Store reset state must be an immutable value, did you forget to call toImmutable')\n      }\n      reactorState.setIn(['state', id], resetStoreState)\n    })\n\n    reactorState.update('storeStates', storeStates => incrementStoreStates(storeStates, storeIds))\n    resetDirtyStores(reactorState)\n  })\n}\n\n/**\n * @param {ReactorState} reactorState\n * @param {KeyPath|Gettter} keyPathOrGetter\n * @return {EvaluateResult}\n */\nexport function evaluate(reactorState, keyPathOrGetter) {\n  const state = reactorState.get('state')\n\n  if (isKeyPath(keyPathOrGetter)) {\n    // if its a keyPath simply return\n    return evaluateResult(\n      state.getIn(keyPathOrGetter),\n      reactorState\n    )\n  } else if (!isGetter(keyPathOrGetter)) {\n    throw new Error('evaluate must be passed a keyPath or Getter')\n  }\n\n  // Must be a Getter\n\n  const cache = reactorState.get('cache')\n  var cacheEntry = cache.lookup(keyPathOrGetter)\n  const isCacheMiss = !cacheEntry || isDirtyCacheEntry(reactorState, cacheEntry)\n  if (isCacheMiss) {\n    cacheEntry = createCacheEntry(reactorState, keyPathOrGetter)\n  }\n\n  return evaluateResult(\n    cacheEntry.get('value'),\n    reactorState.update('cache', cache => {\n      return isCacheMiss ?\n        cache.miss(keyPathOrGetter, cacheEntry) :\n        cache.hit(keyPathOrGetter)\n    })\n  )\n}\n\n/**\n * Returns serialized state for all stores\n * @param {ReactorState} reactorState\n * @return {Object}\n */\nexport function serialize(reactorState) {\n  let serialized = {}\n  reactorState.get('stores').forEach((store, id) => {\n    let storeState = reactorState.getIn(['state', id])\n    let serializedState = store.serialize(storeState)\n    if (serializedState !== undefined) {\n      serialized[id] = serializedState\n    }\n  })\n  return serialized\n}\n\n/**\n * Returns serialized state for all stores\n * @param {ReactorState} reactorState\n * @return {ReactorState}\n */\nexport function resetDirtyStores(reactorState) {\n  return reactorState.set('dirtyStores', Immutable.Set())\n}\n\n/**\n * @param {ReactorState} reactorState\n * @param {CacheEntry} cacheEntry\n * @return {boolean}\n */\nfunction isDirtyCacheEntry(reactorState, cacheEntry) {\n  const storeStates = cacheEntry.get('storeStates')\n\n  // if there are no store states for this entry then it was never cached before\n  return !storeStates.size || storeStates.some((stateId, storeId) => {\n    return reactorState.getIn(['storeStates', storeId]) !== stateId\n  })\n}\n\n/**\n * Evaluates getter for given reactorState and returns CacheEntry\n * @param {ReactorState} reactorState\n * @param {Getter} getter\n * @return {CacheEntry}\n */\nfunction createCacheEntry(reactorState, getter) {\n  // evaluate dependencies\n  const args = getDeps(getter).map(dep => evaluate(reactorState, dep).result)\n  const value = getComputeFn(getter).apply(null, args)\n\n  const storeDeps = getStoreDeps(getter)\n  const storeStates = toImmutable({}).withMutations(map => {\n    storeDeps.forEach(storeId => {\n      const stateId = reactorState.getIn(['storeStates', storeId])\n      map.set(storeId, stateId)\n    })\n  })\n\n  return CacheEntry({\n    value: value,\n    storeStates: storeStates,\n    dispatchId: reactorState.get('dispatchId'),\n  })\n}\n\n/**\n * @param {ReactorState} reactorState\n * @return {ReactorState}\n */\nfunction incrementId(reactorState) {\n  return reactorState.update('dispatchId', id => id + 1)\n}\n\n\n/**\n * @param {Immutable.Map} storeStates\n * @param {Array} storeIds\n * @return {Immutable.Map}\n */\nfunction incrementStoreStates(storeStates, storeIds) {\n  return storeStates.withMutations(map => {\n    storeIds.forEach(id => {\n      const nextId = map.has(id) ? map.get(id) + 1 : 1\n      map.set(id, nextId)\n    })\n  })\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/reactor/fns.js\n **/","import { Map, OrderedSet, Record } from 'immutable'\n\nexport const CacheEntry = Record({\n  value: null,\n  storeStates: Map(),\n  dispatchId: null,\n})\n\n/*******************************************************************************\n * interface PersistentCache {\n *    has(item)\n *    lookup(item, notFoundValue)\n *    hit(item)\n *    miss(item, entry)\n *    evict(item)\n *    asMap()\n * }\n *\n * Inspired by clojure.core.cache/CacheProtocol\n *******************************************************************************/\n\n/**\n * Plain map-based cache\n */\nexport class BasicCache {\n\n  /**\n   * @param {Immutable.Map} cache\n   */\n  constructor(cache = Map()) {\n    this.cache = cache\n  }\n\n  /**\n   * Retrieve the associated value, if it exists in this cache, otherwise\n   * returns notFoundValue (or undefined if not provided)\n   * @param {Object} item\n   * @param {Object?} notFoundValue\n   * @return {CacheEntry?}\n   */\n  lookup(item, notFoundValue) {\n    return this.cache.get(item, notFoundValue)\n  }\n\n  /**\n   * Checks if this cache contains an associated value\n   * @param {Object} item\n   * @return {boolean}\n   */\n  has(item) {\n    return this.cache.has(item)\n  }\n\n  /**\n   * Return cached items as map\n   * @return {Immutable.Map}\n   */\n  asMap() {\n    return this.cache\n  }\n\n  /**\n   * Updates this cache when it is determined to contain the associated value\n   * @param {Object} item\n   * @return {BasicCache}\n   */\n  hit(item) {\n    return this\n  }\n\n  /**\n   * Updates this cache when it is determined to **not** contain the associated value\n   * @param {Object} item\n   * @param {CacheEntry} entry\n   * @return {BasicCache}\n   */\n  miss(item, entry) {\n    return new BasicCache(\n      this.cache.update(item, existingEntry => {\n        if (existingEntry && existingEntry.dispatchId > entry.dispatchId) {\n          throw new Error('Refusing to cache older value')\n        }\n        return entry\n      })\n    )\n  }\n\n  /**\n   * Removes entry from cache\n   * @param {Object} item\n   * @return {BasicCache}\n   */\n  evict(item) {\n    return new BasicCache(this.cache.remove(item))\n  }\n}\n\nconst DEFAULT_LRU_LIMIT = 1000\nconst DEFAULT_LRU_EVICT_COUNT = 1\n\n/**\n * Implements caching strategy that evicts least-recently-used items in cache\n * when an item is being added to a cache that has reached a configured size\n * limit.\n */\nexport class LRUCache {\n\n  constructor(limit = DEFAULT_LRU_LIMIT, evictCount = DEFAULT_LRU_EVICT_COUNT, cache = new BasicCache(), lru = OrderedSet()) {\n    console.log(\"using LRU\")\n    this.limit = limit\n    this.evictCount = evictCount\n    this.cache = cache\n    this.lru = lru\n  }\n\n  /**\n   * Retrieve the associated value, if it exists in this cache, otherwise\n   * returns notFoundValue (or undefined if not provided)\n   * @param {Object} item\n   * @param {Object?} notFoundValue\n   * @return {CacheEntry}\n   */\n  lookup(item, notFoundValue) {\n    return this.cache.lookup(item, notFoundValue)\n  }\n\n  /**\n   * Checks if this cache contains an associated value\n   * @param {Object} item\n   * @return {boolean}\n   */\n  has(item) {\n    return this.cache.has(item)\n  }\n\n  /**\n   * Return cached items as map\n   * @return {Immutable.Map}\n   */\n  asMap() {\n    return this.cache.asMap()\n  }\n\n  /**\n   * Updates this cache when it is determined to contain the associated value\n   * @param {Object} item\n   * @return {LRUCache}\n   */\n  hit(item) {\n    if (!this.cache.has(item)) {\n      return this\n    }\n\n    // remove it first to reorder in lru OrderedSet\n    return new LRUCache(this.limit, this.evictCount, this.cache, this.lru.remove(item).add(item))\n  }\n\n  /**\n   * Updates this cache when it is determined to **not** contain the associated value\n   * If cache has reached size limit, the LRU item is evicted.\n   * @param {Object} item\n   * @param {CacheEntry} entry\n   * @return {LRUCache}\n   */\n  miss(item, entry) {\n    var lruCache\n    if (this.lru.size >= this.limit) {\n      if (this.has(item)) {\n        return new LRUCache(\n          this.limit,\n          this.evictCount,\n          this.cache.miss(item, entry),\n          this.lru.remove(item).add(item)\n        )\n      }\n\n      const cache = (this.lru\n                     .take(this.evictCount)\n                     .reduce((c, evictItem) => c.evict(evictItem), this.cache)\n                     .miss(item, entry))\n\n      lruCache = new LRUCache(\n        this.limit,\n        this.evictCount,\n        cache,\n        this.lru.skip(this.evictCount).add(item)\n      )\n    } else {\n      lruCache = new LRUCache(\n        this.limit,\n        this.evictCount,\n        this.cache.miss(item, entry),\n        this.lru.add(item)\n      )\n    }\n    return lruCache\n  }\n\n  /**\n   * Removes entry from cache\n   * @param {Object} item\n   * @return {LRUCache}\n   */\n  evict(item) {\n    if (!this.cache.has(item)) {\n      return this\n    }\n\n    return new LRUCache(\n      this.limit,\n      this.evictCount,\n      this.cache.evict(item),\n      this.lru.remove(item)\n    )\n  }\n}\n\n/**\n * Returns default cache strategy\n * @return {BasicCache}\n */\nexport function DefaultCache() {\n  return new BasicCache()\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/reactor/cache.js\n **/","import Immutable, { List } from 'immutable'\nimport { isFunction, isArray } from './utils'\nimport { isKeyPath } from './key-path'\n\n/**\n * Getter helper functions\n * A getter is an array with the form:\n * [<KeyPath>, ...<KeyPath>, <function>]\n */\nconst identity = (x) => x\n\n/**\n * Checks if something is a getter literal, ex: ['dep1', 'dep2', function(dep1, dep2) {...}]\n * @param {*} toTest\n * @return {boolean}\n */\nfunction isGetter(toTest) {\n  return (isArray(toTest) && isFunction(toTest[toTest.length - 1]))\n}\n\n/**\n * Returns the compute function from a getter\n * @param {Getter} getter\n * @return {function}\n */\nfunction getComputeFn(getter) {\n  return getter[getter.length - 1]\n}\n\n/**\n * Returns an array of deps from a getter\n * @param {Getter} getter\n * @return {function}\n */\nfunction getDeps(getter) {\n  return getter.slice(0, getter.length - 1)\n}\n\n/**\n * Returns an array of deps from a getter and all its deps\n * @param {Getter} getter\n * @param {Immutable.Set} existing\n * @return {Immutable.Set}\n */\nfunction getFlattenedDeps(getter, existing) {\n  if (!existing) {\n    existing = Immutable.Set()\n  }\n\n  const toAdd = Immutable.Set().withMutations(set => {\n    if (!isGetter(getter)) {\n      throw new Error('getFlattenedDeps must be passed a Getter')\n    }\n\n    getDeps(getter).forEach(dep => {\n      if (isKeyPath(dep)) {\n        set.add(List(dep))\n      } else if (isGetter(dep)) {\n        set.union(getFlattenedDeps(dep))\n      } else {\n        throw new Error('Invalid getter, each dependency must be a KeyPath or Getter')\n      }\n    })\n  })\n\n  return existing.union(toAdd)\n}\n\n/**\n * @param {KeyPath}\n * @return {Getter}\n */\nfunction fromKeyPath(keyPath) {\n  if (!isKeyPath(keyPath)) {\n    throw new Error('Cannot create Getter from KeyPath: ' + keyPath)\n  }\n\n  return [keyPath, identity]\n}\n\n/**\n * Adds non enumerated __storeDeps property\n * @param {Getter}\n */\nfunction getStoreDeps(getter) {\n  if (getter.hasOwnProperty('__storeDeps')) {\n    return getter.__storeDeps\n  }\n\n  const storeDeps = getFlattenedDeps(getter)\n    .map(keyPath => keyPath.first())\n    .filter(x => !!x)\n\n\n  Object.defineProperty(getter, '__storeDeps', {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: storeDeps,\n  })\n\n  return storeDeps\n}\n\nexport default {\n  isGetter,\n  getComputeFn,\n  getFlattenedDeps,\n  getStoreDeps,\n  getDeps,\n  fromKeyPath,\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/getter.js\n **/","import Immutable from 'immutable'\nimport { isArray, isFunction } from './utils'\n\n/**\n * Checks if something is simply a keyPath and not a getter\n * @param {*} toTest\n * @return {boolean}\n */\nexport function isKeyPath(toTest) {\n  return (\n    isArray(toTest) &&\n    !isFunction(toTest[toTest.length - 1])\n  )\n}\n\n/**\n * Checks if two keypaths are equal by value\n * @param {KeyPath} a\n * @param {KeyPath} a\n * @return {Boolean}\n */\nexport function isEqual(a, b) {\n  const iA = Immutable.List(a)\n  const iB = Immutable.List(b)\n\n  return Immutable.is(iA, iB)\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/key-path.js\n **/","import { getOption } from './reactor/fns'\n\n/* eslint-disable no-console */\n/**\n * Wraps a Reactor.react invocation in a console.group\n */\nexport const ConsoleGroupLogger = {\n  /**\n   * @param {ReactorState} reactorState\n   * @param {String} type\n   * @param {*} payload\n   */\n  dispatchStart: function(reactorState, type, payload) {\n    if (!getOption(reactorState, 'logDispatches')) {\n      return\n    }\n\n    if (console.group) {\n      console.groupCollapsed('Dispatch: %s', type)\n      console.group('payload')\n      console.debug(payload)\n      console.groupEnd()\n    }\n  },\n  /**\n   * @param {ReactorState} reactorState\n   * @param {Error} error\n   */\n  dispatchError: function(reactorState, error) {\n    if (!getOption(reactorState, 'logDispatches')) {\n      return\n    }\n\n    if (console.group) {\n      console.debug('Dispatch error: ' + error)\n      console.groupEnd()\n    }\n  },\n  /**\n   * @param {ReactorState} reactorState\n   * @param {Map} state\n   * @param {Set} dirtyStores\n   */\n  dispatchEnd: function(reactorState, state, dirtyStores, previousState) {\n    if (!getOption(reactorState, 'logDispatches')) {\n      return\n    }\n\n    if (console.group) {\n      if (getOption(reactorState, 'logDirtyStores')) {\n        console.log('Stores updated:', dirtyStores.toList().toJS())\n      }\n\n      if (getOption(reactorState, 'logAppState')) {\n        console.debug('Dispatch done, new state: ', state.toJS())\n      }\n      console.groupEnd()\n    }\n  },\n}\n\n/* eslint-enable no-console */\n\nexport const NoopLogger = {\n  /**\n   * @param {ReactorState} reactorState\n   * @param {String} type\n   * @param {*} payload\n   */\n  dispatchStart: function(reactorState, type, payload) {\n  },\n  /**\n   * @param {ReactorState} reactorState\n   * @param {Error} error\n   */\n  dispatchError: function(reactorState, error) {\n  },\n  /**\n   * @param {ReactorState} reactorState\n   * @param {Map} state\n   * @param {Set} dirtyStores\n   */\n  dispatchEnd: function(reactorState, state, dirtyStores) {\n  },\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/logging.js\n **/","import { Map, Set, Record } from 'immutable'\nimport { DefaultCache } from './cache'\nimport { NoopLogger } from '../logging'\n\nexport const PROD_OPTIONS = Map({\n  // logs information for each dispatch\n  logDispatches: false,\n  // log the entire app state after each dispatch\n  logAppState: false,\n  // logs what stores changed after a dispatch\n  logDirtyStores: false,\n  // if true, throws an error when dispatching an `undefined` actionType\n  throwOnUndefinedActionType: false,\n  // if true, throws an error if a store returns undefined\n  throwOnUndefinedStoreReturnValue: false,\n  // if true, throws an error if a store.getInitialState() returns a non immutable value\n  throwOnNonImmutableStore: false,\n  // if true, throws when dispatching in dispatch\n  throwOnDispatchInDispatch: false,\n})\n\nexport const DEBUG_OPTIONS = Map({\n  // logs information for each dispatch\n  logDispatches: true,\n  // log the entire app state after each dispatch\n  logAppState: true,\n  // logs what stores changed after a dispatch\n  logDirtyStores: true,\n  // if true, throws an error when dispatching an `undefined` actionType\n  throwOnUndefinedActionType: true,\n  // if true, throws an error if a store returns undefined\n  throwOnUndefinedStoreReturnValue: true,\n  // if true, throws an error if a store.getInitialState() returns a non immutable value\n  throwOnNonImmutableStore: true,\n  // if true, throws when dispatching in dispatch\n  throwOnDispatchInDispatch: true,\n})\n\nexport const ReactorState = Record({\n  dispatchId: 0,\n  state: Map(),\n  stores: Map(),\n  cache: DefaultCache(),\n  logger: NoopLogger,\n  // maintains a mapping of storeId => state id (monotomically increasing integer whenever store state changes)\n  storeStates: Map(),\n  dirtyStores: Set(),\n  debug: false,\n  // production defaults\n  options: PROD_OPTIONS,\n})\n\nexport const ObserverState = Record({\n  // observers registered to any store change\n  any: Set(),\n  // observers registered to specific store changes\n  stores: Map({}),\n\n  observersMap: Map({}),\n\n  nextId: 1,\n})\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/reactor/records.js\n **/"],"sourceRoot":""}