(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) { if (!value) return false; return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!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.delete(propOrOldValue); 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 // Although the original test case doesn't seem valid anyway, so if this in the way we can turn the next line // back to each(result, ....) each(state.type_ === 3 /* Set */ ? new Set(result) : result, function (key, childValue) { return finalizeProperty(rootScope, state, result, key, childValue, path); }); // 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) { 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; } // 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; } if (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: NaN typeof value !== "number" && ( // special case: handle new props with value 'undefined' value !== undefined || prop in state.copy_)) 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} 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 */ 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 (arg1, arg2, arg3) { if (typeof arg1 === "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 arg1.apply(void 0, [draft].concat(args)); }); }; } var patches, inversePatches; var result = _this.produce(arg1, arg2, 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]; // 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