Index: frontend/node_modules/immer/LICENSE =================================================================== --- frontend/node_modules/immer/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Michel Weststrate + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. Index: frontend/node_modules/immer/compat/pre-3.7/dist/immer.d.ts =================================================================== --- frontend/node_modules/immer/compat/pre-3.7/dist/immer.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/compat/pre-3.7/dist/immer.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,318 @@ +type Tail = ((...t: T) => any) extends ( + _: any, + ...tail: infer TT +) => any + ? TT + : [] + +type PrimitiveType = number | string | boolean + +/** Object types that should never be mapped */ +type AtomicObject = + | Function + | WeakMap + | WeakSet + | Promise + | Date + | RegExp + +export type Draft = T extends PrimitiveType + ? T + : T extends AtomicObject + ? T + : T extends Map + ? DraftMap + : T extends Set + ? DraftSet + : T extends object + ? {-readonly [K in keyof T]: Draft} + : T + +// Inline these in ts 3.7 +interface DraftMap extends Map, Draft> {} + +// Inline these in ts 3.7 +interface DraftSet extends Set> {} + +/** Convert a mutable type into a readonly type */ +export type Immutable = T extends PrimitiveType + ? T + : T extends AtomicObject + ? T + : T extends Map // Ideally, but wait for TS 3.7: ? Omit, "set" | "delete" | "clear"> + ? ImmutableMap + : T extends Set // Ideally, but wait for TS 3.7: ? Omit, "add" | "delete" | "clear"> + ? ImmutableSet + : T extends object + ? {readonly [K in keyof T]: Immutable} + : T + +interface ImmutableMap extends Map, Immutable> {} + +interface ImmutableSet extends Set> {} + +export interface Patch { + op: "replace" | "remove" | "add" + path: (string | number)[] + value?: any +} + +export type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void + +/** Converts `nothing` into `undefined` */ +type FromNothing = T extends Nothing ? undefined : T + +/** The inferred return type of `produce` */ +export type Produced = Return extends void + ? Base + : Return extends Promise + ? Promise> + : FromNothing + +/** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ +export interface IProduce { + /** Curried producer */ + < + Recipe extends (...args: any[]) => any, + Params extends any[] = Parameters, + T = Params[0] + >( + recipe: Recipe + ): >( + base: Base, + ...rest: Tail + ) => Produced> + // ^ by making the returned type generic, the actual type of the passed in object is preferred + // over the type used in the recipe. However, it does have to satisfy the immutable version used in the recipe + // Note: the type of S is the widened version of T, so it can have more props than T, but that is technically actually correct! + + /** Curried producer with initial state */ + < + Recipe extends (...args: any[]) => any, + Params extends any[] = Parameters, + T = Params[0] + >( + recipe: Recipe, + initialState: Immutable + ): >( + base?: Base, + ...rest: Tail + ) => Produced> + + /** Normal producer */ + , Return = void>( + base: Base, + recipe: (draft: D) => Return, + listener?: PatchListener + ): Produced +} + +export const produce: IProduce +export default produce + +/** + * Like `produce`, but instead of just returning the new state, + * a tuple is returned with [nextState, patches, inversePatches] + * + * Like produce, this function supports currying + */ +export interface IProduceWithPatches { + /** Curried producer */ + < + Recipe extends (...args: any[]) => any, + Params extends any[] = Parameters, + T = Params[0] + >( + recipe: Recipe + ): >( + base: Base, + ...rest: Tail + ) => [Produced>, Patch[], Patch[]] + // ^ by making the returned type generic, the actual type of the passed in object is preferred + // over the type used in the recipe. However, it does have to satisfy the immutable version used in the recipe + // Note: the type of S is the widened version of T, so it can have more props than T, but that is technically actually correct! + + /** Curried producer with initial state */ + < + Recipe extends (...args: any[]) => any, + Params extends any[] = Parameters, + T = Params[0] + >( + recipe: Recipe, + initialState: Immutable + ): >( + base?: Base, + ...rest: Tail + ) => [Produced>, Patch[], Patch[]] + + /** Normal producer */ + , Return = void>( + base: Base, + recipe: (draft: D) => Return + ): [Produced, Patch[], Patch[]] +} +export const produceWithPatches: IProduceWithPatches + +/** Use a class type for `nothing` so its type is unique */ +declare class Nothing { + // This lets us do `Exclude` + private _: any +} + +/** + * The sentinel value returned by producers to replace the draft with undefined. + */ +export const nothing: Nothing + +/** + * To let Immer treat your class instances as plain immutable objects + * (albeit with a custom prototype), you must define either an instance property + * or a static property on each of your custom classes. + * + * Otherwise, your class instance will never be drafted, which means it won't be + * safe to mutate in a produce callback. + */ +export const immerable: unique symbol + +/** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is disabled in production. + */ +export function setAutoFreeze(autoFreeze: boolean): void + +/** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ +export function setUseProxies(useProxies: boolean): void + +/** + * Apply an array of Immer patches to the first argument. + * + * This function is a producer, which means copy-on-write is in effect. + */ +export function applyPatches(base: S, patches: Patch[]): S + +/** + * Create an Immer draft from the given base state, which may be a draft itself. + * The draft can be modified until you finalize it with the `finishDraft` function. + */ +export function createDraft(base: T): Draft + +/** + * Finalize an Immer draft from a `createDraft` call, returning the base state + * (if no changes were made) or a modified copy. The draft must *not* be + * mutated afterwards. + * + * Pass a function as the 2nd argument to generate Immer patches based on the + * changes that were made. + */ +export function finishDraft(draft: T, listener?: PatchListener): Immutable + +/** Get the underlying object that is represented by the given draft */ +export function original(value: T): T | void + +/** 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. */ +export function current(value: T): T + +/** Returns true if the given value is an Immer draft */ +export function isDraft(value: any): boolean + +/** Returns true if the given value can be drafted by Immer */ +export function isDraftable(value: any): boolean + +export class Immer { + constructor(config: { + useProxies?: boolean + autoFreeze?: boolean + onAssign?: ( + state: ImmerState, + prop: string | number, + value: unknown + ) => void + onDelete?: (state: ImmerState, prop: string | number) => void + onCopy?: (state: ImmerState) => void + }) + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + produce: IProduce + /** + * When true, `produce` will freeze the copies it creates. + */ + readonly autoFreeze: boolean + /** + * When true, drafts are ES2015 proxies. + */ + readonly useProxies: boolean + /** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is disabled in production. + */ + setAutoFreeze(autoFreeze: boolean): void + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + setUseProxies(useProxies: boolean): void +} + +export interface ImmerState { + parent?: ImmerState + base: T + copy: T + assigned: {[prop: string]: boolean; [index: number]: boolean} +} + +// Backward compatibility with --target es5 +declare global { + interface Set {} + interface Map {} + interface WeakSet {} + interface WeakMap {} +} + +export declare function enableAllPlugins(): void +export declare function enableES5(): void +export declare function enableMapSet(): void +export declare function enablePatches(): void Index: frontend/node_modules/immer/dist/core/current.d.ts =================================================================== --- frontend/node_modules/immer/dist/core/current.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/current.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,3 @@ +/** 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. */ +export declare function current(value: T): T; +//# sourceMappingURL=current.d.ts.map Index: frontend/node_modules/immer/dist/core/current.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/core/current.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/current.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"current.d.ts","sourceRoot":"","sources":["../src/core/current.ts"],"names":[],"mappings":"AAeA,mQAAmQ;AACnQ,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAA"} Index: frontend/node_modules/immer/dist/core/finalize.d.ts =================================================================== --- frontend/node_modules/immer/dist/core/finalize.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/finalize.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,3 @@ +import { ImmerScope } from "../internal"; +export declare function processResult(result: any, scope: ImmerScope): any; +//# sourceMappingURL=finalize.d.ts.map Index: frontend/node_modules/immer/dist/core/finalize.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/core/finalize.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/finalize.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../src/core/finalize.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,UAAU,EAkBV,MAAM,aAAa,CAAA;AAEpB,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,OAiC3D"} Index: frontend/node_modules/immer/dist/core/immerClass.d.ts =================================================================== --- frontend/node_modules/immer/dist/core/immerClass.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/immerClass.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,53 @@ +import { IProduceWithPatches, IProduce, ImmerState, Drafted, Patch, Objectish, Draft, PatchListener } from "../internal"; +interface ProducersFns { + produce: IProduce; + produceWithPatches: IProduceWithPatches; +} +export declare class Immer implements ProducersFns { + useProxies_: boolean; + autoFreeze_: boolean; + constructor(config?: { + useProxies?: boolean; + autoFreeze?: boolean; + }); + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + produce: IProduce; + produceWithPatches: IProduceWithPatches; + createDraft(base: T): Draft; + finishDraft>(draft: D, patchListener?: PatchListener): D extends Draft ? T : never; + /** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is enabled. + */ + setAutoFreeze(value: boolean): void; + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + setUseProxies(value: boolean): void; + applyPatches(base: T, patches: Patch[]): T; +} +export declare function createProxy(immer: Immer, value: T, parent?: ImmerState): Drafted; +export {}; +//# sourceMappingURL=immerClass.d.ts.map Index: frontend/node_modules/immer/dist/core/immerClass.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/core/immerClass.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/immerClass.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immerClass.d.ts","sourceRoot":"","sources":["../src/core/immerClass.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,mBAAmB,EACnB,QAAQ,EACR,UAAU,EACV,OAAO,EAGP,KAAK,EACL,SAAS,EAET,KAAK,EACL,aAAa,EAgBb,MAAM,aAAa,CAAA;AAEpB,UAAU,YAAY;IACrB,OAAO,EAAE,QAAQ,CAAA;IACjB,kBAAkB,EAAE,mBAAmB,CAAA;CACvC;AAED,qBAAa,KAAM,YAAW,YAAY;IACzC,WAAW,EAAE,OAAO,CAAa;IAEjC,WAAW,EAAE,OAAO,CAAO;gBAEf,MAAM,CAAC,EAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAC;IAOjE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,EAAE,QAAQ,CA8DhB;IAED,kBAAkB,EAAE,mBAAmB,CAiBtC;IAED,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAUnD,WAAW,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAC/B,KAAK,EAAE,CAAC,EACR,aAAa,CAAC,EAAE,aAAa,GAC3B,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;IAWvC;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,OAAO;IAI5B;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,OAAO;IAO5B,YAAY,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC;CA2B/D;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,EAC9C,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,CAAC,EACR,MAAM,CAAC,EAAE,UAAU,GACjB,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,CAaxB"} Index: frontend/node_modules/immer/dist/core/proxy.d.ts =================================================================== --- frontend/node_modules/immer/dist/core/proxy.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/proxy.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,38 @@ +import { ImmerBaseState, ImmerState, Drafted, AnyObject, AnyArray, Objectish, ProxyType } from "../internal"; +interface ProxyBaseState extends ImmerBaseState { + assigned_: { + [property: string]: boolean; + }; + parent_?: ImmerState; + revoke_(): void; +} +export interface ProxyObjectState extends ProxyBaseState { + type_: ProxyType.ProxyObject; + base_: any; + copy_: any; + draft_: Drafted; +} +export interface ProxyArrayState extends ProxyBaseState { + type_: ProxyType.ProxyArray; + base_: AnyArray; + copy_: AnyArray | null; + draft_: Drafted; +} +declare type ProxyState = ProxyObjectState | ProxyArrayState; +/** + * Returns a new draft of the `base` object. + * + * The second argument is the parent draft-state (used internally). + */ +export declare function createProxyProxy(base: T, parent?: ImmerState): Drafted; +/** + * Object drafts + */ +export declare const objectTraps: ProxyHandler; +export declare function markChanged(state: ImmerState): void; +export declare function prepareCopy(state: { + base_: any; + copy_: any; +}): void; +export {}; +//# sourceMappingURL=proxy.d.ts.map Index: frontend/node_modules/immer/dist/core/proxy.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/core/proxy.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/proxy.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/core/proxy.ts"],"names":[],"mappings":"AAAA,OAAO,EAON,cAAc,EACd,UAAU,EACV,OAAO,EACP,SAAS,EACT,QAAQ,EACR,SAAS,EAKT,SAAS,EACT,MAAM,aAAa,CAAA;AAEpB,UAAU,cAAe,SAAQ,cAAc;IAC9C,SAAS,EAAE;QACV,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;KAC3B,CAAA;IACD,OAAO,CAAC,EAAE,UAAU,CAAA;IACpB,OAAO,IAAI,IAAI,CAAA;CACf;AAED,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACvD,KAAK,EAAE,SAAS,CAAC,WAAW,CAAA;IAC5B,KAAK,EAAE,GAAG,CAAA;IACV,KAAK,EAAE,GAAG,CAAA;IACV,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAA;CAC5C;AAED,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACtD,KAAK,EAAE,SAAS,CAAC,UAAU,CAAA;IAC3B,KAAK,EAAE,QAAQ,CAAA;IACf,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;IACtB,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAA;CAC1C;AAED,aAAK,UAAU,GAAG,gBAAgB,GAAG,eAAe,CAAA;AAEpD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,EACnD,IAAI,EAAE,CAAC,EACP,MAAM,CAAC,EAAE,UAAU,GACjB,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,CA0CxB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,UAAU,CA8GhD,CAAA;AAyDD,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,QAO5C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAC,QAI1D"} Index: frontend/node_modules/immer/dist/core/scope.d.ts =================================================================== --- frontend/node_modules/immer/dist/core/scope.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/scope.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,18 @@ +import { Patch, PatchListener, Immer } from "../internal"; +/** Each scope represents a `produce` call. */ +export interface ImmerScope { + patches_?: Patch[]; + inversePatches_?: Patch[]; + canAutoFreeze_: boolean; + drafts_: any[]; + parent_?: ImmerScope; + patchListener_?: PatchListener; + immer_: Immer; + unfinalizedDrafts_: number; +} +export declare function getCurrentScope(): ImmerScope; +export declare function usePatchesInScope(scope: ImmerScope, patchListener?: PatchListener): void; +export declare function revokeScope(scope: ImmerScope): void; +export declare function leaveScope(scope: ImmerScope): void; +export declare function enterScope(immer: Immer): ImmerScope; +//# sourceMappingURL=scope.d.ts.map Index: frontend/node_modules/immer/dist/core/scope.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/core/scope.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/core/scope.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../src/core/scope.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,EACL,aAAa,EAEb,KAAK,EAKL,MAAM,aAAa,CAAA;AAGpB,8CAA8C;AAE9C,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAA;IAClB,eAAe,CAAC,EAAE,KAAK,EAAE,CAAA;IACzB,cAAc,EAAE,OAAO,CAAA;IACvB,OAAO,EAAE,GAAG,EAAE,CAAA;IACd,OAAO,CAAC,EAAE,UAAU,CAAA;IACpB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,MAAM,EAAE,KAAK,CAAA;IACb,kBAAkB,EAAE,MAAM,CAAA;CAC1B;AAID,wBAAgB,eAAe,eAG9B;AAiBD,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,UAAU,EACjB,aAAa,CAAC,EAAE,aAAa,QAQ7B;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,QAK5C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,QAI3C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,cAEtC"} Index: frontend/node_modules/immer/dist/immer.cjs.development.js =================================================================== --- frontend/node_modules/immer/dist/immer.cjs.development.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.cjs.development.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2085 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var _ref; + +// Should be no imports here! +// Some things that should be evaluated before all else... +// We only want to know if non-polyfilled symbols are available +var hasSymbol = typeof Symbol !== "undefined" && typeof +/*#__PURE__*/ +Symbol("x") === "symbol"; +var hasMap = typeof Map !== "undefined"; +var hasSet = typeof Set !== "undefined"; +var hasProxies = typeof Proxy !== "undefined" && typeof Proxy.revocable !== "undefined" && typeof Reflect !== "undefined"; +/** + * The sentinel value returned by producers to replace the draft with undefined. + */ + +var NOTHING = hasSymbol ? +/*#__PURE__*/ +Symbol.for("immer-nothing") : (_ref = {}, _ref["immer-nothing"] = true, _ref); +/** + * To let Immer treat your class instances as plain immutable objects + * (albeit with a custom prototype), you must define either an instance property + * or a static property on each of your custom classes. + * + * Otherwise, your class instance will never be drafted, which means it won't be + * safe to mutate in a produce callback. + */ + +var DRAFTABLE = hasSymbol ? +/*#__PURE__*/ +Symbol.for("immer-draftable") : "__$immer_draftable"; +var DRAFT_STATE = hasSymbol ? +/*#__PURE__*/ +Symbol.for("immer-state") : "__$immer_state"; // Even a polyfilled Symbol might provide Symbol.iterator + +var iteratorSymbol = typeof Symbol != "undefined" && Symbol.iterator || "@@iterator"; + +var errors = { + 0: "Illegal state", + 1: "Immer drafts cannot have computed properties", + 2: "This object has been frozen and should not be mutated", + 3: function _(data) { + return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data; + }, + 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", + 5: "Immer forbids circular references", + 6: "The first or second argument to `produce` must be a function", + 7: "The third argument to `produce` must be a function or undefined", + 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object", + 9: "First argument to `finishDraft` must be a draft returned by `createDraft`", + 10: "The given draft is already finalized", + 11: "Object.defineProperty() cannot be used on an Immer draft", + 12: "Object.setPrototypeOf() cannot be used on an Immer draft", + 13: "Immer only supports deleting array indices", + 14: "Immer only supports setting array indices and the 'length' property", + 15: function _(path) { + return "Cannot apply patch, path doesn't resolve: " + path; + }, + 16: 'Sets cannot have "replace" patches.', + 17: function _(op) { + return "Unsupported patch operation: " + op; + }, + 18: function _(plugin) { + return "The plugin for '" + plugin + "' has not been loaded into Immer. To enable the plugin, import and call `enable" + plugin + "()` when initializing your application."; + }, + 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available", + 21: function _(thing) { + return "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 + "'"; + }, + 22: function _(thing) { + return "'current' expects a draft, got: " + thing; + }, + 23: function _(thing) { + return "'original' expects a draft, got: " + thing; + }, + 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed" +}; +function die(error) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + { + var e = errors[error]; + var msg = !e ? "unknown error nr: " + error : typeof e === "function" ? e.apply(null, args) : e; + throw new Error("[Immer] " + msg); + } +} + +/** Returns true if the given value is an Immer draft */ + +/*#__PURE__*/ + +function isDraft(value) { + return !!value && !!value[DRAFT_STATE]; +} +/** Returns true if the given value can be drafted by Immer */ + +/*#__PURE__*/ + +function isDraftable(value) { + var _value$constructor; + + if (!value) return false; + return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor[DRAFTABLE]) || isMap(value) || isSet(value); +} +var objectCtorString = +/*#__PURE__*/ +Object.prototype.constructor.toString(); +/*#__PURE__*/ + +function isPlainObject(value) { + if (!value || typeof value !== "object") return false; + var proto = Object.getPrototypeOf(value); + + if (proto === null) { + return true; + } + + var Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor; + if (Ctor === Object) return true; + return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString; +} +function original(value) { + if (!isDraft(value)) die(23, value); + return value[DRAFT_STATE].base_; +} +/*#__PURE__*/ + +var ownKeys = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function (obj) { + return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)); +} : +/* istanbul ignore next */ +Object.getOwnPropertyNames; +var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(target) { + // Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274 + var res = {}; + ownKeys(target).forEach(function (key) { + res[key] = Object.getOwnPropertyDescriptor(target, key); + }); + return res; +}; +function each(obj, iter, enumerableOnly) { + if (enumerableOnly === void 0) { + enumerableOnly = false; + } + + if (getArchtype(obj) === 0 + /* Object */ + ) { + (enumerableOnly ? Object.keys : ownKeys)(obj).forEach(function (key) { + if (!enumerableOnly || typeof key !== "symbol") iter(key, obj[key], obj); + }); + } else { + obj.forEach(function (entry, index) { + return iter(index, entry, obj); + }); + } +} +/*#__PURE__*/ + +function getArchtype(thing) { + /* istanbul ignore next */ + var state = thing[DRAFT_STATE]; + return state ? state.type_ > 3 ? state.type_ - 4 // cause Object and Array map back from 4 and 5 + : state.type_ // others are the same + : Array.isArray(thing) ? 1 + /* Array */ + : isMap(thing) ? 2 + /* Map */ + : isSet(thing) ? 3 + /* Set */ + : 0 + /* Object */ + ; +} +/*#__PURE__*/ + +function has(thing, prop) { + return getArchtype(thing) === 2 + /* Map */ + ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop); +} +/*#__PURE__*/ + +function get(thing, prop) { + // @ts-ignore + return getArchtype(thing) === 2 + /* Map */ + ? thing.get(prop) : thing[prop]; +} +/*#__PURE__*/ + +function set(thing, propOrOldValue, value) { + var t = getArchtype(thing); + if (t === 2 + /* Map */ + ) thing.set(propOrOldValue, value);else if (t === 3 + /* Set */ + ) { + thing.add(value); + } else thing[propOrOldValue] = value; +} +/*#__PURE__*/ + +function is(x, y) { + // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js + if (x === y) { + return x !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } +} +/*#__PURE__*/ + +function isMap(target) { + return hasMap && target instanceof Map; +} +/*#__PURE__*/ + +function isSet(target) { + return hasSet && target instanceof Set; +} +/*#__PURE__*/ + +function latest(state) { + return state.copy_ || state.base_; +} +/*#__PURE__*/ + +function shallowCopy(base) { + if (Array.isArray(base)) return Array.prototype.slice.call(base); + var descriptors = getOwnPropertyDescriptors(base); + delete descriptors[DRAFT_STATE]; + var keys = ownKeys(descriptors); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var desc = descriptors[key]; + + if (desc.writable === false) { + desc.writable = true; + desc.configurable = true; + } // like object.assign, we will read any _own_, get/set accessors. This helps in dealing + // with libraries that trap values, like mobx or vue + // unlike object.assign, non-enumerables will be copied as well + + + if (desc.get || desc.set) descriptors[key] = { + configurable: true, + writable: true, + enumerable: desc.enumerable, + value: base[key] + }; + } + + return Object.create(Object.getPrototypeOf(base), descriptors); +} +function freeze(obj, deep) { + if (deep === void 0) { + deep = false; + } + + if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj; + + if (getArchtype(obj) > 1 + /* Map or Set */ + ) { + obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections; + } + + Object.freeze(obj); + if (deep) each(obj, function (key, value) { + return freeze(value, true); + }, true); + return obj; +} + +function dontMutateFrozenCollections() { + die(2); +} + +function isFrozen(obj) { + if (obj == null || typeof obj !== "object") return true; // See #600, IE dies on non-objects in Object.isFrozen + + return Object.isFrozen(obj); +} + +/** Plugin utilities */ + +var plugins = {}; +function getPlugin(pluginKey) { + var plugin = plugins[pluginKey]; + + if (!plugin) { + die(18, pluginKey); + } // @ts-ignore + + + return plugin; +} +function loadPlugin(pluginKey, implementation) { + if (!plugins[pluginKey]) plugins[pluginKey] = implementation; +} + +var currentScope; +function getCurrentScope() { + if ( !currentScope) die(0); + return currentScope; +} + +function createScope(parent_, immer_) { + return { + drafts_: [], + parent_: parent_, + immer_: immer_, + // Whenever the modified draft contains a draft from another scope, we + // need to prevent auto-freezing so the unowned draft can be finalized. + canAutoFreeze_: true, + unfinalizedDrafts_: 0 + }; +} + +function usePatchesInScope(scope, patchListener) { + if (patchListener) { + getPlugin("Patches"); // assert we have the plugin + + scope.patches_ = []; + scope.inversePatches_ = []; + scope.patchListener_ = patchListener; + } +} +function revokeScope(scope) { + leaveScope(scope); + scope.drafts_.forEach(revokeDraft); // @ts-ignore + + scope.drafts_ = null; +} +function leaveScope(scope) { + if (scope === currentScope) { + currentScope = scope.parent_; + } +} +function enterScope(immer) { + return currentScope = createScope(currentScope, immer); +} + +function revokeDraft(draft) { + var state = draft[DRAFT_STATE]; + if (state.type_ === 0 + /* ProxyObject */ + || state.type_ === 1 + /* ProxyArray */ + ) state.revoke_();else state.revoked_ = true; +} + +function processResult(result, scope) { + scope.unfinalizedDrafts_ = scope.drafts_.length; + var baseDraft = scope.drafts_[0]; + var isReplaced = result !== undefined && result !== baseDraft; + if (!scope.immer_.useProxies_) getPlugin("ES5").willFinalizeES5_(scope, result, isReplaced); + + if (isReplaced) { + if (baseDraft[DRAFT_STATE].modified_) { + revokeScope(scope); + die(4); + } + + if (isDraftable(result)) { + // Finalize the result in case it contains (or is) a subset of the draft. + result = finalize(scope, result); + if (!scope.parent_) maybeFreeze(scope, result); + } + + if (scope.patches_) { + getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_); + } + } else { + // Finalize the base draft. + result = finalize(scope, baseDraft, []); + } + + revokeScope(scope); + + if (scope.patches_) { + scope.patchListener_(scope.patches_, scope.inversePatches_); + } + + return result !== NOTHING ? result : undefined; +} + +function finalize(rootScope, value, path) { + // Don't recurse in tho recursive data structures + if (isFrozen(value)) return value; + var state = value[DRAFT_STATE]; // A plain object, might need freezing, might contain drafts + + if (!state) { + each(value, function (key, childValue) { + return finalizeProperty(rootScope, state, value, key, childValue, path); + }, true // See #590, don't recurse into non-enumerable of non drafted objects + ); + return value; + } // Never finalize drafts owned by another scope. + + + if (state.scope_ !== rootScope) return value; // Unmodified draft, return the (frozen) original + + if (!state.modified_) { + maybeFreeze(rootScope, state.base_, true); + return state.base_; + } // Not finalized yet, let's do that now + + + if (!state.finalized_) { + state.finalized_ = true; + state.scope_.unfinalizedDrafts_--; + var result = // For ES5, create a good copy from the draft first, with added keys and without deleted keys. + state.type_ === 4 + /* ES5Object */ + || state.type_ === 5 + /* ES5Array */ + ? state.copy_ = shallowCopy(state.draft_) : state.copy_; // Finalize all children of the copy + // For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628 + // To preserve insertion order in all cases we then clear the set + // And we let finalizeProperty know it needs to re-add non-draft children back to the target + + var resultEach = result; + var isSet = false; + + if (state.type_ === 3 + /* Set */ + ) { + resultEach = new Set(result); + result.clear(); + isSet = true; + } + + each(resultEach, function (key, childValue) { + return finalizeProperty(rootScope, state, result, key, childValue, path, isSet); + }); // everything inside is frozen, we can freeze here + + maybeFreeze(rootScope, result, false); // first time finalizing, let's create those patches + + if (path && rootScope.patches_) { + getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_); + } + } + + return state.copy_; +} + +function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) { + if ( childValue === targetObject) die(5); + + if (isDraft(childValue)) { + var path = rootPath && parentState && parentState.type_ !== 3 + /* Set */ + && // Set objects are atomic since they have no keys. + !has(parentState.assigned_, prop) // Skip deep patches for assigned keys. + ? rootPath.concat(prop) : undefined; // Drafts owned by `scope` are finalized here. + + var res = finalize(rootScope, childValue, path); + set(targetObject, prop, res); // Drafts from another scope must prevented to be frozen + // if we got a draft back from finalize, we're in a nested produce and shouldn't freeze + + if (isDraft(res)) { + rootScope.canAutoFreeze_ = false; + } else return; + } else if (targetIsSet) { + targetObject.add(childValue); + } // Search new objects for unfinalized drafts. Frozen objects should never contain drafts. + + + if (isDraftable(childValue) && !isFrozen(childValue)) { + if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) { + // optimization: if an object is not a draft, and we don't have to + // deepfreeze everything, and we are sure that no drafts are left in the remaining object + // cause we saw and finalized all drafts already; we can stop visiting the rest of the tree. + // This benefits especially adding large data tree's without further processing. + // See add-data.js perf test + return; + } + + finalize(rootScope, childValue); // immer deep freezes plain objects, so if there is no parent state, we freeze as well + + if (!parentState || !parentState.scope_.parent_) maybeFreeze(rootScope, childValue); + } +} + +function maybeFreeze(scope, value, deep) { + if (deep === void 0) { + deep = false; + } + + // we never freeze for a non-root scope; as it would prevent pruning for drafts inside wrapping objects + if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) { + freeze(value, deep); + } +} + +/** + * Returns a new draft of the `base` object. + * + * The second argument is the parent draft-state (used internally). + */ + +function createProxyProxy(base, parent) { + var isArray = Array.isArray(base); + var state = { + type_: isArray ? 1 + /* ProxyArray */ + : 0 + /* ProxyObject */ + , + // Track which produce call this is associated with. + scope_: parent ? parent.scope_ : getCurrentScope(), + // True for both shallow and deep changes. + modified_: false, + // Used during finalization. + finalized_: false, + // Track which properties have been assigned (true) or deleted (false). + assigned_: {}, + // The parent draft state. + parent_: parent, + // The base state. + base_: base, + // The base proxy. + draft_: null, + // The base copy with any updated values. + copy_: null, + // Called by the `produce` function. + revoke_: null, + isManual_: false + }; // the traps must target something, a bit like the 'real' base. + // but also, we need to be able to determine from the target what the relevant state is + // (to avoid creating traps per instance to capture the state in closure, + // and to avoid creating weird hidden properties as well) + // So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything) + // Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb + + var target = state; + var traps = objectTraps; + + if (isArray) { + target = [state]; + traps = arrayTraps; + } + + var _Proxy$revocable = Proxy.revocable(target, traps), + revoke = _Proxy$revocable.revoke, + proxy = _Proxy$revocable.proxy; + + state.draft_ = proxy; + state.revoke_ = revoke; + return proxy; +} +/** + * Object drafts + */ + +var objectTraps = { + get: function get(state, prop) { + if (prop === DRAFT_STATE) return state; + var source = latest(state); + + if (!has(source, prop)) { + // non-existing or non-own property... + return readPropFromProto(state, source, prop); + } + + var value = source[prop]; + + if (state.finalized_ || !isDraftable(value)) { + return value; + } // Check for existing draft in modified state. + // Assigned values are never drafted. This catches any drafts we created, too. + + + if (value === peek(state.base_, prop)) { + prepareCopy(state); + return state.copy_[prop] = createProxy(state.scope_.immer_, value, state); + } + + return value; + }, + has: function has(state, prop) { + return prop in latest(state); + }, + ownKeys: function ownKeys(state) { + return Reflect.ownKeys(latest(state)); + }, + set: function set(state, prop + /* strictly not, but helps TS */ + , value) { + var desc = getDescriptorFromProto(latest(state), prop); + + if (desc === null || desc === void 0 ? void 0 : desc.set) { + // special case: if this write is captured by a setter, we have + // to trigger it with the correct context + desc.set.call(state.draft_, value); + return true; + } + + if (!state.modified_) { + // the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change) + // from setting an existing property with value undefined to undefined (which is not a change) + var current = peek(latest(state), prop); // special case, if we assigning the original value to a draft, we can ignore the assignment + + var currentState = current === null || current === void 0 ? void 0 : current[DRAFT_STATE]; + + if (currentState && currentState.base_ === value) { + state.copy_[prop] = value; + state.assigned_[prop] = false; + return true; + } + + if (is(value, current) && (value !== undefined || has(state.base_, prop))) return true; + prepareCopy(state); + markChanged(state); + } + + if (state.copy_[prop] === value && ( // special case: handle new props with value 'undefined' + value !== undefined || prop in state.copy_) || // special case: NaN + Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true; // @ts-ignore + + state.copy_[prop] = value; + state.assigned_[prop] = true; + return true; + }, + deleteProperty: function deleteProperty(state, prop) { + // The `undefined` check is a fast path for pre-existing keys. + if (peek(state.base_, prop) !== undefined || prop in state.base_) { + state.assigned_[prop] = false; + prepareCopy(state); + markChanged(state); + } else { + // if an originally not assigned property was deleted + delete state.assigned_[prop]; + } // @ts-ignore + + + if (state.copy_) delete state.copy_[prop]; + return true; + }, + // Note: We never coerce `desc.value` into an Immer draft, because we can't make + // the same guarantee in ES5 mode. + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(state, prop) { + var owner = latest(state); + var desc = Reflect.getOwnPropertyDescriptor(owner, prop); + if (!desc) return desc; + return { + writable: true, + configurable: state.type_ !== 1 + /* ProxyArray */ + || prop !== "length", + enumerable: desc.enumerable, + value: owner[prop] + }; + }, + defineProperty: function defineProperty() { + die(11); + }, + getPrototypeOf: function getPrototypeOf(state) { + return Object.getPrototypeOf(state.base_); + }, + setPrototypeOf: function setPrototypeOf() { + die(12); + } +}; +/** + * Array drafts + */ + +var arrayTraps = {}; +each(objectTraps, function (key, fn) { + // @ts-ignore + arrayTraps[key] = function () { + arguments[0] = arguments[0][0]; + return fn.apply(this, arguments); + }; +}); + +arrayTraps.deleteProperty = function (state, prop) { + if ( isNaN(parseInt(prop))) die(13); // @ts-ignore + + return arrayTraps.set.call(this, state, prop, undefined); +}; + +arrayTraps.set = function (state, prop, value) { + if ( prop !== "length" && isNaN(parseInt(prop))) die(14); + return objectTraps.set.call(this, state[0], prop, value, state[0]); +}; // Access a property without creating an Immer draft. + + +function peek(draft, prop) { + var state = draft[DRAFT_STATE]; + var source = state ? latest(state) : draft; + return source[prop]; +} + +function readPropFromProto(state, source, prop) { + var _desc$get; + + var desc = getDescriptorFromProto(source, prop); + return desc ? "value" in desc ? desc.value : // This is a very special case, if the prop is a getter defined by the + // prototype, we should invoke it with the draft as context! + (_desc$get = desc.get) === null || _desc$get === void 0 ? void 0 : _desc$get.call(state.draft_) : undefined; +} + +function getDescriptorFromProto(source, prop) { + // 'in' checks proto! + if (!(prop in source)) return undefined; + var proto = Object.getPrototypeOf(source); + + while (proto) { + var desc = Object.getOwnPropertyDescriptor(proto, prop); + if (desc) return desc; + proto = Object.getPrototypeOf(proto); + } + + return undefined; +} + +function markChanged(state) { + if (!state.modified_) { + state.modified_ = true; + + if (state.parent_) { + markChanged(state.parent_); + } + } +} +function prepareCopy(state) { + if (!state.copy_) { + state.copy_ = shallowCopy(state.base_); + } +} + +var Immer = +/*#__PURE__*/ +function () { + function Immer(config) { + var _this = this; + + this.useProxies_ = hasProxies; + this.autoFreeze_ = true; + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + + this.produce = function (base, recipe, patchListener) { + // curried invocation + if (typeof base === "function" && typeof recipe !== "function") { + var defaultBase = recipe; + recipe = base; + var self = _this; + return function curriedProduce(base) { + var _this2 = this; + + if (base === void 0) { + base = defaultBase; + } + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return self.produce(base, function (draft) { + var _recipe; + + return (_recipe = recipe).call.apply(_recipe, [_this2, draft].concat(args)); + }); // prettier-ignore + }; + } + + if (typeof recipe !== "function") die(6); + if (patchListener !== undefined && typeof patchListener !== "function") die(7); + var result; // Only plain objects, arrays, and "immerable classes" are drafted. + + if (isDraftable(base)) { + var scope = enterScope(_this); + var proxy = createProxy(_this, base, undefined); + var hasError = true; + + try { + result = recipe(proxy); + hasError = false; + } finally { + // finally instead of catch + rethrow better preserves original stack + if (hasError) revokeScope(scope);else leaveScope(scope); + } + + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function (result) { + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + }, function (error) { + revokeScope(scope); + throw error; + }); + } + + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + } else if (!base || typeof base !== "object") { + result = recipe(base); + if (result === undefined) result = base; + if (result === NOTHING) result = undefined; + if (_this.autoFreeze_) freeze(result, true); + + if (patchListener) { + var p = []; + var ip = []; + getPlugin("Patches").generateReplacementPatches_(base, result, p, ip); + patchListener(p, ip); + } + + return result; + } else die(21, base); + }; + + this.produceWithPatches = function (base, recipe) { + // curried invocation + if (typeof base === "function") { + return function (state) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + return _this.produceWithPatches(state, function (draft) { + return base.apply(void 0, [draft].concat(args)); + }); + }; + } + + var patches, inversePatches; + + var result = _this.produce(base, recipe, function (p, ip) { + patches = p; + inversePatches = ip; + }); + + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function (nextState) { + return [nextState, patches, inversePatches]; + }); + } + + return [result, patches, inversePatches]; + }; + + if (typeof (config === null || config === void 0 ? void 0 : config.useProxies) === "boolean") this.setUseProxies(config.useProxies); + if (typeof (config === null || config === void 0 ? void 0 : config.autoFreeze) === "boolean") this.setAutoFreeze(config.autoFreeze); + } + + var _proto = Immer.prototype; + + _proto.createDraft = function createDraft(base) { + if (!isDraftable(base)) die(8); + if (isDraft(base)) base = current(base); + var scope = enterScope(this); + var proxy = createProxy(this, base, undefined); + proxy[DRAFT_STATE].isManual_ = true; + leaveScope(scope); + return proxy; + }; + + _proto.finishDraft = function finishDraft(draft, patchListener) { + var state = draft && draft[DRAFT_STATE]; + + { + if (!state || !state.isManual_) die(9); + if (state.finalized_) die(10); + } + + var scope = state.scope_; + usePatchesInScope(scope, patchListener); + return processResult(undefined, scope); + } + /** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is enabled. + */ + ; + + _proto.setAutoFreeze = function setAutoFreeze(value) { + this.autoFreeze_ = value; + } + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + ; + + _proto.setUseProxies = function setUseProxies(value) { + if (value && !hasProxies) { + die(20); + } + + this.useProxies_ = value; + }; + + _proto.applyPatches = function applyPatches(base, patches) { + // If a patch replaces the entire state, take that replacement as base + // before applying patches + var i; + + for (i = patches.length - 1; i >= 0; i--) { + var patch = patches[i]; + + if (patch.path.length === 0 && patch.op === "replace") { + base = patch.value; + break; + } + } // If there was a patch that replaced the entire state, start from the + // patch after that. + + + if (i > -1) { + patches = patches.slice(i + 1); + } + + var applyPatchesImpl = getPlugin("Patches").applyPatches_; + + if (isDraft(base)) { + // N.B: never hits if some patch a replacement, patches are never drafts + return applyPatchesImpl(base, patches); + } // Otherwise, produce a copy of the base state. + + + return this.produce(base, function (draft) { + return applyPatchesImpl(draft, patches); + }); + }; + + return Immer; +}(); +function createProxy(immer, value, parent) { + // precondition: createProxy should be guarded by isDraftable, so we know we can safely draft + var draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : immer.useProxies_ ? createProxyProxy(value, parent) : getPlugin("ES5").createES5Proxy_(value, parent); + var scope = parent ? parent.scope_ : getCurrentScope(); + scope.drafts_.push(draft); + return draft; +} + +function current(value) { + if (!isDraft(value)) die(22, value); + return currentImpl(value); +} + +function currentImpl(value) { + if (!isDraftable(value)) return value; + var state = value[DRAFT_STATE]; + var copy; + var archType = getArchtype(value); + + if (state) { + if (!state.modified_ && (state.type_ < 4 || !getPlugin("ES5").hasChanges_(state))) return state.base_; // Optimization: avoid generating new drafts during copying + + state.finalized_ = true; + copy = copyHelper(value, archType); + state.finalized_ = false; + } else { + copy = copyHelper(value, archType); + } + + each(copy, function (key, childValue) { + if (state && get(state.base_, key) === childValue) return; // no need to copy or search in something that didn't change + + set(copy, key, currentImpl(childValue)); + }); // In the future, we might consider freezing here, based on the current settings + + return archType === 3 + /* Set */ + ? new Set(copy) : copy; +} + +function copyHelper(value, archType) { + // creates a shallow copy, even if it is a map or set + switch (archType) { + case 2 + /* Map */ + : + return new Map(value); + + case 3 + /* Set */ + : + // Set will be cloned as array temporarily, so that we can replace individual items + return Array.from(value); + } + + return shallowCopy(value); +} + +function enableES5() { + function willFinalizeES5_(scope, result, isReplaced) { + if (!isReplaced) { + if (scope.patches_) { + markChangesRecursively(scope.drafts_[0]); + } // This is faster when we don't care about which attributes changed. + + + markChangesSweep(scope.drafts_); + } // When a child draft is returned, look for changes. + else if (isDraft(result) && result[DRAFT_STATE].scope_ === scope) { + markChangesSweep(scope.drafts_); + } + } + + function createES5Draft(isArray, base) { + if (isArray) { + var draft = new Array(base.length); + + for (var i = 0; i < base.length; i++) { + Object.defineProperty(draft, "" + i, proxyProperty(i, true)); + } + + return draft; + } else { + var _descriptors = getOwnPropertyDescriptors(base); + + delete _descriptors[DRAFT_STATE]; + var keys = ownKeys(_descriptors); + + for (var _i = 0; _i < keys.length; _i++) { + var key = keys[_i]; + _descriptors[key] = proxyProperty(key, isArray || !!_descriptors[key].enumerable); + } + + return Object.create(Object.getPrototypeOf(base), _descriptors); + } + } + + function createES5Proxy_(base, parent) { + var isArray = Array.isArray(base); + var draft = createES5Draft(isArray, base); + var state = { + type_: isArray ? 5 + /* ES5Array */ + : 4 + /* ES5Object */ + , + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + assigned_: {}, + parent_: parent, + // base is the object we are drafting + base_: base, + // draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified) + draft_: draft, + copy_: null, + revoked_: false, + isManual_: false + }; + Object.defineProperty(draft, DRAFT_STATE, { + value: state, + // enumerable: false <- the default + writable: true + }); + return draft; + } // property descriptors are recycled to make sure we don't create a get and set closure per property, + // but share them all instead + + + var descriptors = {}; + + function proxyProperty(prop, enumerable) { + var desc = descriptors[prop]; + + if (desc) { + desc.enumerable = enumerable; + } else { + descriptors[prop] = desc = { + configurable: true, + enumerable: enumerable, + get: function get() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // @ts-ignore + + return objectTraps.get(state, prop); + }, + set: function set(value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // @ts-ignore + + objectTraps.set(state, prop, value); + } + }; + } + + return desc; + } // This looks expensive, but only proxies are visited, and only objects without known changes are scanned. + + + function markChangesSweep(drafts) { + // The natural order of drafts in the `scope` array is based on when they + // were accessed. By processing drafts in reverse natural order, we have a + // better chance of processing leaf nodes first. When a leaf node is known to + // have changed, we can avoid any traversal of its ancestor nodes. + for (var i = drafts.length - 1; i >= 0; i--) { + var state = drafts[i][DRAFT_STATE]; + + if (!state.modified_) { + switch (state.type_) { + case 5 + /* ES5Array */ + : + if (hasArrayChanges(state)) markChanged(state); + break; + + case 4 + /* ES5Object */ + : + if (hasObjectChanges(state)) markChanged(state); + break; + } + } + } + } + + function markChangesRecursively(object) { + if (!object || typeof object !== "object") return; + var state = object[DRAFT_STATE]; + if (!state) return; + var base_ = state.base_, + draft_ = state.draft_, + assigned_ = state.assigned_, + type_ = state.type_; + + if (type_ === 4 + /* ES5Object */ + ) { + // Look for added keys. + // probably there is a faster way to detect changes, as sweep + recurse seems to do some + // unnecessary work. + // also: probably we can store the information we detect here, to speed up tree finalization! + each(draft_, function (key) { + if (key === DRAFT_STATE) return; // The `undefined` check is a fast path for pre-existing keys. + + if (base_[key] === undefined && !has(base_, key)) { + assigned_[key] = true; + markChanged(state); + } else if (!assigned_[key]) { + // Only untouched properties trigger recursion. + markChangesRecursively(draft_[key]); + } + }); // Look for removed keys. + + each(base_, function (key) { + // The `undefined` check is a fast path for pre-existing keys. + if (draft_[key] === undefined && !has(draft_, key)) { + assigned_[key] = false; + markChanged(state); + } + }); + } else if (type_ === 5 + /* ES5Array */ + ) { + if (hasArrayChanges(state)) { + markChanged(state); + assigned_.length = true; + } + + if (draft_.length < base_.length) { + for (var i = draft_.length; i < base_.length; i++) { + assigned_[i] = false; + } + } else { + for (var _i2 = base_.length; _i2 < draft_.length; _i2++) { + assigned_[_i2] = true; + } + } // Minimum count is enough, the other parts has been processed. + + + var min = Math.min(draft_.length, base_.length); + + for (var _i3 = 0; _i3 < min; _i3++) { + // Only untouched indices trigger recursion. + if (!draft_.hasOwnProperty(_i3)) { + assigned_[_i3] = true; + } + + if (assigned_[_i3] === undefined) markChangesRecursively(draft_[_i3]); + } + } + } + + function hasObjectChanges(state) { + var base_ = state.base_, + draft_ = state.draft_; // Search for added keys and changed keys. Start at the back, because + // non-numeric keys are ordered by time of definition on the object. + + var keys = ownKeys(draft_); + + for (var i = keys.length - 1; i >= 0; i--) { + var key = keys[i]; + if (key === DRAFT_STATE) continue; + var baseValue = base_[key]; // The `undefined` check is a fast path for pre-existing keys. + + if (baseValue === undefined && !has(base_, key)) { + return true; + } // Once a base key is deleted, future changes go undetected, because its + // descriptor is erased. This branch detects any missed changes. + else { + var value = draft_[key]; + + var _state = value && value[DRAFT_STATE]; + + if (_state ? _state.base_ !== baseValue : !is(value, baseValue)) { + return true; + } + } + } // At this point, no keys were added or changed. + // Compare key count to determine if keys were deleted. + + + var baseIsDraft = !!base_[DRAFT_STATE]; + return keys.length !== ownKeys(base_).length + (baseIsDraft ? 0 : 1); // + 1 to correct for DRAFT_STATE + } + + function hasArrayChanges(state) { + var draft_ = state.draft_; + if (draft_.length !== state.base_.length) return true; // See #116 + // If we first shorten the length, our array interceptors will be removed. + // If after that new items are added, result in the same original length, + // those last items will have no intercepting property. + // So if there is no own descriptor on the last position, we know that items were removed and added + // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check + // the last one + // last descriptor can be not a trap, if the array was extended + + var descriptor = Object.getOwnPropertyDescriptor(draft_, draft_.length - 1); // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10) + + if (descriptor && !descriptor.get) return true; // if we miss a property, it has been deleted, so array probobaly changed + + for (var i = 0; i < draft_.length; i++) { + if (!draft_.hasOwnProperty(i)) return true; + } // For all other cases, we don't have to compare, as they would have been picked up by the index setters + + + return false; + } + + function hasChanges_(state) { + return state.type_ === 4 + /* ES5Object */ + ? hasObjectChanges(state) : hasArrayChanges(state); + } + + function assertUnrevoked(state + /*ES5State | MapState | SetState*/ + ) { + if (state.revoked_) die(3, JSON.stringify(latest(state))); + } + + loadPlugin("ES5", { + createES5Proxy_: createES5Proxy_, + willFinalizeES5_: willFinalizeES5_, + hasChanges_: hasChanges_ + }); +} + +function enablePatches() { + var REPLACE = "replace"; + var ADD = "add"; + var REMOVE = "remove"; + + function generatePatches_(state, basePath, patches, inversePatches) { + switch (state.type_) { + case 0 + /* ProxyObject */ + : + case 4 + /* ES5Object */ + : + case 2 + /* Map */ + : + return generatePatchesFromAssigned(state, basePath, patches, inversePatches); + + case 5 + /* ES5Array */ + : + case 1 + /* ProxyArray */ + : + return generateArrayPatches(state, basePath, patches, inversePatches); + + case 3 + /* Set */ + : + return generateSetPatches(state, basePath, patches, inversePatches); + } + } + + function generateArrayPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, + assigned_ = state.assigned_; + var copy_ = state.copy_; // Reduce complexity by ensuring `base` is never longer. + + if (copy_.length < base_.length) { + var _ref = [copy_, base_]; + base_ = _ref[0]; + copy_ = _ref[1]; + var _ref2 = [inversePatches, patches]; + patches = _ref2[0]; + inversePatches = _ref2[1]; + } // Process replaced indices. + + + for (var i = 0; i < base_.length; i++) { + if (assigned_[i] && copy_[i] !== base_[i]) { + var path = basePath.concat([i]); + patches.push({ + op: REPLACE, + path: path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[i]) + }); + inversePatches.push({ + op: REPLACE, + path: path, + value: clonePatchValueIfNeeded(base_[i]) + }); + } + } // Process added indices. + + + for (var _i = base_.length; _i < copy_.length; _i++) { + var _path = basePath.concat([_i]); + + patches.push({ + op: ADD, + path: _path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[_i]) + }); + } + + if (base_.length < copy_.length) { + inversePatches.push({ + op: REPLACE, + path: basePath.concat(["length"]), + value: base_.length + }); + } + } // This is used for both Map objects and normal objects. + + + function generatePatchesFromAssigned(state, basePath, patches, inversePatches) { + var base_ = state.base_, + copy_ = state.copy_; + each(state.assigned_, function (key, assignedValue) { + var origValue = get(base_, key); + var value = get(copy_, key); + var op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD; + if (origValue === value && op === REPLACE) return; + var path = basePath.concat(key); + patches.push(op === REMOVE ? { + op: op, + path: path + } : { + op: op, + path: path, + value: value + }); + inversePatches.push(op === ADD ? { + op: REMOVE, + path: path + } : op === REMOVE ? { + op: ADD, + path: path, + value: clonePatchValueIfNeeded(origValue) + } : { + op: REPLACE, + path: path, + value: clonePatchValueIfNeeded(origValue) + }); + }); + } + + function generateSetPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, + copy_ = state.copy_; + var i = 0; + base_.forEach(function (value) { + if (!copy_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: REMOVE, + path: path, + value: value + }); + inversePatches.unshift({ + op: ADD, + path: path, + value: value + }); + } + + i++; + }); + i = 0; + copy_.forEach(function (value) { + if (!base_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: ADD, + path: path, + value: value + }); + inversePatches.unshift({ + op: REMOVE, + path: path, + value: value + }); + } + + i++; + }); + } + + function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) { + patches.push({ + op: REPLACE, + path: [], + value: replacement === NOTHING ? undefined : replacement + }); + inversePatches.push({ + op: REPLACE, + path: [], + value: baseValue + }); + } + + function applyPatches_(draft, patches) { + patches.forEach(function (patch) { + var path = patch.path, + op = patch.op; + var base = draft; + + for (var i = 0; i < path.length - 1; i++) { + var parentType = getArchtype(base); + var p = path[i]; + + if (typeof p !== "string" && typeof p !== "number") { + p = "" + p; + } // See #738, avoid prototype pollution + + + if ((parentType === 0 + /* Object */ + || parentType === 1 + /* Array */ + ) && (p === "__proto__" || p === "constructor")) die(24); + if (typeof base === "function" && p === "prototype") die(24); + base = get(base, p); + if (typeof base !== "object") die(15, path.join("/")); + } + + var type = getArchtype(base); + var value = deepClonePatchValue(patch.value); // used to clone patch to ensure original patch is not modified, see #411 + + var key = path[path.length - 1]; + + switch (op) { + case REPLACE: + switch (type) { + case 2 + /* Map */ + : + return base.set(key, value); + + /* istanbul ignore next */ + + case 3 + /* Set */ + : + die(16); + + default: + // if value is an object, then it's assigned by reference + // in the following add or remove ops, the value field inside the patch will also be modifyed + // so we use value from the cloned patch + // @ts-ignore + return base[key] = value; + } + + case ADD: + switch (type) { + case 1 + /* Array */ + : + return key === "-" ? base.push(value) : base.splice(key, 0, value); + + case 2 + /* Map */ + : + return base.set(key, value); + + case 3 + /* Set */ + : + return base.add(value); + + default: + return base[key] = value; + } + + case REMOVE: + switch (type) { + case 1 + /* Array */ + : + return base.splice(key, 1); + + case 2 + /* Map */ + : + return base.delete(key); + + case 3 + /* Set */ + : + return base.delete(patch.value); + + default: + return delete base[key]; + } + + default: + die(17, op); + } + }); + return draft; + } + + function deepClonePatchValue(obj) { + if (!isDraftable(obj)) return obj; + if (Array.isArray(obj)) return obj.map(deepClonePatchValue); + if (isMap(obj)) return new Map(Array.from(obj.entries()).map(function (_ref3) { + var k = _ref3[0], + v = _ref3[1]; + return [k, deepClonePatchValue(v)]; + })); + if (isSet(obj)) return new Set(Array.from(obj).map(deepClonePatchValue)); + var cloned = Object.create(Object.getPrototypeOf(obj)); + + for (var key in obj) { + cloned[key] = deepClonePatchValue(obj[key]); + } + + if (has(obj, DRAFTABLE)) cloned[DRAFTABLE] = obj[DRAFTABLE]; + return cloned; + } + + function clonePatchValueIfNeeded(obj) { + if (isDraft(obj)) { + return deepClonePatchValue(obj); + } else return obj; + } + + loadPlugin("Patches", { + applyPatches_: applyPatches_, + generatePatches_: generatePatches_, + generateReplacementPatches_: generateReplacementPatches_ + }); +} + +// types only! +function enableMapSet() { + /* istanbul ignore next */ + var _extendStatics = function extendStatics(d, b) { + _extendStatics = Object.setPrototypeOf || { + __proto__: [] + } instanceof Array && function (d, b) { + d.__proto__ = b; + } || function (d, b) { + for (var p in b) { + if (b.hasOwnProperty(p)) d[p] = b[p]; + } + }; + + return _extendStatics(d, b); + }; // Ugly hack to resolve #502 and inherit built in Map / Set + + + function __extends(d, b) { + _extendStatics(d, b); + + function __() { + this.constructor = d; + } + + d.prototype = ( // @ts-ignore + __.prototype = b.prototype, new __()); + } + + var DraftMap = function (_super) { + __extends(DraftMap, _super); // Create class manually, cause #502 + + + function DraftMap(target, parent) { + this[DRAFT_STATE] = { + type_: 2 + /* Map */ + , + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: undefined, + assigned_: undefined, + base_: target, + draft_: this, + isManual_: false, + revoked_: false + }; + return this; + } + + var p = DraftMap.prototype; + Object.defineProperty(p, "size", { + get: function get() { + return latest(this[DRAFT_STATE]).size; + } // enumerable: false, + // configurable: true + + }); + + p.has = function (key) { + return latest(this[DRAFT_STATE]).has(key); + }; + + p.set = function (key, value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (!latest(state).has(key) || latest(state).get(key) !== value) { + prepareMapCopy(state); + markChanged(state); + state.assigned_.set(key, true); + state.copy_.set(key, value); + state.assigned_.set(key, true); + } + + return this; + }; + + p.delete = function (key) { + if (!this.has(key)) { + return false; + } + + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareMapCopy(state); + markChanged(state); + + if (state.base_.has(key)) { + state.assigned_.set(key, false); + } else { + state.assigned_.delete(key); + } + + state.copy_.delete(key); + return true; + }; + + p.clear = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (latest(state).size) { + prepareMapCopy(state); + markChanged(state); + state.assigned_ = new Map(); + each(state.base_, function (key) { + state.assigned_.set(key, false); + }); + state.copy_.clear(); + } + }; + + p.forEach = function (cb, thisArg) { + var _this = this; + + var state = this[DRAFT_STATE]; + latest(state).forEach(function (_value, key, _map) { + cb.call(thisArg, _this.get(key), key, _this); + }); + }; + + p.get = function (key) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + var value = latest(state).get(key); + + if (state.finalized_ || !isDraftable(value)) { + return value; + } + + if (value !== state.base_.get(key)) { + return value; // either already drafted or reassigned + } // despite what it looks, this creates a draft only once, see above condition + + + var draft = createProxy(state.scope_.immer_, value, state); + prepareMapCopy(state); + state.copy_.set(key, draft); + return draft; + }; + + p.keys = function () { + return latest(this[DRAFT_STATE]).keys(); + }; + + p.values = function () { + var _this2 = this, + _ref; + + var iterator = this.keys(); + return _ref = {}, _ref[iteratorSymbol] = function () { + return _this2.values(); + }, _ref.next = function next() { + var r = iterator.next(); + /* istanbul ignore next */ + + if (r.done) return r; + + var value = _this2.get(r.value); + + return { + done: false, + value: value + }; + }, _ref; + }; + + p.entries = function () { + var _this3 = this, + _ref2; + + var iterator = this.keys(); + return _ref2 = {}, _ref2[iteratorSymbol] = function () { + return _this3.entries(); + }, _ref2.next = function next() { + var r = iterator.next(); + /* istanbul ignore next */ + + if (r.done) return r; + + var value = _this3.get(r.value); + + return { + done: false, + value: [r.value, value] + }; + }, _ref2; + }; + + p[iteratorSymbol] = function () { + return this.entries(); + }; + + return DraftMap; + }(Map); + + function proxyMap_(target, parent) { + // @ts-ignore + return new DraftMap(target, parent); + } + + function prepareMapCopy(state) { + if (!state.copy_) { + state.assigned_ = new Map(); + state.copy_ = new Map(state.base_); + } + } + + var DraftSet = function (_super) { + __extends(DraftSet, _super); // Create class manually, cause #502 + + + function DraftSet(target, parent) { + this[DRAFT_STATE] = { + type_: 3 + /* Set */ + , + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: undefined, + base_: target, + draft_: this, + drafts_: new Map(), + revoked_: false, + isManual_: false + }; + return this; + } + + var p = DraftSet.prototype; + Object.defineProperty(p, "size", { + get: function get() { + return latest(this[DRAFT_STATE]).size; + } // enumerable: true, + + }); + + p.has = function (value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // bit of trickery here, to be able to recognize both the value, and the draft of its value + + if (!state.copy_) { + return state.base_.has(value); + } + + if (state.copy_.has(value)) return true; + if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) return true; + return false; + }; + + p.add = function (value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (!this.has(value)) { + prepareSetCopy(state); + markChanged(state); + state.copy_.add(value); + } + + return this; + }; + + p.delete = function (value) { + if (!this.has(value)) { + return false; + } + + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + markChanged(state); + return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : + /* istanbul ignore next */ + false); + }; + + p.clear = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (latest(state).size) { + prepareSetCopy(state); + markChanged(state); + state.copy_.clear(); + } + }; + + p.values = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.values(); + }; + + p.entries = function entries() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.entries(); + }; + + p.keys = function () { + return this.values(); + }; + + p[iteratorSymbol] = function () { + return this.values(); + }; + + p.forEach = function forEach(cb, thisArg) { + var iterator = this.values(); + var result = iterator.next(); + + while (!result.done) { + cb.call(thisArg, result.value, result.value, this); + result = iterator.next(); + } + }; + + return DraftSet; + }(Set); + + function proxySet_(target, parent) { + // @ts-ignore + return new DraftSet(target, parent); + } + + function prepareSetCopy(state) { + if (!state.copy_) { + // create drafts for all entries to preserve insertion order + state.copy_ = new Set(); + state.base_.forEach(function (value) { + if (isDraftable(value)) { + var draft = createProxy(state.scope_.immer_, value, state); + state.drafts_.set(value, draft); + state.copy_.add(draft); + } else { + state.copy_.add(value); + } + }); + } + } + + function assertUnrevoked(state + /*ES5State | MapState | SetState*/ + ) { + if (state.revoked_) die(3, JSON.stringify(latest(state))); + } + + loadPlugin("MapSet", { + proxyMap_: proxyMap_, + proxySet_: proxySet_ + }); +} + +function enableAllPlugins() { + enableES5(); + enableMapSet(); + enablePatches(); +} + +var immer = +/*#__PURE__*/ +new Immer(); +/** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + +var produce = immer.produce; +/** + * Like `produce`, but `produceWithPatches` always returns a tuple + * [nextState, patches, inversePatches] (instead of just the next state) + */ + +var produceWithPatches = +/*#__PURE__*/ +immer.produceWithPatches.bind(immer); +/** + * Pass true to automatically freeze all copies created by Immer. + * + * Always freeze by default, even in production mode + */ + +var setAutoFreeze = +/*#__PURE__*/ +immer.setAutoFreeze.bind(immer); +/** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + +var setUseProxies = +/*#__PURE__*/ +immer.setUseProxies.bind(immer); +/** + * Apply an array of Immer patches to the first argument. + * + * This function is a producer, which means copy-on-write is in effect. + */ + +var applyPatches = +/*#__PURE__*/ +immer.applyPatches.bind(immer); +/** + * Create an Immer draft from the given base state, which may be a draft itself. + * The draft can be modified until you finalize it with the `finishDraft` function. + */ + +var createDraft = +/*#__PURE__*/ +immer.createDraft.bind(immer); +/** + * Finalize an Immer draft from a `createDraft` call, returning the base state + * (if no changes were made) or a modified copy. The draft must *not* be + * mutated afterwards. + * + * Pass a function as the 2nd argument to generate Immer patches based on the + * changes that were made. + */ + +var finishDraft = +/*#__PURE__*/ +immer.finishDraft.bind(immer); +/** + * This function is actually a no-op, but can be used to cast an immutable type + * to an draft type and make TypeScript happy + * + * @param value + */ + +function castDraft(value) { + return value; +} +/** + * This function is actually a no-op, but can be used to cast a mutable type + * to an immutable type and make TypeScript happy + * @param value + */ + +function castImmutable(value) { + return value; +} + +exports.Immer = Immer; +exports.applyPatches = applyPatches; +exports.castDraft = castDraft; +exports.castImmutable = castImmutable; +exports.createDraft = createDraft; +exports.current = current; +exports.default = produce; +exports.enableAllPlugins = enableAllPlugins; +exports.enableES5 = enableES5; +exports.enableMapSet = enableMapSet; +exports.enablePatches = enablePatches; +exports.finishDraft = finishDraft; +exports.freeze = freeze; +exports.immerable = DRAFTABLE; +exports.isDraft = isDraft; +exports.isDraftable = isDraftable; +exports.nothing = NOTHING; +exports.original = original; +exports.produce = produce; +exports.produceWithPatches = produceWithPatches; +exports.setAutoFreeze = setAutoFreeze; +exports.setUseProxies = setUseProxies; +//# sourceMappingURL=immer.cjs.development.js.map Index: frontend/node_modules/immer/dist/immer.cjs.development.js.map =================================================================== --- frontend/node_modules/immer/dist/immer.cjs.development.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.cjs.development.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immer.cjs.development.js","sources":["../src/utils/env.ts","../src/utils/errors.ts","../src/utils/common.ts","../src/utils/plugins.ts","../src/core/scope.ts","../src/core/finalize.ts","../src/core/proxy.ts","../src/core/immerClass.ts","../src/core/current.ts","../src/plugins/es5.ts","../src/plugins/patches.ts","../src/plugins/mapset.ts","../src/plugins/all.ts","../src/immer.ts"],"sourcesContent":["// 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","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","// types only!\nimport {\n\tImmerState,\n\tAnyMap,\n\tAnySet,\n\tMapState,\n\tSetState,\n\tDRAFT_STATE,\n\tgetCurrentScope,\n\tlatest,\n\titeratorSymbol,\n\tisDraftable,\n\tcreateProxy,\n\tloadPlugin,\n\tmarkChanged,\n\tProxyType,\n\tdie,\n\teach\n} from \"../internal\"\n\nexport function enableMapSet() {\n\t/* istanbul ignore next */\n\tvar extendStatics = function(d: any, b: any): any {\n\t\textendStatics =\n\t\t\tObject.setPrototypeOf ||\n\t\t\t({__proto__: []} instanceof Array &&\n\t\t\t\tfunction(d, b) {\n\t\t\t\t\td.__proto__ = b\n\t\t\t\t}) ||\n\t\t\tfunction(d, b) {\n\t\t\t\tfor (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]\n\t\t\t}\n\t\treturn extendStatics(d, b)\n\t}\n\n\t// Ugly hack to resolve #502 and inherit built in Map / Set\n\tfunction __extends(d: any, b: any): any {\n\t\textendStatics(d, b)\n\t\tfunction __(this: any): any {\n\t\t\tthis.constructor = d\n\t\t}\n\t\td.prototype =\n\t\t\t// @ts-ignore\n\t\t\t((__.prototype = b.prototype), new __())\n\t}\n\n\tconst DraftMap = (function(_super) {\n\t\t__extends(DraftMap, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftMap(this: any, target: AnyMap, parent?: ImmerState): any {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Map,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tassigned_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this as any,\n\t\t\t\tisManual_: false,\n\t\t\t\trevoked_: false\n\t\t\t} as MapState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftMap.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: false,\n\t\t\t// configurable: true\n\t\t})\n\n\t\tp.has = function(key: any): boolean {\n\t\t\treturn latest(this[DRAFT_STATE]).has(key)\n\t\t}\n\n\t\tp.set = function(key: any, value: any) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!latest(state).has(key) || latest(state).get(key) !== value) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t\tstate.copy_!.set(key, value)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(key: any): boolean {\n\t\t\tif (!this.has(key)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareMapCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\tif (state.base_.has(key)) {\n\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t} else {\n\t\t\t\tstate.assigned_!.delete(key)\n\t\t\t}\n\t\t\tstate.copy_!.delete(key)\n\t\t\treturn true\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_ = new Map()\n\t\t\t\teach(state.base_, key => {\n\t\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t\t})\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.forEach = function(\n\t\t\tcb: (value: any, key: any, self: any) => void,\n\t\t\tthisArg?: any\n\t\t) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tlatest(state).forEach((_value: any, key: any, _map: any) => {\n\t\t\t\tcb.call(thisArg, this.get(key), key, this)\n\t\t\t})\n\t\t}\n\n\t\tp.get = function(key: any): any {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tconst value = latest(state).get(key)\n\t\t\tif (state.finalized_ || !isDraftable(value)) {\n\t\t\t\treturn value\n\t\t\t}\n\t\t\tif (value !== state.base_.get(key)) {\n\t\t\t\treturn value // either already drafted or reassigned\n\t\t\t}\n\t\t\t// despite what it looks, this creates a draft only once, see above condition\n\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\tprepareMapCopy(state)\n\t\t\tstate.copy_!.set(key, draft)\n\t\t\treturn draft\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn latest(this[DRAFT_STATE]).keys()\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.values(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp.entries = function(): IterableIterator<[any, any]> {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.entries(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue: [r.value, value]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.entries()\n\t\t}\n\n\t\treturn DraftMap\n\t})(Map)\n\n\tfunction proxyMap_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftMap(target, parent)\n\t}\n\n\tfunction prepareMapCopy(state: MapState) {\n\t\tif (!state.copy_) {\n\t\t\tstate.assigned_ = new Map()\n\t\t\tstate.copy_ = new Map(state.base_)\n\t\t}\n\t}\n\n\tconst DraftSet = (function(_super) {\n\t\t__extends(DraftSet, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftSet(this: any, target: AnySet, parent?: ImmerState) {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Set,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this,\n\t\t\t\tdrafts_: new Map(),\n\t\t\t\trevoked_: false,\n\t\t\t\tisManual_: false\n\t\t\t} as SetState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftSet.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: true,\n\t\t})\n\n\t\tp.has = function(value: any): boolean {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\t// bit of trickery here, to be able to recognize both the value, and the draft of its value\n\t\t\tif (!state.copy_) {\n\t\t\t\treturn state.base_.has(value)\n\t\t\t}\n\t\t\tif (state.copy_.has(value)) return true\n\t\t\tif (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n\t\t\t\treturn true\n\t\t\treturn false\n\t\t}\n\n\t\tp.add = function(value: any): any {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!this.has(value)) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.add(value)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(value: any): any {\n\t\t\tif (!this.has(value)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\treturn (\n\t\t\t\tstate.copy_!.delete(value) ||\n\t\t\t\t(state.drafts_.has(value)\n\t\t\t\t\t? state.copy_!.delete(state.drafts_.get(value))\n\t\t\t\t\t: /* istanbul ignore next */ false)\n\t\t\t)\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.values()\n\t\t}\n\n\t\tp.entries = function entries(): IterableIterator<[any, any]> {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.entries()\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp.forEach = function forEach(cb: any, thisArg?: any) {\n\t\t\tconst iterator = this.values()\n\t\t\tlet result = iterator.next()\n\t\t\twhile (!result.done) {\n\t\t\t\tcb.call(thisArg, result.value, result.value, this)\n\t\t\t\tresult = iterator.next()\n\t\t\t}\n\t\t}\n\n\t\treturn DraftSet\n\t})(Set)\n\n\tfunction proxySet_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftSet(target, parent)\n\t}\n\n\tfunction prepareSetCopy(state: SetState) {\n\t\tif (!state.copy_) {\n\t\t\t// create drafts for all entries to preserve insertion order\n\t\t\tstate.copy_ = new Set()\n\t\t\tstate.base_.forEach(value => {\n\t\t\t\tif (isDraftable(value)) {\n\t\t\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\t\t\tstate.drafts_.set(value, draft)\n\t\t\t\t\tstate.copy_!.add(draft)\n\t\t\t\t} else {\n\t\t\t\t\tstate.copy_!.add(value)\n\t\t\t\t}\n\t\t\t})\n\t\t}\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(\"MapSet\", {proxyMap_, proxySet_})\n}\n","import {enableES5} from \"./es5\"\nimport {enableMapSet} from \"./mapset\"\nimport {enablePatches} from \"./patches\"\n\nexport function enableAllPlugins() {\n\tenableES5()\n\tenableMapSet()\n\tenablePatches()\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"],"names":["hasSymbol","Symbol","hasMap","Map","hasSet","Set","hasProxies","Proxy","revocable","Reflect","NOTHING","for","DRAFTABLE","DRAFT_STATE","iteratorSymbol","iterator","errors","data","path","op","plugin","thing","die","error","args","e","msg","apply","Error","isDraft","value","isDraftable","isPlainObject","Array","isArray","constructor","isMap","isSet","objectCtorString","Object","prototype","toString","proto","getPrototypeOf","Ctor","hasOwnProperty","call","Function","original","base_","ownKeys","getOwnPropertySymbols","obj","getOwnPropertyNames","concat","getOwnPropertyDescriptors","target","res","forEach","key","getOwnPropertyDescriptor","each","iter","enumerableOnly","getArchtype","keys","entry","index","state","type_","has","prop","get","set","propOrOldValue","t","add","is","x","y","latest","copy_","shallowCopy","base","slice","descriptors","i","length","desc","writable","configurable","enumerable","create","freeze","deep","isFrozen","clear","delete","dontMutateFrozenCollections","plugins","getPlugin","pluginKey","loadPlugin","implementation","currentScope","getCurrentScope","createScope","parent_","immer_","drafts_","canAutoFreeze_","unfinalizedDrafts_","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","revokeDraft","enterScope","immer","draft","revoke_","revoked_","processResult","result","baseDraft","isReplaced","undefined","useProxies_","willFinalizeES5_","modified_","finalize","maybeFreeze","generateReplacementPatches_","rootScope","childValue","finalizeProperty","scope_","finalized_","draft_","resultEach","generatePatches_","parentState","targetObject","rootPath","targetIsSet","assigned_","autoFreeze_","createProxyProxy","parent","isManual_","traps","objectTraps","arrayTraps","revoke","proxy","source","readPropFromProto","peek","prepareCopy","createProxy","getDescriptorFromProto","current","currentState","markChanged","Number","isNaN","deleteProperty","owner","defineProperty","setPrototypeOf","fn","arguments","parseInt","Immer","config","recipe","defaultBase","self","curriedProduce","produce","hasError","Promise","then","p","ip","produceWithPatches","patches","inversePatches","nextState","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","patch","applyPatchesImpl","applyPatches_","proxyMap_","proxySet_","createES5Proxy_","push","currentImpl","copy","archType","hasChanges_","copyHelper","from","enableES5","markChangesRecursively","markChangesSweep","createES5Draft","proxyProperty","assertUnrevoked","drafts","hasArrayChanges","hasObjectChanges","object","min","Math","baseValue","baseIsDraft","descriptor","JSON","stringify","enablePatches","REPLACE","ADD","REMOVE","basePath","generatePatchesFromAssigned","generateArrayPatches","generateSetPatches","clonePatchValueIfNeeded","assignedValue","origValue","unshift","replacement","parentType","join","type","deepClonePatchValue","splice","map","entries","k","v","cloned","immerable","enableMapSet","extendStatics","d","b","__proto__","__extends","__","DraftMap","_super","size","prepareMapCopy","cb","thisArg","_value","_map","values","next","r","done","DraftSet","prepareSetCopy","enableAllPlugins","bind","castDraft","castImmutable"],"mappings":"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"} Index: frontend/node_modules/immer/dist/immer.cjs.production.min.js =================================================================== --- frontend/node_modules/immer/dist/immer.cjs.production.min.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.cjs.production.min.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e3?r.t-4:r.t:Array.isArray(n)?1:c(n)?2:v(n)?3:0}function u(n,r){return 2===i(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function o(n,r){return 2===i(n)?n.get(r):n[r]}function f(n,r,t){var e=i(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t}function a(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function c(n){return W&&n instanceof Map}function v(n){return X&&n instanceof Set}function s(n){return n.i||n.u}function p(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=U(n);delete r[H];for(var t=T(r),e=0;e1&&(n.set=n.add=n.clear=n.delete=d),Object.freeze(n),u&&e(n,(function(n,r){return l(r,!0)}),!0)),n}function d(){n(2)}function h(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function y(r){var t=V[r];return t||n(18,r),t}function _(n,r){V[n]||(V[n]=r)}function b(){return I}function m(n,r){r&&(y("Patches"),n.o=[],n.v=[],n.s=r)}function j(n){O(n),n.p.forEach(w),n.p=null}function O(n){n===I&&(I=n.l)}function x(n){return I={p:[],l:I,h:n,_:!0,m:0}}function w(n){var r=n[H];0===r.t||1===r.t?r.j():r.O=!0}function S(r,e){e.m=e.p.length;var i=e.p[0],u=void 0!==r&&r!==i;return e.h.S||y("ES5").P(e,r,u),u?(i[H].g&&(j(e),n(4)),t(r)&&(r=P(e,r),e.l||M(e,r)),e.o&&y("Patches").M(i[H].u,r,e.o,e.v)):r=P(e,i,[]),j(e),e.o&&e.s(e.o,e.v),r!==B?r:void 0}function P(n,r,t){if(h(r))return r;var i=r[H];if(!i)return e(r,(function(e,u){return g(n,i,r,e,u,t)}),!0),r;if(i.A!==n)return r;if(!i.g)return M(n,i.u,!0),i.u;if(!i.R){i.R=!0,i.A.m--;var u=4===i.t||5===i.t?i.i=p(i.k):i.i,o=u,f=!1;3===i.t&&(o=new Set(u),u.clear(),f=!0),e(o,(function(r,e){return g(n,i,u,r,e,t,f)})),M(n,u,!1),t&&n.o&&y("Patches").F(i,t,n.o,n.v)}return i.i}function g(n,e,i,o,a,c,v){if(r(a)){var s=P(n,a,c&&e&&3!==e.t&&!u(e.N,o)?c.concat(o):void 0);if(f(i,o,s),!r(s))return;n._=!1}else v&&i.add(a);if(t(a)&&!h(a)){if(!n.h.D&&n.m<1)return;P(n,a),e&&e.A.l||M(n,a)}}function M(n,r,t){void 0===t&&(t=!1),!n.l&&n.h.D&&n._&&l(r,t)}function A(n,r){var t=n[H];return(t?s(t):n)[r]}function z(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t)}}function E(n){n.g||(n.g=!0,n.l&&E(n.l))}function R(n){n.i||(n.i=p(n.u))}function k(n,r,t){var e=c(r)?y("MapSet").K(r,t):v(r)?y("MapSet").$(r,t):n.S?function(n,r){var t=Array.isArray(n),e={t:t?1:0,A:r?r.A:b(),g:!1,R:!1,N:{},l:r,u:n,k:null,i:null,j:null,C:!1},i=e,u=Y;t&&(i=[e],u=Z);var o=Proxy.revocable(i,u),f=o.revoke,a=o.proxy;return e.k=a,e.j=f,a}(r,t):y("ES5").I(r,t);return(t?t.A:b()).p.push(e),e}function F(u){return r(u)||n(22,u),function n(r){if(!t(r))return r;var u,a=r[H],c=i(r);if(a){if(!a.g&&(a.t<4||!y("ES5").J(a)))return a.u;a.R=!0,u=N(r,c),a.R=!1}else u=N(r,c);return e(u,(function(r,t){a&&o(a.u,r)===t||f(u,r,n(t))})),3===c?new Set(u):u}(u)}function N(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return p(n)}function D(){function n(n,r){var t=f[n];return t?t.enumerable=r:f[n]=t={configurable:!0,enumerable:r,get:function(){return Y.get(this[H],n)},set:function(r){Y.set(this[H],n,r)}},t}function t(n){for(var r=n.length-1;r>=0;r--){var t=n[r][H];if(!t.g)switch(t.t){case 5:o(t)&&E(t);break;case 4:i(t)&&E(t)}}}function i(n){for(var r=n.u,t=n.k,e=T(t),i=e.length-1;i>=0;i--){var o=e[i];if(o!==H){var f=r[o];if(void 0===f&&!u(r,o))return!0;var c=t[o],v=c&&c[H];if(v?v.u!==f:!a(c,f))return!0}}var s=!!r[H];return e.length!==T(r).length+(s?0:1)}function o(n){var r=n.k;if(r.length!==n.u.length)return!0;var t=Object.getOwnPropertyDescriptor(r,r.length-1);if(t&&!t.get)return!0;for(var e=0;e1?t-1:0),u=1;u1?t-1:0),u=1;u=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var u=y("Patches").W;return r(n)?u(n,t):this.produce(n,(function(n){return u(n,t)}))},e}(),rn=new nn,tn=rn.produce,en=rn.produceWithPatches.bind(rn),un=rn.setAutoFreeze.bind(rn),on=rn.setUseProxies.bind(rn),fn=rn.applyPatches.bind(rn),an=rn.createDraft.bind(rn),cn=rn.finishDraft.bind(rn);exports.Immer=nn,exports.applyPatches=fn,exports.castDraft=function(n){return n},exports.castImmutable=function(n){return n},exports.createDraft=an,exports.current=F,exports.default=tn,exports.enableAllPlugins=function(){D(),$(),K()},exports.enableES5=D,exports.enableMapSet=$,exports.enablePatches=K,exports.finishDraft=cn,exports.freeze=l,exports.immerable=G,exports.isDraft=r,exports.isDraftable=t,exports.nothing=B,exports.original=function(t){return r(t)||n(23,t),t[H].u},exports.produce=tn,exports.produceWithPatches=en,exports.setAutoFreeze=un,exports.setUseProxies=on; +//# sourceMappingURL=immer.cjs.production.min.js.map Index: frontend/node_modules/immer/dist/immer.cjs.production.min.js.map =================================================================== --- frontend/node_modules/immer/dist/immer.cjs.production.min.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.cjs.production.min.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immer.cjs.production.min.js","sources":["../src/utils/errors.ts","../src/utils/common.ts","../src/utils/plugins.ts","../src/core/scope.ts","../src/core/finalize.ts","../src/core/proxy.ts","../src/core/immerClass.ts","../src/core/current.ts","../src/plugins/es5.ts","../src/plugins/patches.ts","../src/plugins/mapset.ts","../src/utils/env.ts","../src/immer.ts","../src/plugins/all.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","// types only!\nimport {\n\tImmerState,\n\tAnyMap,\n\tAnySet,\n\tMapState,\n\tSetState,\n\tDRAFT_STATE,\n\tgetCurrentScope,\n\tlatest,\n\titeratorSymbol,\n\tisDraftable,\n\tcreateProxy,\n\tloadPlugin,\n\tmarkChanged,\n\tProxyType,\n\tdie,\n\teach\n} from \"../internal\"\n\nexport function enableMapSet() {\n\t/* istanbul ignore next */\n\tvar extendStatics = function(d: any, b: any): any {\n\t\textendStatics =\n\t\t\tObject.setPrototypeOf ||\n\t\t\t({__proto__: []} instanceof Array &&\n\t\t\t\tfunction(d, b) {\n\t\t\t\t\td.__proto__ = b\n\t\t\t\t}) ||\n\t\t\tfunction(d, b) {\n\t\t\t\tfor (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]\n\t\t\t}\n\t\treturn extendStatics(d, b)\n\t}\n\n\t// Ugly hack to resolve #502 and inherit built in Map / Set\n\tfunction __extends(d: any, b: any): any {\n\t\textendStatics(d, b)\n\t\tfunction __(this: any): any {\n\t\t\tthis.constructor = d\n\t\t}\n\t\td.prototype =\n\t\t\t// @ts-ignore\n\t\t\t((__.prototype = b.prototype), new __())\n\t}\n\n\tconst DraftMap = (function(_super) {\n\t\t__extends(DraftMap, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftMap(this: any, target: AnyMap, parent?: ImmerState): any {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Map,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tassigned_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this as any,\n\t\t\t\tisManual_: false,\n\t\t\t\trevoked_: false\n\t\t\t} as MapState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftMap.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: false,\n\t\t\t// configurable: true\n\t\t})\n\n\t\tp.has = function(key: any): boolean {\n\t\t\treturn latest(this[DRAFT_STATE]).has(key)\n\t\t}\n\n\t\tp.set = function(key: any, value: any) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!latest(state).has(key) || latest(state).get(key) !== value) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t\tstate.copy_!.set(key, value)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(key: any): boolean {\n\t\t\tif (!this.has(key)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareMapCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\tif (state.base_.has(key)) {\n\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t} else {\n\t\t\t\tstate.assigned_!.delete(key)\n\t\t\t}\n\t\t\tstate.copy_!.delete(key)\n\t\t\treturn true\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_ = new Map()\n\t\t\t\teach(state.base_, key => {\n\t\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t\t})\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.forEach = function(\n\t\t\tcb: (value: any, key: any, self: any) => void,\n\t\t\tthisArg?: any\n\t\t) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tlatest(state).forEach((_value: any, key: any, _map: any) => {\n\t\t\t\tcb.call(thisArg, this.get(key), key, this)\n\t\t\t})\n\t\t}\n\n\t\tp.get = function(key: any): any {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tconst value = latest(state).get(key)\n\t\t\tif (state.finalized_ || !isDraftable(value)) {\n\t\t\t\treturn value\n\t\t\t}\n\t\t\tif (value !== state.base_.get(key)) {\n\t\t\t\treturn value // either already drafted or reassigned\n\t\t\t}\n\t\t\t// despite what it looks, this creates a draft only once, see above condition\n\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\tprepareMapCopy(state)\n\t\t\tstate.copy_!.set(key, draft)\n\t\t\treturn draft\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn latest(this[DRAFT_STATE]).keys()\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.values(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp.entries = function(): IterableIterator<[any, any]> {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.entries(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue: [r.value, value]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.entries()\n\t\t}\n\n\t\treturn DraftMap\n\t})(Map)\n\n\tfunction proxyMap_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftMap(target, parent)\n\t}\n\n\tfunction prepareMapCopy(state: MapState) {\n\t\tif (!state.copy_) {\n\t\t\tstate.assigned_ = new Map()\n\t\t\tstate.copy_ = new Map(state.base_)\n\t\t}\n\t}\n\n\tconst DraftSet = (function(_super) {\n\t\t__extends(DraftSet, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftSet(this: any, target: AnySet, parent?: ImmerState) {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Set,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this,\n\t\t\t\tdrafts_: new Map(),\n\t\t\t\trevoked_: false,\n\t\t\t\tisManual_: false\n\t\t\t} as SetState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftSet.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: true,\n\t\t})\n\n\t\tp.has = function(value: any): boolean {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\t// bit of trickery here, to be able to recognize both the value, and the draft of its value\n\t\t\tif (!state.copy_) {\n\t\t\t\treturn state.base_.has(value)\n\t\t\t}\n\t\t\tif (state.copy_.has(value)) return true\n\t\t\tif (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n\t\t\t\treturn true\n\t\t\treturn false\n\t\t}\n\n\t\tp.add = function(value: any): any {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!this.has(value)) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.add(value)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(value: any): any {\n\t\t\tif (!this.has(value)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\treturn (\n\t\t\t\tstate.copy_!.delete(value) ||\n\t\t\t\t(state.drafts_.has(value)\n\t\t\t\t\t? state.copy_!.delete(state.drafts_.get(value))\n\t\t\t\t\t: /* istanbul ignore next */ false)\n\t\t\t)\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.values()\n\t\t}\n\n\t\tp.entries = function entries(): IterableIterator<[any, any]> {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.entries()\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp.forEach = function forEach(cb: any, thisArg?: any) {\n\t\t\tconst iterator = this.values()\n\t\t\tlet result = iterator.next()\n\t\t\twhile (!result.done) {\n\t\t\t\tcb.call(thisArg, result.value, result.value, this)\n\t\t\t\tresult = iterator.next()\n\t\t\t}\n\t\t}\n\n\t\treturn DraftSet\n\t})(Set)\n\n\tfunction proxySet_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftSet(target, parent)\n\t}\n\n\tfunction prepareSetCopy(state: SetState) {\n\t\tif (!state.copy_) {\n\t\t\t// create drafts for all entries to preserve insertion order\n\t\t\tstate.copy_ = new Set()\n\t\t\tstate.base_.forEach(value => {\n\t\t\t\tif (isDraftable(value)) {\n\t\t\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\t\t\tstate.drafts_.set(value, draft)\n\t\t\t\t\tstate.copy_!.add(draft)\n\t\t\t\t} else {\n\t\t\t\t\tstate.copy_!.add(value)\n\t\t\t\t}\n\t\t\t})\n\t\t}\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(\"MapSet\", {proxyMap_, proxySet_})\n}\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","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","import {enableES5} from \"./es5\"\nimport {enableMapSet} from \"./mapset\"\nimport {enablePatches} from \"./patches\"\n\nexport function enableAllPlugins() {\n\tenableES5()\n\tenableMapSet()\n\tenablePatches()\n}\n"],"names":["die","error","args","Error","length","map","s","join","isDraft","value","DRAFT_STATE","isDraftable","proto","Object","getPrototypeOf","Ctor","hasOwnProperty","call","constructor","Function","toString","objectCtorString","Array","isArray","DRAFTABLE","_value$constructor","isMap","isSet","each","obj","iter","enumerableOnly","getArchtype","keys","ownKeys","forEach","key","entry","index","thing","state","type_","has","prop","prototype","get","set","propOrOldValue","t","add","is","x","y","target","hasMap","Map","hasSet","Set","latest","copy_","base_","shallowCopy","base","slice","descriptors","getOwnPropertyDescriptors","i","desc","writable","configurable","enumerable","create","freeze","deep","isFrozen","clear","delete","dontMutateFrozenCollections","getPlugin","pluginKey","plugin","plugins","loadPlugin","implementation","getCurrentScope","currentScope","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","drafts_","revokeDraft","parent_","enterScope","immer","immer_","canAutoFreeze_","unfinalizedDrafts_","draft","revoke_","revoked_","processResult","result","baseDraft","isReplaced","useProxies_","willFinalizeES5_","modified_","finalize","maybeFreeze","generateReplacementPatches_","NOTHING","rootScope","path","childValue","finalizeProperty","scope_","finalized_","draft_","resultEach","generatePatches_","parentState","targetObject","rootPath","targetIsSet","res","assigned_","concat","autoFreeze_","peek","getDescriptorFromProto","source","getOwnPropertyDescriptor","markChanged","prepareCopy","createProxy","parent","proxyMap_","proxySet_","isManual_","traps","objectTraps","arrayTraps","Proxy","revocable","revoke","proxy","createES5Proxy_","push","current","currentImpl","copy","archType","hasChanges_","copyHelper","from","enableES5","proxyProperty","this","markChangesSweep","drafts","hasArrayChanges","hasObjectChanges","baseValue","baseIsDraft","descriptor","defineProperty","markChangesRecursively","object","min","Math","enablePatches","deepClonePatchValue","entries","cloned","immerable","clonePatchValueIfNeeded","ADD","applyPatches_","patches","patch","op","parentType","p","type","splice","basePath","inversePatches","assignedValue","origValue","unshift","replacement","enableMapSet","__extends","d","b","__","extendStatics","prepareMapCopy","prepareSetCopy","assertUnrevoked","JSON","stringify","setPrototypeOf","__proto__","DraftMap","size","cb","thisArg","_value","_this","values","iterator","iteratorSymbol","_this2","next","r","done","_this3","DraftSet","hasSymbol","Symbol","hasProxies","Reflect","for","getOwnPropertySymbols","getOwnPropertyNames","_desc$get","currentState","Number","isNaN","deleteProperty","owner","fn","arguments","apply","Immer","config","recipe","defaultBase","self","produce","hasError","Promise","then","ip","produceWithPatches","nextState","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","applyPatchesImpl","bind"],"mappings":"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"} Index: frontend/node_modules/immer/dist/immer.d.ts =================================================================== --- frontend/node_modules/immer/dist/immer.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,80 @@ +import { IProduce, IProduceWithPatches, Immer, Draft, Immutable } from "./internal"; +export { Draft, Immutable, Patch, PatchListener, original, current, isDraft, isDraftable, NOTHING as nothing, DRAFTABLE as immerable, freeze } from "./internal"; +/** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ +export declare const produce: IProduce; +export default produce; +/** + * Like `produce`, but `produceWithPatches` always returns a tuple + * [nextState, patches, inversePatches] (instead of just the next state) + */ +export declare const produceWithPatches: IProduceWithPatches; +/** + * Pass true to automatically freeze all copies created by Immer. + * + * Always freeze by default, even in production mode + */ +export declare const setAutoFreeze: (value: boolean) => void; +/** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ +export declare const setUseProxies: (value: boolean) => void; +/** + * Apply an array of Immer patches to the first argument. + * + * This function is a producer, which means copy-on-write is in effect. + */ +export declare const applyPatches: (base: T, patches: import("./internal").Patch[]) => T; +/** + * Create an Immer draft from the given base state, which may be a draft itself. + * The draft can be modified until you finalize it with the `finishDraft` function. + */ +export declare const createDraft: (base: T) => Draft; +/** + * Finalize an Immer draft from a `createDraft` call, returning the base state + * (if no changes were made) or a modified copy. The draft must *not* be + * mutated afterwards. + * + * Pass a function as the 2nd argument to generate Immer patches based on the + * changes that were made. + */ +export declare const finishDraft: (draft: D, patchListener?: import("./internal").PatchListener | undefined) => D extends Draft ? T : never; +/** + * This function is actually a no-op, but can be used to cast an immutable type + * to an draft type and make TypeScript happy + * + * @param value + */ +export declare function castDraft(value: T): Draft; +/** + * This function is actually a no-op, but can be used to cast a mutable type + * to an immutable type and make TypeScript happy + * @param value + */ +export declare function castImmutable(value: T): Immutable; +export { Immer }; +export { enableES5 } from "./plugins/es5"; +export { enablePatches } from "./plugins/patches"; +export { enableMapSet } from "./plugins/mapset"; +export { enableAllPlugins } from "./plugins/all"; +//# sourceMappingURL=immer.d.ts.map Index: frontend/node_modules/immer/dist/immer.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/immer.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immer.d.ts","sourceRoot":"","sources":["src/immer.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACL,KAAK,EACL,SAAS,EACT,MAAM,YAAY,CAAA;AAEnB,OAAO,EACN,KAAK,EACL,SAAS,EACT,KAAK,EACL,aAAa,EACb,QAAQ,EACR,OAAO,EACP,OAAO,EACP,WAAW,EACX,OAAO,IAAI,OAAO,EAClB,SAAS,IAAI,SAAS,EACtB,MAAM,EACN,MAAM,YAAY,CAAA;AAInB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,EAAE,QAAwB,CAAA;AAC9C,eAAe,OAAO,CAAA;AAEtB;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,mBAEhC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,0BAAkC,CAAA;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,aAAa,0BAAkC,CAAA;AAE5D;;;;GAIG;AACH,eAAO,MAAM,YAAY,iGAAiC,CAAA;AAE1D;;;GAGG;AACH,eAAO,MAAM,WAAW,iEAAgC,CAAA;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,mIAAgC,CAAA;AAExD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEvD;AAED,OAAO,EAAC,KAAK,EAAC,CAAA;AAEd,OAAO,EAAC,SAAS,EAAC,MAAM,eAAe,CAAA;AACvC,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAC,YAAY,EAAC,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,eAAe,CAAA"} Index: frontend/node_modules/immer/dist/immer.esm.js =================================================================== --- frontend/node_modules/immer/dist/immer.esm.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.esm.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,!0)}),!0)),n}function h(){n(2)}function y(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function m(n,r){tn[n]||(tn[n]=r)}function _(){return"production"===process.env.NODE_ENV||U||n(0),U}function j(n,r){r&&(b("Patches"),n.u=[],n.s=[],n.v=r)}function g(n){O(n),n.p.forEach(S),n.p=null}function O(n){n===U&&(U=n.l)}function w(n){return U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.g=!0}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.O||b("ES5").S(e,r,o),o?(i[Q].P&&(g(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b("Patches").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),g(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),!0),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o,u=o,a=!1;3===e.i&&(u=new Set(o),o.clear(),a=!0),i(u,(function(r,i){return A(n,e,o,r,i,t,a)})),x(n,o,!1),t&&n.u&&b("Patches").N(e,t,n.u,n.s)}return e.o}function A(e,i,o,a,c,s,v){if("production"!==process.env.NODE_ENV&&c===o&&n(5),r(c)){var p=M(e,c,s&&i&&3!==i.i&&!u(i.R,a)?s.concat(a):void 0);if(f(o,a,p),!r(p))return;e.m=!1}else v&&o.add(c);if(t(c)&&!y(c)){if(!e.h.D&&e._<1)return;M(e,c),i&&i.A.l||x(e,c)}}function x(n,r,t){void 0===t&&(t=!1),!n.l&&n.h.D&&n.m&&d(r,t)}function z(n,r){var t=n[Q];return(t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t)}}function k(n){n.P||(n.P=!0,n.l&&k(n.l))}function E(n){n.o||(n.o=l(n.t))}function N(n,r,t){var e=s(r)?b("MapSet").F(r,t):v(r)?b("MapSet").T(r,t):n.O?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:null,o:null,j:null,C:!1},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b("ES5").J(r,t);return(t?t.A:_()).p.push(e),e}function R(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b("ES5").K(u)))return u.t;u.I=!0,e=D(r,c),u.I=!1}else e=D(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t))})),3===c?new Set(e):e}(e)}function D(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}function F(){function t(n,r){var t=s[n];return t?t.enumerable=r:s[n]=t={configurable:!0,enumerable:r,get:function(){var r=this[Q];return"production"!==process.env.NODE_ENV&&f(r),en.get(r,n)},set:function(r){var t=this[Q];"production"!==process.env.NODE_ENV&&f(t),en.set(t,n,r)}},t}function e(n){for(var r=n.length-1;r>=0;r--){var t=n[r][Q];if(!t.P)switch(t.i){case 5:a(t)&&k(t);break;case 4:o(t)&&k(t)}}}function o(n){for(var r=n.t,t=n.k,e=nn(t),i=e.length-1;i>=0;i--){var o=e[i];if(o!==Q){var a=r[o];if(void 0===a&&!u(r,o))return!0;var f=t[o],s=f&&f[Q];if(s?s.t!==a:!c(f,a))return!0}}var v=!!r[Q];return e.length!==nn(r).length+(v?0:1)}function a(n){var r=n.k;if(r.length!==n.t.length)return!0;var t=Object.getOwnPropertyDescriptor(r,r.length-1);if(t&&!t.get)return!0;for(var e=0;e1?t-1:0),o=1;o1?t-1:0),o=1;o=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b("Patches").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce,cn=an.produceWithPatches.bind(an),sn=an.setAutoFreeze.bind(an),vn=an.setUseProxies.bind(an),pn=an.applyPatches.bind(an),ln=an.createDraft.bind(an),dn=an.finishDraft.bind(an);export default fn;export{un as Immer,pn as applyPatches,K as castDraft,$ as castImmutable,ln as createDraft,R as current,J as enableAllPlugins,F as enableES5,C as enableMapSet,T as enablePatches,dn as finishDraft,d as freeze,L as immerable,r as isDraft,t as isDraftable,H as nothing,e as original,fn as produce,cn as produceWithPatches,sn as setAutoFreeze,vn as setUseProxies}; +//# sourceMappingURL=immer.esm.js.map Index: frontend/node_modules/immer/dist/immer.esm.js.map =================================================================== --- frontend/node_modules/immer/dist/immer.esm.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.esm.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immer.esm.js","sources":["../src/utils/errors.ts","../src/utils/common.ts","../src/utils/plugins.ts","../src/core/scope.ts","../src/core/finalize.ts","../src/core/proxy.ts","../src/core/immerClass.ts","../src/core/current.ts","../src/plugins/es5.ts","../src/plugins/patches.ts","../src/plugins/mapset.ts","../src/plugins/all.ts","../src/immer.ts","../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","// types only!\nimport {\n\tImmerState,\n\tAnyMap,\n\tAnySet,\n\tMapState,\n\tSetState,\n\tDRAFT_STATE,\n\tgetCurrentScope,\n\tlatest,\n\titeratorSymbol,\n\tisDraftable,\n\tcreateProxy,\n\tloadPlugin,\n\tmarkChanged,\n\tProxyType,\n\tdie,\n\teach\n} from \"../internal\"\n\nexport function enableMapSet() {\n\t/* istanbul ignore next */\n\tvar extendStatics = function(d: any, b: any): any {\n\t\textendStatics =\n\t\t\tObject.setPrototypeOf ||\n\t\t\t({__proto__: []} instanceof Array &&\n\t\t\t\tfunction(d, b) {\n\t\t\t\t\td.__proto__ = b\n\t\t\t\t}) ||\n\t\t\tfunction(d, b) {\n\t\t\t\tfor (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]\n\t\t\t}\n\t\treturn extendStatics(d, b)\n\t}\n\n\t// Ugly hack to resolve #502 and inherit built in Map / Set\n\tfunction __extends(d: any, b: any): any {\n\t\textendStatics(d, b)\n\t\tfunction __(this: any): any {\n\t\t\tthis.constructor = d\n\t\t}\n\t\td.prototype =\n\t\t\t// @ts-ignore\n\t\t\t((__.prototype = b.prototype), new __())\n\t}\n\n\tconst DraftMap = (function(_super) {\n\t\t__extends(DraftMap, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftMap(this: any, target: AnyMap, parent?: ImmerState): any {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Map,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tassigned_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this as any,\n\t\t\t\tisManual_: false,\n\t\t\t\trevoked_: false\n\t\t\t} as MapState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftMap.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: false,\n\t\t\t// configurable: true\n\t\t})\n\n\t\tp.has = function(key: any): boolean {\n\t\t\treturn latest(this[DRAFT_STATE]).has(key)\n\t\t}\n\n\t\tp.set = function(key: any, value: any) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!latest(state).has(key) || latest(state).get(key) !== value) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t\tstate.copy_!.set(key, value)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(key: any): boolean {\n\t\t\tif (!this.has(key)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareMapCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\tif (state.base_.has(key)) {\n\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t} else {\n\t\t\t\tstate.assigned_!.delete(key)\n\t\t\t}\n\t\t\tstate.copy_!.delete(key)\n\t\t\treturn true\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_ = new Map()\n\t\t\t\teach(state.base_, key => {\n\t\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t\t})\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.forEach = function(\n\t\t\tcb: (value: any, key: any, self: any) => void,\n\t\t\tthisArg?: any\n\t\t) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tlatest(state).forEach((_value: any, key: any, _map: any) => {\n\t\t\t\tcb.call(thisArg, this.get(key), key, this)\n\t\t\t})\n\t\t}\n\n\t\tp.get = function(key: any): any {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tconst value = latest(state).get(key)\n\t\t\tif (state.finalized_ || !isDraftable(value)) {\n\t\t\t\treturn value\n\t\t\t}\n\t\t\tif (value !== state.base_.get(key)) {\n\t\t\t\treturn value // either already drafted or reassigned\n\t\t\t}\n\t\t\t// despite what it looks, this creates a draft only once, see above condition\n\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\tprepareMapCopy(state)\n\t\t\tstate.copy_!.set(key, draft)\n\t\t\treturn draft\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn latest(this[DRAFT_STATE]).keys()\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.values(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp.entries = function(): IterableIterator<[any, any]> {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.entries(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue: [r.value, value]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.entries()\n\t\t}\n\n\t\treturn DraftMap\n\t})(Map)\n\n\tfunction proxyMap_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftMap(target, parent)\n\t}\n\n\tfunction prepareMapCopy(state: MapState) {\n\t\tif (!state.copy_) {\n\t\t\tstate.assigned_ = new Map()\n\t\t\tstate.copy_ = new Map(state.base_)\n\t\t}\n\t}\n\n\tconst DraftSet = (function(_super) {\n\t\t__extends(DraftSet, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftSet(this: any, target: AnySet, parent?: ImmerState) {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Set,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this,\n\t\t\t\tdrafts_: new Map(),\n\t\t\t\trevoked_: false,\n\t\t\t\tisManual_: false\n\t\t\t} as SetState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftSet.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: true,\n\t\t})\n\n\t\tp.has = function(value: any): boolean {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\t// bit of trickery here, to be able to recognize both the value, and the draft of its value\n\t\t\tif (!state.copy_) {\n\t\t\t\treturn state.base_.has(value)\n\t\t\t}\n\t\t\tif (state.copy_.has(value)) return true\n\t\t\tif (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n\t\t\t\treturn true\n\t\t\treturn false\n\t\t}\n\n\t\tp.add = function(value: any): any {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!this.has(value)) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.add(value)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(value: any): any {\n\t\t\tif (!this.has(value)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\treturn (\n\t\t\t\tstate.copy_!.delete(value) ||\n\t\t\t\t(state.drafts_.has(value)\n\t\t\t\t\t? state.copy_!.delete(state.drafts_.get(value))\n\t\t\t\t\t: /* istanbul ignore next */ false)\n\t\t\t)\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.values()\n\t\t}\n\n\t\tp.entries = function entries(): IterableIterator<[any, any]> {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.entries()\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp.forEach = function forEach(cb: any, thisArg?: any) {\n\t\t\tconst iterator = this.values()\n\t\t\tlet result = iterator.next()\n\t\t\twhile (!result.done) {\n\t\t\t\tcb.call(thisArg, result.value, result.value, this)\n\t\t\t\tresult = iterator.next()\n\t\t\t}\n\t\t}\n\n\t\treturn DraftSet\n\t})(Set)\n\n\tfunction proxySet_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftSet(target, parent)\n\t}\n\n\tfunction prepareSetCopy(state: SetState) {\n\t\tif (!state.copy_) {\n\t\t\t// create drafts for all entries to preserve insertion order\n\t\t\tstate.copy_ = new Set()\n\t\t\tstate.base_.forEach(value => {\n\t\t\t\tif (isDraftable(value)) {\n\t\t\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\t\t\tstate.drafts_.set(value, draft)\n\t\t\t\t\tstate.copy_!.add(draft)\n\t\t\t\t} else {\n\t\t\t\t\tstate.copy_!.add(value)\n\t\t\t\t}\n\t\t\t})\n\t\t}\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(\"MapSet\", {proxyMap_, proxySet_})\n}\n","import {enableES5} from \"./es5\"\nimport {enableMapSet} from \"./mapset\"\nimport {enablePatches} from \"./patches\"\n\nexport function enableAllPlugins() {\n\tenableES5()\n\tenableMapSet()\n\tenablePatches()\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":["die","error","args","e","errors","msg","apply","Error","length","map","s","join","isDraft","value","DRAFT_STATE","isDraftable","proto","Object","getPrototypeOf","Ctor","hasOwnProperty","call","constructor","Function","toString","objectCtorString","isPlainObject","Array","isArray","DRAFTABLE","_value$constructor","isMap","isSet","original","base_","each","obj","iter","enumerableOnly","getArchtype","keys","ownKeys","forEach","key","entry","index","thing","state","type_","has","prop","prototype","get","set","propOrOldValue","t","add","is","x","y","target","hasMap","Map","hasSet","Set","latest","copy_","shallowCopy","base","slice","descriptors","getOwnPropertyDescriptors","i","desc","writable","configurable","enumerable","create","freeze","deep","isFrozen","clear","delete","dontMutateFrozenCollections","getPlugin","pluginKey","plugin","plugins","loadPlugin","implementation","getCurrentScope","process","currentScope","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","drafts_","revokeDraft","parent_","enterScope","immer","immer_","canAutoFreeze_","unfinalizedDrafts_","draft","revoke_","revoked_","processResult","result","baseDraft","isReplaced","undefined","useProxies_","willFinalizeES5_","modified_","finalize","maybeFreeze","generateReplacementPatches_","NOTHING","rootScope","path","childValue","finalizeProperty","scope_","finalized_","draft_","resultEach","generatePatches_","parentState","targetObject","rootPath","targetIsSet","res","assigned_","concat","autoFreeze_","peek","getDescriptorFromProto","source","getOwnPropertyDescriptor","markChanged","prepareCopy","createProxy","parent","proxyMap_","proxySet_","isManual_","traps","objectTraps","arrayTraps","Proxy","revocable","revoke","proxy","createProxyProxy","createES5Proxy_","push","current","currentImpl","copy","archType","hasChanges_","copyHelper","from","enableES5","proxyProperty","this","assertUnrevoked","markChangesSweep","drafts","hasArrayChanges","hasObjectChanges","baseValue","baseIsDraft","descriptor","JSON","stringify","defineProperty","createES5Draft","markChangesRecursively","object","min","Math","enablePatches","deepClonePatchValue","entries","cloned","immerable","clonePatchValueIfNeeded","ADD","applyPatches_","patches","patch","op","parentType","p","type","splice","basePath","inversePatches","assignedValue","origValue","generatePatchesFromAssigned","generateArrayPatches","unshift","generateSetPatches","replacement","enableMapSet","__extends","d","b","__","extendStatics","prepareMapCopy","prepareSetCopy","setPrototypeOf","__proto__","DraftMap","size","cb","thisArg","_value","_this","values","iterator","iteratorSymbol","_this2","next","r","done","_this3","DraftSet","enableAllPlugins","castDraft","castImmutable","hasSymbol","Symbol","hasProxies","Reflect","for","data","getOwnPropertySymbols","getOwnPropertyNames","_desc$get","readPropFromProto","currentState","Number","isNaN","deleteProperty","owner","fn","arguments","parseInt","Immer","config","recipe","defaultBase","self","produce","hasError","Promise","then","ip","produceWithPatches","nextState","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","applyPatchesImpl","bind"],"mappings":"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"} Index: frontend/node_modules/immer/dist/immer.esm.mjs =================================================================== --- frontend/node_modules/immer/dist/immer.esm.mjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.esm.mjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,!0)}),!0)),n}function h(){n(2)}function y(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function m(n,r){tn[n]||(tn[n]=r)}function _(){return"production"===process.env.NODE_ENV||U||n(0),U}function j(n,r){r&&(b("Patches"),n.u=[],n.s=[],n.v=r)}function g(n){O(n),n.p.forEach(S),n.p=null}function O(n){n===U&&(U=n.l)}function w(n){return U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.g=!0}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.O||b("ES5").S(e,r,o),o?(i[Q].P&&(g(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b("Patches").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),g(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),!0),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o,u=o,a=!1;3===e.i&&(u=new Set(o),o.clear(),a=!0),i(u,(function(r,i){return A(n,e,o,r,i,t,a)})),x(n,o,!1),t&&n.u&&b("Patches").N(e,t,n.u,n.s)}return e.o}function A(e,i,o,a,c,s,v){if("production"!==process.env.NODE_ENV&&c===o&&n(5),r(c)){var p=M(e,c,s&&i&&3!==i.i&&!u(i.R,a)?s.concat(a):void 0);if(f(o,a,p),!r(p))return;e.m=!1}else v&&o.add(c);if(t(c)&&!y(c)){if(!e.h.D&&e._<1)return;M(e,c),i&&i.A.l||x(e,c)}}function x(n,r,t){void 0===t&&(t=!1),!n.l&&n.h.D&&n.m&&d(r,t)}function z(n,r){var t=n[Q];return(t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t)}}function k(n){n.P||(n.P=!0,n.l&&k(n.l))}function E(n){n.o||(n.o=l(n.t))}function N(n,r,t){var e=s(r)?b("MapSet").F(r,t):v(r)?b("MapSet").T(r,t):n.O?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:null,o:null,j:null,C:!1},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b("ES5").J(r,t);return(t?t.A:_()).p.push(e),e}function R(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b("ES5").K(u)))return u.t;u.I=!0,e=D(r,c),u.I=!1}else e=D(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t))})),3===c?new Set(e):e}(e)}function D(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}function F(){function t(n,r){var t=s[n];return t?t.enumerable=r:s[n]=t={configurable:!0,enumerable:r,get:function(){var r=this[Q];return"production"!==process.env.NODE_ENV&&f(r),en.get(r,n)},set:function(r){var t=this[Q];"production"!==process.env.NODE_ENV&&f(t),en.set(t,n,r)}},t}function e(n){for(var r=n.length-1;r>=0;r--){var t=n[r][Q];if(!t.P)switch(t.i){case 5:a(t)&&k(t);break;case 4:o(t)&&k(t)}}}function o(n){for(var r=n.t,t=n.k,e=nn(t),i=e.length-1;i>=0;i--){var o=e[i];if(o!==Q){var a=r[o];if(void 0===a&&!u(r,o))return!0;var f=t[o],s=f&&f[Q];if(s?s.t!==a:!c(f,a))return!0}}var v=!!r[Q];return e.length!==nn(r).length+(v?0:1)}function a(n){var r=n.k;if(r.length!==n.t.length)return!0;var t=Object.getOwnPropertyDescriptor(r,r.length-1);if(t&&!t.get)return!0;for(var e=0;e1?t-1:0),o=1;o1?t-1:0),o=1;o=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b("Patches").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce,cn=an.produceWithPatches.bind(an),sn=an.setAutoFreeze.bind(an),vn=an.setUseProxies.bind(an),pn=an.applyPatches.bind(an),ln=an.createDraft.bind(an),dn=an.finishDraft.bind(an);export default fn;export{un as Immer,pn as applyPatches,K as castDraft,$ as castImmutable,ln as createDraft,R as current,J as enableAllPlugins,F as enableES5,C as enableMapSet,T as enablePatches,dn as finishDraft,d as freeze,L as immerable,r as isDraft,t as isDraftable,H as nothing,e as original,fn as produce,cn as produceWithPatches,sn as setAutoFreeze,vn as setUseProxies}; +//# sourceMappingURL=immer.esm.js.map Index: frontend/node_modules/immer/dist/immer.umd.development.js =================================================================== --- frontend/node_modules/immer/dist/immer.umd.development.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.umd.development.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2091 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = global || self, factory(global.immer = {})); +}(this, (function (exports) { 'use strict'; + + var _ref; + + // Should be no imports here! + // Some things that should be evaluated before all else... + // We only want to know if non-polyfilled symbols are available + var hasSymbol = typeof Symbol !== "undefined" && typeof + /*#__PURE__*/ + Symbol("x") === "symbol"; + var hasMap = typeof Map !== "undefined"; + var hasSet = typeof Set !== "undefined"; + var hasProxies = typeof Proxy !== "undefined" && typeof Proxy.revocable !== "undefined" && typeof Reflect !== "undefined"; + /** + * The sentinel value returned by producers to replace the draft with undefined. + */ + + var NOTHING = hasSymbol ? + /*#__PURE__*/ + Symbol.for("immer-nothing") : (_ref = {}, _ref["immer-nothing"] = true, _ref); + /** + * To let Immer treat your class instances as plain immutable objects + * (albeit with a custom prototype), you must define either an instance property + * or a static property on each of your custom classes. + * + * Otherwise, your class instance will never be drafted, which means it won't be + * safe to mutate in a produce callback. + */ + + var DRAFTABLE = hasSymbol ? + /*#__PURE__*/ + Symbol.for("immer-draftable") : "__$immer_draftable"; + var DRAFT_STATE = hasSymbol ? + /*#__PURE__*/ + Symbol.for("immer-state") : "__$immer_state"; // Even a polyfilled Symbol might provide Symbol.iterator + + var iteratorSymbol = typeof Symbol != "undefined" && Symbol.iterator || "@@iterator"; + + var errors = { + 0: "Illegal state", + 1: "Immer drafts cannot have computed properties", + 2: "This object has been frozen and should not be mutated", + 3: function _(data) { + return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data; + }, + 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", + 5: "Immer forbids circular references", + 6: "The first or second argument to `produce` must be a function", + 7: "The third argument to `produce` must be a function or undefined", + 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object", + 9: "First argument to `finishDraft` must be a draft returned by `createDraft`", + 10: "The given draft is already finalized", + 11: "Object.defineProperty() cannot be used on an Immer draft", + 12: "Object.setPrototypeOf() cannot be used on an Immer draft", + 13: "Immer only supports deleting array indices", + 14: "Immer only supports setting array indices and the 'length' property", + 15: function _(path) { + return "Cannot apply patch, path doesn't resolve: " + path; + }, + 16: 'Sets cannot have "replace" patches.', + 17: function _(op) { + return "Unsupported patch operation: " + op; + }, + 18: function _(plugin) { + return "The plugin for '" + plugin + "' has not been loaded into Immer. To enable the plugin, import and call `enable" + plugin + "()` when initializing your application."; + }, + 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available", + 21: function _(thing) { + return "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 + "'"; + }, + 22: function _(thing) { + return "'current' expects a draft, got: " + thing; + }, + 23: function _(thing) { + return "'original' expects a draft, got: " + thing; + }, + 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed" + }; + function die(error) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + { + var e = errors[error]; + var msg = !e ? "unknown error nr: " + error : typeof e === "function" ? e.apply(null, args) : e; + throw new Error("[Immer] " + msg); + } + } + + /** Returns true if the given value is an Immer draft */ + + /*#__PURE__*/ + + function isDraft(value) { + return !!value && !!value[DRAFT_STATE]; + } + /** Returns true if the given value can be drafted by Immer */ + + /*#__PURE__*/ + + function isDraftable(value) { + var _value$constructor; + + if (!value) return false; + return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor[DRAFTABLE]) || isMap(value) || isSet(value); + } + var objectCtorString = + /*#__PURE__*/ + Object.prototype.constructor.toString(); + /*#__PURE__*/ + + function isPlainObject(value) { + if (!value || typeof value !== "object") return false; + var proto = Object.getPrototypeOf(value); + + if (proto === null) { + return true; + } + + var Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor; + if (Ctor === Object) return true; + return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString; + } + function original(value) { + if (!isDraft(value)) die(23, value); + return value[DRAFT_STATE].base_; + } + /*#__PURE__*/ + + var ownKeys = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function (obj) { + return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)); + } : + /* istanbul ignore next */ + Object.getOwnPropertyNames; + var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(target) { + // Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274 + var res = {}; + ownKeys(target).forEach(function (key) { + res[key] = Object.getOwnPropertyDescriptor(target, key); + }); + return res; + }; + function each(obj, iter, enumerableOnly) { + if (enumerableOnly === void 0) { + enumerableOnly = false; + } + + if (getArchtype(obj) === 0 + /* Object */ + ) { + (enumerableOnly ? Object.keys : ownKeys)(obj).forEach(function (key) { + if (!enumerableOnly || typeof key !== "symbol") iter(key, obj[key], obj); + }); + } else { + obj.forEach(function (entry, index) { + return iter(index, entry, obj); + }); + } + } + /*#__PURE__*/ + + function getArchtype(thing) { + /* istanbul ignore next */ + var state = thing[DRAFT_STATE]; + return state ? state.type_ > 3 ? state.type_ - 4 // cause Object and Array map back from 4 and 5 + : state.type_ // others are the same + : Array.isArray(thing) ? 1 + /* Array */ + : isMap(thing) ? 2 + /* Map */ + : isSet(thing) ? 3 + /* Set */ + : 0 + /* Object */ + ; + } + /*#__PURE__*/ + + function has(thing, prop) { + return getArchtype(thing) === 2 + /* Map */ + ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop); + } + /*#__PURE__*/ + + function get(thing, prop) { + // @ts-ignore + return getArchtype(thing) === 2 + /* Map */ + ? thing.get(prop) : thing[prop]; + } + /*#__PURE__*/ + + function set(thing, propOrOldValue, value) { + var t = getArchtype(thing); + if (t === 2 + /* Map */ + ) thing.set(propOrOldValue, value);else if (t === 3 + /* Set */ + ) { + thing.add(value); + } else thing[propOrOldValue] = value; + } + /*#__PURE__*/ + + function is(x, y) { + // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js + if (x === y) { + return x !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } + } + /*#__PURE__*/ + + function isMap(target) { + return hasMap && target instanceof Map; + } + /*#__PURE__*/ + + function isSet(target) { + return hasSet && target instanceof Set; + } + /*#__PURE__*/ + + function latest(state) { + return state.copy_ || state.base_; + } + /*#__PURE__*/ + + function shallowCopy(base) { + if (Array.isArray(base)) return Array.prototype.slice.call(base); + var descriptors = getOwnPropertyDescriptors(base); + delete descriptors[DRAFT_STATE]; + var keys = ownKeys(descriptors); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var desc = descriptors[key]; + + if (desc.writable === false) { + desc.writable = true; + desc.configurable = true; + } // like object.assign, we will read any _own_, get/set accessors. This helps in dealing + // with libraries that trap values, like mobx or vue + // unlike object.assign, non-enumerables will be copied as well + + + if (desc.get || desc.set) descriptors[key] = { + configurable: true, + writable: true, + enumerable: desc.enumerable, + value: base[key] + }; + } + + return Object.create(Object.getPrototypeOf(base), descriptors); + } + function freeze(obj, deep) { + if (deep === void 0) { + deep = false; + } + + if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj; + + if (getArchtype(obj) > 1 + /* Map or Set */ + ) { + obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections; + } + + Object.freeze(obj); + if (deep) each(obj, function (key, value) { + return freeze(value, true); + }, true); + return obj; + } + + function dontMutateFrozenCollections() { + die(2); + } + + function isFrozen(obj) { + if (obj == null || typeof obj !== "object") return true; // See #600, IE dies on non-objects in Object.isFrozen + + return Object.isFrozen(obj); + } + + /** Plugin utilities */ + + var plugins = {}; + function getPlugin(pluginKey) { + var plugin = plugins[pluginKey]; + + if (!plugin) { + die(18, pluginKey); + } // @ts-ignore + + + return plugin; + } + function loadPlugin(pluginKey, implementation) { + if (!plugins[pluginKey]) plugins[pluginKey] = implementation; + } + + var currentScope; + function getCurrentScope() { + if ( !currentScope) die(0); + return currentScope; + } + + function createScope(parent_, immer_) { + return { + drafts_: [], + parent_: parent_, + immer_: immer_, + // Whenever the modified draft contains a draft from another scope, we + // need to prevent auto-freezing so the unowned draft can be finalized. + canAutoFreeze_: true, + unfinalizedDrafts_: 0 + }; + } + + function usePatchesInScope(scope, patchListener) { + if (patchListener) { + getPlugin("Patches"); // assert we have the plugin + + scope.patches_ = []; + scope.inversePatches_ = []; + scope.patchListener_ = patchListener; + } + } + function revokeScope(scope) { + leaveScope(scope); + scope.drafts_.forEach(revokeDraft); // @ts-ignore + + scope.drafts_ = null; + } + function leaveScope(scope) { + if (scope === currentScope) { + currentScope = scope.parent_; + } + } + function enterScope(immer) { + return currentScope = createScope(currentScope, immer); + } + + function revokeDraft(draft) { + var state = draft[DRAFT_STATE]; + if (state.type_ === 0 + /* ProxyObject */ + || state.type_ === 1 + /* ProxyArray */ + ) state.revoke_();else state.revoked_ = true; + } + + function processResult(result, scope) { + scope.unfinalizedDrafts_ = scope.drafts_.length; + var baseDraft = scope.drafts_[0]; + var isReplaced = result !== undefined && result !== baseDraft; + if (!scope.immer_.useProxies_) getPlugin("ES5").willFinalizeES5_(scope, result, isReplaced); + + if (isReplaced) { + if (baseDraft[DRAFT_STATE].modified_) { + revokeScope(scope); + die(4); + } + + if (isDraftable(result)) { + // Finalize the result in case it contains (or is) a subset of the draft. + result = finalize(scope, result); + if (!scope.parent_) maybeFreeze(scope, result); + } + + if (scope.patches_) { + getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_); + } + } else { + // Finalize the base draft. + result = finalize(scope, baseDraft, []); + } + + revokeScope(scope); + + if (scope.patches_) { + scope.patchListener_(scope.patches_, scope.inversePatches_); + } + + return result !== NOTHING ? result : undefined; + } + + function finalize(rootScope, value, path) { + // Don't recurse in tho recursive data structures + if (isFrozen(value)) return value; + var state = value[DRAFT_STATE]; // A plain object, might need freezing, might contain drafts + + if (!state) { + each(value, function (key, childValue) { + return finalizeProperty(rootScope, state, value, key, childValue, path); + }, true // See #590, don't recurse into non-enumerable of non drafted objects + ); + return value; + } // Never finalize drafts owned by another scope. + + + if (state.scope_ !== rootScope) return value; // Unmodified draft, return the (frozen) original + + if (!state.modified_) { + maybeFreeze(rootScope, state.base_, true); + return state.base_; + } // Not finalized yet, let's do that now + + + if (!state.finalized_) { + state.finalized_ = true; + state.scope_.unfinalizedDrafts_--; + var result = // For ES5, create a good copy from the draft first, with added keys and without deleted keys. + state.type_ === 4 + /* ES5Object */ + || state.type_ === 5 + /* ES5Array */ + ? state.copy_ = shallowCopy(state.draft_) : state.copy_; // Finalize all children of the copy + // For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628 + // To preserve insertion order in all cases we then clear the set + // And we let finalizeProperty know it needs to re-add non-draft children back to the target + + var resultEach = result; + var isSet = false; + + if (state.type_ === 3 + /* Set */ + ) { + resultEach = new Set(result); + result.clear(); + isSet = true; + } + + each(resultEach, function (key, childValue) { + return finalizeProperty(rootScope, state, result, key, childValue, path, isSet); + }); // everything inside is frozen, we can freeze here + + maybeFreeze(rootScope, result, false); // first time finalizing, let's create those patches + + if (path && rootScope.patches_) { + getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_); + } + } + + return state.copy_; + } + + function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) { + if ( childValue === targetObject) die(5); + + if (isDraft(childValue)) { + var path = rootPath && parentState && parentState.type_ !== 3 + /* Set */ + && // Set objects are atomic since they have no keys. + !has(parentState.assigned_, prop) // Skip deep patches for assigned keys. + ? rootPath.concat(prop) : undefined; // Drafts owned by `scope` are finalized here. + + var res = finalize(rootScope, childValue, path); + set(targetObject, prop, res); // Drafts from another scope must prevented to be frozen + // if we got a draft back from finalize, we're in a nested produce and shouldn't freeze + + if (isDraft(res)) { + rootScope.canAutoFreeze_ = false; + } else return; + } else if (targetIsSet) { + targetObject.add(childValue); + } // Search new objects for unfinalized drafts. Frozen objects should never contain drafts. + + + if (isDraftable(childValue) && !isFrozen(childValue)) { + if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) { + // optimization: if an object is not a draft, and we don't have to + // deepfreeze everything, and we are sure that no drafts are left in the remaining object + // cause we saw and finalized all drafts already; we can stop visiting the rest of the tree. + // This benefits especially adding large data tree's without further processing. + // See add-data.js perf test + return; + } + + finalize(rootScope, childValue); // immer deep freezes plain objects, so if there is no parent state, we freeze as well + + if (!parentState || !parentState.scope_.parent_) maybeFreeze(rootScope, childValue); + } + } + + function maybeFreeze(scope, value, deep) { + if (deep === void 0) { + deep = false; + } + + // we never freeze for a non-root scope; as it would prevent pruning for drafts inside wrapping objects + if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) { + freeze(value, deep); + } + } + + /** + * Returns a new draft of the `base` object. + * + * The second argument is the parent draft-state (used internally). + */ + + function createProxyProxy(base, parent) { + var isArray = Array.isArray(base); + var state = { + type_: isArray ? 1 + /* ProxyArray */ + : 0 + /* ProxyObject */ + , + // Track which produce call this is associated with. + scope_: parent ? parent.scope_ : getCurrentScope(), + // True for both shallow and deep changes. + modified_: false, + // Used during finalization. + finalized_: false, + // Track which properties have been assigned (true) or deleted (false). + assigned_: {}, + // The parent draft state. + parent_: parent, + // The base state. + base_: base, + // The base proxy. + draft_: null, + // The base copy with any updated values. + copy_: null, + // Called by the `produce` function. + revoke_: null, + isManual_: false + }; // the traps must target something, a bit like the 'real' base. + // but also, we need to be able to determine from the target what the relevant state is + // (to avoid creating traps per instance to capture the state in closure, + // and to avoid creating weird hidden properties as well) + // So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything) + // Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb + + var target = state; + var traps = objectTraps; + + if (isArray) { + target = [state]; + traps = arrayTraps; + } + + var _Proxy$revocable = Proxy.revocable(target, traps), + revoke = _Proxy$revocable.revoke, + proxy = _Proxy$revocable.proxy; + + state.draft_ = proxy; + state.revoke_ = revoke; + return proxy; + } + /** + * Object drafts + */ + + var objectTraps = { + get: function get(state, prop) { + if (prop === DRAFT_STATE) return state; + var source = latest(state); + + if (!has(source, prop)) { + // non-existing or non-own property... + return readPropFromProto(state, source, prop); + } + + var value = source[prop]; + + if (state.finalized_ || !isDraftable(value)) { + return value; + } // Check for existing draft in modified state. + // Assigned values are never drafted. This catches any drafts we created, too. + + + if (value === peek(state.base_, prop)) { + prepareCopy(state); + return state.copy_[prop] = createProxy(state.scope_.immer_, value, state); + } + + return value; + }, + has: function has(state, prop) { + return prop in latest(state); + }, + ownKeys: function ownKeys(state) { + return Reflect.ownKeys(latest(state)); + }, + set: function set(state, prop + /* strictly not, but helps TS */ + , value) { + var desc = getDescriptorFromProto(latest(state), prop); + + if (desc === null || desc === void 0 ? void 0 : desc.set) { + // special case: if this write is captured by a setter, we have + // to trigger it with the correct context + desc.set.call(state.draft_, value); + return true; + } + + if (!state.modified_) { + // the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change) + // from setting an existing property with value undefined to undefined (which is not a change) + var current = peek(latest(state), prop); // special case, if we assigning the original value to a draft, we can ignore the assignment + + var currentState = current === null || current === void 0 ? void 0 : current[DRAFT_STATE]; + + if (currentState && currentState.base_ === value) { + state.copy_[prop] = value; + state.assigned_[prop] = false; + return true; + } + + if (is(value, current) && (value !== undefined || has(state.base_, prop))) return true; + prepareCopy(state); + markChanged(state); + } + + if (state.copy_[prop] === value && ( // special case: handle new props with value 'undefined' + value !== undefined || prop in state.copy_) || // special case: NaN + Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true; // @ts-ignore + + state.copy_[prop] = value; + state.assigned_[prop] = true; + return true; + }, + deleteProperty: function deleteProperty(state, prop) { + // The `undefined` check is a fast path for pre-existing keys. + if (peek(state.base_, prop) !== undefined || prop in state.base_) { + state.assigned_[prop] = false; + prepareCopy(state); + markChanged(state); + } else { + // if an originally not assigned property was deleted + delete state.assigned_[prop]; + } // @ts-ignore + + + if (state.copy_) delete state.copy_[prop]; + return true; + }, + // Note: We never coerce `desc.value` into an Immer draft, because we can't make + // the same guarantee in ES5 mode. + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(state, prop) { + var owner = latest(state); + var desc = Reflect.getOwnPropertyDescriptor(owner, prop); + if (!desc) return desc; + return { + writable: true, + configurable: state.type_ !== 1 + /* ProxyArray */ + || prop !== "length", + enumerable: desc.enumerable, + value: owner[prop] + }; + }, + defineProperty: function defineProperty() { + die(11); + }, + getPrototypeOf: function getPrototypeOf(state) { + return Object.getPrototypeOf(state.base_); + }, + setPrototypeOf: function setPrototypeOf() { + die(12); + } + }; + /** + * Array drafts + */ + + var arrayTraps = {}; + each(objectTraps, function (key, fn) { + // @ts-ignore + arrayTraps[key] = function () { + arguments[0] = arguments[0][0]; + return fn.apply(this, arguments); + }; + }); + + arrayTraps.deleteProperty = function (state, prop) { + if ( isNaN(parseInt(prop))) die(13); // @ts-ignore + + return arrayTraps.set.call(this, state, prop, undefined); + }; + + arrayTraps.set = function (state, prop, value) { + if ( prop !== "length" && isNaN(parseInt(prop))) die(14); + return objectTraps.set.call(this, state[0], prop, value, state[0]); + }; // Access a property without creating an Immer draft. + + + function peek(draft, prop) { + var state = draft[DRAFT_STATE]; + var source = state ? latest(state) : draft; + return source[prop]; + } + + function readPropFromProto(state, source, prop) { + var _desc$get; + + var desc = getDescriptorFromProto(source, prop); + return desc ? "value" in desc ? desc.value : // This is a very special case, if the prop is a getter defined by the + // prototype, we should invoke it with the draft as context! + (_desc$get = desc.get) === null || _desc$get === void 0 ? void 0 : _desc$get.call(state.draft_) : undefined; + } + + function getDescriptorFromProto(source, prop) { + // 'in' checks proto! + if (!(prop in source)) return undefined; + var proto = Object.getPrototypeOf(source); + + while (proto) { + var desc = Object.getOwnPropertyDescriptor(proto, prop); + if (desc) return desc; + proto = Object.getPrototypeOf(proto); + } + + return undefined; + } + + function markChanged(state) { + if (!state.modified_) { + state.modified_ = true; + + if (state.parent_) { + markChanged(state.parent_); + } + } + } + function prepareCopy(state) { + if (!state.copy_) { + state.copy_ = shallowCopy(state.base_); + } + } + + var Immer = + /*#__PURE__*/ + function () { + function Immer(config) { + var _this = this; + + this.useProxies_ = hasProxies; + this.autoFreeze_ = true; + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + + this.produce = function (base, recipe, patchListener) { + // curried invocation + if (typeof base === "function" && typeof recipe !== "function") { + var defaultBase = recipe; + recipe = base; + var self = _this; + return function curriedProduce(base) { + var _this2 = this; + + if (base === void 0) { + base = defaultBase; + } + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return self.produce(base, function (draft) { + var _recipe; + + return (_recipe = recipe).call.apply(_recipe, [_this2, draft].concat(args)); + }); // prettier-ignore + }; + } + + if (typeof recipe !== "function") die(6); + if (patchListener !== undefined && typeof patchListener !== "function") die(7); + var result; // Only plain objects, arrays, and "immerable classes" are drafted. + + if (isDraftable(base)) { + var scope = enterScope(_this); + var proxy = createProxy(_this, base, undefined); + var hasError = true; + + try { + result = recipe(proxy); + hasError = false; + } finally { + // finally instead of catch + rethrow better preserves original stack + if (hasError) revokeScope(scope);else leaveScope(scope); + } + + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function (result) { + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + }, function (error) { + revokeScope(scope); + throw error; + }); + } + + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + } else if (!base || typeof base !== "object") { + result = recipe(base); + if (result === undefined) result = base; + if (result === NOTHING) result = undefined; + if (_this.autoFreeze_) freeze(result, true); + + if (patchListener) { + var p = []; + var ip = []; + getPlugin("Patches").generateReplacementPatches_(base, result, p, ip); + patchListener(p, ip); + } + + return result; + } else die(21, base); + }; + + this.produceWithPatches = function (base, recipe) { + // curried invocation + if (typeof base === "function") { + return function (state) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + return _this.produceWithPatches(state, function (draft) { + return base.apply(void 0, [draft].concat(args)); + }); + }; + } + + var patches, inversePatches; + + var result = _this.produce(base, recipe, function (p, ip) { + patches = p; + inversePatches = ip; + }); + + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function (nextState) { + return [nextState, patches, inversePatches]; + }); + } + + return [result, patches, inversePatches]; + }; + + if (typeof (config === null || config === void 0 ? void 0 : config.useProxies) === "boolean") this.setUseProxies(config.useProxies); + if (typeof (config === null || config === void 0 ? void 0 : config.autoFreeze) === "boolean") this.setAutoFreeze(config.autoFreeze); + } + + var _proto = Immer.prototype; + + _proto.createDraft = function createDraft(base) { + if (!isDraftable(base)) die(8); + if (isDraft(base)) base = current(base); + var scope = enterScope(this); + var proxy = createProxy(this, base, undefined); + proxy[DRAFT_STATE].isManual_ = true; + leaveScope(scope); + return proxy; + }; + + _proto.finishDraft = function finishDraft(draft, patchListener) { + var state = draft && draft[DRAFT_STATE]; + + { + if (!state || !state.isManual_) die(9); + if (state.finalized_) die(10); + } + + var scope = state.scope_; + usePatchesInScope(scope, patchListener); + return processResult(undefined, scope); + } + /** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is enabled. + */ + ; + + _proto.setAutoFreeze = function setAutoFreeze(value) { + this.autoFreeze_ = value; + } + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + ; + + _proto.setUseProxies = function setUseProxies(value) { + if (value && !hasProxies) { + die(20); + } + + this.useProxies_ = value; + }; + + _proto.applyPatches = function applyPatches(base, patches) { + // If a patch replaces the entire state, take that replacement as base + // before applying patches + var i; + + for (i = patches.length - 1; i >= 0; i--) { + var patch = patches[i]; + + if (patch.path.length === 0 && patch.op === "replace") { + base = patch.value; + break; + } + } // If there was a patch that replaced the entire state, start from the + // patch after that. + + + if (i > -1) { + patches = patches.slice(i + 1); + } + + var applyPatchesImpl = getPlugin("Patches").applyPatches_; + + if (isDraft(base)) { + // N.B: never hits if some patch a replacement, patches are never drafts + return applyPatchesImpl(base, patches); + } // Otherwise, produce a copy of the base state. + + + return this.produce(base, function (draft) { + return applyPatchesImpl(draft, patches); + }); + }; + + return Immer; + }(); + function createProxy(immer, value, parent) { + // precondition: createProxy should be guarded by isDraftable, so we know we can safely draft + var draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : immer.useProxies_ ? createProxyProxy(value, parent) : getPlugin("ES5").createES5Proxy_(value, parent); + var scope = parent ? parent.scope_ : getCurrentScope(); + scope.drafts_.push(draft); + return draft; + } + + function current(value) { + if (!isDraft(value)) die(22, value); + return currentImpl(value); + } + + function currentImpl(value) { + if (!isDraftable(value)) return value; + var state = value[DRAFT_STATE]; + var copy; + var archType = getArchtype(value); + + if (state) { + if (!state.modified_ && (state.type_ < 4 || !getPlugin("ES5").hasChanges_(state))) return state.base_; // Optimization: avoid generating new drafts during copying + + state.finalized_ = true; + copy = copyHelper(value, archType); + state.finalized_ = false; + } else { + copy = copyHelper(value, archType); + } + + each(copy, function (key, childValue) { + if (state && get(state.base_, key) === childValue) return; // no need to copy or search in something that didn't change + + set(copy, key, currentImpl(childValue)); + }); // In the future, we might consider freezing here, based on the current settings + + return archType === 3 + /* Set */ + ? new Set(copy) : copy; + } + + function copyHelper(value, archType) { + // creates a shallow copy, even if it is a map or set + switch (archType) { + case 2 + /* Map */ + : + return new Map(value); + + case 3 + /* Set */ + : + // Set will be cloned as array temporarily, so that we can replace individual items + return Array.from(value); + } + + return shallowCopy(value); + } + + function enableES5() { + function willFinalizeES5_(scope, result, isReplaced) { + if (!isReplaced) { + if (scope.patches_) { + markChangesRecursively(scope.drafts_[0]); + } // This is faster when we don't care about which attributes changed. + + + markChangesSweep(scope.drafts_); + } // When a child draft is returned, look for changes. + else if (isDraft(result) && result[DRAFT_STATE].scope_ === scope) { + markChangesSweep(scope.drafts_); + } + } + + function createES5Draft(isArray, base) { + if (isArray) { + var draft = new Array(base.length); + + for (var i = 0; i < base.length; i++) { + Object.defineProperty(draft, "" + i, proxyProperty(i, true)); + } + + return draft; + } else { + var _descriptors = getOwnPropertyDescriptors(base); + + delete _descriptors[DRAFT_STATE]; + var keys = ownKeys(_descriptors); + + for (var _i = 0; _i < keys.length; _i++) { + var key = keys[_i]; + _descriptors[key] = proxyProperty(key, isArray || !!_descriptors[key].enumerable); + } + + return Object.create(Object.getPrototypeOf(base), _descriptors); + } + } + + function createES5Proxy_(base, parent) { + var isArray = Array.isArray(base); + var draft = createES5Draft(isArray, base); + var state = { + type_: isArray ? 5 + /* ES5Array */ + : 4 + /* ES5Object */ + , + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + assigned_: {}, + parent_: parent, + // base is the object we are drafting + base_: base, + // draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified) + draft_: draft, + copy_: null, + revoked_: false, + isManual_: false + }; + Object.defineProperty(draft, DRAFT_STATE, { + value: state, + // enumerable: false <- the default + writable: true + }); + return draft; + } // property descriptors are recycled to make sure we don't create a get and set closure per property, + // but share them all instead + + + var descriptors = {}; + + function proxyProperty(prop, enumerable) { + var desc = descriptors[prop]; + + if (desc) { + desc.enumerable = enumerable; + } else { + descriptors[prop] = desc = { + configurable: true, + enumerable: enumerable, + get: function get() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // @ts-ignore + + return objectTraps.get(state, prop); + }, + set: function set(value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // @ts-ignore + + objectTraps.set(state, prop, value); + } + }; + } + + return desc; + } // This looks expensive, but only proxies are visited, and only objects without known changes are scanned. + + + function markChangesSweep(drafts) { + // The natural order of drafts in the `scope` array is based on when they + // were accessed. By processing drafts in reverse natural order, we have a + // better chance of processing leaf nodes first. When a leaf node is known to + // have changed, we can avoid any traversal of its ancestor nodes. + for (var i = drafts.length - 1; i >= 0; i--) { + var state = drafts[i][DRAFT_STATE]; + + if (!state.modified_) { + switch (state.type_) { + case 5 + /* ES5Array */ + : + if (hasArrayChanges(state)) markChanged(state); + break; + + case 4 + /* ES5Object */ + : + if (hasObjectChanges(state)) markChanged(state); + break; + } + } + } + } + + function markChangesRecursively(object) { + if (!object || typeof object !== "object") return; + var state = object[DRAFT_STATE]; + if (!state) return; + var base_ = state.base_, + draft_ = state.draft_, + assigned_ = state.assigned_, + type_ = state.type_; + + if (type_ === 4 + /* ES5Object */ + ) { + // Look for added keys. + // probably there is a faster way to detect changes, as sweep + recurse seems to do some + // unnecessary work. + // also: probably we can store the information we detect here, to speed up tree finalization! + each(draft_, function (key) { + if (key === DRAFT_STATE) return; // The `undefined` check is a fast path for pre-existing keys. + + if (base_[key] === undefined && !has(base_, key)) { + assigned_[key] = true; + markChanged(state); + } else if (!assigned_[key]) { + // Only untouched properties trigger recursion. + markChangesRecursively(draft_[key]); + } + }); // Look for removed keys. + + each(base_, function (key) { + // The `undefined` check is a fast path for pre-existing keys. + if (draft_[key] === undefined && !has(draft_, key)) { + assigned_[key] = false; + markChanged(state); + } + }); + } else if (type_ === 5 + /* ES5Array */ + ) { + if (hasArrayChanges(state)) { + markChanged(state); + assigned_.length = true; + } + + if (draft_.length < base_.length) { + for (var i = draft_.length; i < base_.length; i++) { + assigned_[i] = false; + } + } else { + for (var _i2 = base_.length; _i2 < draft_.length; _i2++) { + assigned_[_i2] = true; + } + } // Minimum count is enough, the other parts has been processed. + + + var min = Math.min(draft_.length, base_.length); + + for (var _i3 = 0; _i3 < min; _i3++) { + // Only untouched indices trigger recursion. + if (!draft_.hasOwnProperty(_i3)) { + assigned_[_i3] = true; + } + + if (assigned_[_i3] === undefined) markChangesRecursively(draft_[_i3]); + } + } + } + + function hasObjectChanges(state) { + var base_ = state.base_, + draft_ = state.draft_; // Search for added keys and changed keys. Start at the back, because + // non-numeric keys are ordered by time of definition on the object. + + var keys = ownKeys(draft_); + + for (var i = keys.length - 1; i >= 0; i--) { + var key = keys[i]; + if (key === DRAFT_STATE) continue; + var baseValue = base_[key]; // The `undefined` check is a fast path for pre-existing keys. + + if (baseValue === undefined && !has(base_, key)) { + return true; + } // Once a base key is deleted, future changes go undetected, because its + // descriptor is erased. This branch detects any missed changes. + else { + var value = draft_[key]; + + var _state = value && value[DRAFT_STATE]; + + if (_state ? _state.base_ !== baseValue : !is(value, baseValue)) { + return true; + } + } + } // At this point, no keys were added or changed. + // Compare key count to determine if keys were deleted. + + + var baseIsDraft = !!base_[DRAFT_STATE]; + return keys.length !== ownKeys(base_).length + (baseIsDraft ? 0 : 1); // + 1 to correct for DRAFT_STATE + } + + function hasArrayChanges(state) { + var draft_ = state.draft_; + if (draft_.length !== state.base_.length) return true; // See #116 + // If we first shorten the length, our array interceptors will be removed. + // If after that new items are added, result in the same original length, + // those last items will have no intercepting property. + // So if there is no own descriptor on the last position, we know that items were removed and added + // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check + // the last one + // last descriptor can be not a trap, if the array was extended + + var descriptor = Object.getOwnPropertyDescriptor(draft_, draft_.length - 1); // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10) + + if (descriptor && !descriptor.get) return true; // if we miss a property, it has been deleted, so array probobaly changed + + for (var i = 0; i < draft_.length; i++) { + if (!draft_.hasOwnProperty(i)) return true; + } // For all other cases, we don't have to compare, as they would have been picked up by the index setters + + + return false; + } + + function hasChanges_(state) { + return state.type_ === 4 + /* ES5Object */ + ? hasObjectChanges(state) : hasArrayChanges(state); + } + + function assertUnrevoked(state + /*ES5State | MapState | SetState*/ + ) { + if (state.revoked_) die(3, JSON.stringify(latest(state))); + } + + loadPlugin("ES5", { + createES5Proxy_: createES5Proxy_, + willFinalizeES5_: willFinalizeES5_, + hasChanges_: hasChanges_ + }); + } + + function enablePatches() { + var REPLACE = "replace"; + var ADD = "add"; + var REMOVE = "remove"; + + function generatePatches_(state, basePath, patches, inversePatches) { + switch (state.type_) { + case 0 + /* ProxyObject */ + : + case 4 + /* ES5Object */ + : + case 2 + /* Map */ + : + return generatePatchesFromAssigned(state, basePath, patches, inversePatches); + + case 5 + /* ES5Array */ + : + case 1 + /* ProxyArray */ + : + return generateArrayPatches(state, basePath, patches, inversePatches); + + case 3 + /* Set */ + : + return generateSetPatches(state, basePath, patches, inversePatches); + } + } + + function generateArrayPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, + assigned_ = state.assigned_; + var copy_ = state.copy_; // Reduce complexity by ensuring `base` is never longer. + + if (copy_.length < base_.length) { + var _ref = [copy_, base_]; + base_ = _ref[0]; + copy_ = _ref[1]; + var _ref2 = [inversePatches, patches]; + patches = _ref2[0]; + inversePatches = _ref2[1]; + } // Process replaced indices. + + + for (var i = 0; i < base_.length; i++) { + if (assigned_[i] && copy_[i] !== base_[i]) { + var path = basePath.concat([i]); + patches.push({ + op: REPLACE, + path: path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[i]) + }); + inversePatches.push({ + op: REPLACE, + path: path, + value: clonePatchValueIfNeeded(base_[i]) + }); + } + } // Process added indices. + + + for (var _i = base_.length; _i < copy_.length; _i++) { + var _path = basePath.concat([_i]); + + patches.push({ + op: ADD, + path: _path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[_i]) + }); + } + + if (base_.length < copy_.length) { + inversePatches.push({ + op: REPLACE, + path: basePath.concat(["length"]), + value: base_.length + }); + } + } // This is used for both Map objects and normal objects. + + + function generatePatchesFromAssigned(state, basePath, patches, inversePatches) { + var base_ = state.base_, + copy_ = state.copy_; + each(state.assigned_, function (key, assignedValue) { + var origValue = get(base_, key); + var value = get(copy_, key); + var op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD; + if (origValue === value && op === REPLACE) return; + var path = basePath.concat(key); + patches.push(op === REMOVE ? { + op: op, + path: path + } : { + op: op, + path: path, + value: value + }); + inversePatches.push(op === ADD ? { + op: REMOVE, + path: path + } : op === REMOVE ? { + op: ADD, + path: path, + value: clonePatchValueIfNeeded(origValue) + } : { + op: REPLACE, + path: path, + value: clonePatchValueIfNeeded(origValue) + }); + }); + } + + function generateSetPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, + copy_ = state.copy_; + var i = 0; + base_.forEach(function (value) { + if (!copy_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: REMOVE, + path: path, + value: value + }); + inversePatches.unshift({ + op: ADD, + path: path, + value: value + }); + } + + i++; + }); + i = 0; + copy_.forEach(function (value) { + if (!base_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: ADD, + path: path, + value: value + }); + inversePatches.unshift({ + op: REMOVE, + path: path, + value: value + }); + } + + i++; + }); + } + + function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) { + patches.push({ + op: REPLACE, + path: [], + value: replacement === NOTHING ? undefined : replacement + }); + inversePatches.push({ + op: REPLACE, + path: [], + value: baseValue + }); + } + + function applyPatches_(draft, patches) { + patches.forEach(function (patch) { + var path = patch.path, + op = patch.op; + var base = draft; + + for (var i = 0; i < path.length - 1; i++) { + var parentType = getArchtype(base); + var p = path[i]; + + if (typeof p !== "string" && typeof p !== "number") { + p = "" + p; + } // See #738, avoid prototype pollution + + + if ((parentType === 0 + /* Object */ + || parentType === 1 + /* Array */ + ) && (p === "__proto__" || p === "constructor")) die(24); + if (typeof base === "function" && p === "prototype") die(24); + base = get(base, p); + if (typeof base !== "object") die(15, path.join("/")); + } + + var type = getArchtype(base); + var value = deepClonePatchValue(patch.value); // used to clone patch to ensure original patch is not modified, see #411 + + var key = path[path.length - 1]; + + switch (op) { + case REPLACE: + switch (type) { + case 2 + /* Map */ + : + return base.set(key, value); + + /* istanbul ignore next */ + + case 3 + /* Set */ + : + die(16); + + default: + // if value is an object, then it's assigned by reference + // in the following add or remove ops, the value field inside the patch will also be modifyed + // so we use value from the cloned patch + // @ts-ignore + return base[key] = value; + } + + case ADD: + switch (type) { + case 1 + /* Array */ + : + return key === "-" ? base.push(value) : base.splice(key, 0, value); + + case 2 + /* Map */ + : + return base.set(key, value); + + case 3 + /* Set */ + : + return base.add(value); + + default: + return base[key] = value; + } + + case REMOVE: + switch (type) { + case 1 + /* Array */ + : + return base.splice(key, 1); + + case 2 + /* Map */ + : + return base.delete(key); + + case 3 + /* Set */ + : + return base.delete(patch.value); + + default: + return delete base[key]; + } + + default: + die(17, op); + } + }); + return draft; + } + + function deepClonePatchValue(obj) { + if (!isDraftable(obj)) return obj; + if (Array.isArray(obj)) return obj.map(deepClonePatchValue); + if (isMap(obj)) return new Map(Array.from(obj.entries()).map(function (_ref3) { + var k = _ref3[0], + v = _ref3[1]; + return [k, deepClonePatchValue(v)]; + })); + if (isSet(obj)) return new Set(Array.from(obj).map(deepClonePatchValue)); + var cloned = Object.create(Object.getPrototypeOf(obj)); + + for (var key in obj) { + cloned[key] = deepClonePatchValue(obj[key]); + } + + if (has(obj, DRAFTABLE)) cloned[DRAFTABLE] = obj[DRAFTABLE]; + return cloned; + } + + function clonePatchValueIfNeeded(obj) { + if (isDraft(obj)) { + return deepClonePatchValue(obj); + } else return obj; + } + + loadPlugin("Patches", { + applyPatches_: applyPatches_, + generatePatches_: generatePatches_, + generateReplacementPatches_: generateReplacementPatches_ + }); + } + + // types only! + function enableMapSet() { + /* istanbul ignore next */ + var _extendStatics = function extendStatics(d, b) { + _extendStatics = Object.setPrototypeOf || { + __proto__: [] + } instanceof Array && function (d, b) { + d.__proto__ = b; + } || function (d, b) { + for (var p in b) { + if (b.hasOwnProperty(p)) d[p] = b[p]; + } + }; + + return _extendStatics(d, b); + }; // Ugly hack to resolve #502 and inherit built in Map / Set + + + function __extends(d, b) { + _extendStatics(d, b); + + function __() { + this.constructor = d; + } + + d.prototype = ( // @ts-ignore + __.prototype = b.prototype, new __()); + } + + var DraftMap = function (_super) { + __extends(DraftMap, _super); // Create class manually, cause #502 + + + function DraftMap(target, parent) { + this[DRAFT_STATE] = { + type_: 2 + /* Map */ + , + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: undefined, + assigned_: undefined, + base_: target, + draft_: this, + isManual_: false, + revoked_: false + }; + return this; + } + + var p = DraftMap.prototype; + Object.defineProperty(p, "size", { + get: function get() { + return latest(this[DRAFT_STATE]).size; + } // enumerable: false, + // configurable: true + + }); + + p.has = function (key) { + return latest(this[DRAFT_STATE]).has(key); + }; + + p.set = function (key, value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (!latest(state).has(key) || latest(state).get(key) !== value) { + prepareMapCopy(state); + markChanged(state); + state.assigned_.set(key, true); + state.copy_.set(key, value); + state.assigned_.set(key, true); + } + + return this; + }; + + p.delete = function (key) { + if (!this.has(key)) { + return false; + } + + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareMapCopy(state); + markChanged(state); + + if (state.base_.has(key)) { + state.assigned_.set(key, false); + } else { + state.assigned_.delete(key); + } + + state.copy_.delete(key); + return true; + }; + + p.clear = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (latest(state).size) { + prepareMapCopy(state); + markChanged(state); + state.assigned_ = new Map(); + each(state.base_, function (key) { + state.assigned_.set(key, false); + }); + state.copy_.clear(); + } + }; + + p.forEach = function (cb, thisArg) { + var _this = this; + + var state = this[DRAFT_STATE]; + latest(state).forEach(function (_value, key, _map) { + cb.call(thisArg, _this.get(key), key, _this); + }); + }; + + p.get = function (key) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + var value = latest(state).get(key); + + if (state.finalized_ || !isDraftable(value)) { + return value; + } + + if (value !== state.base_.get(key)) { + return value; // either already drafted or reassigned + } // despite what it looks, this creates a draft only once, see above condition + + + var draft = createProxy(state.scope_.immer_, value, state); + prepareMapCopy(state); + state.copy_.set(key, draft); + return draft; + }; + + p.keys = function () { + return latest(this[DRAFT_STATE]).keys(); + }; + + p.values = function () { + var _this2 = this, + _ref; + + var iterator = this.keys(); + return _ref = {}, _ref[iteratorSymbol] = function () { + return _this2.values(); + }, _ref.next = function next() { + var r = iterator.next(); + /* istanbul ignore next */ + + if (r.done) return r; + + var value = _this2.get(r.value); + + return { + done: false, + value: value + }; + }, _ref; + }; + + p.entries = function () { + var _this3 = this, + _ref2; + + var iterator = this.keys(); + return _ref2 = {}, _ref2[iteratorSymbol] = function () { + return _this3.entries(); + }, _ref2.next = function next() { + var r = iterator.next(); + /* istanbul ignore next */ + + if (r.done) return r; + + var value = _this3.get(r.value); + + return { + done: false, + value: [r.value, value] + }; + }, _ref2; + }; + + p[iteratorSymbol] = function () { + return this.entries(); + }; + + return DraftMap; + }(Map); + + function proxyMap_(target, parent) { + // @ts-ignore + return new DraftMap(target, parent); + } + + function prepareMapCopy(state) { + if (!state.copy_) { + state.assigned_ = new Map(); + state.copy_ = new Map(state.base_); + } + } + + var DraftSet = function (_super) { + __extends(DraftSet, _super); // Create class manually, cause #502 + + + function DraftSet(target, parent) { + this[DRAFT_STATE] = { + type_: 3 + /* Set */ + , + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: undefined, + base_: target, + draft_: this, + drafts_: new Map(), + revoked_: false, + isManual_: false + }; + return this; + } + + var p = DraftSet.prototype; + Object.defineProperty(p, "size", { + get: function get() { + return latest(this[DRAFT_STATE]).size; + } // enumerable: true, + + }); + + p.has = function (value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // bit of trickery here, to be able to recognize both the value, and the draft of its value + + if (!state.copy_) { + return state.base_.has(value); + } + + if (state.copy_.has(value)) return true; + if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) return true; + return false; + }; + + p.add = function (value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (!this.has(value)) { + prepareSetCopy(state); + markChanged(state); + state.copy_.add(value); + } + + return this; + }; + + p.delete = function (value) { + if (!this.has(value)) { + return false; + } + + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + markChanged(state); + return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : + /* istanbul ignore next */ + false); + }; + + p.clear = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (latest(state).size) { + prepareSetCopy(state); + markChanged(state); + state.copy_.clear(); + } + }; + + p.values = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.values(); + }; + + p.entries = function entries() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.entries(); + }; + + p.keys = function () { + return this.values(); + }; + + p[iteratorSymbol] = function () { + return this.values(); + }; + + p.forEach = function forEach(cb, thisArg) { + var iterator = this.values(); + var result = iterator.next(); + + while (!result.done) { + cb.call(thisArg, result.value, result.value, this); + result = iterator.next(); + } + }; + + return DraftSet; + }(Set); + + function proxySet_(target, parent) { + // @ts-ignore + return new DraftSet(target, parent); + } + + function prepareSetCopy(state) { + if (!state.copy_) { + // create drafts for all entries to preserve insertion order + state.copy_ = new Set(); + state.base_.forEach(function (value) { + if (isDraftable(value)) { + var draft = createProxy(state.scope_.immer_, value, state); + state.drafts_.set(value, draft); + state.copy_.add(draft); + } else { + state.copy_.add(value); + } + }); + } + } + + function assertUnrevoked(state + /*ES5State | MapState | SetState*/ + ) { + if (state.revoked_) die(3, JSON.stringify(latest(state))); + } + + loadPlugin("MapSet", { + proxyMap_: proxyMap_, + proxySet_: proxySet_ + }); + } + + function enableAllPlugins() { + enableES5(); + enableMapSet(); + enablePatches(); + } + + var immer = + /*#__PURE__*/ + new Immer(); + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + + var produce = immer.produce; + /** + * Like `produce`, but `produceWithPatches` always returns a tuple + * [nextState, patches, inversePatches] (instead of just the next state) + */ + + var produceWithPatches = + /*#__PURE__*/ + immer.produceWithPatches.bind(immer); + /** + * Pass true to automatically freeze all copies created by Immer. + * + * Always freeze by default, even in production mode + */ + + var setAutoFreeze = + /*#__PURE__*/ + immer.setAutoFreeze.bind(immer); + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + + var setUseProxies = + /*#__PURE__*/ + immer.setUseProxies.bind(immer); + /** + * Apply an array of Immer patches to the first argument. + * + * This function is a producer, which means copy-on-write is in effect. + */ + + var applyPatches = + /*#__PURE__*/ + immer.applyPatches.bind(immer); + /** + * Create an Immer draft from the given base state, which may be a draft itself. + * The draft can be modified until you finalize it with the `finishDraft` function. + */ + + var createDraft = + /*#__PURE__*/ + immer.createDraft.bind(immer); + /** + * Finalize an Immer draft from a `createDraft` call, returning the base state + * (if no changes were made) or a modified copy. The draft must *not* be + * mutated afterwards. + * + * Pass a function as the 2nd argument to generate Immer patches based on the + * changes that were made. + */ + + var finishDraft = + /*#__PURE__*/ + immer.finishDraft.bind(immer); + /** + * This function is actually a no-op, but can be used to cast an immutable type + * to an draft type and make TypeScript happy + * + * @param value + */ + + function castDraft(value) { + return value; + } + /** + * This function is actually a no-op, but can be used to cast a mutable type + * to an immutable type and make TypeScript happy + * @param value + */ + + function castImmutable(value) { + return value; + } + + exports.Immer = Immer; + exports.applyPatches = applyPatches; + exports.castDraft = castDraft; + exports.castImmutable = castImmutable; + exports.createDraft = createDraft; + exports.current = current; + exports.default = produce; + exports.enableAllPlugins = enableAllPlugins; + exports.enableES5 = enableES5; + exports.enableMapSet = enableMapSet; + exports.enablePatches = enablePatches; + exports.finishDraft = finishDraft; + exports.freeze = freeze; + exports.immerable = DRAFTABLE; + exports.isDraft = isDraft; + exports.isDraftable = isDraftable; + exports.nothing = NOTHING; + exports.original = original; + exports.produce = produce; + exports.produceWithPatches = produceWithPatches; + exports.setAutoFreeze = setAutoFreeze; + exports.setUseProxies = setUseProxies; + + Object.defineProperty(exports, '__esModule', { value: true }); + +}))); +//# sourceMappingURL=immer.umd.development.js.map Index: frontend/node_modules/immer/dist/immer.umd.development.js.map =================================================================== --- frontend/node_modules/immer/dist/immer.umd.development.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.umd.development.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immer.umd.development.js","sources":["../src/utils/env.ts","../src/utils/errors.ts","../src/utils/common.ts","../src/utils/plugins.ts","../src/core/scope.ts","../src/core/finalize.ts","../src/core/proxy.ts","../src/core/immerClass.ts","../src/core/current.ts","../src/plugins/es5.ts","../src/plugins/patches.ts","../src/plugins/mapset.ts","../src/plugins/all.ts","../src/immer.ts"],"sourcesContent":["// 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","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","// types only!\nimport {\n\tImmerState,\n\tAnyMap,\n\tAnySet,\n\tMapState,\n\tSetState,\n\tDRAFT_STATE,\n\tgetCurrentScope,\n\tlatest,\n\titeratorSymbol,\n\tisDraftable,\n\tcreateProxy,\n\tloadPlugin,\n\tmarkChanged,\n\tProxyType,\n\tdie,\n\teach\n} from \"../internal\"\n\nexport function enableMapSet() {\n\t/* istanbul ignore next */\n\tvar extendStatics = function(d: any, b: any): any {\n\t\textendStatics =\n\t\t\tObject.setPrototypeOf ||\n\t\t\t({__proto__: []} instanceof Array &&\n\t\t\t\tfunction(d, b) {\n\t\t\t\t\td.__proto__ = b\n\t\t\t\t}) ||\n\t\t\tfunction(d, b) {\n\t\t\t\tfor (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]\n\t\t\t}\n\t\treturn extendStatics(d, b)\n\t}\n\n\t// Ugly hack to resolve #502 and inherit built in Map / Set\n\tfunction __extends(d: any, b: any): any {\n\t\textendStatics(d, b)\n\t\tfunction __(this: any): any {\n\t\t\tthis.constructor = d\n\t\t}\n\t\td.prototype =\n\t\t\t// @ts-ignore\n\t\t\t((__.prototype = b.prototype), new __())\n\t}\n\n\tconst DraftMap = (function(_super) {\n\t\t__extends(DraftMap, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftMap(this: any, target: AnyMap, parent?: ImmerState): any {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Map,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tassigned_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this as any,\n\t\t\t\tisManual_: false,\n\t\t\t\trevoked_: false\n\t\t\t} as MapState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftMap.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: false,\n\t\t\t// configurable: true\n\t\t})\n\n\t\tp.has = function(key: any): boolean {\n\t\t\treturn latest(this[DRAFT_STATE]).has(key)\n\t\t}\n\n\t\tp.set = function(key: any, value: any) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!latest(state).has(key) || latest(state).get(key) !== value) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t\tstate.copy_!.set(key, value)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(key: any): boolean {\n\t\t\tif (!this.has(key)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareMapCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\tif (state.base_.has(key)) {\n\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t} else {\n\t\t\t\tstate.assigned_!.delete(key)\n\t\t\t}\n\t\t\tstate.copy_!.delete(key)\n\t\t\treturn true\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_ = new Map()\n\t\t\t\teach(state.base_, key => {\n\t\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t\t})\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.forEach = function(\n\t\t\tcb: (value: any, key: any, self: any) => void,\n\t\t\tthisArg?: any\n\t\t) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tlatest(state).forEach((_value: any, key: any, _map: any) => {\n\t\t\t\tcb.call(thisArg, this.get(key), key, this)\n\t\t\t})\n\t\t}\n\n\t\tp.get = function(key: any): any {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tconst value = latest(state).get(key)\n\t\t\tif (state.finalized_ || !isDraftable(value)) {\n\t\t\t\treturn value\n\t\t\t}\n\t\t\tif (value !== state.base_.get(key)) {\n\t\t\t\treturn value // either already drafted or reassigned\n\t\t\t}\n\t\t\t// despite what it looks, this creates a draft only once, see above condition\n\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\tprepareMapCopy(state)\n\t\t\tstate.copy_!.set(key, draft)\n\t\t\treturn draft\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn latest(this[DRAFT_STATE]).keys()\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.values(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp.entries = function(): IterableIterator<[any, any]> {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.entries(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue: [r.value, value]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.entries()\n\t\t}\n\n\t\treturn DraftMap\n\t})(Map)\n\n\tfunction proxyMap_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftMap(target, parent)\n\t}\n\n\tfunction prepareMapCopy(state: MapState) {\n\t\tif (!state.copy_) {\n\t\t\tstate.assigned_ = new Map()\n\t\t\tstate.copy_ = new Map(state.base_)\n\t\t}\n\t}\n\n\tconst DraftSet = (function(_super) {\n\t\t__extends(DraftSet, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftSet(this: any, target: AnySet, parent?: ImmerState) {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Set,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this,\n\t\t\t\tdrafts_: new Map(),\n\t\t\t\trevoked_: false,\n\t\t\t\tisManual_: false\n\t\t\t} as SetState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftSet.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: true,\n\t\t})\n\n\t\tp.has = function(value: any): boolean {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\t// bit of trickery here, to be able to recognize both the value, and the draft of its value\n\t\t\tif (!state.copy_) {\n\t\t\t\treturn state.base_.has(value)\n\t\t\t}\n\t\t\tif (state.copy_.has(value)) return true\n\t\t\tif (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n\t\t\t\treturn true\n\t\t\treturn false\n\t\t}\n\n\t\tp.add = function(value: any): any {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!this.has(value)) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.add(value)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(value: any): any {\n\t\t\tif (!this.has(value)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\treturn (\n\t\t\t\tstate.copy_!.delete(value) ||\n\t\t\t\t(state.drafts_.has(value)\n\t\t\t\t\t? state.copy_!.delete(state.drafts_.get(value))\n\t\t\t\t\t: /* istanbul ignore next */ false)\n\t\t\t)\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.values()\n\t\t}\n\n\t\tp.entries = function entries(): IterableIterator<[any, any]> {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.entries()\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp.forEach = function forEach(cb: any, thisArg?: any) {\n\t\t\tconst iterator = this.values()\n\t\t\tlet result = iterator.next()\n\t\t\twhile (!result.done) {\n\t\t\t\tcb.call(thisArg, result.value, result.value, this)\n\t\t\t\tresult = iterator.next()\n\t\t\t}\n\t\t}\n\n\t\treturn DraftSet\n\t})(Set)\n\n\tfunction proxySet_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftSet(target, parent)\n\t}\n\n\tfunction prepareSetCopy(state: SetState) {\n\t\tif (!state.copy_) {\n\t\t\t// create drafts for all entries to preserve insertion order\n\t\t\tstate.copy_ = new Set()\n\t\t\tstate.base_.forEach(value => {\n\t\t\t\tif (isDraftable(value)) {\n\t\t\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\t\t\tstate.drafts_.set(value, draft)\n\t\t\t\t\tstate.copy_!.add(draft)\n\t\t\t\t} else {\n\t\t\t\t\tstate.copy_!.add(value)\n\t\t\t\t}\n\t\t\t})\n\t\t}\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(\"MapSet\", {proxyMap_, proxySet_})\n}\n","import {enableES5} from \"./es5\"\nimport {enableMapSet} from \"./mapset\"\nimport {enablePatches} from \"./patches\"\n\nexport function enableAllPlugins() {\n\tenableES5()\n\tenableMapSet()\n\tenablePatches()\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"],"names":["hasSymbol","Symbol","hasMap","Map","hasSet","Set","hasProxies","Proxy","revocable","Reflect","NOTHING","for","DRAFTABLE","DRAFT_STATE","iteratorSymbol","iterator","errors","data","path","op","plugin","thing","die","error","args","e","msg","apply","Error","isDraft","value","isDraftable","isPlainObject","Array","isArray","constructor","isMap","isSet","objectCtorString","Object","prototype","toString","proto","getPrototypeOf","Ctor","hasOwnProperty","call","Function","original","base_","ownKeys","getOwnPropertySymbols","obj","getOwnPropertyNames","concat","getOwnPropertyDescriptors","target","res","forEach","key","getOwnPropertyDescriptor","each","iter","enumerableOnly","getArchtype","keys","entry","index","state","type_","has","prop","get","set","propOrOldValue","t","add","is","x","y","latest","copy_","shallowCopy","base","slice","descriptors","i","length","desc","writable","configurable","enumerable","create","freeze","deep","isFrozen","clear","delete","dontMutateFrozenCollections","plugins","getPlugin","pluginKey","loadPlugin","implementation","currentScope","getCurrentScope","createScope","parent_","immer_","drafts_","canAutoFreeze_","unfinalizedDrafts_","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","revokeDraft","enterScope","immer","draft","revoke_","revoked_","processResult","result","baseDraft","isReplaced","undefined","useProxies_","willFinalizeES5_","modified_","finalize","maybeFreeze","generateReplacementPatches_","rootScope","childValue","finalizeProperty","scope_","finalized_","draft_","resultEach","generatePatches_","parentState","targetObject","rootPath","targetIsSet","assigned_","autoFreeze_","createProxyProxy","parent","isManual_","traps","objectTraps","arrayTraps","revoke","proxy","source","readPropFromProto","peek","prepareCopy","createProxy","getDescriptorFromProto","current","currentState","markChanged","Number","isNaN","deleteProperty","owner","defineProperty","setPrototypeOf","fn","arguments","parseInt","Immer","config","recipe","defaultBase","self","curriedProduce","produce","hasError","Promise","then","p","ip","produceWithPatches","patches","inversePatches","nextState","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","patch","applyPatchesImpl","applyPatches_","proxyMap_","proxySet_","createES5Proxy_","push","currentImpl","copy","archType","hasChanges_","copyHelper","from","enableES5","markChangesRecursively","markChangesSweep","createES5Draft","proxyProperty","assertUnrevoked","drafts","hasArrayChanges","hasObjectChanges","object","min","Math","baseValue","baseIsDraft","descriptor","JSON","stringify","enablePatches","REPLACE","ADD","REMOVE","basePath","generatePatchesFromAssigned","generateArrayPatches","generateSetPatches","clonePatchValueIfNeeded","assignedValue","origValue","unshift","replacement","parentType","join","type","deepClonePatchValue","splice","map","entries","k","v","cloned","immerable","enableMapSet","extendStatics","d","b","__proto__","__extends","__","DraftMap","_super","size","prepareMapCopy","cb","thisArg","_value","_map","values","next","r","done","DraftSet","prepareSetCopy","enableAllPlugins","bind","castDraft","castImmutable"],"mappings":"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"} Index: frontend/node_modules/immer/dist/immer.umd.production.min.js =================================================================== --- frontend/node_modules/immer/dist/immer.umd.production.min.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.umd.production.min.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n=n||self).immer={})}(this,(function(n){function t(n){for(var t=arguments.length,r=Array(t>1?t-1:0),e=1;e3?t.t-4:t.t:Array.isArray(n)?1:v(n)?2:s(n)?3:0}function o(n,t){return 2===u(n)?n.has(t):Object.prototype.hasOwnProperty.call(n,t)}function f(n,t){return 2===u(n)?n.get(t):n[t]}function a(n,t,r){var e=u(n);2===e?n.set(t,r):3===e?n.add(r):n[t]=r}function c(n,t){return n===t?0!==n||1/n==1/t:n!=n&&t!=t}function v(n){return X&&n instanceof Map}function s(n){return q&&n instanceof Set}function l(n){return n.i||n.u}function p(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var t=V(n);delete t[L];for(var r=U(t),e=0;e1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),t&&i(n,(function(n,t){return d(t,!0)}),!0)),n}function h(){t(2)}function y(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function _(n){var r=Y[n];return r||t(18,n),r}function b(n,t){Y[n]||(Y[n]=t)}function m(){return J}function j(n,t){t&&(_("Patches"),n.o=[],n.v=[],n.s=t)}function O(n){w(n),n.l.forEach(P),n.l=null}function w(n){n===J&&(J=n.p)}function S(n){return J={l:[],p:J,h:n,_:!0,m:0}}function P(n){var t=n[L];0===t.t||1===t.t?t.j():t.O=!0}function g(n,r){r.m=r.l.length;var i=r.l[0],u=void 0!==n&&n!==i;return r.h.S||_("ES5").P(r,n,u),u?(i[L].g&&(O(r),t(4)),e(n)&&(n=M(r,n),r.p||x(r,n)),r.o&&_("Patches").M(i[L].u,n,r.o,r.v)):n=M(r,i,[]),O(r),r.o&&r.s(r.o,r.v),n!==G?n:void 0}function M(n,t,r){if(y(t))return t;var e=t[L];if(!e)return i(t,(function(i,u){return A(n,e,t,i,u,r)}),!0),t;if(e.A!==n)return t;if(!e.g)return x(n,e.u,!0),e.u;if(!e.R){e.R=!0,e.A.m--;var u=4===e.t||5===e.t?e.i=p(e.k):e.i,o=u,f=!1;3===e.t&&(o=new Set(u),u.clear(),f=!0),i(o,(function(t,i){return A(n,e,u,t,i,r,f)})),x(n,u,!1),r&&n.o&&_("Patches").F(e,r,n.o,n.v)}return e.i}function A(n,t,i,u,f,c,v){if(r(f)){var s=M(n,f,c&&t&&3!==t.t&&!o(t.N,u)?c.concat(u):void 0);if(a(i,u,s),!r(s))return;n._=!1}else v&&i.add(f);if(e(f)&&!y(f)){if(!n.h.D&&n.m<1)return;M(n,f),t&&t.A.p||x(n,f)}}function x(n,t,r){void 0===r&&(r=!1),!n.p&&n.h.D&&n._&&d(t,r)}function z(n,t){var r=n[L];return(r?l(r):n)[t]}function E(n,t){if(t in n)for(var r=Object.getPrototypeOf(n);r;){var e=Object.getOwnPropertyDescriptor(r,t);if(e)return e;r=Object.getPrototypeOf(r)}}function R(n){n.g||(n.g=!0,n.p&&R(n.p))}function k(n){n.i||(n.i=p(n.u))}function F(n,t,r){var e=v(t)?_("MapSet").K(t,r):s(t)?_("MapSet").$(t,r):n.S?function(n,t){var r=Array.isArray(n),e={t:r?1:0,A:t?t.A:m(),g:!1,R:!1,N:{},p:t,u:n,k:null,i:null,j:null,C:!1},i=e,u=Z;r&&(i=[e],u=nn);var o=Proxy.revocable(i,u),f=o.revoke,a=o.proxy;return e.k=a,e.j=f,a}(t,r):_("ES5").I(t,r);return(r?r.A:m()).l.push(e),e}function N(n){return r(n)||t(22,n),function n(t){if(!e(t))return t;var r,o=t[L],c=u(t);if(o){if(!o.g&&(o.t<4||!_("ES5").J(o)))return o.u;o.R=!0,r=D(t,c),o.R=!1}else r=D(t,c);return i(r,(function(t,e){o&&f(o.u,t)===e||a(r,t,n(e))})),3===c?new Set(r):r}(n)}function D(n,t){switch(t){case 2:return new Map(n);case 3:return Array.from(n)}return p(n)}function K(){function n(n,t){var r=f[n];return r?r.enumerable=t:f[n]=r={configurable:!0,enumerable:t,get:function(){return Z.get(this[L],n)},set:function(t){Z.set(this[L],n,t)}},r}function t(n){for(var t=n.length-1;t>=0;t--){var r=n[t][L];if(!r.g)switch(r.t){case 5:u(r)&&R(r);break;case 4:e(r)&&R(r)}}}function e(n){for(var t=n.u,r=n.k,e=U(r),i=e.length-1;i>=0;i--){var u=e[i];if(u!==L){var f=t[u];if(void 0===f&&!o(t,u))return!0;var a=r[u],v=a&&a[L];if(v?v.u!==f:!c(a,f))return!0}}var s=!!t[L];return e.length!==U(t).length+(s?0:1)}function u(n){var t=n.k;if(t.length!==n.u.length)return!0;var r=Object.getOwnPropertyDescriptor(t,t.length-1);if(r&&!r.get)return!0;for(var e=0;e1?r-1:0),u=1;u1?e-1:0),u=1;u=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var u=_("Patches").W;return r(n)?u(n,t):this.produce(n,(function(n){return u(n,t)}))},n}(),rn=new tn,en=rn.produce,un=rn.produceWithPatches.bind(rn),on=rn.setAutoFreeze.bind(rn),fn=rn.setUseProxies.bind(rn),an=rn.applyPatches.bind(rn),cn=rn.createDraft.bind(rn),vn=rn.finishDraft.bind(rn);n.Immer=tn,n.applyPatches=an,n.castDraft=function(n){return n},n.castImmutable=function(n){return n},n.createDraft=cn,n.current=N,n.default=en,n.enableAllPlugins=function(){K(),C(),$()},n.enableES5=K,n.enableMapSet=C,n.enablePatches=$,n.finishDraft=vn,n.freeze=d,n.immerable=H,n.isDraft=r,n.isDraftable=e,n.nothing=G,n.original=function(n){return r(n)||t(23,n),n[L].u},n.produce=en,n.produceWithPatches=un,n.setAutoFreeze=on,n.setUseProxies=fn,Object.defineProperty(n,"__esModule",{value:!0})})); +//# sourceMappingURL=immer.umd.production.min.js.map Index: frontend/node_modules/immer/dist/immer.umd.production.min.js.map =================================================================== --- frontend/node_modules/immer/dist/immer.umd.production.min.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/immer.umd.production.min.js.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"immer.umd.production.min.js","sources":["../src/utils/errors.ts","../src/utils/common.ts","../src/utils/plugins.ts","../src/core/scope.ts","../src/core/finalize.ts","../src/core/proxy.ts","../src/core/immerClass.ts","../src/core/current.ts","../src/plugins/es5.ts","../src/plugins/patches.ts","../src/plugins/mapset.ts","../src/utils/env.ts","../src/immer.ts","../src/plugins/all.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","// types only!\nimport {\n\tImmerState,\n\tAnyMap,\n\tAnySet,\n\tMapState,\n\tSetState,\n\tDRAFT_STATE,\n\tgetCurrentScope,\n\tlatest,\n\titeratorSymbol,\n\tisDraftable,\n\tcreateProxy,\n\tloadPlugin,\n\tmarkChanged,\n\tProxyType,\n\tdie,\n\teach\n} from \"../internal\"\n\nexport function enableMapSet() {\n\t/* istanbul ignore next */\n\tvar extendStatics = function(d: any, b: any): any {\n\t\textendStatics =\n\t\t\tObject.setPrototypeOf ||\n\t\t\t({__proto__: []} instanceof Array &&\n\t\t\t\tfunction(d, b) {\n\t\t\t\t\td.__proto__ = b\n\t\t\t\t}) ||\n\t\t\tfunction(d, b) {\n\t\t\t\tfor (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]\n\t\t\t}\n\t\treturn extendStatics(d, b)\n\t}\n\n\t// Ugly hack to resolve #502 and inherit built in Map / Set\n\tfunction __extends(d: any, b: any): any {\n\t\textendStatics(d, b)\n\t\tfunction __(this: any): any {\n\t\t\tthis.constructor = d\n\t\t}\n\t\td.prototype =\n\t\t\t// @ts-ignore\n\t\t\t((__.prototype = b.prototype), new __())\n\t}\n\n\tconst DraftMap = (function(_super) {\n\t\t__extends(DraftMap, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftMap(this: any, target: AnyMap, parent?: ImmerState): any {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Map,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tassigned_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this as any,\n\t\t\t\tisManual_: false,\n\t\t\t\trevoked_: false\n\t\t\t} as MapState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftMap.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: false,\n\t\t\t// configurable: true\n\t\t})\n\n\t\tp.has = function(key: any): boolean {\n\t\t\treturn latest(this[DRAFT_STATE]).has(key)\n\t\t}\n\n\t\tp.set = function(key: any, value: any) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!latest(state).has(key) || latest(state).get(key) !== value) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t\tstate.copy_!.set(key, value)\n\t\t\t\tstate.assigned_!.set(key, true)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(key: any): boolean {\n\t\t\tif (!this.has(key)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareMapCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\tif (state.base_.has(key)) {\n\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t} else {\n\t\t\t\tstate.assigned_!.delete(key)\n\t\t\t}\n\t\t\tstate.copy_!.delete(key)\n\t\t\treturn true\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareMapCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.assigned_ = new Map()\n\t\t\t\teach(state.base_, key => {\n\t\t\t\t\tstate.assigned_!.set(key, false)\n\t\t\t\t})\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.forEach = function(\n\t\t\tcb: (value: any, key: any, self: any) => void,\n\t\t\tthisArg?: any\n\t\t) {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tlatest(state).forEach((_value: any, key: any, _map: any) => {\n\t\t\t\tcb.call(thisArg, this.get(key), key, this)\n\t\t\t})\n\t\t}\n\n\t\tp.get = function(key: any): any {\n\t\t\tconst state: MapState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tconst value = latest(state).get(key)\n\t\t\tif (state.finalized_ || !isDraftable(value)) {\n\t\t\t\treturn value\n\t\t\t}\n\t\t\tif (value !== state.base_.get(key)) {\n\t\t\t\treturn value // either already drafted or reassigned\n\t\t\t}\n\t\t\t// despite what it looks, this creates a draft only once, see above condition\n\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\tprepareMapCopy(state)\n\t\t\tstate.copy_!.set(key, draft)\n\t\t\treturn draft\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn latest(this[DRAFT_STATE]).keys()\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.values(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp.entries = function(): IterableIterator<[any, any]> {\n\t\t\tconst iterator = this.keys()\n\t\t\treturn {\n\t\t\t\t[iteratorSymbol]: () => this.entries(),\n\t\t\t\tnext: () => {\n\t\t\t\t\tconst r = iterator.next()\n\t\t\t\t\t/* istanbul ignore next */\n\t\t\t\t\tif (r.done) return r\n\t\t\t\t\tconst value = this.get(r.value)\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdone: false,\n\t\t\t\t\t\tvalue: [r.value, value]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} as any\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.entries()\n\t\t}\n\n\t\treturn DraftMap\n\t})(Map)\n\n\tfunction proxyMap_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftMap(target, parent)\n\t}\n\n\tfunction prepareMapCopy(state: MapState) {\n\t\tif (!state.copy_) {\n\t\t\tstate.assigned_ = new Map()\n\t\t\tstate.copy_ = new Map(state.base_)\n\t\t}\n\t}\n\n\tconst DraftSet = (function(_super) {\n\t\t__extends(DraftSet, _super)\n\t\t// Create class manually, cause #502\n\t\tfunction DraftSet(this: any, target: AnySet, parent?: ImmerState) {\n\t\t\tthis[DRAFT_STATE] = {\n\t\t\t\ttype_: ProxyType.Set,\n\t\t\t\tparent_: parent,\n\t\t\t\tscope_: parent ? parent.scope_ : getCurrentScope()!,\n\t\t\t\tmodified_: false,\n\t\t\t\tfinalized_: false,\n\t\t\t\tcopy_: undefined,\n\t\t\t\tbase_: target,\n\t\t\t\tdraft_: this,\n\t\t\t\tdrafts_: new Map(),\n\t\t\t\trevoked_: false,\n\t\t\t\tisManual_: false\n\t\t\t} as SetState\n\t\t\treturn this\n\t\t}\n\t\tconst p = DraftSet.prototype\n\n\t\tObject.defineProperty(p, \"size\", {\n\t\t\tget: function() {\n\t\t\t\treturn latest(this[DRAFT_STATE]).size\n\t\t\t}\n\t\t\t// enumerable: true,\n\t\t})\n\n\t\tp.has = function(value: any): boolean {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\t// bit of trickery here, to be able to recognize both the value, and the draft of its value\n\t\t\tif (!state.copy_) {\n\t\t\t\treturn state.base_.has(value)\n\t\t\t}\n\t\t\tif (state.copy_.has(value)) return true\n\t\t\tif (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n\t\t\t\treturn true\n\t\t\treturn false\n\t\t}\n\n\t\tp.add = function(value: any): any {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (!this.has(value)) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.add(value)\n\t\t\t}\n\t\t\treturn this\n\t\t}\n\n\t\tp.delete = function(value: any): any {\n\t\t\tif (!this.has(value)) {\n\t\t\t\treturn false\n\t\t\t}\n\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\tmarkChanged(state)\n\t\t\treturn (\n\t\t\t\tstate.copy_!.delete(value) ||\n\t\t\t\t(state.drafts_.has(value)\n\t\t\t\t\t? state.copy_!.delete(state.drafts_.get(value))\n\t\t\t\t\t: /* istanbul ignore next */ false)\n\t\t\t)\n\t\t}\n\n\t\tp.clear = function() {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tif (latest(state).size) {\n\t\t\t\tprepareSetCopy(state)\n\t\t\t\tmarkChanged(state)\n\t\t\t\tstate.copy_!.clear()\n\t\t\t}\n\t\t}\n\n\t\tp.values = function(): IterableIterator {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.values()\n\t\t}\n\n\t\tp.entries = function entries(): IterableIterator<[any, any]> {\n\t\t\tconst state: SetState = this[DRAFT_STATE]\n\t\t\tassertUnrevoked(state)\n\t\t\tprepareSetCopy(state)\n\t\t\treturn state.copy_!.entries()\n\t\t}\n\n\t\tp.keys = function(): IterableIterator {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp[iteratorSymbol] = function() {\n\t\t\treturn this.values()\n\t\t}\n\n\t\tp.forEach = function forEach(cb: any, thisArg?: any) {\n\t\t\tconst iterator = this.values()\n\t\t\tlet result = iterator.next()\n\t\t\twhile (!result.done) {\n\t\t\t\tcb.call(thisArg, result.value, result.value, this)\n\t\t\t\tresult = iterator.next()\n\t\t\t}\n\t\t}\n\n\t\treturn DraftSet\n\t})(Set)\n\n\tfunction proxySet_(target: T, parent?: ImmerState): T {\n\t\t// @ts-ignore\n\t\treturn new DraftSet(target, parent)\n\t}\n\n\tfunction prepareSetCopy(state: SetState) {\n\t\tif (!state.copy_) {\n\t\t\t// create drafts for all entries to preserve insertion order\n\t\t\tstate.copy_ = new Set()\n\t\t\tstate.base_.forEach(value => {\n\t\t\t\tif (isDraftable(value)) {\n\t\t\t\t\tconst draft = createProxy(state.scope_.immer_, value, state)\n\t\t\t\t\tstate.drafts_.set(value, draft)\n\t\t\t\t\tstate.copy_!.add(draft)\n\t\t\t\t} else {\n\t\t\t\t\tstate.copy_!.add(value)\n\t\t\t\t}\n\t\t\t})\n\t\t}\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(\"MapSet\", {proxyMap_, proxySet_})\n}\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","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","import {enableES5} from \"./es5\"\nimport {enableMapSet} from \"./mapset\"\nimport {enablePatches} from \"./patches\"\n\nexport function enableAllPlugins() {\n\tenableES5()\n\tenableMapSet()\n\tenablePatches()\n}\n"],"names":["die","error","args","Error","length","map","s","join","isDraft","value","DRAFT_STATE","isDraftable","proto","Object","getPrototypeOf","Ctor","hasOwnProperty","call","constructor","Function","toString","objectCtorString","Array","isArray","DRAFTABLE","_value$constructor","isMap","isSet","each","obj","iter","enumerableOnly","getArchtype","keys","ownKeys","forEach","key","entry","index","thing","state","type_","has","prop","prototype","get","set","propOrOldValue","t","add","is","x","y","target","hasMap","Map","hasSet","Set","latest","copy_","base_","shallowCopy","base","slice","descriptors","getOwnPropertyDescriptors","i","desc","writable","configurable","enumerable","create","freeze","deep","isFrozen","clear","delete","dontMutateFrozenCollections","getPlugin","pluginKey","plugin","plugins","loadPlugin","implementation","getCurrentScope","currentScope","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","drafts_","revokeDraft","parent_","enterScope","immer","immer_","canAutoFreeze_","unfinalizedDrafts_","draft","revoke_","revoked_","processResult","result","baseDraft","isReplaced","useProxies_","willFinalizeES5_","modified_","finalize","maybeFreeze","generateReplacementPatches_","NOTHING","rootScope","path","childValue","finalizeProperty","scope_","finalized_","draft_","resultEach","generatePatches_","parentState","targetObject","rootPath","targetIsSet","res","assigned_","concat","autoFreeze_","peek","getDescriptorFromProto","source","getOwnPropertyDescriptor","markChanged","prepareCopy","createProxy","parent","proxyMap_","proxySet_","isManual_","traps","objectTraps","arrayTraps","Proxy","revocable","revoke","proxy","createES5Proxy_","push","current","currentImpl","copy","archType","hasChanges_","copyHelper","from","enableES5","proxyProperty","this","markChangesSweep","drafts","hasArrayChanges","hasObjectChanges","baseValue","baseIsDraft","descriptor","defineProperty","markChangesRecursively","object","min","Math","enablePatches","deepClonePatchValue","entries","cloned","immerable","clonePatchValueIfNeeded","ADD","applyPatches_","patches","patch","op","parentType","p","type","splice","basePath","inversePatches","assignedValue","origValue","unshift","replacement","enableMapSet","__extends","d","b","__","extendStatics","prepareMapCopy","prepareSetCopy","assertUnrevoked","JSON","stringify","setPrototypeOf","__proto__","DraftMap","size","cb","thisArg","_value","_this","values","iterator","iteratorSymbol","_this2","next","r","done","_this3","DraftSet","hasSymbol","Symbol","hasProxies","Reflect","for","getOwnPropertySymbols","getOwnPropertyNames","_desc$get","currentState","Number","isNaN","deleteProperty","owner","fn","arguments","apply","Immer","config","recipe","defaultBase","self","produce","hasError","Promise","then","ip","produceWithPatches","nextState","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","applyPatchesImpl","bind"],"mappings":"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"} Index: frontend/node_modules/immer/dist/index.js =================================================================== --- frontend/node_modules/immer/dist/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,8 @@ + +'use strict' + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./immer.cjs.production.min.js') +} else { + module.exports = require('./immer.cjs.development.js') +} Index: frontend/node_modules/immer/dist/index.js.flow =================================================================== --- frontend/node_modules/immer/dist/index.js.flow (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/index.js.flow (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,113 @@ +// @flow + +export interface Patch { + op: "replace" | "remove" | "add"; + path: (string | number)[]; + value?: any; +} + +export type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void + +type Base = {...} | Array +interface IProduce { + /** + * Immer takes a state, and runs a function against it. + * That function can freely mutate the state, as it will create copies-on-write. + * This means that the original state will stay unchanged, and once the function finishes, the modified state is returned. + * + * If the first argument is a function, this is interpreted as the recipe, and will create a curried function that will execute the recipe + * any time it is called with the current state. + * + * @param currentState - the state to start with + * @param recipe - function that receives a proxy of the current state as first argument and which can be freely modified + * @param initialState - if a curried function is created and this argument was given, it will be used as fallback if the curried function is called with a state of undefined + * @returns The next state: a new state, or the current state if nothing was modified + */ + ( + currentState: S, + recipe: (draftState: S) => S | void, + patchListener?: PatchListener + ): S; + // curried invocations with initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void, + initialState: S + ): (currentState: S | void, a: A, b: B, c: C, ...extraArgs: any[]) => S; + // curried invocations without initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void + ): (currentState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S; +} + +interface IProduceWithPatches { + /** + * Like `produce`, but instead of just returning the new state, + * a tuple is returned with [nextState, patches, inversePatches] + * + * Like produce, this function supports currying + */ + ( + currentState: S, + recipe: (draftState: S) => S | void + ): [S, Patch[], Patch[]]; + // curried invocations with initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void, + initialState: S + ): (currentState: S | void, a: A, b: B, c: C, ...extraArgs: any[]) => [S, Patch[], Patch[]]; + // curried invocations without initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void + ): (currentState: S, a: A, b: B, c: C, ...extraArgs: any[]) => [S, Patch[], Patch[]]; +} + +declare export var produce: IProduce +declare export default IProduce + +declare export var produceWithPatches: IProduceWithPatches + +declare export var nothing: typeof undefined + +declare export var immerable: Symbol + +/** + * Automatically freezes any state trees generated by immer. + * This protects against accidental modifications of the state tree outside of an immer function. + * This comes with a performance impact, so it is recommended to disable this option in production. + * By default it is turned on during local development, and turned off in production. + */ +declare export function setAutoFreeze(autoFreeze: boolean): void + +/** + * Manually override whether proxies should be used. + * By default done by using feature detection + */ +declare export function setUseProxies(useProxies: boolean): void + +declare export function applyPatches(state: S, patches: Patch[]): S + +declare export function original(value: S): S + +declare export function current(value: S): S + +declare export function isDraft(value: any): boolean + +/** + * Creates a mutable draft from an (immutable) object / array. + * The draft can be modified until `finishDraft` is called + */ +declare export function createDraft(base: T): T + +/** + * Given a draft that was created using `createDraft`, + * finalizes the draft into a new immutable object. + * Optionally a patch-listener can be provided to gather the patches that are needed to construct the object. + */ +declare export function finishDraft(base: T, listener?: PatchListener): T + +declare export function enableES5(): void +declare export function enableMapSet(): void +declare export function enablePatches(): void +declare export function enableAllPlugins(): void + +declare export function freeze(obj: T, freeze?: boolean): T Index: frontend/node_modules/immer/dist/internal.d.ts =================================================================== --- frontend/node_modules/immer/dist/internal.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/internal.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,12 @@ +export * from "./utils/env"; +export * from "./utils/errors"; +export * from "./types/types-external"; +export * from "./types/types-internal"; +export * from "./utils/common"; +export * from "./utils/plugins"; +export * from "./core/scope"; +export * from "./core/finalize"; +export * from "./core/proxy"; +export * from "./core/immerClass"; +export * from "./core/current"; +//# sourceMappingURL=internal.d.ts.map Index: frontend/node_modules/immer/dist/internal.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/internal.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/internal.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["src/internal.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA"} Index: frontend/node_modules/immer/dist/plugins/all.d.ts =================================================================== --- frontend/node_modules/immer/dist/plugins/all.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/all.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +export declare function enableAllPlugins(): void; +//# sourceMappingURL=all.d.ts.map Index: frontend/node_modules/immer/dist/plugins/all.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/plugins/all.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/all.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../src/plugins/all.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,SAI/B"} Index: frontend/node_modules/immer/dist/plugins/es5.d.ts =================================================================== --- frontend/node_modules/immer/dist/plugins/es5.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/es5.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +export declare function enableES5(): void; +//# sourceMappingURL=es5.d.ts.map Index: frontend/node_modules/immer/dist/plugins/es5.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/plugins/es5.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/es5.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"es5.d.ts","sourceRoot":"","sources":["../src/plugins/es5.ts"],"names":[],"mappings":"AAwBA,wBAAgB,SAAS,SA4PxB"} Index: frontend/node_modules/immer/dist/plugins/mapset.d.ts =================================================================== --- frontend/node_modules/immer/dist/plugins/mapset.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/mapset.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +export declare function enableMapSet(): void; +//# sourceMappingURL=mapset.d.ts.map Index: frontend/node_modules/immer/dist/plugins/mapset.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/plugins/mapset.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/mapset.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"mapset.d.ts","sourceRoot":"","sources":["../src/plugins/mapset.ts"],"names":[],"mappings":"AAoBA,wBAAgB,YAAY,SAuU3B"} Index: frontend/node_modules/immer/dist/plugins/patches.d.ts =================================================================== --- frontend/node_modules/immer/dist/plugins/patches.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/patches.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,2 @@ +export declare function enablePatches(): void; +//# sourceMappingURL=patches.d.ts.map Index: frontend/node_modules/immer/dist/plugins/patches.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/plugins/patches.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/plugins/patches.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"patches.d.ts","sourceRoot":"","sources":["../src/plugins/patches.ts"],"names":[],"mappings":"AA0BA,wBAAgB,aAAa,SAsR5B"} Index: frontend/node_modules/immer/dist/types/types-external.d.ts =================================================================== --- frontend/node_modules/immer/dist/types/types-external.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/types/types-external.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,107 @@ +import { Nothing } from "../internal"; +declare type AnyFunc = (...args: any[]) => any; +declare type PrimitiveType = number | string | boolean; +/** Object types that should never be mapped */ +declare type AtomicObject = Function | Promise | Date | RegExp; +/** + * If the lib "ES2015.Collection" is not included in tsconfig.json, + * types like ReadonlyArray, WeakMap etc. fall back to `any` (specified nowhere) + * or `{}` (from the node types), in both cases entering an infinite recursion in + * pattern matching type mappings + * This type can be used to cast these types to `void` in these cases. + */ +export declare type IfAvailable = true | false extends (T extends never ? true : false) ? Fallback : keyof T extends never ? Fallback : T; +/** + * These should also never be mapped but must be tested after regular Map and + * Set + */ +declare type WeakReferences = IfAvailable> | IfAvailable>; +export declare type WritableDraft = { + -readonly [K in keyof T]: Draft; +}; +/** Convert a readonly type into a mutable type, if possible */ +export declare type Draft = T extends PrimitiveType ? T : T extends AtomicObject ? T : T extends IfAvailable> ? Map, Draft> : T extends IfAvailable> ? Set> : T extends WeakReferences ? T : T extends object ? WritableDraft : T; +/** Convert a mutable type into a readonly type */ +export declare type Immutable = T extends PrimitiveType ? T : T extends AtomicObject ? T : T extends IfAvailable> ? ReadonlyMap, Immutable> : T extends IfAvailable> ? ReadonlySet> : T extends WeakReferences ? T : T extends object ? { + readonly [K in keyof T]: Immutable; +} : T; +export interface Patch { + op: "replace" | "remove" | "add"; + path: (string | number)[]; + value?: any; +} +export declare type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void; +/** Converts `nothing` into `undefined` */ +declare type FromNothing = T extends Nothing ? undefined : T; +/** The inferred return type of `produce` */ +export declare type Produced = Return extends void ? Base : Return extends Promise ? Promise> : FromNothing; +/** + * Utility types + */ +declare type PatchesTuple = readonly [T, Patch[], Patch[]]; +declare type ValidRecipeReturnType = State | void | undefined | (State extends undefined ? Nothing : never); +declare type ValidRecipeReturnTypePossiblyPromise = ValidRecipeReturnType | Promise>; +declare type PromisifyReturnIfNeeded = ReturnType extends Promise ? Promise : State> : UsePatches extends true ? PatchesTuple : State; +/** + * Core Producer inference + */ +declare type InferRecipeFromCurried = Curried extends (base: infer State, ...rest: infer Args) => any ? ReturnType extends State ? (draft: Draft, ...rest: Args) => ValidRecipeReturnType> : never : never; +declare type InferInitialStateFromCurried = Curried extends (base: infer State, ...rest: any[]) => any ? State : never; +declare type InferCurriedFromRecipe = Recipe extends (draft: infer DraftState, ...args: infer RestArgs) => any ? ReturnType extends ValidRecipeReturnTypePossiblyPromise ? (base: Immutable, ...args: RestArgs) => PromisifyReturnIfNeeded : never : never; +declare type InferCurriedFromInitialStateAndRecipe = Recipe extends (draft: Draft, ...rest: infer RestArgs) => ValidRecipeReturnTypePossiblyPromise ? (base?: State | undefined, ...args: RestArgs) => PromisifyReturnIfNeeded : never; +/** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ +export interface IProduce { + /** Curried producer that infers the recipe from the curried output function (e.g. when passing to setState) */ + (recipe: InferRecipeFromCurried, initialState?: InferInitialStateFromCurried): Curried; + /** Curried producer that infers curried from the recipe */ + (recipe: Recipe): InferCurriedFromRecipe; + /** Curried producer that infers curried from the State generic, which is explicitly passed in. */ + (recipe: (state: Draft, initialState: State) => ValidRecipeReturnType): (state?: State) => State; + (recipe: (state: Draft, ...args: Args) => ValidRecipeReturnType, initialState: State): (state?: State, ...args: Args) => State; + (recipe: (state: Draft) => ValidRecipeReturnType): (state: State) => State; + (recipe: (state: Draft, ...args: Args) => ValidRecipeReturnType): (state: State, ...args: Args) => State; + /** Curried producer with initial state, infers recipe from initial state */ + (recipe: Recipe, initialState: State): InferCurriedFromInitialStateAndRecipe; + /** Normal producer */ + >(// By using a default inferred D, rather than Draft in the recipe, we can override it. + base: Base, recipe: (draft: D) => ValidRecipeReturnType, listener?: PatchListener): Base; + /** Promisified normal producer */ + >(base: Base, recipe: (draft: D) => Promise>, listener?: PatchListener): Promise; +} +/** + * Like `produce`, but instead of just returning the new state, + * a tuple is returned with [nextState, patches, inversePatches] + * + * Like produce, this function supports currying + */ +export interface IProduceWithPatches { + (recipe: Recipe): InferCurriedFromRecipe; + (recipe: Recipe, initialState: State): InferCurriedFromInitialStateAndRecipe; + >(base: Base, recipe: (draft: D) => ValidRecipeReturnType, listener?: PatchListener): PatchesTuple; + >(base: Base, recipe: (draft: D) => Promise>, listener?: PatchListener): Promise>; +} +/** + * The type for `recipe function` + */ +export declare type Producer = (draft: Draft) => ValidRecipeReturnType> | Promise>>; +export declare function never_used(): void; +export {}; +//# sourceMappingURL=types-external.d.ts.map Index: frontend/node_modules/immer/dist/types/types-external.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/types/types-external.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/types/types-external.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"types-external.d.ts","sourceRoot":"","sources":["../src/types/types-external.ts"],"names":[],"mappings":"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"} Index: frontend/node_modules/immer/dist/types/types-internal.d.ts =================================================================== --- frontend/node_modules/immer/dist/types/types-internal.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/types/types-internal.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,35 @@ +import { SetState, ImmerScope, ProxyObjectState, ProxyArrayState, ES5ObjectState, ES5ArrayState, MapState, DRAFT_STATE } from "../internal"; +export declare type Objectish = AnyObject | AnyArray | AnyMap | AnySet; +export declare type ObjectishNoSet = AnyObject | AnyArray | AnyMap; +export declare type AnyObject = { + [key: string]: any; +}; +export declare type AnyArray = Array; +export declare type AnySet = Set; +export declare type AnyMap = Map; +export declare const enum Archtype { + Object = 0, + Array = 1, + Map = 2, + Set = 3 +} +export declare const enum ProxyType { + ProxyObject = 0, + ProxyArray = 1, + Map = 2, + Set = 3, + ES5Object = 4, + ES5Array = 5 +} +export interface ImmerBaseState { + parent_?: ImmerState; + scope_: ImmerScope; + modified_: boolean; + finalized_: boolean; + isManual_: boolean; +} +export declare type ImmerState = ProxyObjectState | ProxyArrayState | ES5ObjectState | ES5ArrayState | MapState | SetState; +export declare type Drafted = { + [DRAFT_STATE]: T; +} & Base; +//# sourceMappingURL=types-internal.d.ts.map Index: frontend/node_modules/immer/dist/types/types-internal.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/types/types-internal.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/types/types-internal.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"types-internal.d.ts","sourceRoot":"","sources":["../src/types/types-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,aAAa,EACb,QAAQ,EACR,WAAW,EACX,MAAM,aAAa,CAAA;AAEpB,oBAAY,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAC9D,oBAAY,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE1D,oBAAY,SAAS,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAAA;AAC5C,oBAAY,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;AACjC,oBAAY,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAA;AAC7B,oBAAY,MAAM,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAElC,0BAAkB,QAAQ;IACzB,MAAM,IAAA;IACN,KAAK,IAAA;IACL,GAAG,IAAA;IACH,GAAG,IAAA;CACH;AAED,0BAAkB,SAAS;IAC1B,WAAW,IAAA;IACX,UAAU,IAAA;IACV,GAAG,IAAA;IACH,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;CACR;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,CAAC,EAAE,UAAU,CAAA;IACpB,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,OAAO,CAAA;CAClB;AAED,oBAAY,UAAU,GACnB,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,aAAa,GACb,QAAQ,GACR,QAAQ,CAAA;AAGX,oBAAY,OAAO,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI;IACpE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;CAChB,GAAG,IAAI,CAAA"} Index: frontend/node_modules/immer/dist/utils/common.d.ts =================================================================== --- frontend/node_modules/immer/dist/utils/common.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/common.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,32 @@ +import { Objectish, AnyObject, AnyMap, AnySet, ImmerState, Archtype } from "../internal"; +/** Returns true if the given value is an Immer draft */ +export declare function isDraft(value: any): boolean; +/** Returns true if the given value can be drafted by Immer */ +export declare function isDraftable(value: any): boolean; +export declare function isPlainObject(value: any): boolean; +/** Get the underlying object that is represented by the given draft */ +export declare function original(value: T): T | undefined; +export declare const ownKeys: (target: AnyObject) => PropertyKey[]; +export declare const getOwnPropertyDescriptors: (o: T) => { [P in keyof T]: TypedPropertyDescriptor; } & { + [x: string]: PropertyDescriptor; +}; +export declare function each(obj: T, iter: (key: string | number, value: any, source: T) => void, enumerableOnly?: boolean): void; +export declare function getArchtype(thing: any): Archtype; +export declare function has(thing: any, prop: PropertyKey): boolean; +export declare function get(thing: AnyMap | AnyObject, prop: PropertyKey): any; +export declare function set(thing: any, propOrOldValue: PropertyKey, value: any): void; +export declare function is(x: any, y: any): boolean; +export declare function isMap(target: any): target is AnyMap; +export declare function isSet(target: any): target is AnySet; +export declare function latest(state: ImmerState): any; +export declare function shallowCopy(base: any): any; +/** + * Freezes draftable objects. Returns the original object. + * By default freezes shallowly, but if the second argument is `true` it will freeze recursively. + * + * @param obj + * @param deep + */ +export declare function freeze(obj: T, deep?: boolean): T; +export declare function isFrozen(obj: any): boolean; +//# sourceMappingURL=common.d.ts.map Index: frontend/node_modules/immer/dist/utils/common.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/utils/common.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/common.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../src/utils/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAIN,SAAS,EAET,SAAS,EACT,MAAM,EACN,MAAM,EACN,UAAU,EAEV,QAAQ,EAER,MAAM,aAAa,CAAA;AAEpB,wDAAwD;AAExD,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAE3C;AAED,8DAA8D;AAE9D,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAU/C;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAejD;AAED,uEAAuE;AAEvE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAA;AAOpD,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,WAAW,EAQC,CAAA;AAEzD,eAAO,MAAM,yBAAyB;;CASpC,CAAA;AAEF,wBAAgB,IAAI,CAAC,CAAC,SAAS,SAAS,EACvC,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,KAAK,IAAI,EAC3D,cAAc,CAAC,EAAE,OAAO,GACtB,IAAI,CAAA;AAYP,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,QAAQ,CAchD;AAGD,wBAAgB,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAI1D;AAGD,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,WAAW,GAAG,GAAG,CAGrE;AAGD,wBAAgB,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,cAAc,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,QAMtE;AAGD,wBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAO1C;AAGD,wBAAgB,KAAK,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,MAAM,CAEnD;AAGD,wBAAgB,KAAK,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,MAAM,CAEnD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,GAAG,CAE7C;AAGD,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,OAwBpC;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,CAAC,CAAA;AAepD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAI1C"} Index: frontend/node_modules/immer/dist/utils/env.d.ts =================================================================== --- frontend/node_modules/immer/dist/utils/env.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/env.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,23 @@ +export declare const hasMap: boolean; +export declare const hasSet: boolean; +export declare const hasProxies: boolean; +/** + * The sentinel value returned by producers to replace the draft with undefined. + */ +export declare const NOTHING: Nothing; +/** + * To let Immer treat your class instances as plain immutable objects + * (albeit with a custom prototype), you must define either an instance property + * or a static property on each of your custom classes. + * + * Otherwise, your class instance will never be drafted, which means it won't be + * safe to mutate in a produce callback. + */ +export declare const DRAFTABLE: unique symbol; +export declare const DRAFT_STATE: unique symbol; +export declare const iteratorSymbol: typeof Symbol.iterator; +/** Use a class type for `nothing` so its type is unique */ +export declare class Nothing { + private _; +} +//# sourceMappingURL=env.d.ts.map Index: frontend/node_modules/immer/dist/utils/env.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/utils/env.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/env.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/utils/env.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,MAAM,SAA6B,CAAA;AAChD,eAAO,MAAM,MAAM,SAA6B,CAAA;AAChD,eAAO,MAAM,UAAU,SAGQ,CAAA;AAE/B;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAEe,CAAA;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,OAAO,MAEC,CAAA;AAEhC,eAAO,MAAM,WAAW,EAAE,OAAO,MAEL,CAAA;AAG5B,eAAO,MAAM,cAAc,EAAE,OAAO,MAAM,CAAC,QACgC,CAAA;AAE3E,2DAA2D;AAC3D,qBAAa,OAAO;IAGnB,OAAO,CAAC,CAAC,CAAgB;CACzB"} Index: frontend/node_modules/immer/dist/utils/errors.d.ts =================================================================== --- frontend/node_modules/immer/dist/utils/errors.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/errors.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,29 @@ +declare const errors: { + readonly 0: "Illegal state"; + readonly 1: "Immer drafts cannot have computed properties"; + readonly 2: "This object has been frozen and should not be mutated"; + readonly 3: (data: any) => string; + readonly 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft."; + readonly 5: "Immer forbids circular references"; + readonly 6: "The first or second argument to `produce` must be a function"; + readonly 7: "The third argument to `produce` must be a function or undefined"; + readonly 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object"; + readonly 9: "First argument to `finishDraft` must be a draft returned by `createDraft`"; + readonly 10: "The given draft is already finalized"; + readonly 11: "Object.defineProperty() cannot be used on an Immer draft"; + readonly 12: "Object.setPrototypeOf() cannot be used on an Immer draft"; + readonly 13: "Immer only supports deleting array indices"; + readonly 14: "Immer only supports setting array indices and the 'length' property"; + readonly 15: (path: string) => string; + readonly 16: "Sets cannot have \"replace\" patches."; + readonly 17: (op: string) => string; + readonly 18: (plugin: string) => string; + readonly 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available"; + readonly 21: (thing: string) => string; + readonly 22: (thing: string) => string; + readonly 23: (thing: string) => string; + readonly 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed"; +}; +export declare function die(error: keyof typeof errors, ...args: any[]): never; +export {}; +//# sourceMappingURL=errors.d.ts.map Index: frontend/node_modules/immer/dist/utils/errors.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/utils/errors.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/errors.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/utils/errors.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;CA0CF,CAAA;AAEV,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,OAAO,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,KAAK,CAerE"} Index: frontend/node_modules/immer/dist/utils/plugins.d.ts =================================================================== --- frontend/node_modules/immer/dist/utils/plugins.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/plugins.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,62 @@ +import { ImmerState, Patch, ImmerScope, Drafted, AnyObject, ImmerBaseState, AnyMap, AnySet, ProxyType } from "../internal"; +/** Plugin utilities */ +declare const plugins: { + Patches?: { + generatePatches_(state: ImmerState, basePath: PatchPath, patches: Patch[], inversePatches: Patch[]): void; + generateReplacementPatches_(base: any, replacement: any, patches: Patch[], inversePatches: Patch[]): void; + applyPatches_(draft: T, patches: Patch[]): T; + }; + ES5?: { + willFinalizeES5_(scope: ImmerScope, result: any, isReplaced: boolean): void; + createES5Proxy_(base: T, parent?: ImmerState): Drafted; + hasChanges_(state: ES5ArrayState | ES5ObjectState): boolean; + }; + MapSet?: { + proxyMap_(target: T, parent?: ImmerState): T; + proxySet_(target: T, parent?: ImmerState): T; + }; +}; +declare type Plugins = typeof plugins; +export declare function getPlugin(pluginKey: K): Exclude; +export declare function loadPlugin(pluginKey: K, implementation: Plugins[K]): void; +/** ES5 Plugin */ +interface ES5BaseState extends ImmerBaseState { + assigned_: { + [key: string]: any; + }; + parent_?: ImmerState; + revoked_: boolean; +} +export interface ES5ObjectState extends ES5BaseState { + type_: ProxyType.ES5Object; + draft_: Drafted; + base_: AnyObject; + copy_: AnyObject | null; +} +export interface ES5ArrayState extends ES5BaseState { + type_: ProxyType.ES5Array; + draft_: Drafted; + base_: any; + copy_: any; +} +/** Map / Set plugin */ +export interface MapState extends ImmerBaseState { + type_: ProxyType.Map; + copy_: AnyMap | undefined; + assigned_: Map | undefined; + base_: AnyMap; + revoked_: boolean; + draft_: Drafted; +} +export interface SetState extends ImmerBaseState { + type_: ProxyType.Set; + copy_: AnySet | undefined; + base_: AnySet; + drafts_: Map; + revoked_: boolean; + draft_: Drafted; +} +/** Patches plugin */ +export declare type PatchPath = (string | number)[]; +export {}; +//# sourceMappingURL=plugins.d.ts.map Index: frontend/node_modules/immer/dist/utils/plugins.d.ts.map =================================================================== --- frontend/node_modules/immer/dist/utils/plugins.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/dist/utils/plugins.d.ts.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/utils/plugins.ts"],"names":[],"mappings":"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"} Index: frontend/node_modules/immer/package.json =================================================================== --- frontend/node_modules/immer/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,104 @@ +{ + "name": "immer", + "version": "9.0.21", + "description": "Create your next immutable state by mutating the current one", + "main": "dist/index.js", + "module": "dist/immer.esm.js", + "exports": { + ".": { + "types": "./dist/immer.d.ts", + "import": "./dist/immer.esm.mjs", + "require": "./dist/index.js" + }, + "./*": "./*" + }, + "umd:main": "dist/immer.umd.production.min.js", + "unpkg": "dist/immer.umd.production.min.js", + "jsdelivr": "dist/immer.umd.production.min.js", + "jsnext:main": "dist/immer.esm.js", + "react-native": "dist/immer.esm.js", + "source": "src/immer.ts", + "types": "./dist/immer.d.ts", + "typesVersions": { + ">=3.7": { + "*": [ + "./*" + ] + }, + ">=3.1": { + "*": [ + "compat/pre-3.7/*" + ] + } + }, + "sideEffects": false, + "scripts": { + "test": "jest && yarn test:build && yarn test:flow", + "test:perf": "cd __performance_tests__ && babel-node add-data.js && babel-node todo.js && babel-node incremental.js", + "test:flow": "yarn flow check __tests__/flow", + "test:build": "yarn build && NODE_ENV='production' yarn jest --config jest.config.build.js", + "watch": "jest --watch", + "coverage": "jest --coverage", + "coveralls": "jest --coverage && cat ./coverage/lcov.info | ./node_modules/.bin/coveralls && rm -rf ./coverage", + "build": "rimraf dist/ && tsdx build --name immer --format esm,cjs,umd && cp dist/immer.esm.js dist/immer.esm.mjs && yarn build:flow", + "build:flow": "cpx 'src/types/index.js.flow' dist -v", + "publish-docs": "cd website && GIT_USER=mweststrate USE_SSH=true yarn docusaurus deploy", + "start": "cd website && yarn start", + "test:size": "yarn build && yarn import-size --report . produce enableES5 enableMapSet enablePatches enableAllPlugins", + "test:sizequick": "tsdx build --name immer --format esm && yarn import-size . produce" + }, + "husky": { + "hooks": { + "pre-commit": "pretty-quick --staged" + } + }, + "repository": { + "type": "git", + "url": "https://github.com/immerjs/immer.git" + }, + "keywords": [ + "immutable", + "mutable", + "copy-on-write" + ], + "author": "Michel Weststrate", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + }, + "bugs": { + "url": "https://github.com/immerjs/immer/issues" + }, + "homepage": "https://github.com/immerjs/immer#readme", + "files": [ + "dist", + "compat", + "src" + ], + "devDependencies": { + "@babel/core": "^7.8.4", + "@babel/node": "^7.8.4", + "@types/jest": "^25.1.2", + "coveralls": "^3.0.0", + "cpx2": "^3.0.0", + "deep-freeze": "^0.0.1", + "flow-bin": "^0.123.0", + "husky": "^1.2.0", + "immutable": "^3.8.2", + "import-size": "^1.0.2", + "jest": "^25.1.0", + "lodash": "^4.17.4", + "lodash.clonedeep": "^4.5.0", + "prettier": "1.19.1", + "pretty-quick": "^1.8.0", + "redux": "^4.0.5", + "rimraf": "^2.6.2", + "seamless-immutable": "^7.1.3", + "semantic-release": "^17.0.2", + "spec.ts": "^1.1.0", + "ts-jest": "^25.2.0", + "tsdx": "^0.12.3", + "typescript": "^4.2.3" + } +} Index: frontend/node_modules/immer/readme.md =================================================================== --- frontend/node_modules/immer/readme.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/readme.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,33 @@ + + +# Immer + +[![npm](https://img.shields.io/npm/v/immer.svg)](https://www.npmjs.com/package/immer) [![Build Status](https://travis-ci.org/immerjs/immer.svg?branch=main)](https://travis-ci.org/immerjs/immer) [![Coverage Status](https://coveralls.io/repos/github/mweststrate/immer/badge.svg?branch=main)](https://coveralls.io/github/mweststrate/immer?branch=main) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier) [![OpenCollective](https://opencollective.com/immer/backers/badge.svg)](#backers) [![OpenCollective](https://opencollective.com/immer/sponsors/badge.svg)](#sponsors) [![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/immerjs/immer) + +_Create the next immutable state tree by simply modifying the current tree_ + +Winner of the "Breakthrough of the year" [React open source award](https://osawards.com/react/) and "Most impactful contribution" [JavaScript open source award](https://osawards.com/javascript/) in 2019 + +## Contribute using one-click online setup + +You can use Gitpod (a free online VS Code like IDE) for contributing online. With a single click it will launch a workspace and automatically: + +- clone the immer repo. +- install the dependencies. +- run `yarn run start`. + +so that you can start coding straight away. + +[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/from-referrer/) + +## Documentation + +The documentation of this package is hosted at https://immerjs.github.io/immer/ + +## Support + +Did Immer make a difference to your project? Join the open collective at https://opencollective.com/immer! + +## Release notes + +https://github.com/immerjs/immer/releases Index: frontend/node_modules/immer/src/core/current.ts =================================================================== --- frontend/node_modules/immer/src/core/current.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/core/current.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,60 @@ +import { + die, + isDraft, + shallowCopy, + each, + DRAFT_STATE, + get, + set, + ImmerState, + isDraftable, + Archtype, + getArchtype, + getPlugin +} from "../internal" + +/** 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. */ +export function current(value: T): T +export function current(value: any): any { + if (!isDraft(value)) die(22, value) + return currentImpl(value) +} + +function currentImpl(value: any): any { + if (!isDraftable(value)) return value + const state: ImmerState | undefined = value[DRAFT_STATE] + let copy: any + const archType = getArchtype(value) + if (state) { + if ( + !state.modified_ && + (state.type_ < 4 || !getPlugin("ES5").hasChanges_(state as any)) + ) + return state.base_ + // Optimization: avoid generating new drafts during copying + state.finalized_ = true + copy = copyHelper(value, archType) + state.finalized_ = false + } else { + copy = copyHelper(value, archType) + } + + each(copy, (key, childValue) => { + if (state && get(state.base_, key) === childValue) return // no need to copy or search in something that didn't change + set(copy, key, currentImpl(childValue)) + }) + // In the future, we might consider freezing here, based on the current settings + return archType === Archtype.Set ? new Set(copy) : copy +} + +function copyHelper(value: any, archType: number): any { + // creates a shallow copy, even if it is a map or set + switch (archType) { + case Archtype.Map: + return new Map(value) + case Archtype.Set: + // Set will be cloned as array temporarily, so that we can replace individual items + return Array.from(value) + } + return shallowCopy(value) +} Index: frontend/node_modules/immer/src/core/finalize.ts =================================================================== --- frontend/node_modules/immer/src/core/finalize.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/core/finalize.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,168 @@ +import { + ImmerScope, + DRAFT_STATE, + isDraftable, + NOTHING, + PatchPath, + each, + has, + freeze, + ImmerState, + isDraft, + SetState, + set, + ProxyType, + getPlugin, + die, + revokeScope, + isFrozen, + shallowCopy +} from "../internal" + +export function processResult(result: any, scope: ImmerScope) { + scope.unfinalizedDrafts_ = scope.drafts_.length + const baseDraft = scope.drafts_![0] + const isReplaced = result !== undefined && result !== baseDraft + if (!scope.immer_.useProxies_) + getPlugin("ES5").willFinalizeES5_(scope, result, isReplaced) + if (isReplaced) { + if (baseDraft[DRAFT_STATE].modified_) { + revokeScope(scope) + die(4) + } + if (isDraftable(result)) { + // Finalize the result in case it contains (or is) a subset of the draft. + result = finalize(scope, result) + if (!scope.parent_) maybeFreeze(scope, result) + } + if (scope.patches_) { + getPlugin("Patches").generateReplacementPatches_( + baseDraft[DRAFT_STATE].base_, + result, + scope.patches_, + scope.inversePatches_! + ) + } + } else { + // Finalize the base draft. + result = finalize(scope, baseDraft, []) + } + revokeScope(scope) + if (scope.patches_) { + scope.patchListener_!(scope.patches_, scope.inversePatches_!) + } + return result !== NOTHING ? result : undefined +} + +function finalize(rootScope: ImmerScope, value: any, path?: PatchPath) { + // Don't recurse in tho recursive data structures + if (isFrozen(value)) return value + + const state: ImmerState = value[DRAFT_STATE] + // A plain object, might need freezing, might contain drafts + if (!state) { + each( + value, + (key, childValue) => + finalizeProperty(rootScope, state, value, key, childValue, path), + true // See #590, don't recurse into non-enumerable of non drafted objects + ) + return value + } + // Never finalize drafts owned by another scope. + if (state.scope_ !== rootScope) return value + // Unmodified draft, return the (frozen) original + if (!state.modified_) { + maybeFreeze(rootScope, state.base_, true) + return state.base_ + } + // Not finalized yet, let's do that now + if (!state.finalized_) { + state.finalized_ = true + state.scope_.unfinalizedDrafts_-- + const result = + // For ES5, create a good copy from the draft first, with added keys and without deleted keys. + state.type_ === ProxyType.ES5Object || state.type_ === ProxyType.ES5Array + ? (state.copy_ = shallowCopy(state.draft_)) + : state.copy_ + // Finalize all children of the copy + // For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628 + // To preserve insertion order in all cases we then clear the set + // And we let finalizeProperty know it needs to re-add non-draft children back to the target + let resultEach = result + let isSet = false + if (state.type_ === ProxyType.Set) { + resultEach = new Set(result) + result.clear() + isSet = true + } + each(resultEach, (key, childValue) => + finalizeProperty(rootScope, state, result, key, childValue, path, isSet) + ) + // everything inside is frozen, we can freeze here + maybeFreeze(rootScope, result, false) + // first time finalizing, let's create those patches + if (path && rootScope.patches_) { + getPlugin("Patches").generatePatches_( + state, + path, + rootScope.patches_, + rootScope.inversePatches_! + ) + } + } + return state.copy_ +} + +function finalizeProperty( + rootScope: ImmerScope, + parentState: undefined | ImmerState, + targetObject: any, + prop: string | number, + childValue: any, + rootPath?: PatchPath, + targetIsSet?: boolean +) { + if (__DEV__ && childValue === targetObject) die(5) + if (isDraft(childValue)) { + const path = + rootPath && + parentState && + parentState!.type_ !== ProxyType.Set && // Set objects are atomic since they have no keys. + !has((parentState as Exclude).assigned_!, prop) // Skip deep patches for assigned keys. + ? rootPath!.concat(prop) + : undefined + // Drafts owned by `scope` are finalized here. + const res = finalize(rootScope, childValue, path) + set(targetObject, prop, res) + // Drafts from another scope must prevented to be frozen + // if we got a draft back from finalize, we're in a nested produce and shouldn't freeze + if (isDraft(res)) { + rootScope.canAutoFreeze_ = false + } else return + } else if (targetIsSet) { + targetObject.add(childValue) + } + // Search new objects for unfinalized drafts. Frozen objects should never contain drafts. + if (isDraftable(childValue) && !isFrozen(childValue)) { + if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) { + // optimization: if an object is not a draft, and we don't have to + // deepfreeze everything, and we are sure that no drafts are left in the remaining object + // cause we saw and finalized all drafts already; we can stop visiting the rest of the tree. + // This benefits especially adding large data tree's without further processing. + // See add-data.js perf test + return + } + finalize(rootScope, childValue) + // immer deep freezes plain objects, so if there is no parent state, we freeze as well + if (!parentState || !parentState.scope_.parent_) + maybeFreeze(rootScope, childValue) + } +} + +function maybeFreeze(scope: ImmerScope, value: any, deep = false) { + // we never freeze for a non-root scope; as it would prevent pruning for drafts inside wrapping objects + if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) { + freeze(value, deep) + } +} Index: frontend/node_modules/immer/src/core/immerClass.ts =================================================================== --- frontend/node_modules/immer/src/core/immerClass.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/core/immerClass.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,241 @@ +import { + IProduceWithPatches, + IProduce, + ImmerState, + Drafted, + isDraftable, + processResult, + Patch, + Objectish, + DRAFT_STATE, + Draft, + PatchListener, + isDraft, + isMap, + isSet, + createProxyProxy, + getPlugin, + die, + hasProxies, + enterScope, + revokeScope, + leaveScope, + usePatchesInScope, + getCurrentScope, + NOTHING, + freeze, + current +} from "../internal" + +interface ProducersFns { + produce: IProduce + produceWithPatches: IProduceWithPatches +} + +export class Immer implements ProducersFns { + useProxies_: boolean = hasProxies + + autoFreeze_: boolean = true + + constructor(config?: {useProxies?: boolean; autoFreeze?: boolean}) { + if (typeof config?.useProxies === "boolean") + this.setUseProxies(config!.useProxies) + if (typeof config?.autoFreeze === "boolean") + this.setAutoFreeze(config!.autoFreeze) + } + + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + produce: IProduce = (base: any, recipe?: any, patchListener?: any) => { + // curried invocation + if (typeof base === "function" && typeof recipe !== "function") { + const defaultBase = recipe + recipe = base + + const self = this + return function curriedProduce( + this: any, + base = defaultBase, + ...args: any[] + ) { + return self.produce(base, (draft: Drafted) => recipe.call(this, draft, ...args)) // prettier-ignore + } + } + + if (typeof recipe !== "function") die(6) + if (patchListener !== undefined && typeof patchListener !== "function") + die(7) + + let result + + // Only plain objects, arrays, and "immerable classes" are drafted. + if (isDraftable(base)) { + const scope = enterScope(this) + const proxy = createProxy(this, base, undefined) + let hasError = true + try { + result = recipe(proxy) + hasError = false + } finally { + // finally instead of catch + rethrow better preserves original stack + if (hasError) revokeScope(scope) + else leaveScope(scope) + } + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then( + result => { + usePatchesInScope(scope, patchListener) + return processResult(result, scope) + }, + error => { + revokeScope(scope) + throw error + } + ) + } + usePatchesInScope(scope, patchListener) + return processResult(result, scope) + } else if (!base || typeof base !== "object") { + result = recipe(base) + if (result === undefined) result = base + if (result === NOTHING) result = undefined + if (this.autoFreeze_) freeze(result, true) + if (patchListener) { + const p: Patch[] = [] + const ip: Patch[] = [] + getPlugin("Patches").generateReplacementPatches_(base, result, p, ip) + patchListener(p, ip) + } + return result + } else die(21, base) + } + + produceWithPatches: IProduceWithPatches = (base: any, recipe?: any): any => { + // curried invocation + if (typeof base === "function") { + return (state: any, ...args: any[]) => + this.produceWithPatches(state, (draft: any) => base(draft, ...args)) + } + + let patches: Patch[], inversePatches: Patch[] + const result = this.produce(base, recipe, (p: Patch[], ip: Patch[]) => { + patches = p + inversePatches = ip + }) + + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(nextState => [nextState, patches!, inversePatches!]) + } + return [result, patches!, inversePatches!] + } + + createDraft(base: T): Draft { + if (!isDraftable(base)) die(8) + if (isDraft(base)) base = current(base) + const scope = enterScope(this) + const proxy = createProxy(this, base, undefined) + proxy[DRAFT_STATE].isManual_ = true + leaveScope(scope) + return proxy as any + } + + finishDraft>( + draft: D, + patchListener?: PatchListener + ): D extends Draft ? T : never { + const state: ImmerState = draft && (draft as any)[DRAFT_STATE] + if (__DEV__) { + if (!state || !state.isManual_) die(9) + if (state.finalized_) die(10) + } + const {scope_: scope} = state + usePatchesInScope(scope, patchListener) + return processResult(undefined, scope) + } + + /** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is enabled. + */ + setAutoFreeze(value: boolean) { + this.autoFreeze_ = value + } + + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + setUseProxies(value: boolean) { + if (value && !hasProxies) { + die(20) + } + this.useProxies_ = value + } + + applyPatches(base: T, patches: Patch[]): T { + // If a patch replaces the entire state, take that replacement as base + // before applying patches + let i: number + for (i = patches.length - 1; i >= 0; i--) { + const patch = patches[i] + if (patch.path.length === 0 && patch.op === "replace") { + base = patch.value + break + } + } + // If there was a patch that replaced the entire state, start from the + // patch after that. + if (i > -1) { + patches = patches.slice(i + 1) + } + + const applyPatchesImpl = getPlugin("Patches").applyPatches_ + if (isDraft(base)) { + // N.B: never hits if some patch a replacement, patches are never drafts + return applyPatchesImpl(base, patches) + } + // Otherwise, produce a copy of the base state. + return this.produce(base, (draft: Drafted) => + applyPatchesImpl(draft, patches) + ) + } +} + +export function createProxy( + immer: Immer, + value: T, + parent?: ImmerState +): Drafted { + // precondition: createProxy should be guarded by isDraftable, so we know we can safely draft + const draft: Drafted = isMap(value) + ? getPlugin("MapSet").proxyMap_(value, parent) + : isSet(value) + ? getPlugin("MapSet").proxySet_(value, parent) + : immer.useProxies_ + ? createProxyProxy(value, parent) + : getPlugin("ES5").createES5Proxy_(value, parent) + + const scope = parent ? parent.scope_ : getCurrentScope() + scope.drafts_.push(draft) + return draft +} Index: frontend/node_modules/immer/src/core/proxy.ts =================================================================== --- frontend/node_modules/immer/src/core/proxy.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/core/proxy.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,280 @@ +import { + each, + has, + is, + isDraftable, + shallowCopy, + latest, + ImmerBaseState, + ImmerState, + Drafted, + AnyObject, + AnyArray, + Objectish, + getCurrentScope, + DRAFT_STATE, + die, + createProxy, + ProxyType +} from "../internal" + +interface ProxyBaseState extends ImmerBaseState { + assigned_: { + [property: string]: boolean + } + parent_?: ImmerState + revoke_(): void +} + +export interface ProxyObjectState extends ProxyBaseState { + type_: ProxyType.ProxyObject + base_: any + copy_: any + draft_: Drafted +} + +export interface ProxyArrayState extends ProxyBaseState { + type_: ProxyType.ProxyArray + base_: AnyArray + copy_: AnyArray | null + draft_: Drafted +} + +type ProxyState = ProxyObjectState | ProxyArrayState + +/** + * Returns a new draft of the `base` object. + * + * The second argument is the parent draft-state (used internally). + */ +export function createProxyProxy( + base: T, + parent?: ImmerState +): Drafted { + const isArray = Array.isArray(base) + const state: ProxyState = { + type_: isArray ? ProxyType.ProxyArray : (ProxyType.ProxyObject as any), + // Track which produce call this is associated with. + scope_: parent ? parent.scope_ : getCurrentScope()!, + // True for both shallow and deep changes. + modified_: false, + // Used during finalization. + finalized_: false, + // Track which properties have been assigned (true) or deleted (false). + assigned_: {}, + // The parent draft state. + parent_: parent, + // The base state. + base_: base, + // The base proxy. + draft_: null as any, // set below + // The base copy with any updated values. + copy_: null, + // Called by the `produce` function. + revoke_: null as any, + isManual_: false + } + + // the traps must target something, a bit like the 'real' base. + // but also, we need to be able to determine from the target what the relevant state is + // (to avoid creating traps per instance to capture the state in closure, + // and to avoid creating weird hidden properties as well) + // So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything) + // Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb + let target: T = state as any + let traps: ProxyHandler> = objectTraps + if (isArray) { + target = [state] as any + traps = arrayTraps + } + + const {revoke, proxy} = Proxy.revocable(target, traps) + state.draft_ = proxy as any + state.revoke_ = revoke + return proxy as any +} + +/** + * Object drafts + */ +export const objectTraps: ProxyHandler = { + get(state, prop) { + if (prop === DRAFT_STATE) return state + + const source = latest(state) + if (!has(source, prop)) { + // non-existing or non-own property... + return readPropFromProto(state, source, prop) + } + const value = source[prop] + if (state.finalized_ || !isDraftable(value)) { + return value + } + // Check for existing draft in modified state. + // Assigned values are never drafted. This catches any drafts we created, too. + if (value === peek(state.base_, prop)) { + prepareCopy(state) + return (state.copy_![prop as any] = createProxy( + state.scope_.immer_, + value, + state + )) + } + return value + }, + has(state, prop) { + return prop in latest(state) + }, + ownKeys(state) { + return Reflect.ownKeys(latest(state)) + }, + set( + state: ProxyObjectState, + prop: string /* strictly not, but helps TS */, + value + ) { + const desc = getDescriptorFromProto(latest(state), prop) + if (desc?.set) { + // special case: if this write is captured by a setter, we have + // to trigger it with the correct context + desc.set.call(state.draft_, value) + return true + } + if (!state.modified_) { + // the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change) + // from setting an existing property with value undefined to undefined (which is not a change) + const current = peek(latest(state), prop) + // special case, if we assigning the original value to a draft, we can ignore the assignment + const currentState: ProxyObjectState = current?.[DRAFT_STATE] + if (currentState && currentState.base_ === value) { + state.copy_![prop] = value + state.assigned_[prop] = false + return true + } + if (is(value, current) && (value !== undefined || has(state.base_, prop))) + return true + prepareCopy(state) + markChanged(state) + } + + if ( + (state.copy_![prop] === value && + // special case: handle new props with value 'undefined' + (value !== undefined || prop in state.copy_)) || + // special case: NaN + (Number.isNaN(value) && Number.isNaN(state.copy_![prop])) + ) + return true + + // @ts-ignore + state.copy_![prop] = value + state.assigned_[prop] = true + return true + }, + deleteProperty(state, prop: string) { + // The `undefined` check is a fast path for pre-existing keys. + if (peek(state.base_, prop) !== undefined || prop in state.base_) { + state.assigned_[prop] = false + prepareCopy(state) + markChanged(state) + } else { + // if an originally not assigned property was deleted + delete state.assigned_[prop] + } + // @ts-ignore + if (state.copy_) delete state.copy_[prop] + return true + }, + // Note: We never coerce `desc.value` into an Immer draft, because we can't make + // the same guarantee in ES5 mode. + getOwnPropertyDescriptor(state, prop) { + const owner = latest(state) + const desc = Reflect.getOwnPropertyDescriptor(owner, prop) + if (!desc) return desc + return { + writable: true, + configurable: state.type_ !== ProxyType.ProxyArray || prop !== "length", + enumerable: desc.enumerable, + value: owner[prop] + } + }, + defineProperty() { + die(11) + }, + getPrototypeOf(state) { + return Object.getPrototypeOf(state.base_) + }, + setPrototypeOf() { + die(12) + } +} + +/** + * Array drafts + */ + +const arrayTraps: ProxyHandler<[ProxyArrayState]> = {} +each(objectTraps, (key, fn) => { + // @ts-ignore + arrayTraps[key] = function() { + arguments[0] = arguments[0][0] + return fn.apply(this, arguments) + } +}) +arrayTraps.deleteProperty = function(state, prop) { + if (__DEV__ && isNaN(parseInt(prop as any))) die(13) + // @ts-ignore + return arrayTraps.set!.call(this, state, prop, undefined) +} +arrayTraps.set = function(state, prop, value) { + if (__DEV__ && prop !== "length" && isNaN(parseInt(prop as any))) die(14) + return objectTraps.set!.call(this, state[0], prop, value, state[0]) +} + +// Access a property without creating an Immer draft. +function peek(draft: Drafted, prop: PropertyKey) { + const state = draft[DRAFT_STATE] + const source = state ? latest(state) : draft + return source[prop] +} + +function readPropFromProto(state: ImmerState, source: any, prop: PropertyKey) { + const desc = getDescriptorFromProto(source, prop) + return desc + ? `value` in desc + ? desc.value + : // This is a very special case, if the prop is a getter defined by the + // prototype, we should invoke it with the draft as context! + desc.get?.call(state.draft_) + : undefined +} + +function getDescriptorFromProto( + source: any, + prop: PropertyKey +): PropertyDescriptor | undefined { + // 'in' checks proto! + if (!(prop in source)) return undefined + let proto = Object.getPrototypeOf(source) + while (proto) { + const desc = Object.getOwnPropertyDescriptor(proto, prop) + if (desc) return desc + proto = Object.getPrototypeOf(proto) + } + return undefined +} + +export function markChanged(state: ImmerState) { + if (!state.modified_) { + state.modified_ = true + if (state.parent_) { + markChanged(state.parent_) + } + } +} + +export function prepareCopy(state: {base_: any; copy_: any}) { + if (!state.copy_) { + state.copy_ = shallowCopy(state.base_) + } +} Index: frontend/node_modules/immer/src/core/scope.ts =================================================================== --- frontend/node_modules/immer/src/core/scope.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/core/scope.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,85 @@ +import { + Patch, + PatchListener, + Drafted, + Immer, + DRAFT_STATE, + ImmerState, + ProxyType, + getPlugin +} from "../internal" +import {die} from "../utils/errors" + +/** Each scope represents a `produce` call. */ + +export interface ImmerScope { + patches_?: Patch[] + inversePatches_?: Patch[] + canAutoFreeze_: boolean + drafts_: any[] + parent_?: ImmerScope + patchListener_?: PatchListener + immer_: Immer + unfinalizedDrafts_: number +} + +let currentScope: ImmerScope | undefined + +export function getCurrentScope() { + if (__DEV__ && !currentScope) die(0) + return currentScope! +} + +function createScope( + parent_: ImmerScope | undefined, + immer_: Immer +): ImmerScope { + return { + drafts_: [], + parent_, + immer_, + // Whenever the modified draft contains a draft from another scope, we + // need to prevent auto-freezing so the unowned draft can be finalized. + canAutoFreeze_: true, + unfinalizedDrafts_: 0 + } +} + +export function usePatchesInScope( + scope: ImmerScope, + patchListener?: PatchListener +) { + if (patchListener) { + getPlugin("Patches") // assert we have the plugin + scope.patches_ = [] + scope.inversePatches_ = [] + scope.patchListener_ = patchListener + } +} + +export function revokeScope(scope: ImmerScope) { + leaveScope(scope) + scope.drafts_.forEach(revokeDraft) + // @ts-ignore + scope.drafts_ = null +} + +export function leaveScope(scope: ImmerScope) { + if (scope === currentScope) { + currentScope = scope.parent_ + } +} + +export function enterScope(immer: Immer) { + return (currentScope = createScope(currentScope, immer)) +} + +function revokeDraft(draft: Drafted) { + const state: ImmerState = draft[DRAFT_STATE] + if ( + state.type_ === ProxyType.ProxyObject || + state.type_ === ProxyType.ProxyArray + ) + state.revoke_() + else state.revoked_ = true +} Index: frontend/node_modules/immer/src/immer.ts =================================================================== --- frontend/node_modules/immer/src/immer.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/immer.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,117 @@ +import { + IProduce, + IProduceWithPatches, + Immer, + Draft, + Immutable +} from "./internal" + +export { + Draft, + Immutable, + Patch, + PatchListener, + original, + current, + isDraft, + isDraftable, + NOTHING as nothing, + DRAFTABLE as immerable, + freeze +} from "./internal" + +const immer = new Immer() + +/** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ +export const produce: IProduce = immer.produce +export default produce + +/** + * Like `produce`, but `produceWithPatches` always returns a tuple + * [nextState, patches, inversePatches] (instead of just the next state) + */ +export const produceWithPatches: IProduceWithPatches = immer.produceWithPatches.bind( + immer +) + +/** + * Pass true to automatically freeze all copies created by Immer. + * + * Always freeze by default, even in production mode + */ +export const setAutoFreeze = immer.setAutoFreeze.bind(immer) + +/** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ +export const setUseProxies = immer.setUseProxies.bind(immer) + +/** + * Apply an array of Immer patches to the first argument. + * + * This function is a producer, which means copy-on-write is in effect. + */ +export const applyPatches = immer.applyPatches.bind(immer) + +/** + * Create an Immer draft from the given base state, which may be a draft itself. + * The draft can be modified until you finalize it with the `finishDraft` function. + */ +export const createDraft = immer.createDraft.bind(immer) + +/** + * Finalize an Immer draft from a `createDraft` call, returning the base state + * (if no changes were made) or a modified copy. The draft must *not* be + * mutated afterwards. + * + * Pass a function as the 2nd argument to generate Immer patches based on the + * changes that were made. + */ +export const finishDraft = immer.finishDraft.bind(immer) + +/** + * This function is actually a no-op, but can be used to cast an immutable type + * to an draft type and make TypeScript happy + * + * @param value + */ +export function castDraft(value: T): Draft { + return value as any +} + +/** + * This function is actually a no-op, but can be used to cast a mutable type + * to an immutable type and make TypeScript happy + * @param value + */ +export function castImmutable(value: T): Immutable { + return value as any +} + +export {Immer} + +export {enableES5} from "./plugins/es5" +export {enablePatches} from "./plugins/patches" +export {enableMapSet} from "./plugins/mapset" +export {enableAllPlugins} from "./plugins/all" Index: frontend/node_modules/immer/src/internal.ts =================================================================== --- frontend/node_modules/immer/src/internal.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/internal.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,11 @@ +export * from "./utils/env" +export * from "./utils/errors" +export * from "./types/types-external" +export * from "./types/types-internal" +export * from "./utils/common" +export * from "./utils/plugins" +export * from "./core/scope" +export * from "./core/finalize" +export * from "./core/proxy" +export * from "./core/immerClass" +export * from "./core/current" Index: frontend/node_modules/immer/src/plugins/all.ts =================================================================== --- frontend/node_modules/immer/src/plugins/all.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/plugins/all.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,9 @@ +import {enableES5} from "./es5" +import {enableMapSet} from "./mapset" +import {enablePatches} from "./patches" + +export function enableAllPlugins() { + enableES5() + enableMapSet() + enablePatches() +} Index: frontend/node_modules/immer/src/plugins/es5.ts =================================================================== --- frontend/node_modules/immer/src/plugins/es5.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/plugins/es5.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,277 @@ +import { + ImmerState, + Drafted, + ES5ArrayState, + ES5ObjectState, + each, + has, + isDraft, + latest, + DRAFT_STATE, + is, + loadPlugin, + ImmerScope, + ProxyType, + getCurrentScope, + die, + markChanged, + objectTraps, + ownKeys, + getOwnPropertyDescriptors +} from "../internal" + +type ES5State = ES5ArrayState | ES5ObjectState + +export function enableES5() { + function willFinalizeES5_( + scope: ImmerScope, + result: any, + isReplaced: boolean + ) { + if (!isReplaced) { + if (scope.patches_) { + markChangesRecursively(scope.drafts_![0]) + } + // This is faster when we don't care about which attributes changed. + markChangesSweep(scope.drafts_) + } + // When a child draft is returned, look for changes. + else if ( + isDraft(result) && + (result[DRAFT_STATE] as ES5State).scope_ === scope + ) { + markChangesSweep(scope.drafts_) + } + } + + function createES5Draft(isArray: boolean, base: any) { + if (isArray) { + const draft = new Array(base.length) + for (let i = 0; i < base.length; i++) + Object.defineProperty(draft, "" + i, proxyProperty(i, true)) + return draft + } else { + const descriptors = getOwnPropertyDescriptors(base) + delete descriptors[DRAFT_STATE as any] + const keys = ownKeys(descriptors) + for (let i = 0; i < keys.length; i++) { + const key: any = keys[i] + descriptors[key] = proxyProperty( + key, + isArray || !!descriptors[key].enumerable + ) + } + return Object.create(Object.getPrototypeOf(base), descriptors) + } + } + + function createES5Proxy_( + base: T, + parent?: ImmerState + ): Drafted { + const isArray = Array.isArray(base) + const draft = createES5Draft(isArray, base) + + const state: ES5ObjectState | ES5ArrayState = { + type_: isArray ? ProxyType.ES5Array : (ProxyType.ES5Object as any), + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + assigned_: {}, + parent_: parent, + // base is the object we are drafting + base_: base, + // draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified) + draft_: draft, + copy_: null, + revoked_: false, + isManual_: false + } + + Object.defineProperty(draft, DRAFT_STATE, { + value: state, + // enumerable: false <- the default + writable: true + }) + return draft + } + + // property descriptors are recycled to make sure we don't create a get and set closure per property, + // but share them all instead + const descriptors: {[prop: string]: PropertyDescriptor} = {} + + function proxyProperty( + prop: string | number, + enumerable: boolean + ): PropertyDescriptor { + let desc = descriptors[prop] + if (desc) { + desc.enumerable = enumerable + } else { + descriptors[prop] = desc = { + configurable: true, + enumerable, + get(this: any) { + const state = this[DRAFT_STATE] + if (__DEV__) assertUnrevoked(state) + // @ts-ignore + return objectTraps.get(state, prop) + }, + set(this: any, value) { + const state = this[DRAFT_STATE] + if (__DEV__) assertUnrevoked(state) + // @ts-ignore + objectTraps.set(state, prop, value) + } + } + } + return desc + } + + // This looks expensive, but only proxies are visited, and only objects without known changes are scanned. + function markChangesSweep(drafts: Drafted[]) { + // The natural order of drafts in the `scope` array is based on when they + // were accessed. By processing drafts in reverse natural order, we have a + // better chance of processing leaf nodes first. When a leaf node is known to + // have changed, we can avoid any traversal of its ancestor nodes. + for (let i = drafts.length - 1; i >= 0; i--) { + const state: ES5State = drafts[i][DRAFT_STATE] + if (!state.modified_) { + switch (state.type_) { + case ProxyType.ES5Array: + if (hasArrayChanges(state)) markChanged(state) + break + case ProxyType.ES5Object: + if (hasObjectChanges(state)) markChanged(state) + break + } + } + } + } + + function markChangesRecursively(object: any) { + if (!object || typeof object !== "object") return + const state: ES5State | undefined = object[DRAFT_STATE] + if (!state) return + const {base_, draft_, assigned_, type_} = state + if (type_ === ProxyType.ES5Object) { + // Look for added keys. + // probably there is a faster way to detect changes, as sweep + recurse seems to do some + // unnecessary work. + // also: probably we can store the information we detect here, to speed up tree finalization! + each(draft_, key => { + if ((key as any) === DRAFT_STATE) return + // The `undefined` check is a fast path for pre-existing keys. + if ((base_ as any)[key] === undefined && !has(base_, key)) { + assigned_[key] = true + markChanged(state) + } else if (!assigned_[key]) { + // Only untouched properties trigger recursion. + markChangesRecursively(draft_[key]) + } + }) + // Look for removed keys. + each(base_, key => { + // The `undefined` check is a fast path for pre-existing keys. + if (draft_[key] === undefined && !has(draft_, key)) { + assigned_[key] = false + markChanged(state) + } + }) + } else if (type_ === ProxyType.ES5Array) { + if (hasArrayChanges(state as ES5ArrayState)) { + markChanged(state) + assigned_.length = true + } + + if (draft_.length < base_.length) { + for (let i = draft_.length; i < base_.length; i++) assigned_[i] = false + } else { + for (let i = base_.length; i < draft_.length; i++) assigned_[i] = true + } + + // Minimum count is enough, the other parts has been processed. + const min = Math.min(draft_.length, base_.length) + + for (let i = 0; i < min; i++) { + // Only untouched indices trigger recursion. + if (!draft_.hasOwnProperty(i)) { + assigned_[i] = true + } + if (assigned_[i] === undefined) markChangesRecursively(draft_[i]) + } + } + } + + function hasObjectChanges(state: ES5ObjectState) { + const {base_, draft_} = state + + // Search for added keys and changed keys. Start at the back, because + // non-numeric keys are ordered by time of definition on the object. + const keys = ownKeys(draft_) + for (let i = keys.length - 1; i >= 0; i--) { + const key: any = keys[i] + if (key === DRAFT_STATE) continue + const baseValue = base_[key] + // The `undefined` check is a fast path for pre-existing keys. + if (baseValue === undefined && !has(base_, key)) { + return true + } + // Once a base key is deleted, future changes go undetected, because its + // descriptor is erased. This branch detects any missed changes. + else { + const value = draft_[key] + const state: ImmerState = value && value[DRAFT_STATE] + if (state ? state.base_ !== baseValue : !is(value, baseValue)) { + return true + } + } + } + + // At this point, no keys were added or changed. + // Compare key count to determine if keys were deleted. + const baseIsDraft = !!base_[DRAFT_STATE as any] + return keys.length !== ownKeys(base_).length + (baseIsDraft ? 0 : 1) // + 1 to correct for DRAFT_STATE + } + + function hasArrayChanges(state: ES5ArrayState) { + const {draft_} = state + if (draft_.length !== state.base_.length) return true + // See #116 + // If we first shorten the length, our array interceptors will be removed. + // If after that new items are added, result in the same original length, + // those last items will have no intercepting property. + // So if there is no own descriptor on the last position, we know that items were removed and added + // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check + // the last one + // last descriptor can be not a trap, if the array was extended + const descriptor = Object.getOwnPropertyDescriptor( + draft_, + draft_.length - 1 + ) + // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10) + if (descriptor && !descriptor.get) return true + // if we miss a property, it has been deleted, so array probobaly changed + for (let i = 0; i < draft_.length; i++) { + if (!draft_.hasOwnProperty(i)) return true + } + // For all other cases, we don't have to compare, as they would have been picked up by the index setters + return false + } + + function hasChanges_(state: ES5State) { + return state.type_ === ProxyType.ES5Object + ? hasObjectChanges(state) + : hasArrayChanges(state) + } + + function assertUnrevoked(state: any /*ES5State | MapState | SetState*/) { + if (state.revoked_) die(3, JSON.stringify(latest(state))) + } + + loadPlugin("ES5", { + createES5Proxy_, + willFinalizeES5_, + hasChanges_ + }) +} Index: frontend/node_modules/immer/src/plugins/mapset.ts =================================================================== --- frontend/node_modules/immer/src/plugins/mapset.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/plugins/mapset.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,348 @@ +// types only! +import { + ImmerState, + AnyMap, + AnySet, + MapState, + SetState, + DRAFT_STATE, + getCurrentScope, + latest, + iteratorSymbol, + isDraftable, + createProxy, + loadPlugin, + markChanged, + ProxyType, + die, + each +} from "../internal" + +export function enableMapSet() { + /* istanbul ignore next */ + var extendStatics = function(d: any, b: any): any { + extendStatics = + Object.setPrototypeOf || + ({__proto__: []} instanceof Array && + function(d, b) { + d.__proto__ = b + }) || + function(d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p] + } + return extendStatics(d, b) + } + + // Ugly hack to resolve #502 and inherit built in Map / Set + function __extends(d: any, b: any): any { + extendStatics(d, b) + function __(this: any): any { + this.constructor = d + } + d.prototype = + // @ts-ignore + ((__.prototype = b.prototype), new __()) + } + + const DraftMap = (function(_super) { + __extends(DraftMap, _super) + // Create class manually, cause #502 + function DraftMap(this: any, target: AnyMap, parent?: ImmerState): any { + this[DRAFT_STATE] = { + type_: ProxyType.Map, + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope()!, + modified_: false, + finalized_: false, + copy_: undefined, + assigned_: undefined, + base_: target, + draft_: this as any, + isManual_: false, + revoked_: false + } as MapState + return this + } + const p = DraftMap.prototype + + Object.defineProperty(p, "size", { + get: function() { + return latest(this[DRAFT_STATE]).size + } + // enumerable: false, + // configurable: true + }) + + p.has = function(key: any): boolean { + return latest(this[DRAFT_STATE]).has(key) + } + + p.set = function(key: any, value: any) { + const state: MapState = this[DRAFT_STATE] + assertUnrevoked(state) + if (!latest(state).has(key) || latest(state).get(key) !== value) { + prepareMapCopy(state) + markChanged(state) + state.assigned_!.set(key, true) + state.copy_!.set(key, value) + state.assigned_!.set(key, true) + } + return this + } + + p.delete = function(key: any): boolean { + if (!this.has(key)) { + return false + } + + const state: MapState = this[DRAFT_STATE] + assertUnrevoked(state) + prepareMapCopy(state) + markChanged(state) + if (state.base_.has(key)) { + state.assigned_!.set(key, false) + } else { + state.assigned_!.delete(key) + } + state.copy_!.delete(key) + return true + } + + p.clear = function() { + const state: MapState = this[DRAFT_STATE] + assertUnrevoked(state) + if (latest(state).size) { + prepareMapCopy(state) + markChanged(state) + state.assigned_ = new Map() + each(state.base_, key => { + state.assigned_!.set(key, false) + }) + state.copy_!.clear() + } + } + + p.forEach = function( + cb: (value: any, key: any, self: any) => void, + thisArg?: any + ) { + const state: MapState = this[DRAFT_STATE] + latest(state).forEach((_value: any, key: any, _map: any) => { + cb.call(thisArg, this.get(key), key, this) + }) + } + + p.get = function(key: any): any { + const state: MapState = this[DRAFT_STATE] + assertUnrevoked(state) + const value = latest(state).get(key) + if (state.finalized_ || !isDraftable(value)) { + return value + } + if (value !== state.base_.get(key)) { + return value // either already drafted or reassigned + } + // despite what it looks, this creates a draft only once, see above condition + const draft = createProxy(state.scope_.immer_, value, state) + prepareMapCopy(state) + state.copy_!.set(key, draft) + return draft + } + + p.keys = function(): IterableIterator { + return latest(this[DRAFT_STATE]).keys() + } + + p.values = function(): IterableIterator { + const iterator = this.keys() + return { + [iteratorSymbol]: () => this.values(), + next: () => { + const r = iterator.next() + /* istanbul ignore next */ + if (r.done) return r + const value = this.get(r.value) + return { + done: false, + value + } + } + } as any + } + + p.entries = function(): IterableIterator<[any, any]> { + const iterator = this.keys() + return { + [iteratorSymbol]: () => this.entries(), + next: () => { + const r = iterator.next() + /* istanbul ignore next */ + if (r.done) return r + const value = this.get(r.value) + return { + done: false, + value: [r.value, value] + } + } + } as any + } + + p[iteratorSymbol] = function() { + return this.entries() + } + + return DraftMap + })(Map) + + function proxyMap_(target: T, parent?: ImmerState): T { + // @ts-ignore + return new DraftMap(target, parent) + } + + function prepareMapCopy(state: MapState) { + if (!state.copy_) { + state.assigned_ = new Map() + state.copy_ = new Map(state.base_) + } + } + + const DraftSet = (function(_super) { + __extends(DraftSet, _super) + // Create class manually, cause #502 + function DraftSet(this: any, target: AnySet, parent?: ImmerState) { + this[DRAFT_STATE] = { + type_: ProxyType.Set, + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope()!, + modified_: false, + finalized_: false, + copy_: undefined, + base_: target, + draft_: this, + drafts_: new Map(), + revoked_: false, + isManual_: false + } as SetState + return this + } + const p = DraftSet.prototype + + Object.defineProperty(p, "size", { + get: function() { + return latest(this[DRAFT_STATE]).size + } + // enumerable: true, + }) + + p.has = function(value: any): boolean { + const state: SetState = this[DRAFT_STATE] + assertUnrevoked(state) + // bit of trickery here, to be able to recognize both the value, and the draft of its value + if (!state.copy_) { + return state.base_.has(value) + } + if (state.copy_.has(value)) return true + if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) + return true + return false + } + + p.add = function(value: any): any { + const state: SetState = this[DRAFT_STATE] + assertUnrevoked(state) + if (!this.has(value)) { + prepareSetCopy(state) + markChanged(state) + state.copy_!.add(value) + } + return this + } + + p.delete = function(value: any): any { + if (!this.has(value)) { + return false + } + + const state: SetState = this[DRAFT_STATE] + assertUnrevoked(state) + prepareSetCopy(state) + markChanged(state) + return ( + state.copy_!.delete(value) || + (state.drafts_.has(value) + ? state.copy_!.delete(state.drafts_.get(value)) + : /* istanbul ignore next */ false) + ) + } + + p.clear = function() { + const state: SetState = this[DRAFT_STATE] + assertUnrevoked(state) + if (latest(state).size) { + prepareSetCopy(state) + markChanged(state) + state.copy_!.clear() + } + } + + p.values = function(): IterableIterator { + const state: SetState = this[DRAFT_STATE] + assertUnrevoked(state) + prepareSetCopy(state) + return state.copy_!.values() + } + + p.entries = function entries(): IterableIterator<[any, any]> { + const state: SetState = this[DRAFT_STATE] + assertUnrevoked(state) + prepareSetCopy(state) + return state.copy_!.entries() + } + + p.keys = function(): IterableIterator { + return this.values() + } + + p[iteratorSymbol] = function() { + return this.values() + } + + p.forEach = function forEach(cb: any, thisArg?: any) { + const iterator = this.values() + let result = iterator.next() + while (!result.done) { + cb.call(thisArg, result.value, result.value, this) + result = iterator.next() + } + } + + return DraftSet + })(Set) + + function proxySet_(target: T, parent?: ImmerState): T { + // @ts-ignore + return new DraftSet(target, parent) + } + + function prepareSetCopy(state: SetState) { + if (!state.copy_) { + // create drafts for all entries to preserve insertion order + state.copy_ = new Set() + state.base_.forEach(value => { + if (isDraftable(value)) { + const draft = createProxy(state.scope_.immer_, value, state) + state.drafts_.set(value, draft) + state.copy_!.add(draft) + } else { + state.copy_!.add(value) + } + }) + } + } + + function assertUnrevoked(state: any /*ES5State | MapState | SetState*/) { + if (state.revoked_) die(3, JSON.stringify(latest(state))) + } + + loadPlugin("MapSet", {proxyMap_, proxySet_}) +} Index: frontend/node_modules/immer/src/plugins/patches.ts =================================================================== --- frontend/node_modules/immer/src/plugins/patches.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/plugins/patches.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,305 @@ +import {immerable} from "../immer" +import { + ImmerState, + Patch, + SetState, + ES5ArrayState, + ProxyArrayState, + MapState, + ES5ObjectState, + ProxyObjectState, + PatchPath, + get, + each, + has, + getArchtype, + isSet, + isMap, + loadPlugin, + ProxyType, + Archtype, + die, + isDraft, + isDraftable, + NOTHING +} from "../internal" + +export function enablePatches() { + const REPLACE = "replace" + const ADD = "add" + const REMOVE = "remove" + + function generatePatches_( + state: ImmerState, + basePath: PatchPath, + patches: Patch[], + inversePatches: Patch[] + ): void { + switch (state.type_) { + case ProxyType.ProxyObject: + case ProxyType.ES5Object: + case ProxyType.Map: + return generatePatchesFromAssigned( + state, + basePath, + patches, + inversePatches + ) + case ProxyType.ES5Array: + case ProxyType.ProxyArray: + return generateArrayPatches(state, basePath, patches, inversePatches) + case ProxyType.Set: + return generateSetPatches( + (state as any) as SetState, + basePath, + patches, + inversePatches + ) + } + } + + function generateArrayPatches( + state: ES5ArrayState | ProxyArrayState, + basePath: PatchPath, + patches: Patch[], + inversePatches: Patch[] + ) { + let {base_, assigned_} = state + let copy_ = state.copy_! + + // Reduce complexity by ensuring `base` is never longer. + if (copy_.length < base_.length) { + // @ts-ignore + ;[base_, copy_] = [copy_, base_] + ;[patches, inversePatches] = [inversePatches, patches] + } + + // Process replaced indices. + for (let i = 0; i < base_.length; i++) { + if (assigned_[i] && copy_[i] !== base_[i]) { + const path = basePath.concat([i]) + patches.push({ + op: REPLACE, + path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[i]) + }) + inversePatches.push({ + op: REPLACE, + path, + value: clonePatchValueIfNeeded(base_[i]) + }) + } + } + + // Process added indices. + for (let i = base_.length; i < copy_.length; i++) { + const path = basePath.concat([i]) + patches.push({ + op: ADD, + path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[i]) + }) + } + if (base_.length < copy_.length) { + inversePatches.push({ + op: REPLACE, + path: basePath.concat(["length"]), + value: base_.length + }) + } + } + + // This is used for both Map objects and normal objects. + function generatePatchesFromAssigned( + state: MapState | ES5ObjectState | ProxyObjectState, + basePath: PatchPath, + patches: Patch[], + inversePatches: Patch[] + ) { + const {base_, copy_} = state + each(state.assigned_!, (key, assignedValue) => { + const origValue = get(base_, key) + const value = get(copy_!, key) + const op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD + if (origValue === value && op === REPLACE) return + const path = basePath.concat(key as any) + patches.push(op === REMOVE ? {op, path} : {op, path, value}) + inversePatches.push( + op === ADD + ? {op: REMOVE, path} + : op === REMOVE + ? {op: ADD, path, value: clonePatchValueIfNeeded(origValue)} + : {op: REPLACE, path, value: clonePatchValueIfNeeded(origValue)} + ) + }) + } + + function generateSetPatches( + state: SetState, + basePath: PatchPath, + patches: Patch[], + inversePatches: Patch[] + ) { + let {base_, copy_} = state + + let i = 0 + base_.forEach((value: any) => { + if (!copy_!.has(value)) { + const path = basePath.concat([i]) + patches.push({ + op: REMOVE, + path, + value + }) + inversePatches.unshift({ + op: ADD, + path, + value + }) + } + i++ + }) + i = 0 + copy_!.forEach((value: any) => { + if (!base_.has(value)) { + const path = basePath.concat([i]) + patches.push({ + op: ADD, + path, + value + }) + inversePatches.unshift({ + op: REMOVE, + path, + value + }) + } + i++ + }) + } + + function generateReplacementPatches_( + baseValue: any, + replacement: any, + patches: Patch[], + inversePatches: Patch[] + ): void { + patches.push({ + op: REPLACE, + path: [], + value: replacement === NOTHING ? undefined : replacement + }) + inversePatches.push({ + op: REPLACE, + path: [], + value: baseValue + }) + } + + function applyPatches_(draft: T, patches: Patch[]): T { + patches.forEach(patch => { + const {path, op} = patch + + let base: any = draft + for (let i = 0; i < path.length - 1; i++) { + const parentType = getArchtype(base) + let p = path[i] + if (typeof p !== "string" && typeof p !== "number") { + p = "" + p + } + + // See #738, avoid prototype pollution + if ( + (parentType === Archtype.Object || parentType === Archtype.Array) && + (p === "__proto__" || p === "constructor") + ) + die(24) + if (typeof base === "function" && p === "prototype") die(24) + base = get(base, p) + if (typeof base !== "object") die(15, path.join("/")) + } + + const type = getArchtype(base) + const value = deepClonePatchValue(patch.value) // used to clone patch to ensure original patch is not modified, see #411 + const key = path[path.length - 1] + switch (op) { + case REPLACE: + switch (type) { + case Archtype.Map: + return base.set(key, value) + /* istanbul ignore next */ + case Archtype.Set: + die(16) + default: + // if value is an object, then it's assigned by reference + // in the following add or remove ops, the value field inside the patch will also be modifyed + // so we use value from the cloned patch + // @ts-ignore + return (base[key] = value) + } + case ADD: + switch (type) { + case Archtype.Array: + return key === "-" + ? base.push(value) + : base.splice(key as any, 0, value) + case Archtype.Map: + return base.set(key, value) + case Archtype.Set: + return base.add(value) + default: + return (base[key] = value) + } + case REMOVE: + switch (type) { + case Archtype.Array: + return base.splice(key as any, 1) + case Archtype.Map: + return base.delete(key) + case Archtype.Set: + return base.delete(patch.value) + default: + return delete base[key] + } + default: + die(17, op) + } + }) + + return draft + } + + // optimize: this is quite a performance hit, can we detect intelligently when it is needed? + // E.g. auto-draft when new objects from outside are assigned and modified? + // (See failing test when deepClone just returns obj) + function deepClonePatchValue(obj: T): T + function deepClonePatchValue(obj: any) { + if (!isDraftable(obj)) return obj + if (Array.isArray(obj)) return obj.map(deepClonePatchValue) + if (isMap(obj)) + return new Map( + Array.from(obj.entries()).map(([k, v]) => [k, deepClonePatchValue(v)]) + ) + if (isSet(obj)) return new Set(Array.from(obj).map(deepClonePatchValue)) + const cloned = Object.create(Object.getPrototypeOf(obj)) + for (const key in obj) cloned[key] = deepClonePatchValue(obj[key]) + if (has(obj, immerable)) cloned[immerable] = obj[immerable] + return cloned + } + + function clonePatchValueIfNeeded(obj: T): T { + if (isDraft(obj)) { + return deepClonePatchValue(obj) + } else return obj + } + + loadPlugin("Patches", { + applyPatches_, + generatePatches_, + generateReplacementPatches_ + }) +} Index: frontend/node_modules/immer/src/types/globals.d.ts =================================================================== --- frontend/node_modules/immer/src/types/globals.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/types/globals.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +declare const __DEV__: boolean Index: frontend/node_modules/immer/src/types/index.js.flow =================================================================== --- frontend/node_modules/immer/src/types/index.js.flow (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/types/index.js.flow (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,113 @@ +// @flow + +export interface Patch { + op: "replace" | "remove" | "add"; + path: (string | number)[]; + value?: any; +} + +export type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void + +type Base = {...} | Array +interface IProduce { + /** + * Immer takes a state, and runs a function against it. + * That function can freely mutate the state, as it will create copies-on-write. + * This means that the original state will stay unchanged, and once the function finishes, the modified state is returned. + * + * If the first argument is a function, this is interpreted as the recipe, and will create a curried function that will execute the recipe + * any time it is called with the current state. + * + * @param currentState - the state to start with + * @param recipe - function that receives a proxy of the current state as first argument and which can be freely modified + * @param initialState - if a curried function is created and this argument was given, it will be used as fallback if the curried function is called with a state of undefined + * @returns The next state: a new state, or the current state if nothing was modified + */ + ( + currentState: S, + recipe: (draftState: S) => S | void, + patchListener?: PatchListener + ): S; + // curried invocations with initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void, + initialState: S + ): (currentState: S | void, a: A, b: B, c: C, ...extraArgs: any[]) => S; + // curried invocations without initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void + ): (currentState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S; +} + +interface IProduceWithPatches { + /** + * Like `produce`, but instead of just returning the new state, + * a tuple is returned with [nextState, patches, inversePatches] + * + * Like produce, this function supports currying + */ + ( + currentState: S, + recipe: (draftState: S) => S | void + ): [S, Patch[], Patch[]]; + // curried invocations with initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void, + initialState: S + ): (currentState: S | void, a: A, b: B, c: C, ...extraArgs: any[]) => [S, Patch[], Patch[]]; + // curried invocations without initial state + ( + recipe: (draftState: S, a: A, b: B, c: C, ...extraArgs: any[]) => S | void + ): (currentState: S, a: A, b: B, c: C, ...extraArgs: any[]) => [S, Patch[], Patch[]]; +} + +declare export var produce: IProduce +declare export default IProduce + +declare export var produceWithPatches: IProduceWithPatches + +declare export var nothing: typeof undefined + +declare export var immerable: Symbol + +/** + * Automatically freezes any state trees generated by immer. + * This protects against accidental modifications of the state tree outside of an immer function. + * This comes with a performance impact, so it is recommended to disable this option in production. + * By default it is turned on during local development, and turned off in production. + */ +declare export function setAutoFreeze(autoFreeze: boolean): void + +/** + * Manually override whether proxies should be used. + * By default done by using feature detection + */ +declare export function setUseProxies(useProxies: boolean): void + +declare export function applyPatches(state: S, patches: Patch[]): S + +declare export function original(value: S): S + +declare export function current(value: S): S + +declare export function isDraft(value: any): boolean + +/** + * Creates a mutable draft from an (immutable) object / array. + * The draft can be modified until `finishDraft` is called + */ +declare export function createDraft(base: T): T + +/** + * Given a draft that was created using `createDraft`, + * finalizes the draft into a new immutable object. + * Optionally a patch-listener can be provided to gather the patches that are needed to construct the object. + */ +declare export function finishDraft(base: T, listener?: PatchListener): T + +declare export function enableES5(): void +declare export function enableMapSet(): void +declare export function enablePatches(): void +declare export function enableAllPlugins(): void + +declare export function freeze(obj: T, freeze?: boolean): T Index: frontend/node_modules/immer/src/types/types-external.ts =================================================================== --- frontend/node_modules/immer/src/types/types-external.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/types/types-external.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,262 @@ +import {Nothing} from "../internal" + +type AnyFunc = (...args: any[]) => any + +type PrimitiveType = number | string | boolean + +/** Object types that should never be mapped */ +type AtomicObject = Function | Promise | Date | RegExp + +/** + * If the lib "ES2015.Collection" is not included in tsconfig.json, + * types like ReadonlyArray, WeakMap etc. fall back to `any` (specified nowhere) + * or `{}` (from the node types), in both cases entering an infinite recursion in + * pattern matching type mappings + * This type can be used to cast these types to `void` in these cases. + */ +export type IfAvailable = + // fallback if any + true | false extends (T extends never + ? true + : false) + ? Fallback // fallback if empty type + : keyof T extends never + ? Fallback // original type + : T + +/** + * These should also never be mapped but must be tested after regular Map and + * Set + */ +type WeakReferences = IfAvailable> | IfAvailable> + +export type WritableDraft = {-readonly [K in keyof T]: Draft} + +/** Convert a readonly type into a mutable type, if possible */ +export type Draft = T extends PrimitiveType + ? T + : T extends AtomicObject + ? T + : T extends IfAvailable> // Map extends ReadonlyMap + ? Map, Draft> + : T extends IfAvailable> // Set extends ReadonlySet + ? Set> + : T extends WeakReferences + ? T + : T extends object + ? WritableDraft + : T + +/** Convert a mutable type into a readonly type */ +export type Immutable = T extends PrimitiveType + ? T + : T extends AtomicObject + ? T + : T extends IfAvailable> // Map extends ReadonlyMap + ? ReadonlyMap, Immutable> + : T extends IfAvailable> // Set extends ReadonlySet + ? ReadonlySet> + : T extends WeakReferences + ? T + : T extends object + ? {readonly [K in keyof T]: Immutable} + : T + +export interface Patch { + op: "replace" | "remove" | "add" + path: (string | number)[] + value?: any +} + +export type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void + +/** Converts `nothing` into `undefined` */ +type FromNothing = T extends Nothing ? undefined : T + +/** The inferred return type of `produce` */ +export type Produced = Return extends void + ? Base + : Return extends Promise + ? Promise> + : FromNothing + +/** + * Utility types + */ +type PatchesTuple = readonly [T, Patch[], Patch[]] + +type ValidRecipeReturnType = + | State + | void + | undefined + | (State extends undefined ? Nothing : never) + +type ValidRecipeReturnTypePossiblyPromise = + | ValidRecipeReturnType + | Promise> + +type PromisifyReturnIfNeeded< + State, + Recipe extends AnyFunc, + UsePatches extends boolean +> = ReturnType extends Promise + ? Promise : State> + : UsePatches extends true + ? PatchesTuple + : State + +/** + * Core Producer inference + */ +type InferRecipeFromCurried = Curried extends ( + base: infer State, + ...rest: infer Args +) => any // extra assertion to make sure this is a proper curried function (state, args) => state + ? ReturnType extends State + ? ( + draft: Draft, + ...rest: Args + ) => ValidRecipeReturnType> + : never + : never + +type InferInitialStateFromCurried = Curried extends ( + base: infer State, + ...rest: any[] +) => any // extra assertion to make sure this is a proper curried function (state, args) => state + ? State + : never + +type InferCurriedFromRecipe< + Recipe, + UsePatches extends boolean +> = Recipe extends (draft: infer DraftState, ...args: infer RestArgs) => any // verify return type + ? ReturnType extends ValidRecipeReturnTypePossiblyPromise + ? ( + base: Immutable, + ...args: RestArgs + ) => PromisifyReturnIfNeeded // N.b. we return mutable draftstate, in case the recipe's first arg isn't read only, and that isn't expected as output either + : never // incorrect return type + : never // not a function + +type InferCurriedFromInitialStateAndRecipe< + State, + Recipe, + UsePatches extends boolean +> = Recipe extends ( + draft: Draft, + ...rest: infer RestArgs +) => ValidRecipeReturnTypePossiblyPromise + ? ( + base?: State | undefined, + ...args: RestArgs + ) => PromisifyReturnIfNeeded + : never // recipe doesn't match initial state + +/** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ +export interface IProduce { + /** Curried producer that infers the recipe from the curried output function (e.g. when passing to setState) */ + ( + recipe: InferRecipeFromCurried, + initialState?: InferInitialStateFromCurried + ): Curried + + /** Curried producer that infers curried from the recipe */ + (recipe: Recipe): InferCurriedFromRecipe< + Recipe, + false + > + + /** Curried producer that infers curried from the State generic, which is explicitly passed in. */ + ( + recipe: ( + state: Draft, + initialState: State + ) => ValidRecipeReturnType + ): (state?: State) => State + ( + recipe: ( + state: Draft, + ...args: Args + ) => ValidRecipeReturnType, + initialState: State + ): (state?: State, ...args: Args) => State + (recipe: (state: Draft) => ValidRecipeReturnType): ( + state: State + ) => State + ( + recipe: (state: Draft, ...args: Args) => ValidRecipeReturnType + ): (state: State, ...args: Args) => State + + /** Curried producer with initial state, infers recipe from initial state */ + ( + recipe: Recipe, + initialState: State + ): InferCurriedFromInitialStateAndRecipe + + /** Normal producer */ + >( // By using a default inferred D, rather than Draft in the recipe, we can override it. + base: Base, + recipe: (draft: D) => ValidRecipeReturnType, + listener?: PatchListener + ): Base + + /** Promisified normal producer */ + >( + base: Base, + recipe: (draft: D) => Promise>, + listener?: PatchListener + ): Promise +} + +/** + * Like `produce`, but instead of just returning the new state, + * a tuple is returned with [nextState, patches, inversePatches] + * + * Like produce, this function supports currying + */ +export interface IProduceWithPatches { + // Types copied from IProduce, wrapped with PatchesTuple + (recipe: Recipe): InferCurriedFromRecipe + ( + recipe: Recipe, + initialState: State + ): InferCurriedFromInitialStateAndRecipe + >( + base: Base, + recipe: (draft: D) => ValidRecipeReturnType, + listener?: PatchListener + ): PatchesTuple + >( + base: Base, + recipe: (draft: D) => Promise>, + listener?: PatchListener + ): Promise> +} + +/** + * The type for `recipe function` + */ +export type Producer = (draft: Draft) => ValidRecipeReturnType> | Promise>> + +// Fixes #507: bili doesn't export the types of this file if there is no actual source in it.. +// hopefully it get's tree-shaken away for everyone :) +export function never_used() {} Index: frontend/node_modules/immer/src/types/types-internal.ts =================================================================== --- frontend/node_modules/immer/src/types/types-internal.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/types/types-internal.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,55 @@ +import { + SetState, + ImmerScope, + ProxyObjectState, + ProxyArrayState, + ES5ObjectState, + ES5ArrayState, + MapState, + DRAFT_STATE +} from "../internal" + +export type Objectish = AnyObject | AnyArray | AnyMap | AnySet +export type ObjectishNoSet = AnyObject | AnyArray | AnyMap + +export type AnyObject = {[key: string]: any} +export type AnyArray = Array +export type AnySet = Set +export type AnyMap = Map + +export const enum Archtype { + Object, + Array, + Map, + Set +} + +export const enum ProxyType { + ProxyObject, + ProxyArray, + Map, + Set, + ES5Object, + ES5Array +} + +export interface ImmerBaseState { + parent_?: ImmerState + scope_: ImmerScope + modified_: boolean + finalized_: boolean + isManual_: boolean +} + +export type ImmerState = + | ProxyObjectState + | ProxyArrayState + | ES5ObjectState + | ES5ArrayState + | MapState + | SetState + +// The _internal_ type used for drafts (not to be confused with Draft, which is public facing) +export type Drafted = { + [DRAFT_STATE]: T +} & Base Index: frontend/node_modules/immer/src/utils/common.ts =================================================================== --- frontend/node_modules/immer/src/utils/common.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/utils/common.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,216 @@ +import { + DRAFT_STATE, + DRAFTABLE, + hasSet, + Objectish, + Drafted, + AnyObject, + AnyMap, + AnySet, + ImmerState, + hasMap, + Archtype, + die +} from "../internal" + +/** Returns true if the given value is an Immer draft */ +/*#__PURE__*/ +export function isDraft(value: any): boolean { + return !!value && !!value[DRAFT_STATE] +} + +/** Returns true if the given value can be drafted by Immer */ +/*#__PURE__*/ +export function isDraftable(value: any): boolean { + if (!value) return false + return ( + isPlainObject(value) || + Array.isArray(value) || + !!value[DRAFTABLE] || + !!value.constructor?.[DRAFTABLE] || + isMap(value) || + isSet(value) + ) +} + +const objectCtorString = Object.prototype.constructor.toString() +/*#__PURE__*/ +export function isPlainObject(value: any): boolean { + if (!value || typeof value !== "object") return false + const proto = Object.getPrototypeOf(value) + if (proto === null) { + return true + } + const Ctor = + Object.hasOwnProperty.call(proto, "constructor") && proto.constructor + + if (Ctor === Object) return true + + return ( + typeof Ctor == "function" && + Function.toString.call(Ctor) === objectCtorString + ) +} + +/** Get the underlying object that is represented by the given draft */ +/*#__PURE__*/ +export function original(value: T): T | undefined +export function original(value: Drafted): any { + if (!isDraft(value)) die(23, value) + return value[DRAFT_STATE].base_ +} + +/*#__PURE__*/ +export const ownKeys: (target: AnyObject) => PropertyKey[] = + typeof Reflect !== "undefined" && Reflect.ownKeys + ? Reflect.ownKeys + : typeof Object.getOwnPropertySymbols !== "undefined" + ? obj => + Object.getOwnPropertyNames(obj).concat( + Object.getOwnPropertySymbols(obj) as any + ) + : /* istanbul ignore next */ Object.getOwnPropertyNames + +export const getOwnPropertyDescriptors = + Object.getOwnPropertyDescriptors || + function getOwnPropertyDescriptors(target: any) { + // Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274 + const res: any = {} + ownKeys(target).forEach(key => { + res[key] = Object.getOwnPropertyDescriptor(target, key) + }) + return res + } + +export function each( + obj: T, + iter: (key: string | number, value: any, source: T) => void, + enumerableOnly?: boolean +): void +export function each(obj: any, iter: any, enumerableOnly = false) { + if (getArchtype(obj) === Archtype.Object) { + ;(enumerableOnly ? Object.keys : ownKeys)(obj).forEach(key => { + if (!enumerableOnly || typeof key !== "symbol") iter(key, obj[key], obj) + }) + } else { + obj.forEach((entry: any, index: any) => iter(index, entry, obj)) + } +} + +/*#__PURE__*/ +export function getArchtype(thing: any): Archtype { + /* istanbul ignore next */ + const state: undefined | ImmerState = thing[DRAFT_STATE] + return state + ? state.type_ > 3 + ? state.type_ - 4 // cause Object and Array map back from 4 and 5 + : (state.type_ as any) // others are the same + : Array.isArray(thing) + ? Archtype.Array + : isMap(thing) + ? Archtype.Map + : isSet(thing) + ? Archtype.Set + : Archtype.Object +} + +/*#__PURE__*/ +export function has(thing: any, prop: PropertyKey): boolean { + return getArchtype(thing) === Archtype.Map + ? thing.has(prop) + : Object.prototype.hasOwnProperty.call(thing, prop) +} + +/*#__PURE__*/ +export function get(thing: AnyMap | AnyObject, prop: PropertyKey): any { + // @ts-ignore + return getArchtype(thing) === Archtype.Map ? thing.get(prop) : thing[prop] +} + +/*#__PURE__*/ +export function set(thing: any, propOrOldValue: PropertyKey, value: any) { + const t = getArchtype(thing) + if (t === Archtype.Map) thing.set(propOrOldValue, value) + else if (t === Archtype.Set) { + thing.add(value) + } else thing[propOrOldValue] = value +} + +/*#__PURE__*/ +export function is(x: any, y: any): boolean { + // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js + if (x === y) { + return x !== 0 || 1 / x === 1 / y + } else { + return x !== x && y !== y + } +} + +/*#__PURE__*/ +export function isMap(target: any): target is AnyMap { + return hasMap && target instanceof Map +} + +/*#__PURE__*/ +export function isSet(target: any): target is AnySet { + return hasSet && target instanceof Set +} +/*#__PURE__*/ +export function latest(state: ImmerState): any { + return state.copy_ || state.base_ +} + +/*#__PURE__*/ +export function shallowCopy(base: any) { + if (Array.isArray(base)) return Array.prototype.slice.call(base) + const descriptors = getOwnPropertyDescriptors(base) + delete descriptors[DRAFT_STATE as any] + let keys = ownKeys(descriptors) + for (let i = 0; i < keys.length; i++) { + const key: any = keys[i] + const desc = descriptors[key] + if (desc.writable === false) { + desc.writable = true + desc.configurable = true + } + // like object.assign, we will read any _own_, get/set accessors. This helps in dealing + // with libraries that trap values, like mobx or vue + // unlike object.assign, non-enumerables will be copied as well + if (desc.get || desc.set) + descriptors[key] = { + configurable: true, + writable: true, // could live with !!desc.set as well here... + enumerable: desc.enumerable, + value: base[key] + } + } + return Object.create(Object.getPrototypeOf(base), descriptors) +} + +/** + * Freezes draftable objects. Returns the original object. + * By default freezes shallowly, but if the second argument is `true` it will freeze recursively. + * + * @param obj + * @param deep + */ +export function freeze(obj: T, deep?: boolean): T +export function freeze(obj: any, deep: boolean = false): T { + if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj + if (getArchtype(obj) > 1 /* Map or Set */) { + obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections as any + } + Object.freeze(obj) + if (deep) each(obj, (key, value) => freeze(value, true), true) + return obj +} + +function dontMutateFrozenCollections() { + die(2) +} + +export function isFrozen(obj: any): boolean { + if (obj == null || typeof obj !== "object") return true + // See #600, IE dies on non-objects in Object.isFrozen + return Object.isFrozen(obj) +} Index: frontend/node_modules/immer/src/utils/env.ts =================================================================== --- frontend/node_modules/immer/src/utils/env.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/utils/env.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,47 @@ +// Should be no imports here! + +// Some things that should be evaluated before all else... + +// We only want to know if non-polyfilled symbols are available +const hasSymbol = + typeof Symbol !== "undefined" && typeof Symbol("x") === "symbol" +export const hasMap = typeof Map !== "undefined" +export const hasSet = typeof Set !== "undefined" +export const hasProxies = + typeof Proxy !== "undefined" && + typeof Proxy.revocable !== "undefined" && + typeof Reflect !== "undefined" + +/** + * The sentinel value returned by producers to replace the draft with undefined. + */ +export const NOTHING: Nothing = hasSymbol + ? Symbol.for("immer-nothing") + : ({["immer-nothing"]: true} as any) + +/** + * To let Immer treat your class instances as plain immutable objects + * (albeit with a custom prototype), you must define either an instance property + * or a static property on each of your custom classes. + * + * Otherwise, your class instance will never be drafted, which means it won't be + * safe to mutate in a produce callback. + */ +export const DRAFTABLE: unique symbol = hasSymbol + ? Symbol.for("immer-draftable") + : ("__$immer_draftable" as any) + +export const DRAFT_STATE: unique symbol = hasSymbol + ? Symbol.for("immer-state") + : ("__$immer_state" as any) + +// Even a polyfilled Symbol might provide Symbol.iterator +export const iteratorSymbol: typeof Symbol.iterator = + (typeof Symbol != "undefined" && Symbol.iterator) || ("@@iterator" as any) + +/** Use a class type for `nothing` so its type is unique */ +export class Nothing { + // This lets us do `Exclude` + // @ts-ignore + private _!: unique symbol +} Index: frontend/node_modules/immer/src/utils/errors.ts =================================================================== --- frontend/node_modules/immer/src/utils/errors.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/utils/errors.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,60 @@ +const errors = { + 0: "Illegal state", + 1: "Immer drafts cannot have computed properties", + 2: "This object has been frozen and should not be mutated", + 3(data: any) { + return ( + "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + + data + ) + }, + 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", + 5: "Immer forbids circular references", + 6: "The first or second argument to `produce` must be a function", + 7: "The third argument to `produce` must be a function or undefined", + 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object", + 9: "First argument to `finishDraft` must be a draft returned by `createDraft`", + 10: "The given draft is already finalized", + 11: "Object.defineProperty() cannot be used on an Immer draft", + 12: "Object.setPrototypeOf() cannot be used on an Immer draft", + 13: "Immer only supports deleting array indices", + 14: "Immer only supports setting array indices and the 'length' property", + 15(path: string) { + return "Cannot apply patch, path doesn't resolve: " + path + }, + 16: 'Sets cannot have "replace" patches.', + 17(op: string) { + return "Unsupported patch operation: " + op + }, + 18(plugin: string) { + return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.` + }, + 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available", + 21(thing: string) { + return `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}'` + }, + 22(thing: string) { + return `'current' expects a draft, got: ${thing}` + }, + 23(thing: string) { + return `'original' expects a draft, got: ${thing}` + }, + 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed" +} as const + +export function die(error: keyof typeof errors, ...args: any[]): never { + if (__DEV__) { + const e = errors[error] + const msg = !e + ? "unknown error nr: " + error + : typeof e === "function" + ? e.apply(null, args as any) + : e + throw new Error(`[Immer] ${msg}`) + } + throw new Error( + `[Immer] minified error nr: ${error}${ + args.length ? " " + args.map(s => `'${s}'`).join(",") : "" + }. Find the full error at: https://bit.ly/3cXEKWf` + ) +} Index: frontend/node_modules/immer/src/utils/plugins.ts =================================================================== --- frontend/node_modules/immer/src/utils/plugins.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/src/utils/plugins.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,109 @@ +import { + ImmerState, + Patch, + ImmerScope, + Drafted, + AnyObject, + ImmerBaseState, + AnyMap, + AnySet, + ProxyType, + die +} from "../internal" + +/** Plugin utilities */ +const plugins: { + Patches?: { + generatePatches_( + state: ImmerState, + basePath: PatchPath, + patches: Patch[], + inversePatches: Patch[] + ): void + generateReplacementPatches_( + base: any, + replacement: any, + patches: Patch[], + inversePatches: Patch[] + ): void + applyPatches_(draft: T, patches: Patch[]): T + } + ES5?: { + willFinalizeES5_(scope: ImmerScope, result: any, isReplaced: boolean): void + createES5Proxy_( + base: T, + parent?: ImmerState + ): Drafted + hasChanges_(state: ES5ArrayState | ES5ObjectState): boolean + } + MapSet?: { + proxyMap_(target: T, parent?: ImmerState): T + proxySet_(target: T, parent?: ImmerState): T + } +} = {} + +type Plugins = typeof plugins + +export function getPlugin( + pluginKey: K +): Exclude { + const plugin = plugins[pluginKey] + if (!plugin) { + die(18, pluginKey) + } + // @ts-ignore + return plugin +} + +export function loadPlugin( + pluginKey: K, + implementation: Plugins[K] +): void { + if (!plugins[pluginKey]) plugins[pluginKey] = implementation +} + +/** ES5 Plugin */ + +interface ES5BaseState extends ImmerBaseState { + assigned_: {[key: string]: any} + parent_?: ImmerState + revoked_: boolean +} + +export interface ES5ObjectState extends ES5BaseState { + type_: ProxyType.ES5Object + draft_: Drafted + base_: AnyObject + copy_: AnyObject | null +} + +export interface ES5ArrayState extends ES5BaseState { + type_: ProxyType.ES5Array + draft_: Drafted + base_: any + copy_: any +} + +/** Map / Set plugin */ + +export interface MapState extends ImmerBaseState { + type_: ProxyType.Map + copy_: AnyMap | undefined + assigned_: Map | undefined + base_: AnyMap + revoked_: boolean + draft_: Drafted +} + +export interface SetState extends ImmerBaseState { + type_: ProxyType.Set + copy_: AnySet | undefined + base_: AnySet + drafts_: Map // maps the original value to the draft value in the new set + revoked_: boolean + draft_: Drafted +} + +/** Patches plugin */ + +export type PatchPath = (string | number)[]