{"version":3,"file":"static/js/vendors-efdee510.af7e0ba1.js","mappings":"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","sources":["../node_modules/@icons/material/CheckIcon.js","../node_modules/@icons/material/UnfoldMoreHorizontalIcon.js","../node_modules/hyphenate-style-name/index.js","../node_modules/immutable/dist/immutable.js","../node_modules/invariant/browser.js","../node_modules/immer/src/utils/env.ts","../node_modules/immer/src/utils/errors.ts","../node_modules/immer/src/utils/common.ts","../node_modules/immer/src/utils/plugins.ts","../node_modules/immer/src/core/scope.ts","../node_modules/immer/src/core/finalize.ts","../node_modules/immer/src/core/proxy.ts","../node_modules/immer/src/core/immerClass.ts","../node_modules/immer/src/core/current.ts","../node_modules/immer/src/plugins/patches.ts","../node_modules/immer/src/immer.ts"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nvar DEFAULT_SIZE = 24;\n\nexports.default = function (_ref) {\n  var _ref$fill = _ref.fill,\n      fill = _ref$fill === undefined ? 'currentColor' : _ref$fill,\n      _ref$width = _ref.width,\n      width = _ref$width === undefined ? DEFAULT_SIZE : _ref$width,\n      _ref$height = _ref.height,\n      height = _ref$height === undefined ? DEFAULT_SIZE : _ref$height,\n      _ref$style = _ref.style,\n      style = _ref$style === undefined ? {} : _ref$style,\n      props = _objectWithoutProperties(_ref, ['fill', 'width', 'height', 'style']);\n\n  return _react2.default.createElement(\n    'svg',\n    _extends({\n      viewBox: '0 0 ' + DEFAULT_SIZE + ' ' + DEFAULT_SIZE,\n      style: _extends({ fill: fill, width: width, height: height }, style)\n    }, props),\n    _react2.default.createElement('path', { d: 'M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z' })\n  );\n};","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nvar DEFAULT_SIZE = 24;\n\nexports.default = function (_ref) {\n  var _ref$fill = _ref.fill,\n      fill = _ref$fill === undefined ? 'currentColor' : _ref$fill,\n      _ref$width = _ref.width,\n      width = _ref$width === undefined ? DEFAULT_SIZE : _ref$width,\n      _ref$height = _ref.height,\n      height = _ref$height === undefined ? DEFAULT_SIZE : _ref$height,\n      _ref$style = _ref.style,\n      style = _ref$style === undefined ? {} : _ref$style,\n      props = _objectWithoutProperties(_ref, ['fill', 'width', 'height', 'style']);\n\n  return _react2.default.createElement(\n    'svg',\n    _extends({\n      viewBox: '0 0 ' + DEFAULT_SIZE + ' ' + DEFAULT_SIZE,\n      style: _extends({ fill: fill, width: width, height: height }, style)\n    }, props),\n    _react2.default.createElement('path', { d: 'M12,18.17L8.83,15L7.42,16.41L12,21L16.59,16.41L15.17,15M12,5.83L15.17,9L16.58,7.59L12,3L7.41,7.59L8.83,9L12,5.83Z' })\n  );\n};","/* eslint-disable no-var, prefer-template */\nvar uppercasePattern = /[A-Z]/g\nvar msPattern = /^ms-/\nvar cache = {}\n\nfunction toHyphenLower(match) {\n  return '-' + match.toLowerCase()\n}\n\nfunction hyphenateStyleName(name) {\n  if (cache.hasOwnProperty(name)) {\n    return cache[name]\n  }\n\n  var hName = name.replace(uppercasePattern, toHyphenLower)\n  return (cache[name] = msPattern.test(hName) ? '-' + hName : hName)\n}\n\nexport default hyphenateStyleName\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      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.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      end = end | 0;\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      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    findEntry: function(predicate, context) {\n      var found;\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    findLastEntry: function(predicate, context) {\n      return this.toSeq().reverse().findEntry(predicate, context);\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    findLast: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\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    keySeq: function() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function() {\n      return this.toSeq().reverse().first();\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  // Temporary warning about using length\n  (function () {\n    try {\n      Object.defineProperty(IterablePrototype, 'length', {\n        get: function () {\n          if (!Iterable.noLengthWarning) {\n            var stack;\n            try {\n              throw new Error();\n            } catch (error) {\n              stack = error.stack;\n            }\n            if (stack.indexOf('_wrapObject') === -1) {\n              console && console.warn && console.warn(\n                'iterable.length has been deprecated, '+\n                'use iterable.size or iterable.count(). '+\n                'This warning will become a silent error in a future version. ' +\n                stack\n              );\n              return this.size;\n            }\n          }\n        }\n      });\n    } catch (e) {}\n  })();\n\n\n\n  mixin(KeyedIterable, {\n\n    // ### More sequential methods\n\n    flip: function() {\n      return reify(this, flipFactory(this));\n    },\n\n    findKey: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLastKey: function(predicate, context) {\n      return this.toSeq().reverse().findKey(predicate, context);\n    },\n\n    keyOf: function(searchValue) {\n      return this.findKey(function(value ) {return is(value, searchValue)});\n    },\n\n    lastKeyOf: function(searchValue) {\n      return this.findLastKey(function(value ) {return is(value, searchValue)});\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.toKeyedSeq().keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function(searchValue) {\n      var key = this.toKeyedSeq().reverse().keyOf(searchValue);\n      return key === undefined ? -1 : key;\n\n      // var index =\n      // return this.toSeq().reverse().indexOf(searchValue);\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 key = this.toKeyedSeq().findLastKey(predicate, context);\n      return key === undefined ? -1 : key;\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    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\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) : 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 * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error(\n        'Minified exception occurred; use the non-minified dev environment ' +\n        'for the full error message and additional helpful warnings.'\n      );\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(\n        format.replace(/%s/g, function() { return args[argIndex++]; })\n      );\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n};\n\nmodule.exports = invariant;\n","// Should be no imports here!\n\n/**\n * The sentinel value returned by producers to replace the draft with undefined.\n */\nexport const NOTHING: unique symbol = Symbol.for(\"immer-nothing\")\n\n/**\n * To let Immer treat your class instances as plain immutable objects\n * (albeit with a custom prototype), you must define either an instance property\n * or a static property on each of your custom classes.\n *\n * Otherwise, your class instance will never be drafted, which means it won't be\n * safe to mutate in a produce callback.\n */\nexport const DRAFTABLE: unique symbol = Symbol.for(\"immer-draftable\")\n\nexport const DRAFT_STATE: unique symbol = Symbol.for(\"immer-state\")\n","export const errors =\n\tprocess.env.NODE_ENV !== \"production\"\n\t\t? [\n\t\t\t\t// All error codes, starting by 0:\n\t\t\t\tfunction(plugin: string) {\n\t\t\t\t\treturn `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \\`enable${plugin}()\\` when initializing your application.`\n\t\t\t\t},\n\t\t\t\tfunction(thing: string) {\n\t\t\t\t\treturn `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`\n\t\t\t\t},\n\t\t\t\t\"This object has been frozen and should not be mutated\",\n\t\t\t\tfunction(data: any) {\n\t\t\t\t\treturn (\n\t\t\t\t\t\t\"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \" +\n\t\t\t\t\t\tdata\n\t\t\t\t\t)\n\t\t\t\t},\n\t\t\t\t\"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\",\n\t\t\t\t\"Immer forbids circular references\",\n\t\t\t\t\"The first or second argument to `produce` must be a function\",\n\t\t\t\t\"The third argument to `produce` must be a function or undefined\",\n\t\t\t\t\"First argument to `createDraft` must be a plain object, an array, or an immerable object\",\n\t\t\t\t\"First argument to `finishDraft` must be a draft returned by `createDraft`\",\n\t\t\t\tfunction(thing: string) {\n\t\t\t\t\treturn `'current' expects a draft, got: ${thing}`\n\t\t\t\t},\n\t\t\t\t\"Object.defineProperty() cannot be used on an Immer draft\",\n\t\t\t\t\"Object.setPrototypeOf() cannot be used on an Immer draft\",\n\t\t\t\t\"Immer only supports deleting array indices\",\n\t\t\t\t\"Immer only supports setting array indices and the 'length' property\",\n\t\t\t\tfunction(thing: string) {\n\t\t\t\t\treturn `'original' expects a draft, got: ${thing}`\n\t\t\t\t}\n\t\t\t\t// Note: if more errors are added, the errorOffset in Patches.ts should be increased\n\t\t\t\t// See Patches.ts for additional errors\n\t\t  ]\n\t\t: []\n\nexport function die(error: number, ...args: any[]): never {\n\tif (process.env.NODE_ENV !== \"production\") {\n\t\tconst e = errors[error]\n\t\tconst msg = typeof e === \"function\" ? e.apply(null, args as any) : e\n\t\tthrow new Error(`[Immer] ${msg}`)\n\t}\n\tthrow new Error(\n\t\t`[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`\n\t)\n}\n","import {\n\tDRAFT_STATE,\n\tDRAFTABLE,\n\tObjectish,\n\tDrafted,\n\tAnyObject,\n\tAnyMap,\n\tAnySet,\n\tImmerState,\n\tArchType,\n\tdie,\n\tStrictMode\n} from \"../internal\"\n\nexport const getPrototypeOf = Object.getPrototypeOf\n\n/** Returns true if the given value is an Immer draft */\n/*#__PURE__*/\nexport function isDraft(value: any): boolean {\n\treturn !!value && !!value[DRAFT_STATE]\n}\n\n/** Returns true if the given value can be drafted by Immer */\n/*#__PURE__*/\nexport function isDraftable(value: any): boolean {\n\tif (!value) return false\n\treturn (\n\t\tisPlainObject(value) ||\n\t\tArray.isArray(value) ||\n\t\t!!value[DRAFTABLE] ||\n\t\t!!value.constructor?.[DRAFTABLE] ||\n\t\tisMap(value) ||\n\t\tisSet(value)\n\t)\n}\n\nconst objectCtorString = Object.prototype.constructor.toString()\n/*#__PURE__*/\nexport function isPlainObject(value: any): boolean {\n\tif (!value || typeof value !== \"object\") return false\n\tconst proto = getPrototypeOf(value)\n\tif (proto === null) {\n\t\treturn true\n\t}\n\tconst Ctor =\n\t\tObject.hasOwnProperty.call(proto, \"constructor\") && proto.constructor\n\n\tif (Ctor === Object) return true\n\n\treturn (\n\t\ttypeof Ctor == \"function\" &&\n\t\tFunction.toString.call(Ctor) === objectCtorString\n\t)\n}\n\n/** Get the underlying object that is represented by the given draft */\n/*#__PURE__*/\nexport function original<T>(value: T): T | undefined\nexport function original(value: Drafted<any>): any {\n\tif (!isDraft(value)) die(15, value)\n\treturn value[DRAFT_STATE].base_\n}\n\n/**\n * Each iterates a map, set or array.\n * Or, if any other kind of object, all of its own properties.\n * Regardless whether they are enumerable or symbols\n */\nexport function each<T extends Objectish>(\n\tobj: T,\n\titer: (key: string | number, value: any, source: T) => void\n): void\nexport function each(obj: any, iter: any) {\n\tif (getArchtype(obj) === ArchType.Object) {\n\t\tReflect.ownKeys(obj).forEach(key => {\n\t\t\titer(key, obj[key], obj)\n\t\t})\n\t} else {\n\t\tobj.forEach((entry: any, index: any) => iter(index, entry, obj))\n\t}\n}\n\n/*#__PURE__*/\nexport function getArchtype(thing: any): ArchType {\n\tconst state: undefined | ImmerState = thing[DRAFT_STATE]\n\treturn state\n\t\t? state.type_\n\t\t: Array.isArray(thing)\n\t\t? ArchType.Array\n\t\t: isMap(thing)\n\t\t? ArchType.Map\n\t\t: isSet(thing)\n\t\t? ArchType.Set\n\t\t: ArchType.Object\n}\n\n/*#__PURE__*/\nexport function has(thing: any, prop: PropertyKey): boolean {\n\treturn getArchtype(thing) === ArchType.Map\n\t\t? thing.has(prop)\n\t\t: Object.prototype.hasOwnProperty.call(thing, prop)\n}\n\n/*#__PURE__*/\nexport function get(thing: AnyMap | AnyObject, prop: PropertyKey): any {\n\t// @ts-ignore\n\treturn getArchtype(thing) === ArchType.Map ? thing.get(prop) : thing[prop]\n}\n\n/*#__PURE__*/\nexport function set(thing: any, propOrOldValue: PropertyKey, value: any) {\n\tconst t = getArchtype(thing)\n\tif (t === ArchType.Map) thing.set(propOrOldValue, value)\n\telse if (t === ArchType.Set) {\n\t\tthing.add(value)\n\t} else thing[propOrOldValue] = value\n}\n\n/*#__PURE__*/\nexport function is(x: any, y: any): boolean {\n\t// From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js\n\tif (x === y) {\n\t\treturn x !== 0 || 1 / x === 1 / y\n\t} else {\n\t\treturn x !== x && y !== y\n\t}\n}\n\n/*#__PURE__*/\nexport function isMap(target: any): target is AnyMap {\n\treturn target instanceof Map\n}\n\n/*#__PURE__*/\nexport function isSet(target: any): target is AnySet {\n\treturn target instanceof Set\n}\n/*#__PURE__*/\nexport function latest(state: ImmerState): any {\n\treturn state.copy_ || state.base_\n}\n\n/*#__PURE__*/\nexport function shallowCopy(base: any, strict: StrictMode) {\n\tif (isMap(base)) {\n\t\treturn new Map(base)\n\t}\n\tif (isSet(base)) {\n\t\treturn new Set(base)\n\t}\n\tif (Array.isArray(base)) return Array.prototype.slice.call(base)\n\n\tconst isPlain = isPlainObject(base)\n\n\tif (strict === true || (strict === \"class_only\" && !isPlain)) {\n\t\t// Perform a strict copy\n\t\tconst descriptors = Object.getOwnPropertyDescriptors(base)\n\t\tdelete descriptors[DRAFT_STATE as any]\n\t\tlet keys = Reflect.ownKeys(descriptors)\n\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\tconst key: any = keys[i]\n\t\t\tconst desc = descriptors[key]\n\t\t\tif (desc.writable === false) {\n\t\t\t\tdesc.writable = true\n\t\t\t\tdesc.configurable = true\n\t\t\t}\n\t\t\t// like object.assign, we will read any _own_, get/set accessors. This helps in dealing\n\t\t\t// with libraries that trap values, like mobx or vue\n\t\t\t// unlike object.assign, non-enumerables will be copied as well\n\t\t\tif (desc.get || desc.set)\n\t\t\t\tdescriptors[key] = {\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true, // could live with !!desc.set as well here...\n\t\t\t\t\tenumerable: desc.enumerable,\n\t\t\t\t\tvalue: base[key]\n\t\t\t\t}\n\t\t}\n\t\treturn Object.create(getPrototypeOf(base), descriptors)\n\t} else {\n\t\t// perform a sloppy copy\n\t\tconst proto = getPrototypeOf(base)\n\t\tif (proto !== null && isPlain) {\n\t\t\treturn {...base} // assumption: better inner class optimization than the assign below\n\t\t}\n\t\tconst obj = Object.create(proto)\n\t\treturn Object.assign(obj, base)\n\t}\n}\n\n/**\n * Freezes draftable objects. Returns the original object.\n * By default freezes shallowly, but if the second argument is `true` it will freeze recursively.\n *\n * @param obj\n * @param deep\n */\nexport function freeze<T>(obj: T, deep?: boolean): T\nexport function freeze<T>(obj: any, deep: boolean = false): T {\n\tif (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj\n\tif (getArchtype(obj) > 1 /* Map or Set */) {\n\t\tobj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections as any\n\t}\n\tObject.freeze(obj)\n\tif (deep)\n\t\t// See #590, don't recurse into non-enumerable / Symbol properties when freezing\n\t\t// So use Object.entries (only string-like, enumerables) instead of each()\n\t\tObject.entries(obj).forEach(([key, value]) => freeze(value, true))\n\treturn obj\n}\n\nfunction dontMutateFrozenCollections() {\n\tdie(2)\n}\n\nexport function isFrozen(obj: any): boolean {\n\treturn Object.isFrozen(obj)\n}\n","import {\n\tImmerState,\n\tPatch,\n\tDrafted,\n\tImmerBaseState,\n\tAnyMap,\n\tAnySet,\n\tArchType,\n\tdie\n} from \"../internal\"\n\n/** Plugin utilities */\nconst plugins: {\n\tPatches?: {\n\t\tgeneratePatches_(\n\t\t\tstate: ImmerState,\n\t\t\tbasePath: PatchPath,\n\t\t\tpatches: Patch[],\n\t\t\tinversePatches: Patch[]\n\t\t): void\n\t\tgenerateReplacementPatches_(\n\t\t\tbase: any,\n\t\t\treplacement: any,\n\t\t\tpatches: Patch[],\n\t\t\tinversePatches: Patch[]\n\t\t): void\n\t\tapplyPatches_<T>(draft: T, patches: readonly Patch[]): T\n\t}\n\tMapSet?: {\n\t\tproxyMap_<T extends AnyMap>(target: T, parent?: ImmerState): T\n\t\tproxySet_<T extends AnySet>(target: T, parent?: ImmerState): T\n\t}\n} = {}\n\ntype Plugins = typeof plugins\n\nexport function getPlugin<K extends keyof Plugins>(\n\tpluginKey: K\n): Exclude<Plugins[K], undefined> {\n\tconst plugin = plugins[pluginKey]\n\tif (!plugin) {\n\t\tdie(0, pluginKey)\n\t}\n\t// @ts-ignore\n\treturn plugin\n}\n\nexport function loadPlugin<K extends keyof Plugins>(\n\tpluginKey: K,\n\timplementation: Plugins[K]\n): void {\n\tif (!plugins[pluginKey]) plugins[pluginKey] = implementation\n}\n/** Map / Set plugin */\n\nexport interface MapState extends ImmerBaseState {\n\ttype_: ArchType.Map\n\tcopy_: AnyMap | undefined\n\tassigned_: Map<any, boolean> | undefined\n\tbase_: AnyMap\n\trevoked_: boolean\n\tdraft_: Drafted<AnyMap, MapState>\n}\n\nexport interface SetState extends ImmerBaseState {\n\ttype_: ArchType.Set\n\tcopy_: AnySet | undefined\n\tbase_: AnySet\n\tdrafts_: Map<any, Drafted> // maps the original value to the draft value in the new set\n\trevoked_: boolean\n\tdraft_: Drafted<AnySet, SetState>\n}\n\n/** Patches plugin */\n\nexport type PatchPath = (string | number)[]\n","import {\n\tPatch,\n\tPatchListener,\n\tDrafted,\n\tImmer,\n\tDRAFT_STATE,\n\tImmerState,\n\tArchType,\n\tgetPlugin\n} from \"../internal\"\n\n/** Each scope represents a `produce` call. */\n\nexport interface ImmerScope {\n\tpatches_?: Patch[]\n\tinversePatches_?: Patch[]\n\tcanAutoFreeze_: boolean\n\tdrafts_: any[]\n\tparent_?: ImmerScope\n\tpatchListener_?: PatchListener\n\timmer_: Immer\n\tunfinalizedDrafts_: number\n}\n\nlet currentScope: ImmerScope | undefined\n\nexport function getCurrentScope() {\n\treturn currentScope!\n}\n\nfunction createScope(\n\tparent_: ImmerScope | undefined,\n\timmer_: Immer\n): ImmerScope {\n\treturn {\n\t\tdrafts_: [],\n\t\tparent_,\n\t\timmer_,\n\t\t// Whenever the modified draft contains a draft from another scope, we\n\t\t// need to prevent auto-freezing so the unowned draft can be finalized.\n\t\tcanAutoFreeze_: true,\n\t\tunfinalizedDrafts_: 0\n\t}\n}\n\nexport function usePatchesInScope(\n\tscope: ImmerScope,\n\tpatchListener?: PatchListener\n) {\n\tif (patchListener) {\n\t\tgetPlugin(\"Patches\") // assert we have the plugin\n\t\tscope.patches_ = []\n\t\tscope.inversePatches_ = []\n\t\tscope.patchListener_ = patchListener\n\t}\n}\n\nexport function revokeScope(scope: ImmerScope) {\n\tleaveScope(scope)\n\tscope.drafts_.forEach(revokeDraft)\n\t// @ts-ignore\n\tscope.drafts_ = null\n}\n\nexport function leaveScope(scope: ImmerScope) {\n\tif (scope === currentScope) {\n\t\tcurrentScope = scope.parent_\n\t}\n}\n\nexport function enterScope(immer: Immer) {\n\treturn (currentScope = createScope(currentScope, immer))\n}\n\nfunction revokeDraft(draft: Drafted) {\n\tconst state: ImmerState = draft[DRAFT_STATE]\n\tif (state.type_ === ArchType.Object || state.type_ === ArchType.Array)\n\t\tstate.revoke_()\n\telse state.revoked_ = true\n}\n","import {\n\tImmerScope,\n\tDRAFT_STATE,\n\tisDraftable,\n\tNOTHING,\n\tPatchPath,\n\teach,\n\thas,\n\tfreeze,\n\tImmerState,\n\tisDraft,\n\tSetState,\n\tset,\n\tArchType,\n\tgetPlugin,\n\tdie,\n\trevokeScope,\n\tisFrozen\n} from \"../internal\"\n\nexport function processResult(result: any, scope: ImmerScope) {\n\tscope.unfinalizedDrafts_ = scope.drafts_.length\n\tconst baseDraft = scope.drafts_![0]\n\tconst isReplaced = result !== undefined && result !== baseDraft\n\tif (isReplaced) {\n\t\tif (baseDraft[DRAFT_STATE].modified_) {\n\t\t\trevokeScope(scope)\n\t\t\tdie(4)\n\t\t}\n\t\tif (isDraftable(result)) {\n\t\t\t// Finalize the result in case it contains (or is) a subset of the draft.\n\t\t\tresult = finalize(scope, result)\n\t\t\tif (!scope.parent_) maybeFreeze(scope, result)\n\t\t}\n\t\tif (scope.patches_) {\n\t\t\tgetPlugin(\"Patches\").generateReplacementPatches_(\n\t\t\t\tbaseDraft[DRAFT_STATE].base_,\n\t\t\t\tresult,\n\t\t\t\tscope.patches_,\n\t\t\t\tscope.inversePatches_!\n\t\t\t)\n\t\t}\n\t} else {\n\t\t// Finalize the base draft.\n\t\tresult = finalize(scope, baseDraft, [])\n\t}\n\trevokeScope(scope)\n\tif (scope.patches_) {\n\t\tscope.patchListener_!(scope.patches_, scope.inversePatches_!)\n\t}\n\treturn result !== NOTHING ? result : undefined\n}\n\nfunction finalize(rootScope: ImmerScope, value: any, path?: PatchPath) {\n\t// Don't recurse in tho recursive data structures\n\tif (isFrozen(value)) return value\n\n\tconst state: ImmerState = value[DRAFT_STATE]\n\t// A plain object, might need freezing, might contain drafts\n\tif (!state) {\n\t\teach(value, (key, childValue) =>\n\t\t\tfinalizeProperty(rootScope, state, value, key, childValue, path)\n\t\t)\n\t\treturn value\n\t}\n\t// Never finalize drafts owned by another scope.\n\tif (state.scope_ !== rootScope) return value\n\t// Unmodified draft, return the (frozen) original\n\tif (!state.modified_) {\n\t\tmaybeFreeze(rootScope, state.base_, true)\n\t\treturn state.base_\n\t}\n\t// Not finalized yet, let's do that now\n\tif (!state.finalized_) {\n\t\tstate.finalized_ = true\n\t\tstate.scope_.unfinalizedDrafts_--\n\t\tconst result = state.copy_\n\t\t// Finalize all children of the copy\n\t\t// For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628\n\t\t// To preserve insertion order in all cases we then clear the set\n\t\t// And we let finalizeProperty know it needs to re-add non-draft children back to the target\n\t\tlet resultEach = result\n\t\tlet isSet = false\n\t\tif (state.type_ === ArchType.Set) {\n\t\t\tresultEach = new Set(result)\n\t\t\tresult.clear()\n\t\t\tisSet = true\n\t\t}\n\t\teach(resultEach, (key, childValue) =>\n\t\t\tfinalizeProperty(rootScope, state, result, key, childValue, path, isSet)\n\t\t)\n\t\t// everything inside is frozen, we can freeze here\n\t\tmaybeFreeze(rootScope, result, false)\n\t\t// first time finalizing, let's create those patches\n\t\tif (path && rootScope.patches_) {\n\t\t\tgetPlugin(\"Patches\").generatePatches_(\n\t\t\t\tstate,\n\t\t\t\tpath,\n\t\t\t\trootScope.patches_,\n\t\t\t\trootScope.inversePatches_!\n\t\t\t)\n\t\t}\n\t}\n\treturn state.copy_\n}\n\nfunction finalizeProperty(\n\trootScope: ImmerScope,\n\tparentState: undefined | ImmerState,\n\ttargetObject: any,\n\tprop: string | number,\n\tchildValue: any,\n\trootPath?: PatchPath,\n\ttargetIsSet?: boolean\n) {\n\tif (process.env.NODE_ENV !== \"production\" && childValue === targetObject)\n\t\tdie(5)\n\tif (isDraft(childValue)) {\n\t\tconst path =\n\t\t\trootPath &&\n\t\t\tparentState &&\n\t\t\tparentState!.type_ !== ArchType.Set && // Set objects are atomic since they have no keys.\n\t\t\t!has((parentState as Exclude<ImmerState, SetState>).assigned_!, prop) // Skip deep patches for assigned keys.\n\t\t\t\t? rootPath!.concat(prop)\n\t\t\t\t: undefined\n\t\t// Drafts owned by `scope` are finalized here.\n\t\tconst res = finalize(rootScope, childValue, path)\n\t\tset(targetObject, prop, res)\n\t\t// Drafts from another scope must prevented to be frozen\n\t\t// if we got a draft back from finalize, we're in a nested produce and shouldn't freeze\n\t\tif (isDraft(res)) {\n\t\t\trootScope.canAutoFreeze_ = false\n\t\t} else return\n\t} else if (targetIsSet) {\n\t\ttargetObject.add(childValue)\n\t}\n\t// Search new objects for unfinalized drafts. Frozen objects should never contain drafts.\n\tif (isDraftable(childValue) && !isFrozen(childValue)) {\n\t\tif (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {\n\t\t\t// optimization: if an object is not a draft, and we don't have to\n\t\t\t// deepfreeze everything, and we are sure that no drafts are left in the remaining object\n\t\t\t// cause we saw and finalized all drafts already; we can stop visiting the rest of the tree.\n\t\t\t// This benefits especially adding large data tree's without further processing.\n\t\t\t// See add-data.js perf test\n\t\t\treturn\n\t\t}\n\t\tfinalize(rootScope, childValue)\n\t\t// Immer deep freezes plain objects, so if there is no parent state, we freeze as well\n\t\t// Per #590, we never freeze symbolic properties. Just to make sure don't accidentally interfere\n\t\t// with other frameworks.\n\t\tif (\n\t\t\t(!parentState || !parentState.scope_.parent_) &&\n\t\t\ttypeof prop !== \"symbol\" &&\n\t\t\tObject.prototype.propertyIsEnumerable.call(targetObject, prop)\n\t\t)\n\t\t\tmaybeFreeze(rootScope, childValue)\n\t}\n}\n\nfunction maybeFreeze(scope: ImmerScope, value: any, deep = false) {\n\t// we never freeze for a non-root scope; as it would prevent pruning for drafts inside wrapping objects\n\tif (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {\n\t\tfreeze(value, deep)\n\t}\n}\n","import {\n\teach,\n\thas,\n\tis,\n\tisDraftable,\n\tshallowCopy,\n\tlatest,\n\tImmerBaseState,\n\tImmerState,\n\tDrafted,\n\tAnyObject,\n\tAnyArray,\n\tObjectish,\n\tgetCurrentScope,\n\tgetPrototypeOf,\n\tDRAFT_STATE,\n\tdie,\n\tcreateProxy,\n\tArchType,\n\tImmerScope\n} from \"../internal\"\n\ninterface ProxyBaseState extends ImmerBaseState {\n\tassigned_: {\n\t\t[property: string]: boolean\n\t}\n\tparent_?: ImmerState\n\trevoke_(): void\n}\n\nexport interface ProxyObjectState extends ProxyBaseState {\n\ttype_: ArchType.Object\n\tbase_: any\n\tcopy_: any\n\tdraft_: Drafted<AnyObject, ProxyObjectState>\n}\n\nexport interface ProxyArrayState extends ProxyBaseState {\n\ttype_: ArchType.Array\n\tbase_: AnyArray\n\tcopy_: AnyArray | null\n\tdraft_: Drafted<AnyArray, ProxyArrayState>\n}\n\ntype ProxyState = ProxyObjectState | ProxyArrayState\n\n/**\n * Returns a new draft of the `base` object.\n *\n * The second argument is the parent draft-state (used internally).\n */\nexport function createProxyProxy<T extends Objectish>(\n\tbase: T,\n\tparent?: ImmerState\n): Drafted<T, ProxyState> {\n\tconst isArray = Array.isArray(base)\n\tconst state: ProxyState = {\n\t\ttype_: isArray ? ArchType.Array : (ArchType.Object as any),\n\t\t// Track which produce call this is associated with.\n\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t// True for both shallow and deep changes.\n\t\tmodified_: false,\n\t\t// Used during finalization.\n\t\tfinalized_: false,\n\t\t// Track which properties have been assigned (true) or deleted (false).\n\t\tassigned_: {},\n\t\t// The parent draft state.\n\t\tparent_: parent,\n\t\t// The base state.\n\t\tbase_: base,\n\t\t// The base proxy.\n\t\tdraft_: null as any, // set below\n\t\t// The base copy with any updated values.\n\t\tcopy_: null,\n\t\t// Called by the `produce` function.\n\t\trevoke_: null as any,\n\t\tisManual_: false\n\t}\n\n\t// the traps must target something, a bit like the 'real' base.\n\t// but also, we need to be able to determine from the target what the relevant state is\n\t// (to avoid creating traps per instance to capture the state in closure,\n\t// and to avoid creating weird hidden properties as well)\n\t// So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything)\n\t// Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb\n\tlet target: T = state as any\n\tlet traps: ProxyHandler<object | Array<any>> = objectTraps\n\tif (isArray) {\n\t\ttarget = [state] as any\n\t\ttraps = arrayTraps\n\t}\n\n\tconst {revoke, proxy} = Proxy.revocable(target, traps)\n\tstate.draft_ = proxy as any\n\tstate.revoke_ = revoke\n\treturn proxy as any\n}\n\n/**\n * Object drafts\n */\nexport const objectTraps: ProxyHandler<ProxyState> = {\n\tget(state, prop) {\n\t\tif (prop === DRAFT_STATE) return state\n\n\t\tconst source = latest(state)\n\t\tif (!has(source, prop)) {\n\t\t\t// non-existing or non-own property...\n\t\t\treturn readPropFromProto(state, source, prop)\n\t\t}\n\t\tconst value = source[prop]\n\t\tif (state.finalized_ || !isDraftable(value)) {\n\t\t\treturn value\n\t\t}\n\t\t// Check for existing draft in modified state.\n\t\t// Assigned values are never drafted. This catches any drafts we created, too.\n\t\tif (value === peek(state.base_, prop)) {\n\t\t\tprepareCopy(state)\n\t\t\treturn (state.copy_![prop as any] = createProxy(value, state))\n\t\t}\n\t\treturn value\n\t},\n\thas(state, prop) {\n\t\treturn prop in latest(state)\n\t},\n\townKeys(state) {\n\t\treturn Reflect.ownKeys(latest(state))\n\t},\n\tset(\n\t\tstate: ProxyObjectState,\n\t\tprop: string /* strictly not, but helps TS */,\n\t\tvalue\n\t) {\n\t\tconst desc = getDescriptorFromProto(latest(state), prop)\n\t\tif (desc?.set) {\n\t\t\t// special case: if this write is captured by a setter, we have\n\t\t\t// to trigger it with the correct context\n\t\t\tdesc.set.call(state.draft_, value)\n\t\t\treturn true\n\t\t}\n\t\tif (!state.modified_) {\n\t\t\t// the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change)\n\t\t\t// from setting an existing property with value undefined to undefined (which is not a change)\n\t\t\tconst current = peek(latest(state), prop)\n\t\t\t// special case, if we assigning the original value to a draft, we can ignore the assignment\n\t\t\tconst currentState: ProxyObjectState = current?.[DRAFT_STATE]\n\t\t\tif (currentState && currentState.base_ === value) {\n\t\t\t\tstate.copy_![prop] = value\n\t\t\t\tstate.assigned_[prop] = false\n\t\t\t\treturn true\n\t\t\t}\n\t\t\tif (is(value, current) && (value !== undefined || has(state.base_, prop)))\n\t\t\t\treturn true\n\t\t\tprepareCopy(state)\n\t\t\tmarkChanged(state)\n\t\t}\n\n\t\tif (\n\t\t\t(state.copy_![prop] === value &&\n\t\t\t\t// special case: handle new props with value 'undefined'\n\t\t\t\t(value !== undefined || prop in state.copy_)) ||\n\t\t\t// special case: NaN\n\t\t\t(Number.isNaN(value) && Number.isNaN(state.copy_![prop]))\n\t\t)\n\t\t\treturn true\n\n\t\t// @ts-ignore\n\t\tstate.copy_![prop] = value\n\t\tstate.assigned_[prop] = true\n\t\treturn true\n\t},\n\tdeleteProperty(state, prop: string) {\n\t\t// The `undefined` check is a fast path for pre-existing keys.\n\t\tif (peek(state.base_, prop) !== undefined || prop in state.base_) {\n\t\t\tstate.assigned_[prop] = false\n\t\t\tprepareCopy(state)\n\t\t\tmarkChanged(state)\n\t\t} else {\n\t\t\t// if an originally not assigned property was deleted\n\t\t\tdelete state.assigned_[prop]\n\t\t}\n\t\tif (state.copy_) {\n\t\t\tdelete state.copy_[prop]\n\t\t}\n\t\treturn true\n\t},\n\t// Note: We never coerce `desc.value` into an Immer draft, because we can't make\n\t// the same guarantee in ES5 mode.\n\tgetOwnPropertyDescriptor(state, prop) {\n\t\tconst owner = latest(state)\n\t\tconst desc = Reflect.getOwnPropertyDescriptor(owner, prop)\n\t\tif (!desc) return desc\n\t\treturn {\n\t\t\twritable: true,\n\t\t\tconfigurable: state.type_ !== ArchType.Array || prop !== \"length\",\n\t\t\tenumerable: desc.enumerable,\n\t\t\tvalue: owner[prop]\n\t\t}\n\t},\n\tdefineProperty() {\n\t\tdie(11)\n\t},\n\tgetPrototypeOf(state) {\n\t\treturn getPrototypeOf(state.base_)\n\t},\n\tsetPrototypeOf() {\n\t\tdie(12)\n\t}\n}\n\n/**\n * Array drafts\n */\n\nconst arrayTraps: ProxyHandler<[ProxyArrayState]> = {}\neach(objectTraps, (key, fn) => {\n\t// @ts-ignore\n\tarrayTraps[key] = function() {\n\t\targuments[0] = arguments[0][0]\n\t\treturn fn.apply(this, arguments)\n\t}\n})\narrayTraps.deleteProperty = function(state, prop) {\n\tif (process.env.NODE_ENV !== \"production\" && isNaN(parseInt(prop as any)))\n\t\tdie(13)\n\t// @ts-ignore\n\treturn arrayTraps.set!.call(this, state, prop, undefined)\n}\narrayTraps.set = function(state, prop, value) {\n\tif (\n\t\tprocess.env.NODE_ENV !== \"production\" &&\n\t\tprop !== \"length\" &&\n\t\tisNaN(parseInt(prop as any))\n\t)\n\t\tdie(14)\n\treturn objectTraps.set!.call(this, state[0], prop, value, state[0])\n}\n\n// Access a property without creating an Immer draft.\nfunction peek(draft: Drafted, prop: PropertyKey) {\n\tconst state = draft[DRAFT_STATE]\n\tconst source = state ? latest(state) : draft\n\treturn source[prop]\n}\n\nfunction readPropFromProto(state: ImmerState, source: any, prop: PropertyKey) {\n\tconst desc = getDescriptorFromProto(source, prop)\n\treturn desc\n\t\t? `value` in desc\n\t\t\t? desc.value\n\t\t\t: // This is a very special case, if the prop is a getter defined by the\n\t\t\t  // prototype, we should invoke it with the draft as context!\n\t\t\t  desc.get?.call(state.draft_)\n\t\t: undefined\n}\n\nfunction getDescriptorFromProto(\n\tsource: any,\n\tprop: PropertyKey\n): PropertyDescriptor | undefined {\n\t// 'in' checks proto!\n\tif (!(prop in source)) return undefined\n\tlet proto = getPrototypeOf(source)\n\twhile (proto) {\n\t\tconst desc = Object.getOwnPropertyDescriptor(proto, prop)\n\t\tif (desc) return desc\n\t\tproto = getPrototypeOf(proto)\n\t}\n\treturn undefined\n}\n\nexport function markChanged(state: ImmerState) {\n\tif (!state.modified_) {\n\t\tstate.modified_ = true\n\t\tif (state.parent_) {\n\t\t\tmarkChanged(state.parent_)\n\t\t}\n\t}\n}\n\nexport function prepareCopy(state: {\n\tbase_: any\n\tcopy_: any\n\tscope_: ImmerScope\n}) {\n\tif (!state.copy_) {\n\t\tstate.copy_ = shallowCopy(\n\t\t\tstate.base_,\n\t\t\tstate.scope_.immer_.useStrictShallowCopy_\n\t\t)\n\t}\n}\n","import {\n\tIProduceWithPatches,\n\tIProduce,\n\tImmerState,\n\tDrafted,\n\tisDraftable,\n\tprocessResult,\n\tPatch,\n\tObjectish,\n\tDRAFT_STATE,\n\tDraft,\n\tPatchListener,\n\tisDraft,\n\tisMap,\n\tisSet,\n\tcreateProxyProxy,\n\tgetPlugin,\n\tdie,\n\tenterScope,\n\trevokeScope,\n\tleaveScope,\n\tusePatchesInScope,\n\tgetCurrentScope,\n\tNOTHING,\n\tfreeze,\n\tcurrent\n} from \"../internal\"\n\ninterface ProducersFns {\n\tproduce: IProduce\n\tproduceWithPatches: IProduceWithPatches\n}\n\nexport type StrictMode = boolean | \"class_only\";\n\nexport class Immer implements ProducersFns {\n\tautoFreeze_: boolean = true\n\tuseStrictShallowCopy_: StrictMode = false\n\n\tconstructor(config?: {\n\t\tautoFreeze?: boolean\n\t\tuseStrictShallowCopy?: StrictMode\n\t}) {\n\t\tif (typeof config?.autoFreeze === \"boolean\")\n\t\t\tthis.setAutoFreeze(config!.autoFreeze)\n\t\tif (typeof config?.useStrictShallowCopy === \"boolean\")\n\t\t\tthis.setUseStrictShallowCopy(config!.useStrictShallowCopy)\n\t}\n\n\t/**\n\t * The `produce` function takes a value and a \"recipe function\" (whose\n\t * return value often depends on the base state). The recipe function is\n\t * free to mutate its first argument however it wants. All mutations are\n\t * only ever applied to a __copy__ of the base state.\n\t *\n\t * Pass only a function to create a \"curried producer\" which relieves you\n\t * from passing the recipe function every time.\n\t *\n\t * Only plain objects and arrays are made mutable. All other objects are\n\t * considered uncopyable.\n\t *\n\t * Note: This function is __bound__ to its `Immer` instance.\n\t *\n\t * @param {any} base - the initial state\n\t * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified\n\t * @param {Function} patchListener - optional function that will be called with all the patches produced here\n\t * @returns {any} a new state, or the initial state if nothing was modified\n\t */\n\tproduce: IProduce = (base: any, recipe?: any, patchListener?: any) => {\n\t\t// curried invocation\n\t\tif (typeof base === \"function\" && typeof recipe !== \"function\") {\n\t\t\tconst defaultBase = recipe\n\t\t\trecipe = base\n\n\t\t\tconst self = this\n\t\t\treturn function curriedProduce(\n\t\t\t\tthis: any,\n\t\t\t\tbase = defaultBase,\n\t\t\t\t...args: any[]\n\t\t\t) {\n\t\t\t\treturn self.produce(base, (draft: Drafted) => recipe.call(this, draft, ...args)) // prettier-ignore\n\t\t\t}\n\t\t}\n\n\t\tif (typeof recipe !== \"function\") die(6)\n\t\tif (patchListener !== undefined && typeof patchListener !== \"function\")\n\t\t\tdie(7)\n\n\t\tlet result\n\n\t\t// Only plain objects, arrays, and \"immerable classes\" are drafted.\n\t\tif (isDraftable(base)) {\n\t\t\tconst scope = enterScope(this)\n\t\t\tconst proxy = createProxy(base, undefined)\n\t\t\tlet hasError = true\n\t\t\ttry {\n\t\t\t\tresult = recipe(proxy)\n\t\t\t\thasError = false\n\t\t\t} finally {\n\t\t\t\t// finally instead of catch + rethrow better preserves original stack\n\t\t\t\tif (hasError) revokeScope(scope)\n\t\t\t\telse leaveScope(scope)\n\t\t\t}\n\t\t\tusePatchesInScope(scope, patchListener)\n\t\t\treturn processResult(result, scope)\n\t\t} else if (!base || typeof base !== \"object\") {\n\t\t\tresult = recipe(base)\n\t\t\tif (result === undefined) result = base\n\t\t\tif (result === NOTHING) result = undefined\n\t\t\tif (this.autoFreeze_) freeze(result, true)\n\t\t\tif (patchListener) {\n\t\t\t\tconst p: Patch[] = []\n\t\t\t\tconst ip: Patch[] = []\n\t\t\t\tgetPlugin(\"Patches\").generateReplacementPatches_(base, result, p, ip)\n\t\t\t\tpatchListener(p, ip)\n\t\t\t}\n\t\t\treturn result\n\t\t} else die(1, base)\n\t}\n\n\tproduceWithPatches: IProduceWithPatches = (base: any, recipe?: any): any => {\n\t\t// curried invocation\n\t\tif (typeof base === \"function\") {\n\t\t\treturn (state: any, ...args: any[]) =>\n\t\t\t\tthis.produceWithPatches(state, (draft: any) => base(draft, ...args))\n\t\t}\n\n\t\tlet patches: Patch[], inversePatches: Patch[]\n\t\tconst result = this.produce(base, recipe, (p: Patch[], ip: Patch[]) => {\n\t\t\tpatches = p\n\t\t\tinversePatches = ip\n\t\t})\n\t\treturn [result, patches!, inversePatches!]\n\t}\n\n\tcreateDraft<T extends Objectish>(base: T): Draft<T> {\n\t\tif (!isDraftable(base)) die(8)\n\t\tif (isDraft(base)) base = current(base)\n\t\tconst scope = enterScope(this)\n\t\tconst proxy = createProxy(base, undefined)\n\t\tproxy[DRAFT_STATE].isManual_ = true\n\t\tleaveScope(scope)\n\t\treturn proxy as any\n\t}\n\n\tfinishDraft<D extends Draft<any>>(\n\t\tdraft: D,\n\t\tpatchListener?: PatchListener\n\t): D extends Draft<infer T> ? T : never {\n\t\tconst state: ImmerState = draft && (draft as any)[DRAFT_STATE]\n\t\tif (!state || !state.isManual_) die(9)\n\t\tconst {scope_: scope} = state\n\t\tusePatchesInScope(scope, patchListener)\n\t\treturn processResult(undefined, scope)\n\t}\n\n\t/**\n\t * Pass true to automatically freeze all copies created by Immer.\n\t *\n\t * By default, auto-freezing is enabled.\n\t */\n\tsetAutoFreeze(value: boolean) {\n\t\tthis.autoFreeze_ = value\n\t}\n\n\t/**\n\t * Pass true to enable strict shallow copy.\n\t *\n\t * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.\n\t */\n\tsetUseStrictShallowCopy(value: StrictMode) {\n\t\tthis.useStrictShallowCopy_ = value\n\t}\n\n\tapplyPatches<T extends Objectish>(base: T, patches: readonly Patch[]): T {\n\t\t// If a patch replaces the entire state, take that replacement as base\n\t\t// before applying patches\n\t\tlet i: number\n\t\tfor (i = patches.length - 1; i >= 0; i--) {\n\t\t\tconst patch = patches[i]\n\t\t\tif (patch.path.length === 0 && patch.op === \"replace\") {\n\t\t\t\tbase = patch.value\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// If there was a patch that replaced the entire state, start from the\n\t\t// patch after that.\n\t\tif (i > -1) {\n\t\t\tpatches = patches.slice(i + 1)\n\t\t}\n\n\t\tconst applyPatchesImpl = getPlugin(\"Patches\").applyPatches_\n\t\tif (isDraft(base)) {\n\t\t\t// N.B: never hits if some patch a replacement, patches are never drafts\n\t\t\treturn applyPatchesImpl(base, patches)\n\t\t}\n\t\t// Otherwise, produce a copy of the base state.\n\t\treturn this.produce(base, (draft: Drafted) =>\n\t\t\tapplyPatchesImpl(draft, patches)\n\t\t)\n\t}\n}\n\nexport function createProxy<T extends Objectish>(\n\tvalue: T,\n\tparent?: ImmerState\n): Drafted<T, ImmerState> {\n\t// precondition: createProxy should be guarded by isDraftable, so we know we can safely draft\n\tconst draft: Drafted = isMap(value)\n\t\t? getPlugin(\"MapSet\").proxyMap_(value, parent)\n\t\t: isSet(value)\n\t\t? getPlugin(\"MapSet\").proxySet_(value, parent)\n\t\t: createProxyProxy(value, parent)\n\n\tconst scope = parent ? parent.scope_ : getCurrentScope()\n\tscope.drafts_.push(draft)\n\treturn draft\n}\n","import {\n\tdie,\n\tisDraft,\n\tshallowCopy,\n\teach,\n\tDRAFT_STATE,\n\tset,\n\tImmerState,\n\tisDraftable,\n\tisFrozen\n} from \"../internal\"\n\n/** Takes a snapshot of the current state of a draft and finalizes it (but without freezing). This is a great utility to print the current state during debugging (no Proxies in the way). The output of current can also be safely leaked outside the producer. */\nexport function current<T>(value: T): T\nexport function current(value: any): any {\n\tif (!isDraft(value)) die(10, value)\n\treturn currentImpl(value)\n}\n\nfunction currentImpl(value: any): any {\n\tif (!isDraftable(value) || isFrozen(value)) return value\n\tconst state: ImmerState | undefined = value[DRAFT_STATE]\n\tlet copy: any\n\tif (state) {\n\t\tif (!state.modified_) return state.base_\n\t\t// Optimization: avoid generating new drafts during copying\n\t\tstate.finalized_ = true\n\t\tcopy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_)\n\t} else {\n\t\tcopy = shallowCopy(value, true)\n\t}\n\t// recurse\n\teach(copy, (key, childValue) => {\n\t\tset(copy, key, currentImpl(childValue))\n\t})\n\tif (state) {\n\t\tstate.finalized_ = false\n\t}\n\treturn copy\n}\n","import {immerable} from \"../immer\"\nimport {\n\tImmerState,\n\tPatch,\n\tSetState,\n\tProxyArrayState,\n\tMapState,\n\tProxyObjectState,\n\tPatchPath,\n\tget,\n\teach,\n\thas,\n\tgetArchtype,\n\tgetPrototypeOf,\n\tisSet,\n\tisMap,\n\tloadPlugin,\n\tArchType,\n\tdie,\n\tisDraft,\n\tisDraftable,\n\tNOTHING,\n\terrors\n} from \"../internal\"\n\nexport function enablePatches() {\n\tconst errorOffset = 16\n\tif (process.env.NODE_ENV !== \"production\") {\n\t\terrors.push(\n\t\t\t'Sets cannot have \"replace\" patches.',\n\t\t\tfunction(op: string) {\n\t\t\t\treturn \"Unsupported patch operation: \" + op\n\t\t\t},\n\t\t\tfunction(path: string) {\n\t\t\t\treturn \"Cannot apply patch, path doesn't resolve: \" + path\n\t\t\t},\n\t\t\t\"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"\n\t\t)\n\t}\n\n\tconst REPLACE = \"replace\"\n\tconst ADD = \"add\"\n\tconst REMOVE = \"remove\"\n\n\tfunction generatePatches_(\n\t\tstate: ImmerState,\n\t\tbasePath: PatchPath,\n\t\tpatches: Patch[],\n\t\tinversePatches: Patch[]\n\t): void {\n\t\tswitch (state.type_) {\n\t\t\tcase ArchType.Object:\n\t\t\tcase ArchType.Map:\n\t\t\t\treturn generatePatchesFromAssigned(\n\t\t\t\t\tstate,\n\t\t\t\t\tbasePath,\n\t\t\t\t\tpatches,\n\t\t\t\t\tinversePatches\n\t\t\t\t)\n\t\t\tcase ArchType.Array:\n\t\t\t\treturn generateArrayPatches(state, basePath, patches, inversePatches)\n\t\t\tcase ArchType.Set:\n\t\t\t\treturn generateSetPatches(\n\t\t\t\t\t(state as any) as SetState,\n\t\t\t\t\tbasePath,\n\t\t\t\t\tpatches,\n\t\t\t\t\tinversePatches\n\t\t\t\t)\n\t\t}\n\t}\n\n\tfunction generateArrayPatches(\n\t\tstate: ProxyArrayState,\n\t\tbasePath: PatchPath,\n\t\tpatches: Patch[],\n\t\tinversePatches: Patch[]\n\t) {\n\t\tlet {base_, assigned_} = state\n\t\tlet copy_ = state.copy_!\n\n\t\t// Reduce complexity by ensuring `base` is never longer.\n\t\tif (copy_.length < base_.length) {\n\t\t\t// @ts-ignore\n\t\t\t;[base_, copy_] = [copy_, base_]\n\t\t\t;[patches, inversePatches] = [inversePatches, patches]\n\t\t}\n\n\t\t// Process replaced indices.\n\t\tfor (let i = 0; i < base_.length; i++) {\n\t\t\tif (assigned_[i] && copy_[i] !== base_[i]) {\n\t\t\t\tconst path = basePath.concat([i])\n\t\t\t\tpatches.push({\n\t\t\t\t\top: REPLACE,\n\t\t\t\t\tpath,\n\t\t\t\t\t// Need to maybe clone it, as it can in fact be the original value\n\t\t\t\t\t// due to the base/copy inversion at the start of this function\n\t\t\t\t\tvalue: clonePatchValueIfNeeded(copy_[i])\n\t\t\t\t})\n\t\t\t\tinversePatches.push({\n\t\t\t\t\top: REPLACE,\n\t\t\t\t\tpath,\n\t\t\t\t\tvalue: clonePatchValueIfNeeded(base_[i])\n\t\t\t\t})\n\t\t\t}\n\t\t}\n\n\t\t// Process added indices.\n\t\tfor (let i = base_.length; i < copy_.length; i++) {\n\t\t\tconst path = basePath.concat([i])\n\t\t\tpatches.push({\n\t\t\t\top: ADD,\n\t\t\t\tpath,\n\t\t\t\t// Need to maybe clone it, as it can in fact be the original value\n\t\t\t\t// due to the base/copy inversion at the start of this function\n\t\t\t\tvalue: clonePatchValueIfNeeded(copy_[i])\n\t\t\t})\n\t\t}\n\t\tfor (let i = copy_.length - 1; base_.length <= i; --i) {\n\t\t\tconst path = basePath.concat([i])\n\t\t\tinversePatches.push({\n\t\t\t\top: REMOVE,\n\t\t\t\tpath\n\t\t\t})\n\t\t}\n\t}\n\n\t// This is used for both Map objects and normal objects.\n\tfunction generatePatchesFromAssigned(\n\t\tstate: MapState | ProxyObjectState,\n\t\tbasePath: PatchPath,\n\t\tpatches: Patch[],\n\t\tinversePatches: Patch[]\n\t) {\n\t\tconst {base_, copy_} = state\n\t\teach(state.assigned_!, (key, assignedValue) => {\n\t\t\tconst origValue = get(base_, key)\n\t\t\tconst value = get(copy_!, key)\n\t\t\tconst op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD\n\t\t\tif (origValue === value && op === REPLACE) return\n\t\t\tconst path = basePath.concat(key as any)\n\t\t\tpatches.push(op === REMOVE ? {op, path} : {op, path, value})\n\t\t\tinversePatches.push(\n\t\t\t\top === ADD\n\t\t\t\t\t? {op: REMOVE, path}\n\t\t\t\t\t: op === REMOVE\n\t\t\t\t\t? {op: ADD, path, value: clonePatchValueIfNeeded(origValue)}\n\t\t\t\t\t: {op: REPLACE, path, value: clonePatchValueIfNeeded(origValue)}\n\t\t\t)\n\t\t})\n\t}\n\n\tfunction generateSetPatches(\n\t\tstate: SetState,\n\t\tbasePath: PatchPath,\n\t\tpatches: Patch[],\n\t\tinversePatches: Patch[]\n\t) {\n\t\tlet {base_, copy_} = state\n\n\t\tlet i = 0\n\t\tbase_.forEach((value: any) => {\n\t\t\tif (!copy_!.has(value)) {\n\t\t\t\tconst path = basePath.concat([i])\n\t\t\t\tpatches.push({\n\t\t\t\t\top: REMOVE,\n\t\t\t\t\tpath,\n\t\t\t\t\tvalue\n\t\t\t\t})\n\t\t\t\tinversePatches.unshift({\n\t\t\t\t\top: ADD,\n\t\t\t\t\tpath,\n\t\t\t\t\tvalue\n\t\t\t\t})\n\t\t\t}\n\t\t\ti++\n\t\t})\n\t\ti = 0\n\t\tcopy_!.forEach((value: any) => {\n\t\t\tif (!base_.has(value)) {\n\t\t\t\tconst path = basePath.concat([i])\n\t\t\t\tpatches.push({\n\t\t\t\t\top: ADD,\n\t\t\t\t\tpath,\n\t\t\t\t\tvalue\n\t\t\t\t})\n\t\t\t\tinversePatches.unshift({\n\t\t\t\t\top: REMOVE,\n\t\t\t\t\tpath,\n\t\t\t\t\tvalue\n\t\t\t\t})\n\t\t\t}\n\t\t\ti++\n\t\t})\n\t}\n\n\tfunction generateReplacementPatches_(\n\t\tbaseValue: any,\n\t\treplacement: any,\n\t\tpatches: Patch[],\n\t\tinversePatches: Patch[]\n\t): void {\n\t\tpatches.push({\n\t\t\top: REPLACE,\n\t\t\tpath: [],\n\t\t\tvalue: replacement === NOTHING ? undefined : replacement\n\t\t})\n\t\tinversePatches.push({\n\t\t\top: REPLACE,\n\t\t\tpath: [],\n\t\t\tvalue: baseValue\n\t\t})\n\t}\n\n\tfunction applyPatches_<T>(draft: T, patches: readonly Patch[]): T {\n\t\tpatches.forEach(patch => {\n\t\t\tconst {path, op} = patch\n\n\t\t\tlet base: any = draft\n\t\t\tfor (let i = 0; i < path.length - 1; i++) {\n\t\t\t\tconst parentType = getArchtype(base)\n\t\t\t\tlet p = path[i]\n\t\t\t\tif (typeof p !== \"string\" && typeof p !== \"number\") {\n\t\t\t\t\tp = \"\" + p\n\t\t\t\t}\n\n\t\t\t\t// See #738, avoid prototype pollution\n\t\t\t\tif (\n\t\t\t\t\t(parentType === ArchType.Object || parentType === ArchType.Array) &&\n\t\t\t\t\t(p === \"__proto__\" || p === \"constructor\")\n\t\t\t\t)\n\t\t\t\t\tdie(errorOffset + 3)\n\t\t\t\tif (typeof base === \"function\" && p === \"prototype\")\n\t\t\t\t\tdie(errorOffset + 3)\n\t\t\t\tbase = get(base, p)\n\t\t\t\tif (typeof base !== \"object\") die(errorOffset + 2, path.join(\"/\"))\n\t\t\t}\n\n\t\t\tconst type = getArchtype(base)\n\t\t\tconst value = deepClonePatchValue(patch.value) // used to clone patch to ensure original patch is not modified, see #411\n\t\t\tconst key = path[path.length - 1]\n\t\t\tswitch (op) {\n\t\t\t\tcase REPLACE:\n\t\t\t\t\tswitch (type) {\n\t\t\t\t\t\tcase ArchType.Map:\n\t\t\t\t\t\t\treturn base.set(key, value)\n\t\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\t\tcase ArchType.Set:\n\t\t\t\t\t\t\tdie(errorOffset)\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t// if value is an object, then it's assigned by reference\n\t\t\t\t\t\t\t// in the following add or remove ops, the value field inside the patch will also be modifyed\n\t\t\t\t\t\t\t// so we use value from the cloned patch\n\t\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\t\treturn (base[key] = value)\n\t\t\t\t\t}\n\t\t\t\tcase ADD:\n\t\t\t\t\tswitch (type) {\n\t\t\t\t\t\tcase ArchType.Array:\n\t\t\t\t\t\t\treturn key === \"-\"\n\t\t\t\t\t\t\t\t? base.push(value)\n\t\t\t\t\t\t\t\t: base.splice(key as any, 0, value)\n\t\t\t\t\t\tcase ArchType.Map:\n\t\t\t\t\t\t\treturn base.set(key, value)\n\t\t\t\t\t\tcase ArchType.Set:\n\t\t\t\t\t\t\treturn base.add(value)\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\treturn (base[key] = value)\n\t\t\t\t\t}\n\t\t\t\tcase REMOVE:\n\t\t\t\t\tswitch (type) {\n\t\t\t\t\t\tcase ArchType.Array:\n\t\t\t\t\t\t\treturn base.splice(key as any, 1)\n\t\t\t\t\t\tcase ArchType.Map:\n\t\t\t\t\t\t\treturn base.delete(key)\n\t\t\t\t\t\tcase ArchType.Set:\n\t\t\t\t\t\t\treturn base.delete(patch.value)\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\treturn delete base[key]\n\t\t\t\t\t}\n\t\t\t\tdefault:\n\t\t\t\t\tdie(errorOffset + 1, op)\n\t\t\t}\n\t\t})\n\n\t\treturn draft\n\t}\n\n\t// optimize: this is quite a performance hit, can we detect intelligently when it is needed?\n\t// E.g. auto-draft when new objects from outside are assigned and modified?\n\t// (See failing test when deepClone just returns obj)\n\tfunction deepClonePatchValue<T>(obj: T): T\n\tfunction deepClonePatchValue(obj: any) {\n\t\tif (!isDraftable(obj)) return obj\n\t\tif (Array.isArray(obj)) return obj.map(deepClonePatchValue)\n\t\tif (isMap(obj))\n\t\t\treturn new Map(\n\t\t\t\tArray.from(obj.entries()).map(([k, v]) => [k, deepClonePatchValue(v)])\n\t\t\t)\n\t\tif (isSet(obj)) return new Set(Array.from(obj).map(deepClonePatchValue))\n\t\tconst cloned = Object.create(getPrototypeOf(obj))\n\t\tfor (const key in obj) cloned[key] = deepClonePatchValue(obj[key])\n\t\tif (has(obj, immerable)) cloned[immerable] = obj[immerable]\n\t\treturn cloned\n\t}\n\n\tfunction clonePatchValueIfNeeded<T>(obj: T): T {\n\t\tif (isDraft(obj)) {\n\t\t\treturn deepClonePatchValue(obj)\n\t\t} else return obj\n\t}\n\n\tloadPlugin(\"Patches\", {\n\t\tapplyPatches_,\n\t\tgeneratePatches_,\n\t\tgenerateReplacementPatches_\n\t})\n}\n","import {\n\tIProduce,\n\tIProduceWithPatches,\n\tImmer,\n\tDraft,\n\tImmutable\n} from \"./internal\"\n\nexport {\n\tDraft,\n\tWritableDraft,\n\tImmutable,\n\tPatch,\n\tPatchListener,\n\tProducer,\n\toriginal,\n\tcurrent,\n\tisDraft,\n\tisDraftable,\n\tNOTHING as nothing,\n\tDRAFTABLE as immerable,\n\tfreeze,\n\tObjectish,\n\tStrictMode\n} from \"./internal\"\n\nconst immer = new Immer()\n\n/**\n * The `produce` function takes a value and a \"recipe function\" (whose\n * return value often depends on the base state). The recipe function is\n * free to mutate its first argument however it wants. All mutations are\n * only ever applied to a __copy__ of the base state.\n *\n * Pass only a function to create a \"curried producer\" which relieves you\n * from passing the recipe function every time.\n *\n * Only plain objects and arrays are made mutable. All other objects are\n * considered uncopyable.\n *\n * Note: This function is __bound__ to its `Immer` instance.\n *\n * @param {any} base - the initial state\n * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified\n * @param {Function} patchListener - optional function that will be called with all the patches produced here\n * @returns {any} a new state, or the initial state if nothing was modified\n */\nexport const produce: IProduce = immer.produce\n\n/**\n * Like `produce`, but `produceWithPatches` always returns a tuple\n * [nextState, patches, inversePatches] (instead of just the next state)\n */\nexport const produceWithPatches: IProduceWithPatches = immer.produceWithPatches.bind(\n\timmer\n)\n\n/**\n * Pass true to automatically freeze all copies created by Immer.\n *\n * Always freeze by default, even in production mode\n */\nexport const setAutoFreeze = immer.setAutoFreeze.bind(immer)\n\n/**\n * Pass true to enable strict shallow copy.\n *\n * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.\n */\nexport const setUseStrictShallowCopy = immer.setUseStrictShallowCopy.bind(immer)\n\n/**\n * Apply an array of Immer patches to the first argument.\n *\n * This function is a producer, which means copy-on-write is in effect.\n */\nexport const applyPatches = immer.applyPatches.bind(immer)\n\n/**\n * Create an Immer draft from the given base state, which may be a draft itself.\n * The draft can be modified until you finalize it with the `finishDraft` function.\n */\nexport const createDraft = immer.createDraft.bind(immer)\n\n/**\n * Finalize an Immer draft from a `createDraft` call, returning the base state\n * (if no changes were made) or a modified copy. The draft must *not* be\n * mutated afterwards.\n *\n * Pass a function as the 2nd argument to generate Immer patches based on the\n * changes that were made.\n */\nexport const finishDraft = immer.finishDraft.bind(immer)\n\n/**\n * This function is actually a no-op, but can be used to cast an immutable type\n * to an draft type and make TypeScript happy\n *\n * @param value\n */\nexport function castDraft<T>(value: T): Draft<T> {\n\treturn value as any\n}\n\n/**\n * This function is actually a no-op, but can be used to cast a mutable type\n * to an immutable type and make TypeScript happy\n * @param value\n */\nexport function castImmutable<T>(value: T): Immutable<T> {\n\treturn value as any\n}\n\nexport {Immer}\n\nexport {enablePatches} from \"./plugins/patches\"\nexport {enableMapSet} from \"./plugins/mapset\"\n"],"names":["obj","_extends","Object","assign","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","_react","require","_react2","__esModule","default","exports","_ref","_ref$fill","fill","undefined","_ref$width","width","_ref$height","height","_ref$style","style","props","keys","indexOf","_objectWithoutProperties","createElement","viewBox","d","uppercasePattern","msPattern","cache","toHyphenLower","match","toLowerCase","hyphenateStyleName","name","hName","replace","test","module","SLICE$0","Array","slice","createClass","ctor","superClass","create","constructor","Iterable","value","isIterable","Seq","KeyedIterable","isKeyed","KeyedSeq","IndexedIterable","isIndexed","IndexedSeq","SetIterable","isAssociative","SetSeq","maybeIterable","IS_ITERABLE_SENTINEL","maybeKeyed","IS_KEYED_SENTINEL","maybeIndexed","IS_INDEXED_SENTINEL","maybeAssociative","isOrdered","maybeOrdered","IS_ORDERED_SENTINEL","Keyed","Indexed","Set","DELETE","SHIFT","SIZE","MASK","NOT_SET","CHANGE_LENGTH","DID_ALTER","MakeRef","ref","SetRef","OwnerID","arrCopy","arr","offset","len","Math","max","newArr","ii","ensureSize","iter","size","__iterate","returnTrue","wrapIndex","index","uint32Index","NaN","wholeSlice","begin","end","resolveBegin","resolveIndex","resolveEnd","defaultIndex","min","ITERATE_KEYS","ITERATE_VALUES","ITERATE_ENTRIES","REAL_ITERATOR_SYMBOL","Symbol","iterator","FAUX_ITERATOR_SYMBOL","ITERATOR_SYMBOL","Iterator","next","this","iteratorValue","type","k","v","iteratorResult","done","iteratorDone","hasIterator","getIteratorFn","isIterator","maybeIterator","getIterator","iterable","iteratorFn","isArrayLike","emptySequence","toSeq","seqFromValue","toKeyedSeq","fromEntrySeq","keyedSeqFromValue","entrySeq","toIndexedSeq","indexedSeqFromValue","toSetSeq","toString","KEYS","VALUES","ENTRIES","inspect","toSource","of","__toString","cacheResult","_cache","__iterateUncached","toArray","fn","reverse","seqIterate","__iterator","seqIterator","isSeq","EMPTY_SEQ","EMPTY_REPEAT","EMPTY_RANGE","IS_SEQ_SENTINEL","ArraySeq","array","_array","ObjectSeq","object","_object","_keys","IterableSeq","_iterable","IteratorSeq","_iterator","_iteratorCache","maybeSeq","seq","isArray","TypeError","maybeIndexedSeqFromValue","useKeys","maxIndex","entry","__iteratorUncached","fromJS","json","converter","fromJSWith","fromJSDefault","parentJSON","map","isPlainObj","toList","toMap","is","valueA","valueB","valueOf","equals","deepEqual","a","b","__hash","notAssociative","entries","every","flipped","_","allEqual","bSize","has","get","Repeat","times","_value","Infinity","invariant","condition","error","Error","Range","start","step","abs","_start","_end","_step","ceil","Collection","KeyedCollection","IndexedCollection","SetCollection","notSetValue","iterations","val","includes","searchValue","lastIndexOf","this$0","other","possibleIndex","floor","offsetValue","imul","c","smi","i32","hash","o","h","STRING_HASH_CACHE_MIN_STRLEN","cachedHashString","hashString","hashCode","hashJSObj","string","stringHashCache","STRING_HASH_CACHE_SIZE","STRING_HASH_CACHE_MAX_SIZE","charCodeAt","usingWeakMap","weakMap","UID_HASH_KEY","canDefineProperty","propertyIsEnumerable","getIENodeHash","objHashUID","set","isExtensible","defineProperty","apply","nodeType","e","node","uniqueID","documentElement","WeakMap","assertNotInfinite","Map","emptyMap","isMap","withMutations","forEach","maybeMap","IS_MAP_SENTINEL","_root","updateMap","setIn","keyPath","updateIn","remove","deleteIn","update","updater","updatedValue","updateInDeepMap","forceIterator","clear","__ownerID","__altered","merge","mergeIntoMapWith","mergeWith","merger","mergeIn","iters","m","mergeDeep","deepMerger","mergeDeepWith","deepMergerWith","mergeDeepIn","sort","comparator","OrderedMap","sortFactory","sortBy","mapper","mutable","asMutable","wasAltered","__ensureOwner","asImmutable","MapIterator","iterate","ownerID","makeMap","EMPTY_MAP","MapPrototype","ArrayMapNode","BitmapIndexedNode","bitmap","nodes","HashArrayMapNode","count","HashCollisionNode","keyHash","ValueNode","_type","_reverse","_stack","mapIteratorFrame","mapIteratorValue","prev","__prev","root","newRoot","newSize","didChangeSize","didAlter","updateNode","shift","isLeafNode","mergeIntoNode","newNode","idx1","idx2","createNodes","packNodes","excluding","packedII","packedNodes","bit","expandNodes","including","expandedNodes","iterables","push","mergeIntoCollectionWith","existing","nextValue","collection","filter","x","mergeIntoMap","keyPathIter","isNotSet","existingValue","newValue","nextExisting","nextUpdated","popCount","idx","canEdit","newArray","spliceIn","newLen","after","spliceOut","pop","removeIn","removed","exists","MAX_ARRAY_MAP_SIZE","isEditable","newEntries","keyHashFrag","MAX_BITMAP_INDEXED_SIZE","newBitmap","newNodes","newCount","MIN_HASH_ARRAY_MAP_SIZE","keyMatch","stack","subNode","List","empty","emptyList","isList","makeList","VNode","list","setSize","maybeList","IS_LIST_SENTINEL","listNodeFor","_origin","updateList","splice","insert","_capacity","_level","_tail","values","oldSize","setListBounds","unshift","mergeIntoListWith","iterateList","DONE","ListPrototype","removeBefore","level","originIndex","newChild","removingFirst","oldChild","editable","editableVNode","removeAfter","sizeIndex","EMPTY_LIST","EMPTY_ORDERED_MAP","left","right","tailPos","getTailOffset","tail","iterateNodeOrLeaf","iterateLeaf","iterateNode","from","to","origin","capacity","newTail","updateVNode","nodeHas","lowerNode","newLowerNode","rawIndex","owner","oldOrigin","oldCapacity","newOrigin","newCapacity","newLevel","offsetShift","oldTailOffset","newTailOffset","oldTail","beginIndex","maxSize","emptyOrderedMap","isOrderedMap","maybeOrderedMap","makeOrderedMap","omap","_map","_list","updateOrderedMap","newMap","newList","flip","ToKeyedSequence","indexed","_iter","_useKeys","ToIndexedSequence","ToSetSequence","FromEntriesSequence","flipFactory","flipSequence","makeSequence","reversedSequence","cacheResultThrough","mapFactory","context","mappedSequence","reverseFactory","filterFactory","predicate","filterSequence","countByFactory","grouper","groups","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","stopped","flatDeep","currentDepth","flatMapFactory","interposeFactory","separator","interposedSequence","defaultComparator","maxFactory","maxCompare","comp","zipWithFactory","keyIter","zipper","zipSequence","iterators","isDone","steps","some","s","validateEntry","resolveSize","Record","defaultValues","hasInitialized","RecordType","setProps","RecordTypePrototype","_name","_defaultValues","RecordPrototype","valueSeq","indexedIterable","recordName","defaultVal","_empty","makeRecord","likeRecord","record","getPrototypeOf","names","setProp","bind","emptySet","isSet","add","maybeSet","IS_SET_SENTINEL","fromKeys","keySeq","updateSet","union","intersect","originalSet","subtract","OrderedSet","__make","EMPTY_SET","SetPrototype","__empty","makeSet","emptyOrderedSet","isOrderedSet","maybeOrderedSet","EMPTY_ORDERED_SET","OrderedSetPrototype","makeOrderedSet","Stack","emptyStack","isStack","unshiftAll","maybeStack","IS_STACK_SENTINEL","head","_head","peek","makeStack","pushAll","EMPTY_STACK","StackPrototype","mixin","methods","keyCopier","getOwnPropertySymbols","toJS","__toJS","toJSON","toObject","toOrderedMap","toOrderedSet","toSet","toStack","__toStringMapper","join","returnValue","find","findEntry","found","findLastEntry","sideEffect","joined","isFirst","reducer","initialReduction","reduction","useFirst","reduceRight","reversed","not","butLast","isEmpty","countBy","entriesSequence","entryMapper","filterNot","findLast","first","flatMap","searchKey","getIn","searchKeyPath","nested","groupBy","hasIn","isSubset","isSuperset","keyMapper","last","maxBy","neg","defaultNegComparator","minBy","rest","skip","amount","skipLast","skipWhile","skipUntil","take","takeLast","takeWhile","takeUntil","hashIterable","IterablePrototype","quoteString","chain","contains","noLengthWarning","console","warn","findKey","findLastKey","keyOf","lastKeyOf","mapEntries","mapKeys","KeyedIterablePrototype","JSON","stringify","defaultZipper","ordered","keyed","murmurHashOfSize","hashMerge","findIndex","removeNum","numArgs","spliced","findLastIndex","interpose","interleave","zipped","interleaved","zip","zipWith","factory","format","f","args","argIndex","framesToPop","NOTHING","for","DRAFTABLE","DRAFT_STATE","die","isDraft","isDraftable","_value$constructor","isPlainObject","objectCtorString","proto","Ctor","Function","original","base_","each","getArchtype","Reflect","ownKeys","thing","state","type_","prop","propOrOldValue","t","latest","copy_","shallowCopy","base","strict","isPlain","descriptors","getOwnPropertyDescriptors","desc","writable","configurable","enumerable","_objectSpread","freeze","deep","isFrozen","delete","dontMutateFrozenCollections","currentScope","plugins","getPlugin","pluginKey","plugin","loadPlugin","implementation","getCurrentScope","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","drafts_","revokeDraft","parent_","enterScope","immer2","immer_","canAutoFreeze_","unfinalizedDrafts_","draft","revoke_","revoked_","processResult","result","baseDraft","modified_","finalize","maybeFreeze","generateReplacementPatches_","rootScope","path","childValue","finalizeProperty","scope_","finalized_","resultEach","isSet2","generatePatches_","parentState","targetObject","rootPath","targetIsSet","res","assigned_","autoFreeze_","objectTraps","_desc$get","getDescriptorFromProto","draft_","readPropFromProto","prepareCopy","createProxy","current2","currentState","y","markChanged","Number","isNaN","deleteProperty","getOwnPropertyDescriptor","setPrototypeOf","arrayTraps","useStrictShallowCopy_","parent","proxyMap_","proxySet_","isManual_","traps","revoke","proxy","Proxy","revocable","createProxyProxy","currentImpl","copy","enablePatches","REPLACE","ADD","REMOVE","deepClonePatchValue","_ref2","cloned","clonePatchValueIfNeeded","applyPatches_","patches","patch","op","parentType","p","errorOffset","basePath","inversePatches","assignedValue","origValue","generatePatchesFromAssigned","generateArrayPatches","generateSetPatches","baseValue","replacement","immer","config","_this","produce","recipe","defaultBase","self","base2","_len2","_key2","hasError","ip","produceWithPatches","_len3","_key3","autoFreeze","setAutoFreeze","useStrictShallowCopy","setUseStrictShallowCopy","createDraft","current","finishDraft","applyPatches","applyPatchesImpl"],"sourceRoot":""}