{"version":3,"file":"static/js/1713.c682aab2.chunk.js","mappings":"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","sources":["../node_modules/reselect/es/defaultMemoize.js","../node_modules/reselect/es/index.js","../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/es5.ts","../node_modules/immer/src/plugins/patches.ts","../node_modules/immer/src/immer.ts","../node_modules/immer/src/utils/env.ts"],"sourcesContent":["// Cache implementation based on Erik Rasmussen's `lru-memoize`:\n// https://github.com/erikras/lru-memoize\nvar NOT_FOUND = 'NOT_FOUND';\n\nfunction createSingletonCache(equals) {\n  var entry;\n  return {\n    get: function get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n\n      return NOT_FOUND;\n    },\n    put: function put(key, value) {\n      entry = {\n        key: key,\n        value: value\n      };\n    },\n    getEntries: function getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear: function clear() {\n      entry = undefined;\n    }\n  };\n}\n\nfunction createLruCache(maxSize, equals) {\n  var entries = [];\n\n  function get(key) {\n    var cacheIndex = entries.findIndex(function (entry) {\n      return equals(key, entry.key);\n    }); // We found a cached entry\n\n    if (cacheIndex > -1) {\n      var entry = entries[cacheIndex]; // Cached entry not at top of cache, move it to the top\n\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n\n      return entry.value;\n    } // No entry found in cache, return sentinel\n\n\n    return NOT_FOUND;\n  }\n\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      // TODO Is unshift slow?\n      entries.unshift({\n        key: key,\n        value: value\n      });\n\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n\n  function getEntries() {\n    return entries;\n  }\n\n  function clear() {\n    entries = [];\n  }\n\n  return {\n    get: get,\n    put: put,\n    getEntries: getEntries,\n    clear: clear\n  };\n}\n\nexport var defaultEqualityCheck = function defaultEqualityCheck(a, b) {\n  return a === b;\n};\nexport function createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    } // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.\n\n\n    var length = prev.length;\n\n    for (var i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n// defaultMemoize now supports a configurable cache size with LRU behavior,\n// and optional comparison of the result value with existing values\nexport function defaultMemoize(func, equalityCheckOrOptions) {\n  var providedOptions = typeof equalityCheckOrOptions === 'object' ? equalityCheckOrOptions : {\n    equalityCheck: equalityCheckOrOptions\n  };\n  var _providedOptions$equa = providedOptions.equalityCheck,\n      equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa,\n      _providedOptions$maxS = providedOptions.maxSize,\n      maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS,\n      resultEqualityCheck = providedOptions.resultEqualityCheck;\n  var comparator = createCacheKeyComparator(equalityCheck);\n  var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator); // we reference arguments instead of spreading them for performance reasons\n\n  function memoized() {\n    var value = cache.get(arguments);\n\n    if (value === NOT_FOUND) {\n      // @ts-ignore\n      value = func.apply(null, arguments);\n\n      if (resultEqualityCheck) {\n        var entries = cache.getEntries();\n        var matchingEntry = entries.find(function (entry) {\n          return resultEqualityCheck(entry.value, value);\n        });\n\n        if (matchingEntry) {\n          value = matchingEntry.value;\n        }\n      }\n\n      cache.put(arguments, value);\n    }\n\n    return value;\n  }\n\n  memoized.clearCache = function () {\n    return cache.clear();\n  };\n\n  return memoized;\n}","import { defaultMemoize, defaultEqualityCheck } from './defaultMemoize';\nexport { defaultMemoize, defaultEqualityCheck };\n\nfunction getDependencies(funcs) {\n  var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;\n\n  if (!dependencies.every(function (dep) {\n    return typeof dep === 'function';\n  })) {\n    var dependencyTypes = dependencies.map(function (dep) {\n      return typeof dep === 'function' ? \"function \" + (dep.name || 'unnamed') + \"()\" : typeof dep;\n    }).join(', ');\n    throw new Error(\"createSelector expects all input-selectors to be functions, but received the following types: [\" + dependencyTypes + \"]\");\n  }\n\n  return dependencies;\n}\n\nexport function createSelectorCreator(memoize) {\n  for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    memoizeOptionsFromArgs[_key - 1] = arguments[_key];\n  }\n\n  var createSelector = function createSelector() {\n    for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      funcs[_key2] = arguments[_key2];\n    }\n\n    var _recomputations = 0;\n\n    var _lastResult; // Due to the intricacies of rest params, we can't do an optional arg after `...funcs`.\n    // So, start by declaring the default value here.\n    // (And yes, the words 'memoize' and 'options' appear too many times in this next sequence.)\n\n\n    var directlyPassedOptions = {\n      memoizeOptions: undefined\n    }; // Normally, the result func or \"output selector\" is the last arg\n\n    var resultFunc = funcs.pop(); // If the result func is actually an _object_, assume it's our options object\n\n    if (typeof resultFunc === 'object') {\n      directlyPassedOptions = resultFunc; // and pop the real result func off\n\n      resultFunc = funcs.pop();\n    }\n\n    if (typeof resultFunc !== 'function') {\n      throw new Error(\"createSelector expects an output function after the inputs, but received: [\" + typeof resultFunc + \"]\");\n    } // Determine which set of options we're using. Prefer options passed directly,\n    // but fall back to options given to createSelectorCreator.\n\n\n    var _directlyPassedOption = directlyPassedOptions,\n        _directlyPassedOption2 = _directlyPassedOption.memoizeOptions,\n        memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2; // Simplifying assumption: it's unlikely that the first options arg of the provided memoizer\n    // is an array. In most libs I've looked at, it's an equality function or options object.\n    // Based on that, if `memoizeOptions` _is_ an array, we assume it's a full\n    // user-provided array of options. Otherwise, it must be just the _first_ arg, and so\n    // we wrap it in an array so we can apply it.\n\n    var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions];\n    var dependencies = getDependencies(funcs);\n    var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() {\n      _recomputations++; // apply arguments instead of spreading for performance.\n\n      return resultFunc.apply(null, arguments);\n    }].concat(finalMemoizeOptions)); // If a selector is called with the exact same arguments we don't need to traverse our dependencies again.\n\n    var selector = memoize(function dependenciesChecker() {\n      var params = [];\n      var length = dependencies.length;\n\n      for (var i = 0; i < length; i++) {\n        // apply arguments instead of spreading and mutate a local list of params for performance.\n        // @ts-ignore\n        params.push(dependencies[i].apply(null, arguments));\n      } // apply arguments instead of spreading for performance.\n\n\n      _lastResult = memoizedResultFunc.apply(null, params);\n      return _lastResult;\n    });\n    Object.assign(selector, {\n      resultFunc: resultFunc,\n      memoizedResultFunc: memoizedResultFunc,\n      dependencies: dependencies,\n      lastResult: function lastResult() {\n        return _lastResult;\n      },\n      recomputations: function recomputations() {\n        return _recomputations;\n      },\n      resetRecomputations: function resetRecomputations() {\n        return _recomputations = 0;\n      }\n    });\n    return selector;\n  }; // @ts-ignore\n\n\n  return createSelector;\n}\nexport var createSelector = /* #__PURE__ */createSelectorCreator(defaultMemoize);\n// Manual definition of state and output arguments\nexport var createStructuredSelector = function createStructuredSelector(selectors, selectorCreator) {\n  if (selectorCreator === void 0) {\n    selectorCreator = createSelector;\n  }\n\n  if (typeof selectors !== 'object') {\n    throw new Error('createStructuredSelector expects first argument to be an object ' + (\"where each property is a selector, instead received a \" + typeof selectors));\n  }\n\n  var objectKeys = Object.keys(selectors);\n  var resultSelector = selectorCreator( // @ts-ignore\n  objectKeys.map(function (key) {\n    return selectors[key];\n  }), function () {\n    for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      values[_key3] = arguments[_key3];\n    }\n\n    return values.reduce(function (composition, value, index) {\n      composition[objectKeys[index]] = value;\n      return composition;\n    }, {});\n  });\n  return resultSelector;\n};","const errors = {\n\t0: \"Illegal state\",\n\t1: \"Immer drafts cannot have computed properties\",\n\t2: \"This object has been frozen and should not be mutated\",\n\t3(data: any) {\n\t\treturn (\n\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\tdata\n\t\t)\n\t},\n\t4: \"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\",\n\t5: \"Immer forbids circular references\",\n\t6: \"The first or second argument to `produce` must be a function\",\n\t7: \"The third argument to `produce` must be a function or undefined\",\n\t8: \"First argument to `createDraft` must be a plain object, an array, or an immerable object\",\n\t9: \"First argument to `finishDraft` must be a draft returned by `createDraft`\",\n\t10: \"The given draft is already finalized\",\n\t11: \"Object.defineProperty() cannot be used on an Immer draft\",\n\t12: \"Object.setPrototypeOf() cannot be used on an Immer draft\",\n\t13: \"Immer only supports deleting array indices\",\n\t14: \"Immer only supports setting array indices and the 'length' property\",\n\t15(path: string) {\n\t\treturn \"Cannot apply patch, path doesn't resolve: \" + path\n\t},\n\t16: 'Sets cannot have \"replace\" patches.',\n\t17(op: string) {\n\t\treturn \"Unsupported patch operation: \" + op\n\t},\n\t18(plugin: string) {\n\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},\n\t20: \"Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available\",\n\t21(thing: string) {\n\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},\n\t22(thing: string) {\n\t\treturn `'current' expects a draft, got: ${thing}`\n\t},\n\t23(thing: string) {\n\t\treturn `'original' expects a draft, got: ${thing}`\n\t},\n\t24: \"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"\n} as const\n\nexport function die(error: keyof typeof errors, ...args: any[]): never {\n\tif (__DEV__) {\n\t\tconst e = errors[error]\n\t\tconst msg = !e\n\t\t\t? \"unknown error nr: \" + error\n\t\t\t: typeof e === \"function\"\n\t\t\t? e.apply(null, args as any)\n\t\t\t: e\n\t\tthrow new Error(`[Immer] ${msg}`)\n\t}\n\tthrow new Error(\n\t\t`[Immer] minified error nr: ${error}${\n\t\t\targs.length ? \" \" + args.map(s => `'${s}'`).join(\",\") : \"\"\n\t\t}. Find the full error at: https://bit.ly/3cXEKWf`\n\t)\n}\n","import {\n\tDRAFT_STATE,\n\tDRAFTABLE,\n\thasSet,\n\tObjectish,\n\tDrafted,\n\tAnyObject,\n\tAnyMap,\n\tAnySet,\n\tImmerState,\n\thasMap,\n\tArchtype,\n\tdie\n} from \"../internal\"\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 = Object.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(23, value)\n\treturn value[DRAFT_STATE].base_\n}\n\n/*#__PURE__*/\nexport const ownKeys: (target: AnyObject) => PropertyKey[] =\n\ttypeof Reflect !== \"undefined\" && Reflect.ownKeys\n\t\t? Reflect.ownKeys\n\t\t: typeof Object.getOwnPropertySymbols !== \"undefined\"\n\t\t? obj =>\n\t\t\t\tObject.getOwnPropertyNames(obj).concat(\n\t\t\t\t\tObject.getOwnPropertySymbols(obj) as any\n\t\t\t\t)\n\t\t: /* istanbul ignore next */ Object.getOwnPropertyNames\n\nexport const getOwnPropertyDescriptors =\n\tObject.getOwnPropertyDescriptors ||\n\tfunction getOwnPropertyDescriptors(target: any) {\n\t\t// Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274\n\t\tconst res: any = {}\n\t\townKeys(target).forEach(key => {\n\t\t\tres[key] = Object.getOwnPropertyDescriptor(target, key)\n\t\t})\n\t\treturn res\n\t}\n\nexport function each<T extends Objectish>(\n\tobj: T,\n\titer: (key: string | number, value: any, source: T) => void,\n\tenumerableOnly?: boolean\n): void\nexport function each(obj: any, iter: any, enumerableOnly = false) {\n\tif (getArchtype(obj) === Archtype.Object) {\n\t\t;(enumerableOnly ? Object.keys : ownKeys)(obj).forEach(key => {\n\t\t\tif (!enumerableOnly || typeof key !== \"symbol\") iter(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\t/* istanbul ignore next */\n\tconst state: undefined | ImmerState = thing[DRAFT_STATE]\n\treturn state\n\t\t? state.type_ > 3\n\t\t\t? state.type_ - 4 // cause Object and Array map back from 4 and 5\n\t\t\t: (state.type_ as any) // others are the same\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 hasMap && target instanceof Map\n}\n\n/*#__PURE__*/\nexport function isSet(target: any): target is AnySet {\n\treturn hasSet && 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) {\n\tif (Array.isArray(base)) return Array.prototype.slice.call(base)\n\tconst descriptors = getOwnPropertyDescriptors(base)\n\tdelete descriptors[DRAFT_STATE as any]\n\tlet keys = ownKeys(descriptors)\n\tfor (let i = 0; i < keys.length; i++) {\n\t\tconst key: any = keys[i]\n\t\tconst desc = descriptors[key]\n\t\tif (desc.writable === false) {\n\t\t\tdesc.writable = true\n\t\t\tdesc.configurable = true\n\t\t}\n\t\t// like object.assign, we will read any _own_, get/set accessors. This helps in dealing\n\t\t// with libraries that trap values, like mobx or vue\n\t\t// unlike object.assign, non-enumerables will be copied as well\n\t\tif (desc.get || desc.set)\n\t\t\tdescriptors[key] = {\n\t\t\t\tconfigurable: true,\n\t\t\t\twritable: true, // could live with !!desc.set as well here...\n\t\t\t\tenumerable: desc.enumerable,\n\t\t\t\tvalue: base[key]\n\t\t\t}\n\t}\n\treturn Object.create(Object.getPrototypeOf(base), descriptors)\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) each(obj, (key, value) => freeze(value, true), true)\n\treturn obj\n}\n\nfunction dontMutateFrozenCollections() {\n\tdie(2)\n}\n\nexport function isFrozen(obj: any): boolean {\n\tif (obj == null || typeof obj !== \"object\") return true\n\t// See #600, IE dies on non-objects in Object.isFrozen\n\treturn Object.isFrozen(obj)\n}\n","import {\n\tImmerState,\n\tPatch,\n\tImmerScope,\n\tDrafted,\n\tAnyObject,\n\tImmerBaseState,\n\tAnyMap,\n\tAnySet,\n\tProxyType,\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: Patch[]): T\n\t}\n\tES5?: {\n\t\twillFinalizeES5_(scope: ImmerScope, result: any, isReplaced: boolean): void\n\t\tcreateES5Proxy_<T>(\n\t\t\tbase: T,\n\t\t\tparent?: ImmerState\n\t\t): Drafted<T, ES5ObjectState | ES5ArrayState>\n\t\thasChanges_(state: ES5ArrayState | ES5ObjectState): boolean\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(18, 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\n/** ES5 Plugin */\n\ninterface ES5BaseState extends ImmerBaseState {\n\tassigned_: {[key: string]: any}\n\tparent_?: ImmerState\n\trevoked_: boolean\n}\n\nexport interface ES5ObjectState extends ES5BaseState {\n\ttype_: ProxyType.ES5Object\n\tdraft_: Drafted<AnyObject, ES5ObjectState>\n\tbase_: AnyObject\n\tcopy_: AnyObject | null\n}\n\nexport interface ES5ArrayState extends ES5BaseState {\n\ttype_: ProxyType.ES5Array\n\tdraft_: Drafted<AnyObject, ES5ArrayState>\n\tbase_: any\n\tcopy_: any\n}\n\n/** Map / Set plugin */\n\nexport interface MapState extends ImmerBaseState {\n\ttype_: ProxyType.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_: ProxyType.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\tProxyType,\n\tgetPlugin\n} from \"../internal\"\nimport {die} from \"../utils/errors\"\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\tif (__DEV__ && !currentScope) die(0)\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 (\n\t\tstate.type_ === ProxyType.ProxyObject ||\n\t\tstate.type_ === ProxyType.ProxyArray\n\t)\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\tProxyType,\n\tgetPlugin,\n\tdie,\n\trevokeScope,\n\tisFrozen,\n\tshallowCopy\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 (!scope.immer_.useProxies_)\n\t\tgetPlugin(\"ES5\").willFinalizeES5_(scope, result, isReplaced)\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(\n\t\t\tvalue,\n\t\t\t(key, childValue) =>\n\t\t\t\tfinalizeProperty(rootScope, state, value, key, childValue, path),\n\t\t\ttrue // See #590, don't recurse into non-enumerable of non drafted objects\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 =\n\t\t\t// For ES5, create a good copy from the draft first, with added keys and without deleted keys.\n\t\t\tstate.type_ === ProxyType.ES5Object || state.type_ === ProxyType.ES5Array\n\t\t\t\t? (state.copy_ = shallowCopy(state.draft_))\n\t\t\t\t: 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_ === ProxyType.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 (__DEV__ && childValue === targetObject) die(5)\n\tif (isDraft(childValue)) {\n\t\tconst path =\n\t\t\trootPath &&\n\t\t\tparentState &&\n\t\t\tparentState!.type_ !== ProxyType.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\tif (!parentState || !parentState.scope_.parent_)\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\tDRAFT_STATE,\n\tdie,\n\tcreateProxy,\n\tProxyType\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_: ProxyType.ProxyObject\n\tbase_: any\n\tcopy_: any\n\tdraft_: Drafted<AnyObject, ProxyObjectState>\n}\n\nexport interface ProxyArrayState extends ProxyBaseState {\n\ttype_: ProxyType.ProxyArray\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 ? ProxyType.ProxyArray : (ProxyType.ProxyObject 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(\n\t\t\t\tstate.scope_.immer_,\n\t\t\t\tvalue,\n\t\t\t\tstate\n\t\t\t))\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\t// @ts-ignore\n\t\tif (state.copy_) delete state.copy_[prop]\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_ !== ProxyType.ProxyArray || 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 Object.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 (__DEV__ && isNaN(parseInt(prop as any))) die(13)\n\t// @ts-ignore\n\treturn arrayTraps.set!.call(this, state, prop, undefined)\n}\narrayTraps.set = function(state, prop, value) {\n\tif (__DEV__ && prop !== \"length\" && isNaN(parseInt(prop as any))) die(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 = Object.getPrototypeOf(source)\n\twhile (proto) {\n\t\tconst desc = Object.getOwnPropertyDescriptor(proto, prop)\n\t\tif (desc) return desc\n\t\tproto = Object.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: {base_: any; copy_: any}) {\n\tif (!state.copy_) {\n\t\tstate.copy_ = shallowCopy(state.base_)\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\thasProxies,\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 class Immer implements ProducersFns {\n\tuseProxies_: boolean = hasProxies\n\n\tautoFreeze_: boolean = true\n\n\tconstructor(config?: {useProxies?: boolean; autoFreeze?: boolean}) {\n\t\tif (typeof config?.useProxies === \"boolean\")\n\t\t\tthis.setUseProxies(config!.useProxies)\n\t\tif (typeof config?.autoFreeze === \"boolean\")\n\t\t\tthis.setAutoFreeze(config!.autoFreeze)\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(this, 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\tif (typeof Promise !== \"undefined\" && result instanceof Promise) {\n\t\t\t\treturn result.then(\n\t\t\t\t\tresult => {\n\t\t\t\t\t\tusePatchesInScope(scope, patchListener)\n\t\t\t\t\t\treturn processResult(result, scope)\n\t\t\t\t\t},\n\t\t\t\t\terror => {\n\t\t\t\t\t\trevokeScope(scope)\n\t\t\t\t\t\tthrow error\n\t\t\t\t\t}\n\t\t\t\t)\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(21, 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\n\t\tif (typeof Promise !== \"undefined\" && result instanceof Promise) {\n\t\t\treturn result.then(nextState => [nextState, patches!, inversePatches!])\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(this, 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 (__DEV__) {\n\t\t\tif (!state || !state.isManual_) die(9)\n\t\t\tif (state.finalized_) die(10)\n\t\t}\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 use the ES2015 `Proxy` class when creating drafts, which is\n\t * always faster than using ES5 proxies.\n\t *\n\t * By default, feature detection is used, so calling this is rarely necessary.\n\t */\n\tsetUseProxies(value: boolean) {\n\t\tif (value && !hasProxies) {\n\t\t\tdie(20)\n\t\t}\n\t\tthis.useProxies_ = value\n\t}\n\n\tapplyPatches<T extends Objectish>(base: T, patches: 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\timmer: Immer,\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: immer.useProxies_\n\t\t? createProxyProxy(value, parent)\n\t\t: getPlugin(\"ES5\").createES5Proxy_(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\tget,\n\tset,\n\tImmerState,\n\tisDraftable,\n\tArchtype,\n\tgetArchtype,\n\tgetPlugin\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(22, value)\n\treturn currentImpl(value)\n}\n\nfunction currentImpl(value: any): any {\n\tif (!isDraftable(value)) return value\n\tconst state: ImmerState | undefined = value[DRAFT_STATE]\n\tlet copy: any\n\tconst archType = getArchtype(value)\n\tif (state) {\n\t\tif (\n\t\t\t!state.modified_ &&\n\t\t\t(state.type_ < 4 || !getPlugin(\"ES5\").hasChanges_(state as any))\n\t\t)\n\t\t\treturn state.base_\n\t\t// Optimization: avoid generating new drafts during copying\n\t\tstate.finalized_ = true\n\t\tcopy = copyHelper(value, archType)\n\t\tstate.finalized_ = false\n\t} else {\n\t\tcopy = copyHelper(value, archType)\n\t}\n\n\teach(copy, (key, childValue) => {\n\t\tif (state && get(state.base_, key) === childValue) return // no need to copy or search in something that didn't change\n\t\tset(copy, key, currentImpl(childValue))\n\t})\n\t// In the future, we might consider freezing here, based on the current settings\n\treturn archType === Archtype.Set ? new Set(copy) : copy\n}\n\nfunction copyHelper(value: any, archType: number): any {\n\t// creates a shallow copy, even if it is a map or set\n\tswitch (archType) {\n\t\tcase Archtype.Map:\n\t\t\treturn new Map(value)\n\t\tcase Archtype.Set:\n\t\t\t// Set will be cloned as array temporarily, so that we can replace individual items\n\t\t\treturn Array.from(value)\n\t}\n\treturn shallowCopy(value)\n}\n","import {\n\tImmerState,\n\tDrafted,\n\tES5ArrayState,\n\tES5ObjectState,\n\teach,\n\thas,\n\tisDraft,\n\tlatest,\n\tDRAFT_STATE,\n\tis,\n\tloadPlugin,\n\tImmerScope,\n\tProxyType,\n\tgetCurrentScope,\n\tdie,\n\tmarkChanged,\n\tobjectTraps,\n\townKeys,\n\tgetOwnPropertyDescriptors\n} from \"../internal\"\n\ntype ES5State = ES5ArrayState | ES5ObjectState\n\nexport function enableES5() {\n\tfunction willFinalizeES5_(\n\t\tscope: ImmerScope,\n\t\tresult: any,\n\t\tisReplaced: boolean\n\t) {\n\t\tif (!isReplaced) {\n\t\t\tif (scope.patches_) {\n\t\t\t\tmarkChangesRecursively(scope.drafts_![0])\n\t\t\t}\n\t\t\t// This is faster when we don't care about which attributes changed.\n\t\t\tmarkChangesSweep(scope.drafts_)\n\t\t}\n\t\t// When a child draft is returned, look for changes.\n\t\telse if (\n\t\t\tisDraft(result) &&\n\t\t\t(result[DRAFT_STATE] as ES5State).scope_ === scope\n\t\t) {\n\t\t\tmarkChangesSweep(scope.drafts_)\n\t\t}\n\t}\n\n\tfunction createES5Draft(isArray: boolean, base: any) {\n\t\tif (isArray) {\n\t\t\tconst draft = new Array(base.length)\n\t\t\tfor (let i = 0; i < base.length; i++)\n\t\t\t\tObject.defineProperty(draft, \"\" + i, proxyProperty(i, true))\n\t\t\treturn draft\n\t\t} else {\n\t\t\tconst descriptors = getOwnPropertyDescriptors(base)\n\t\t\tdelete descriptors[DRAFT_STATE as any]\n\t\t\tconst keys = ownKeys(descriptors)\n\t\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\t\tconst key: any = keys[i]\n\t\t\t\tdescriptors[key] = proxyProperty(\n\t\t\t\t\tkey,\n\t\t\t\t\tisArray || !!descriptors[key].enumerable\n\t\t\t\t)\n\t\t\t}\n\t\t\treturn Object.create(Object.getPrototypeOf(base), descriptors)\n\t\t}\n\t}\n\n\tfunction createES5Proxy_<T>(\n\t\tbase: T,\n\t\tparent?: ImmerState\n\t): Drafted<T, ES5ObjectState | ES5ArrayState> {\n\t\tconst isArray = Array.isArray(base)\n\t\tconst draft = createES5Draft(isArray, base)\n\n\t\tconst state: ES5ObjectState | ES5ArrayState = {\n\t\t\ttype_: isArray ? ProxyType.ES5Array : (ProxyType.ES5Object as any),\n\t\t\tscope_: parent ? parent.scope_ : getCurrentScope(),\n\t\t\tmodified_: false,\n\t\t\tfinalized_: false,\n\t\t\tassigned_: {},\n\t\t\tparent_: parent,\n\t\t\t// base is the object we are drafting\n\t\t\tbase_: base,\n\t\t\t// draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified)\n\t\t\tdraft_: draft,\n\t\t\tcopy_: null,\n\t\t\trevoked_: false,\n\t\t\tisManual_: false\n\t\t}\n\n\t\tObject.defineProperty(draft, DRAFT_STATE, {\n\t\t\tvalue: state,\n\t\t\t// enumerable: false <- the default\n\t\t\twritable: true\n\t\t})\n\t\treturn draft\n\t}\n\n\t// property descriptors are recycled to make sure we don't create a get and set closure per property,\n\t// but share them all instead\n\tconst descriptors: {[prop: string]: PropertyDescriptor} = {}\n\n\tfunction proxyProperty(\n\t\tprop: string | number,\n\t\tenumerable: boolean\n\t): PropertyDescriptor {\n\t\tlet desc = descriptors[prop]\n\t\tif (desc) {\n\t\t\tdesc.enumerable = enumerable\n\t\t} else {\n\t\t\tdescriptors[prop] = desc = {\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable,\n\t\t\t\tget(this: any) {\n\t\t\t\t\tconst state = this[DRAFT_STATE]\n\t\t\t\t\tif (__DEV__) assertUnrevoked(state)\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\treturn objectTraps.get(state, prop)\n\t\t\t\t},\n\t\t\t\tset(this: any, value) {\n\t\t\t\t\tconst state = this[DRAFT_STATE]\n\t\t\t\t\tif (__DEV__) assertUnrevoked(state)\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tobjectTraps.set(state, prop, value)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn desc\n\t}\n\n\t// This looks expensive, but only proxies are visited, and only objects without known changes are scanned.\n\tfunction markChangesSweep(drafts: Drafted<any, ImmerState>[]) {\n\t\t// The natural order of drafts in the `scope` array is based on when they\n\t\t// were accessed. By processing drafts in reverse natural order, we have a\n\t\t// better chance of processing leaf nodes first. When a leaf node is known to\n\t\t// have changed, we can avoid any traversal of its ancestor nodes.\n\t\tfor (let i = drafts.length - 1; i >= 0; i--) {\n\t\t\tconst state: ES5State = drafts[i][DRAFT_STATE]\n\t\t\tif (!state.modified_) {\n\t\t\t\tswitch (state.type_) {\n\t\t\t\t\tcase ProxyType.ES5Array:\n\t\t\t\t\t\tif (hasArrayChanges(state)) markChanged(state)\n\t\t\t\t\t\tbreak\n\t\t\t\t\tcase ProxyType.ES5Object:\n\t\t\t\t\t\tif (hasObjectChanges(state)) markChanged(state)\n\t\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tfunction markChangesRecursively(object: any) {\n\t\tif (!object || typeof object !== \"object\") return\n\t\tconst state: ES5State | undefined = object[DRAFT_STATE]\n\t\tif (!state) return\n\t\tconst {base_, draft_, assigned_, type_} = state\n\t\tif (type_ === ProxyType.ES5Object) {\n\t\t\t// Look for added keys.\n\t\t\t// probably there is a faster way to detect changes, as sweep + recurse seems to do some\n\t\t\t// unnecessary work.\n\t\t\t// also: probably we can store the information we detect here, to speed up tree finalization!\n\t\t\teach(draft_, key => {\n\t\t\t\tif ((key as any) === DRAFT_STATE) return\n\t\t\t\t// The `undefined` check is a fast path for pre-existing keys.\n\t\t\t\tif ((base_ as any)[key] === undefined && !has(base_, key)) {\n\t\t\t\t\tassigned_[key] = true\n\t\t\t\t\tmarkChanged(state)\n\t\t\t\t} else if (!assigned_[key]) {\n\t\t\t\t\t// Only untouched properties trigger recursion.\n\t\t\t\t\tmarkChangesRecursively(draft_[key])\n\t\t\t\t}\n\t\t\t})\n\t\t\t// Look for removed keys.\n\t\t\teach(base_, key => {\n\t\t\t\t// The `undefined` check is a fast path for pre-existing keys.\n\t\t\t\tif (draft_[key] === undefined && !has(draft_, key)) {\n\t\t\t\t\tassigned_[key] = false\n\t\t\t\t\tmarkChanged(state)\n\t\t\t\t}\n\t\t\t})\n\t\t} else if (type_ === ProxyType.ES5Array) {\n\t\t\tif (hasArrayChanges(state as ES5ArrayState)) {\n\t\t\t\tmarkChanged(state)\n\t\t\t\tassigned_.length = true\n\t\t\t}\n\n\t\t\tif (draft_.length < base_.length) {\n\t\t\t\tfor (let i = draft_.length; i < base_.length; i++) assigned_[i] = false\n\t\t\t} else {\n\t\t\t\tfor (let i = base_.length; i < draft_.length; i++) assigned_[i] = true\n\t\t\t}\n\n\t\t\t// Minimum count is enough, the other parts has been processed.\n\t\t\tconst min = Math.min(draft_.length, base_.length)\n\n\t\t\tfor (let i = 0; i < min; i++) {\n\t\t\t\t// Only untouched indices trigger recursion.\n\t\t\t\tif (!draft_.hasOwnProperty(i)) {\n\t\t\t\t\tassigned_[i] = true\n\t\t\t\t}\n\t\t\t\tif (assigned_[i] === undefined) markChangesRecursively(draft_[i])\n\t\t\t}\n\t\t}\n\t}\n\n\tfunction hasObjectChanges(state: ES5ObjectState) {\n\t\tconst {base_, draft_} = state\n\n\t\t// Search for added keys and changed keys. Start at the back, because\n\t\t// non-numeric keys are ordered by time of definition on the object.\n\t\tconst keys = ownKeys(draft_)\n\t\tfor (let i = keys.length - 1; i >= 0; i--) {\n\t\t\tconst key: any = keys[i]\n\t\t\tif (key === DRAFT_STATE) continue\n\t\t\tconst baseValue = base_[key]\n\t\t\t// The `undefined` check is a fast path for pre-existing keys.\n\t\t\tif (baseValue === undefined && !has(base_, key)) {\n\t\t\t\treturn true\n\t\t\t}\n\t\t\t// Once a base key is deleted, future changes go undetected, because its\n\t\t\t// descriptor is erased. This branch detects any missed changes.\n\t\t\telse {\n\t\t\t\tconst value = draft_[key]\n\t\t\t\tconst state: ImmerState = value && value[DRAFT_STATE]\n\t\t\t\tif (state ? state.base_ !== baseValue : !is(value, baseValue)) {\n\t\t\t\t\treturn true\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// At this point, no keys were added or changed.\n\t\t// Compare key count to determine if keys were deleted.\n\t\tconst baseIsDraft = !!base_[DRAFT_STATE as any]\n\t\treturn keys.length !== ownKeys(base_).length + (baseIsDraft ? 0 : 1) // + 1 to correct for DRAFT_STATE\n\t}\n\n\tfunction hasArrayChanges(state: ES5ArrayState) {\n\t\tconst {draft_} = state\n\t\tif (draft_.length !== state.base_.length) return true\n\t\t// See #116\n\t\t// If we first shorten the length, our array interceptors will be removed.\n\t\t// If after that new items are added, result in the same original length,\n\t\t// those last items will have no intercepting property.\n\t\t// So if there is no own descriptor on the last position, we know that items were removed and added\n\t\t// N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check\n\t\t// the last one\n\t\t// last descriptor can be not a trap, if the array was extended\n\t\tconst descriptor = Object.getOwnPropertyDescriptor(\n\t\t\tdraft_,\n\t\t\tdraft_.length - 1\n\t\t)\n\t\t// descriptor can be null, but only for newly created sparse arrays, eg. new Array(10)\n\t\tif (descriptor && !descriptor.get) return true\n\t\t// if we miss a property, it has been deleted, so array probobaly changed\n\t\tfor (let i = 0; i < draft_.length; i++) {\n\t\t\tif (!draft_.hasOwnProperty(i)) return true\n\t\t}\n\t\t// For all other cases, we don't have to compare, as they would have been picked up by the index setters\n\t\treturn false\n\t}\n\n\tfunction hasChanges_(state: ES5State) {\n\t\treturn state.type_ === ProxyType.ES5Object\n\t\t\t? hasObjectChanges(state)\n\t\t\t: hasArrayChanges(state)\n\t}\n\n\tfunction assertUnrevoked(state: any /*ES5State | MapState | SetState*/) {\n\t\tif (state.revoked_) die(3, JSON.stringify(latest(state)))\n\t}\n\n\tloadPlugin(\"ES5\", {\n\t\tcreateES5Proxy_,\n\t\twillFinalizeES5_,\n\t\thasChanges_\n\t})\n}\n","import {immerable} from \"../immer\"\nimport {\n\tImmerState,\n\tPatch,\n\tSetState,\n\tES5ArrayState,\n\tProxyArrayState,\n\tMapState,\n\tES5ObjectState,\n\tProxyObjectState,\n\tPatchPath,\n\tget,\n\teach,\n\thas,\n\tgetArchtype,\n\tisSet,\n\tisMap,\n\tloadPlugin,\n\tProxyType,\n\tArchtype,\n\tdie,\n\tisDraft,\n\tisDraftable,\n\tNOTHING\n} from \"../internal\"\n\nexport function enablePatches() {\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 ProxyType.ProxyObject:\n\t\t\tcase ProxyType.ES5Object:\n\t\t\tcase ProxyType.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 ProxyType.ES5Array:\n\t\t\tcase ProxyType.ProxyArray:\n\t\t\t\treturn generateArrayPatches(state, basePath, patches, inversePatches)\n\t\t\tcase ProxyType.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: ES5ArrayState | 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\tif (base_.length < copy_.length) {\n\t\t\tinversePatches.push({\n\t\t\t\top: REPLACE,\n\t\t\t\tpath: basePath.concat([\"length\"]),\n\t\t\t\tvalue: base_.length\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 | ES5ObjectState | 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: 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(24)\n\t\t\t\tif (typeof base === \"function\" && p === \"prototype\") die(24)\n\t\t\t\tbase = get(base, p)\n\t\t\t\tif (typeof base !== \"object\") die(15, 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(16)\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(17, 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(Object.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\tImmutable,\n\tPatch,\n\tPatchListener,\n\toriginal,\n\tcurrent,\n\tisDraft,\n\tisDraftable,\n\tNOTHING as nothing,\n\tDRAFTABLE as immerable,\n\tfreeze\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\nexport default 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 use the ES2015 `Proxy` class when creating drafts, which is\n * always faster than using ES5 proxies.\n *\n * By default, feature detection is used, so calling this is rarely necessary.\n */\nexport const setUseProxies = immer.setUseProxies.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 {enableES5} from \"./plugins/es5\"\nexport {enablePatches} from \"./plugins/patches\"\nexport {enableMapSet} from \"./plugins/mapset\"\nexport {enableAllPlugins} from \"./plugins/all\"\n","// Should be no imports here!\n\n// Some things that should be evaluated before all else...\n\n// We only want to know if non-polyfilled symbols are available\nconst hasSymbol =\n\ttypeof Symbol !== \"undefined\" && typeof Symbol(\"x\") === \"symbol\"\nexport const hasMap = typeof Map !== \"undefined\"\nexport const hasSet = typeof Set !== \"undefined\"\nexport const hasProxies =\n\ttypeof Proxy !== \"undefined\" &&\n\ttypeof Proxy.revocable !== \"undefined\" &&\n\ttypeof Reflect !== \"undefined\"\n\n/**\n * The sentinel value returned by producers to replace the draft with undefined.\n */\nexport const NOTHING: Nothing = hasSymbol\n\t? Symbol.for(\"immer-nothing\")\n\t: ({[\"immer-nothing\"]: true} as any)\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 = hasSymbol\n\t? Symbol.for(\"immer-draftable\")\n\t: (\"__$immer_draftable\" as any)\n\nexport const DRAFT_STATE: unique symbol = hasSymbol\n\t? Symbol.for(\"immer-state\")\n\t: (\"__$immer_state\" as any)\n\n// Even a polyfilled Symbol might provide Symbol.iterator\nexport const iteratorSymbol: typeof Symbol.iterator =\n\t(typeof Symbol != \"undefined\" && Symbol.iterator) || (\"@@iterator\" as any)\n\n/** Use a class type for `nothing` so its type is unique */\nexport class Nothing {\n\t// This lets us do `Exclude<T, Nothing>`\n\t// @ts-ignore\n\tprivate _!: unique symbol\n}\n"],"names":["NOT_FOUND","defaultEqualityCheck","a","b","defaultMemoize","func","equalityCheckOrOptions","providedOptions","equalityCheck","_providedOptions$equa","_providedOptions$maxS","maxSize","resultEqualityCheck","comparator","prev","next","length","i","createCacheKeyComparator","cache","equals","entry","get","key","value","put","getEntries","clear","undefined","createSingletonCache","entries","cacheIndex","findIndex","splice","unshift","pop","createLruCache","memoized","arguments","apply","matchingEntry","find","clearCache","createSelectorCreator","memoize","_len","memoizeOptionsFromArgs","Array","_key","_len2","funcs","_key2","_lastResult","_recomputations","directlyPassedOptions","memoizeOptions","resultFunc","Error","_directlyPassedOption2","finalMemoizeOptions","isArray","dependencies","every","dep","dependencyTypes","map","name","join","getDependencies","memoizedResultFunc","concat","selector","params","push","Object","assign","lastResult","recomputations","resetRecomputations","createSelector","createStructuredSelector","selectors","selectorCreator","objectKeys","keys","resultSelector","_len3","values","_key3","reduce","composition","index","n","r","t","e","Q","getPrototypeOf","hasOwnProperty","call","constructor","Function","toString","Z","L","s","v","o","nn","forEach","u","has","prototype","f","set","add","c","X","Map","q","Set","p","l","slice","rn","writable","configurable","enumerable","create","d","y","delete","h","freeze","isFrozen","tn","m","_","U","j","g","O","S","w","P","M","x","H","A","I","k","N","R","D","z","getOwnPropertyDescriptor","E","F","T","C","en","on","Proxy","revocable","revoke","proxy","J","K","from","this","defineProperty","Math","min","$","path","op","G","W","Symbol","B","Reflect","for","iterator","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","getOwnPropertyDescriptors","Number","isNaN","deleteProperty","setPrototypeOf","un","produce","Promise","then","produceWithPatches","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","an","fn","cn","bind","pn"],"sourceRoot":""}