{"version":3,"file":"static/js/2546.5f9466cb.chunk.js","mappings":"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","sources":["../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":["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(value: T): T | undefined\nexport function original(value: Drafted): 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(\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(obj: T, deep?: boolean): T\nexport function freeze(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_(draft: T, patches: Patch[]): T\n\t}\n\tES5?: {\n\t\twillFinalizeES5_(scope: ImmerScope, result: any, isReplaced: boolean): void\n\t\tcreateES5Proxy_(\n\t\t\tbase: T,\n\t\t\tparent?: ImmerState\n\t\t): Drafted\n\t\thasChanges_(state: ES5ArrayState | ES5ObjectState): boolean\n\t}\n\tMapSet?: {\n\t\tproxyMap_(target: T, parent?: ImmerState): T\n\t\tproxySet_(target: T, parent?: ImmerState): T\n\t}\n} = {}\n\ntype Plugins = typeof plugins\n\nexport function getPlugin(\n\tpluginKey: K\n): Exclude {\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(\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\n\tbase_: AnyObject\n\tcopy_: AnyObject | null\n}\n\nexport interface ES5ArrayState extends ES5BaseState {\n\ttype_: ProxyType.ES5Array\n\tdraft_: Drafted\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 | undefined\n\tbase_: AnyMap\n\trevoked_: boolean\n\tdraft_: Drafted\n}\n\nexport interface SetState extends ImmerBaseState {\n\ttype_: ProxyType.Set\n\tcopy_: AnySet | undefined\n\tbase_: AnySet\n\tdrafts_: Map // maps the original value to the draft value in the new set\n\trevoked_: boolean\n\tdraft_: Drafted\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).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\n}\n\nexport interface ProxyArrayState extends ProxyBaseState {\n\ttype_: ProxyType.ProxyArray\n\tbase_: AnyArray\n\tcopy_: AnyArray | null\n\tdraft_: Drafted\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(\n\tbase: T,\n\tparent?: ImmerState\n): Drafted {\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> = 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 = {\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(base: T): Draft {\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>(\n\t\tdraft: D,\n\t\tpatchListener?: PatchListener\n\t): D extends Draft ? 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(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(\n\timmer: Immer,\n\tvalue: T,\n\tparent?: ImmerState\n): Drafted {\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(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_(\n\t\tbase: T,\n\t\tparent?: ImmerState\n\t): Drafted {\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[]) {\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_(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(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(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(value: T): Draft {\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(value: T): Immutable {\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`\n\t// @ts-ignore\n\tprivate _!: unique symbol\n}\n"],"names":["n","r","arguments","length","t","Array","e","Error","map","join","Q","Object","getPrototypeOf","hasOwnProperty","call","constructor","Function","toString","Z","isArray","L","s","v","i","o","keys","nn","forEach","u","has","prototype","a","get","f","set","add","c","X","Map","q","Set","p","l","slice","rn","writable","configurable","enumerable","value","create","d","y","clear","delete","h","freeze","isFrozen","b","tn","m","_","U","j","g","O","S","w","P","M","x","H","A","I","k","N","R","concat","D","z","getOwnPropertyDescriptor","E","F","T","C","en","on","Proxy","revocable","revoke","proxy","J","push","K","from","this","defineProperty","Math","min","entries","$","path","op","splice","unshift","G","W","Symbol","B","Reflect","for","iterator","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","getOwnPropertyDescriptors","Number","isNaN","deleteProperty","setPrototypeOf","apply","un","produce","Promise","then","produceWithPatches","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","an","fn","cn","bind","pn"],"sourceRoot":""}