@vve/immer 9.0.0-alpha.3 → 9.0.0-alpha.5

package/es/immer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"immer.js","names":["legacyProxy","modernProxy","applyPatches","generatePatches","assign","each","has","is","isDraft","isDraftable","isEnumerable","shallowCopy","DRAFT_STATE","NOTHING","ImmerScope","verifyMinified","configDefaults","useProxies","Proxy","Reflect","autoFreeze","process","env","NODE_ENV","name","onAssign","onDelete","onCopy","Immer","constructor","config","setUseProxies","produce","bind","base","recipe","patchListener","defaultBase","self","curriedProduce","arguments","length","undefined","_len","args","Array","_key","draft","call","Error","result","scope","enter","proxy","createProxy","hasError","revoke","leave","Promise","then","usePatches","processResult","error","createDraft","isManual","finishDraft","keepAlive","state","finalized","setAutoFreeze","value","patches","baseDraft","drafts","isReplaced","willFinalize","modified","finalize","push","op","path","inversePatches","Object","isFrozen","finalizeTree","assigned","prop","copy","canAutoFreeze","freeze","root","rootPath","needPatches","finalizeProperty","parent","isDraftProp","concat","isArray","defineProperty"],"sources":["../immer.js"],"sourcesContent":["import * as legacyProxy from \"./es5\"\nimport * as modernProxy from \"./proxy\"\nimport {applyPatches, generatePatches} from \"./patches\"\nimport {\n    assign,\n    each,\n    has,\n    is,\n    isDraft,\n    isDraftable,\n    isEnumerable,\n    shallowCopy,\n    DRAFT_STATE,\n    NOTHING\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\nfunction verifyMinified() {}\n\nconst configDefaults = {\n    useProxies: typeof Proxy !== \"undefined\" && typeof Reflect !== \"undefined\",\n    autoFreeze:\n        typeof process !== \"undefined\"\n            ? process.env.NODE_ENV !== \"production\"\n            : verifyMinified.name === \"verifyMinified\",\n    onAssign: null,\n    onDelete: null,\n    onCopy: null\n}\n\nexport class Immer {\n    constructor(config) {\n        assign(this, configDefaults, config)\n        this.setUseProxies(this.useProxies)\n        this.produce = this.produce.bind(this)\n    }\n    produce(base, recipe, patchListener) {\n        // curried invocation\n        if (typeof base === \"function\" && typeof recipe !== \"function\") {\n            const defaultBase = recipe\n            recipe = base\n\n            const self = this\n            return function curriedProduce(base = defaultBase, ...args) {\n                return self.produce(base, draft => recipe.call(this, draft, ...args)) // prettier-ignore\n            }\n        }\n\n        // prettier-ignore\n        {\n            if (typeof recipe !== \"function\") {\n                throw new Error(\"The first or second argument to `produce` must be a function\")\n            }\n            if (patchListener !== undefined && typeof patchListener !== \"function\") {\n                throw new Error(\"The third argument to `produce` must be a function or undefined\")\n            }\n        }\n\n        let result\n\n        // Only plain objects, arrays, and \"immerable classes\" are drafted.\n        if (isDraftable(base)) {\n            const scope = ImmerScope.enter()\n            const proxy = this.createProxy(base)\n            let hasError = true\n            try {\n                result = recipe(proxy)\n                hasError = false\n            } finally {\n                // finally instead of catch + rethrow better preserves original stack\n                if (hasError) scope.revoke()\n                else scope.leave()\n            }\n            if (result instanceof Promise) {\n                return result.then(\n                    result => {\n                        scope.usePatches(patchListener)\n                        return this.processResult(result, scope)\n                    },\n                    error => {\n                        scope.revoke()\n                        throw error\n                    }\n                )\n            }\n            scope.usePatches(patchListener)\n            return this.processResult(result, scope)\n        } else {\n            result = recipe(base)\n            if (result === undefined) return base\n            return result !== NOTHING ? result : undefined\n        }\n    }\n    createDraft(base) {\n        if (!isDraftable(base)) {\n            throw new Error(\"First argument to `createDraft` must be a plain object, an array, or an immerable object\") // prettier-ignore\n        }\n        const scope = ImmerScope.enter()\n        const proxy = this.createProxy(base, null)\n        proxy[DRAFT_STATE].isManual = true\n        scope.leave()\n        return proxy\n    }\n    finishDraft(draft, patchListener, keepAlive) {\n        const state = draft && draft[DRAFT_STATE]\n        if (!state || !state.isManual) {\n            throw new Error(\"First argument to `finishDraft` must be a draft returned by `createDraft`\") // prettier-ignore\n        }\n        if (state.finalized) {\n            throw new Error(\"The given draft is already finalized\") // prettier-ignore\n        }\n        const {scope} = state\n        scope.usePatches(patchListener)\n        return this.processResult(undefined, scope, keepAlive)\n    }\n    setAutoFreeze(value) {\n        this.autoFreeze = value\n    }\n    setUseProxies(value) {\n        this.useProxies = value\n        assign(this, value ? modernProxy : legacyProxy)\n    }\n    applyPatches(base, patches) {\n        // Mutate the base state when a draft is passed.\n        if (isDraft(base)) {\n            return applyPatches(base, patches)\n        }\n        // Otherwise, produce a copy of the base state.\n        return this.produce(base, draft => applyPatches(draft, patches))\n    }\n    /** @internal */\n    processResult(result, scope, keepAlive) {\n        const baseDraft = scope.drafts[0]\n        const isReplaced = result !== undefined && result !== baseDraft\n        this.willFinalize(scope, result, isReplaced)\n        if (isReplaced) {\n            if (baseDraft[DRAFT_STATE].modified) {\n                scope.revoke(keepAlive)\n                throw new Error(\"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\") // prettier-ignore\n            }\n            if (isDraftable(result)) {\n                // Finalize the result in case it contains (or is) a subset of the draft.\n                result = this.finalize(result, null, scope)\n            }\n            if (scope.patches) {\n                scope.patches.push({\n                    op: \"replace\",\n                    path: [],\n                    value: result\n                })\n                scope.inversePatches.push({\n                    op: \"replace\",\n                    path: [],\n                    value: baseDraft[DRAFT_STATE].base\n                })\n            }\n        } else {\n            // Finalize the base draft.\n            result = this.finalize(baseDraft, [], scope, keepAlive)\n        }\n        scope.revoke(keepAlive)\n        if (scope.patches) {\n            scope.patchListener(scope.patches, scope.inversePatches)\n        }\n        return result !== NOTHING ? result : undefined\n    }\n    /**\n     * @internal\n     * Finalize a draft, returning either the unmodified base state or a modified\n     * copy of the base state.\n     */\n    finalize(draft, path, scope, keepAlive) {\n        const state = draft[DRAFT_STATE]\n        if (!state) {\n            if (Object.isFrozen(draft)) return draft\n            return this.finalizeTree(draft, null, scope)\n        }\n        // Never finalize drafts owned by another scope.\n        if (state.scope !== scope) {\n            return draft\n        }\n        if (!state.modified) {\n            return state.base\n        }\n        if (!state.finalized) {\n            if (!keepAlive) state.finalized = true\n            this.finalizeTree(state.draft, path, scope)\n\n            if (this.onDelete) {\n                // The `assigned` object is unreliable with ES5 drafts.\n                if (this.useProxies) {\n                    const {assigned} = state\n                    for (const prop in assigned) {\n                        if (!assigned[prop]) this.onDelete(state, prop)\n                    }\n                } else {\n                    const {base, copy} = state\n                    each(base, prop => {\n                        if (!has(copy, prop)) this.onDelete(state, prop)\n                    })\n                }\n            }\n            if (this.onCopy) {\n                this.onCopy(state)\n            }\n\n            // At this point, all descendants of `state.copy` have been finalized,\n            // so we can be sure that `scope.canAutoFreeze` is accurate.\n            if (this.autoFreeze && scope.canAutoFreeze) {\n                Object.freeze(state.copy)\n            }\n\n            if (path && scope.patches) {\n                generatePatches(\n                    state,\n                    path,\n                    scope.patches,\n                    scope.inversePatches\n                )\n            }\n        }\n        return state.copy\n    }\n    /**\n     * @internal\n     * Finalize all drafts in the given state tree.\n     */\n    finalizeTree(root, rootPath, scope) {\n        const state = root[DRAFT_STATE]\n        if (state) {\n            if (!this.useProxies) {\n                // Create the final copy, with added keys and without deleted keys.\n                state.copy = shallowCopy(state.draft, true)\n            }\n            root = state.copy\n        }\n\n        const needPatches = !!rootPath && !!scope.patches\n        const finalizeProperty = (prop, value, parent) => {\n            if (value === parent) {\n                throw Error(\"Immer forbids circular references\")\n            }\n\n            // In the `finalizeTree` method, only the `root` object may be a draft.\n            const isDraftProp = !!state && parent === root\n\n            if (isDraft(value)) {\n                const path =\n                    isDraftProp && needPatches && !state.assigned[prop]\n                        ? rootPath.concat(prop)\n                        : null\n\n                // Drafts owned by `scope` are finalized here.\n                value = this.finalize(value, path, scope)\n\n                // Drafts from another scope must prevent auto-freezing.\n                if (isDraft(value)) {\n                    scope.canAutoFreeze = false\n                }\n\n                // Preserve non-enumerable properties.\n                if (Array.isArray(parent) || isEnumerable(parent, prop)) {\n                    parent[prop] = value\n                } else {\n                    Object.defineProperty(parent, prop, {value})\n                }\n\n                // Unchanged drafts are never passed to the `onAssign` hook.\n                if (isDraftProp && value === state.base[prop]) return\n            }\n            // Unchanged draft properties are ignored.\n            else if (isDraftProp && is(value, state.base[prop])) {\n                return\n            }\n            // Search new objects for unfinalized drafts. Frozen objects should never contain drafts.\n            else if (isDraftable(value) && !Object.isFrozen(value)) {\n                each(value, finalizeProperty)\n            }\n\n            if (isDraftProp && this.onAssign) {\n                this.onAssign(state, prop, value)\n            }\n        }\n\n        each(root, finalizeProperty)\n        return root\n    }\n}\n"],"mappings":"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"}

package/es/index.js

@@ -0,0 +1,65 @@
+import { Immer } from "./immer";
+var 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 var produce = immer.produce;
+export default produce;
+
+/**
+ * Pass true to automatically freeze all copies created by Immer.
+ *
+ * By default, auto-freezing is disabled in production.
+ */
+export var 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 var 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 var 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 var 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 var finishDraft = immer.finishDraft.bind(immer);
+export { original, isDraft, isDraftable, NOTHING as nothing, DRAFTABLE as immerable, DRAFT_STATE } from "./common";
+export { Immer };
+//# sourceMappingURL=index.js.map

package/es/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["Immer","immer","produce","setAutoFreeze","bind","setUseProxies","applyPatches","createDraft","finishDraft","original","isDraft","isDraftable","NOTHING","nothing","DRAFTABLE","immerable","DRAFT_STATE"],"sources":["../index.js"],"sourcesContent":["import {Immer} from \"./immer\"\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 = immer.produce\nexport default produce\n\n/**\n * Pass true to automatically freeze all copies created by Immer.\n *\n * By default, auto-freezing is disabled in production.\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\nexport {\n    original,\n    isDraft,\n    isDraftable,\n    NOTHING as nothing,\n    DRAFTABLE as immerable,\n    DRAFT_STATE\n} from \"./common\"\n\nexport {Immer}\n"],"mappings":"AAAA,SAAQA,KAAK;AAEb,IAAMC,KAAK,GAAG,IAAID,KAAK,EAAE;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,IAAME,OAAO,GAAGD,KAAK,CAACC,OAAO;AACpC,eAAeA,OAAO;;AAEtB;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMC,aAAa,GAAGF,KAAK,CAACE,aAAa,CAACC,IAAI,CAACH,KAAK,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMI,aAAa,GAAGJ,KAAK,CAACI,aAAa,CAACD,IAAI,CAACH,KAAK,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMK,YAAY,GAAGL,KAAK,CAACK,YAAY,CAACF,IAAI,CAACH,KAAK,CAAC;;AAE1D;AACA;AACA;AACA;AACA,OAAO,IAAMM,WAAW,GAAGN,KAAK,CAACM,WAAW,CAACH,IAAI,CAACH,KAAK,CAAC;;AAExD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMO,WAAW,GAAGP,KAAK,CAACO,WAAW,CAACJ,IAAI,CAACH,KAAK,CAAC;AAExD,SACIQ,QAAQ,EACRC,OAAO,EACPC,WAAW,EACXC,OAAO,IAAIC,OAAO,EAClBC,SAAS,IAAIC,SAAS,EACtBC,WAAW;AAGf,SAAQhB,KAAK"}

package/es/patches.js

@@ -0,0 +1,149 @@
+import { each } from "./common";
+export function generatePatches(state, basePath, patches, inversePatches) {
+  Array.isArray(state.base) ? generateArrayPatches(state, basePath, patches, inversePatches) : generateObjectPatches(state, basePath, patches, inversePatches);
+}
+function generateArrayPatches(state, basePath, patches, inversePatches) {
+  var base = state.base,
+    copy = state.copy,
+    assigned = state.assigned;
+
+  // 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];
+  }
+  var delta = copy.length - base.length;
+
+  // Find the first replaced index.
+  var start = 0;
+  while (base[start] === copy[start] && start < base.length) {
+    ++start;
+  }
+
+  // Find the last replaced index. Search from the end to optimize splice patches.
+  var end = base.length;
+  while (end > start && base[end - 1] === copy[end + delta - 1]) {
+    --end;
+  }
+
+  // Process replaced indices.
+  for (var i = start; i < end; ++i) {
+    if (assigned[i] && copy[i] !== base[i]) {
+      var path = basePath.concat([i]);
+      patches.push({
+        op: "replace",
+        path,
+        value: copy[i]
+      });
+      inversePatches.push({
+        op: "replace",
+        path,
+        value: base[i]
+      });
+    }
+  }
+  var useRemove = end != base.length;
+  var replaceCount = patches.length;
+
+  // Process added indices.
+  for (var _i = end + delta - 1; _i >= end; --_i) {
+    var _path = basePath.concat([_i]);
+    patches[replaceCount + _i - end] = {
+      op: "add",
+      path: _path,
+      value: copy[_i]
+    };
+    if (useRemove) {
+      inversePatches.push({
+        op: "remove",
+        path: _path
+      });
+    }
+  }
+
+  // One "replace" patch reverses all non-splicing "add" patches.
+  if (!useRemove) {
+    inversePatches.push({
+      op: "replace",
+      path: basePath.concat(["length"]),
+      value: base.length
+    });
+  }
+}
+function generateObjectPatches(state, basePath, patches, inversePatches) {
+  var base = state.base,
+    copy = state.copy;
+  each(state.assigned, (key, assignedValue) => {
+    var origValue = base[key];
+    var value = copy[key];
+    var op = !assignedValue ? "remove" : key in base ? "replace" : "add";
+    if (origValue === value && op === "replace") return;
+    var path = basePath.concat(key);
+    patches.push(op === "remove" ? {
+      op,
+      path
+    } : {
+      op,
+      path,
+      value
+    });
+    inversePatches.push(op === "add" ? {
+      op: "remove",
+      path
+    } : op === "remove" ? {
+      op: "add",
+      path,
+      value: origValue
+    } : {
+      op: "replace",
+      path,
+      value: origValue
+    });
+  });
+}
+export function applyPatches(draft, patches) {
+  for (var i = 0; i < patches.length; i++) {
+    var patch = patches[i];
+    var path = patch.path;
+    if (path.length === 0 && patch.op === "replace") {
+      draft = patch.value;
+    } else {
+      var base = draft;
+      for (var _i2 = 0; _i2 < path.length - 1; _i2++) {
+        base = base[path[_i2]];
+        if (!base || typeof base !== "object") throw new Error("Cannot apply patch, path doesn't resolve: " + path.join("/")); // prettier-ignore
+      }
+
+      var key = path[path.length - 1];
+      switch (patch.op) {
+        case "replace":
+          base[key] = patch.value;
+          break;
+        case "add":
+          if (Array.isArray(base)) {
+            // TODO: support "foo/-" paths for appending to an array
+            base.splice(key, 0, patch.value);
+          } else {
+            base[key] = patch.value;
+          }
+          break;
+        case "remove":
+          if (Array.isArray(base)) {
+            base.splice(key, 1);
+          } else {
+            delete base[key];
+          }
+          break;
+        default:
+          throw new Error("Unsupported patch operation: " + patch.op);
+      }
+    }
+  }
+  return draft;
+}
+//# sourceMappingURL=patches.js.map

package/es/patches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patches.js","names":["each","generatePatches","state","basePath","patches","inversePatches","Array","isArray","base","generateArrayPatches","generateObjectPatches","copy","assigned","length","_ref","_ref2","delta","start","end","i","path","concat","push","op","value","useRemove","replaceCount","key","assignedValue","origValue","applyPatches","draft","patch","Error","join","splice"],"sources":["../patches.js"],"sourcesContent":["import {each} from \"./common\"\n\nexport function generatePatches(state, basePath, patches, inversePatches) {\n    Array.isArray(state.base)\n        ? generateArrayPatches(state, basePath, patches, inversePatches)\n        : generateObjectPatches(state, basePath, patches, inversePatches)\n}\n\nfunction generateArrayPatches(state, basePath, patches, inversePatches) {\n    let {base, copy, assigned} = state\n\n    // Reduce complexity by ensuring `base` is never longer.\n    if (copy.length < base.length) {\n        ;[base, copy] = [copy, base]\n        ;[patches, inversePatches] = [inversePatches, patches]\n    }\n\n    const delta = copy.length - base.length\n\n    // Find the first replaced index.\n    let start = 0\n    while (base[start] === copy[start] && start < base.length) {\n        ++start\n    }\n\n    // Find the last replaced index. Search from the end to optimize splice patches.\n    let end = base.length\n    while (end > start && base[end - 1] === copy[end + delta - 1]) {\n        --end\n    }\n\n    // Process replaced indices.\n    for (let i = start; i < end; ++i) {\n        if (assigned[i] && copy[i] !== base[i]) {\n            const path = basePath.concat([i])\n            patches.push({\n                op: \"replace\",\n                path,\n                value: copy[i]\n            })\n            inversePatches.push({\n                op: \"replace\",\n                path,\n                value: base[i]\n            })\n        }\n    }\n\n    const useRemove = end != base.length\n    const replaceCount = patches.length\n\n    // Process added indices.\n    for (let i = end + delta - 1; i >= end; --i) {\n        const path = basePath.concat([i])\n        patches[replaceCount + i - end] = {\n            op: \"add\",\n            path,\n            value: copy[i]\n        }\n        if (useRemove) {\n            inversePatches.push({\n                op: \"remove\",\n                path\n            })\n        }\n    }\n\n    // One \"replace\" patch reverses all non-splicing \"add\" patches.\n    if (!useRemove) {\n        inversePatches.push({\n            op: \"replace\",\n            path: basePath.concat([\"length\"]),\n            value: base.length\n        })\n    }\n}\n\nfunction generateObjectPatches(state, basePath, patches, inversePatches) {\n    const {base, copy} = state\n    each(state.assigned, (key, assignedValue) => {\n        const origValue = base[key]\n        const value = copy[key]\n        const op = !assignedValue ? \"remove\" : key in base ? \"replace\" : \"add\"\n        if (origValue === value && op === \"replace\") return\n        const path = basePath.concat(key)\n        patches.push(op === \"remove\" ? {op, path} : {op, path, value})\n        inversePatches.push(\n            op === \"add\"\n                ? {op: \"remove\", path}\n                : op === \"remove\"\n                ? {op: \"add\", path, value: origValue}\n                : {op: \"replace\", path, value: origValue}\n        )\n    })\n}\n\nexport function applyPatches(draft, patches) {\n    for (let i = 0; i < patches.length; i++) {\n        const patch = patches[i]\n        const {path} = patch\n        if (path.length === 0 && patch.op === \"replace\") {\n            draft = patch.value\n        } else {\n            let base = draft\n            for (let i = 0; i < path.length - 1; i++) {\n                base = base[path[i]]\n                if (!base || typeof base !== \"object\")\n                    throw new Error(\"Cannot apply patch, path doesn't resolve: \" + path.join(\"/\")) // prettier-ignore\n            }\n            const key = path[path.length - 1]\n            switch (patch.op) {\n                case \"replace\":\n                    base[key] = patch.value\n                    break\n                case \"add\":\n                    if (Array.isArray(base)) {\n                        // TODO: support \"foo/-\" paths for appending to an array\n                        base.splice(key, 0, patch.value)\n                    } else {\n                        base[key] = patch.value\n                    }\n                    break\n                case \"remove\":\n                    if (Array.isArray(base)) {\n                        base.splice(key, 1)\n                    } else {\n                        delete base[key]\n                    }\n                    break\n                default:\n                    throw new Error(\"Unsupported patch operation: \" + patch.op)\n            }\n        }\n    }\n    return draft\n}\n"],"mappings":"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"}

package/es/proxy.js

@@ -0,0 +1,164 @@
+"use strict";
+
+import { assign, each, has, is, isDraftable, isDraft, shallowCopy, DRAFT_STATE } from "./common";
+import { ImmerScope } from "./scope";
+
+// Do nothing before being finalized.
+export function willFinalize() {}
+export function createProxy(base, parent) {
+  var scope = parent ? parent.scope : ImmerScope.current;
+  var state = {
+    // Track which produce call this is associated with.
+    scope,
+    // 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,
+    // The base state.
+    base,
+    // The base proxy.
+    draft: null,
+    // Any property proxies.
+    drafts: {},
+    // The base copy with any updated values.
+    copy: null,
+    // Called by the `produce` function.
+    revoke: null
+  };
+  var _ref = Array.isArray(base) ?
+    // [state] is used for arrays, to make sure the proxy is array-ish and not violate invariants,
+    // although state itself is an object
+    Proxy.revocable([state], arrayTraps) : Proxy.revocable(state, objectTraps),
+    revoke = _ref.revoke,
+    proxy = _ref.proxy;
+  state.draft = proxy;
+  state.revoke = revoke;
+  scope.drafts.push(proxy);
+  return proxy;
+}
+var objectTraps = {
+  get,
+  has(target, prop) {
+    return prop in source(target);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(source(target));
+  },
+  set,
+  deleteProperty,
+  getOwnPropertyDescriptor,
+  defineProperty() {
+    throw new Error("Object.defineProperty() cannot be used on an Immer draft"); // prettier-ignore
+  },
+
+  getPrototypeOf(target) {
+    return Object.getPrototypeOf(target.base);
+  },
+  setPrototypeOf() {
+    throw new Error("Object.setPrototypeOf() cannot be used on an Immer draft"); // prettier-ignore
+  }
+};
+
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+  arrayTraps[key] = function () {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+arrayTraps.deleteProperty = function (state, prop) {
+  if (isNaN(parseInt(prop))) {
+    throw new Error("Immer only supports deleting array indices"); // prettier-ignore
+  }
+
+  return objectTraps.deleteProperty.call(this, state[0], prop);
+};
+arrayTraps.set = function (state, prop, value) {
+  if (prop !== "length" && isNaN(parseInt(prop))) {
+    throw new Error("Immer only supports setting array indices and the 'length' property"); // prettier-ignore
+  }
+
+  return objectTraps.set.call(this, state[0], prop, value);
+};
+
+// returns the object we should be reading the current value from, which is base, until some change has been made
+function source(state) {
+  return state.copy || state.base;
+}
+
+// Access a property without creating an Immer draft.
+function peek(draft, prop) {
+  var state = draft[DRAFT_STATE];
+  var desc = Reflect.getOwnPropertyDescriptor(state ? source(state) : draft, prop);
+  return desc && desc.value;
+}
+function get(state, prop) {
+  if (prop === DRAFT_STATE) return state;
+  var drafts = state.drafts;
+
+  // Check for existing draft in unmodified state.
+  if (!state.modified && has(drafts, prop)) {
+    return drafts[prop];
+  }
+  var value = source(state)[prop];
+  if (state.finalized || !isDraftable(value)) {
+    return value;
+  }
+
+  // Check for existing draft in modified state.
+  if (state.modified) {
+    // Assigned values are never drafted. This catches any drafts we created, too.
+    if (value !== peek(state.base, prop)) return value;
+    // Store drafts on the copy (when one exists).
+    drafts = state.copy;
+  }
+  return drafts[prop] = createProxy(value, state);
+}
+function set(state, prop, value) {
+  if (!state.modified) {
+    var baseValue = peek(state.base, prop);
+    // Optimize based on value's truthiness. Truthy values are guaranteed to
+    // never be undefined, so we can avoid the `in` operator. Lastly, truthy
+    // values may be drafts, but falsy values are never drafts.
+    var isUnchanged = value ? is(baseValue, value) || value === state.drafts[prop] : is(baseValue, value) && prop in state.base;
+    if (isUnchanged) return true;
+    markChanged(state);
+  }
+  state.assigned[prop] = true;
+  state.copy[prop] = value;
+  return true;
+}
+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;
+    markChanged(state);
+  }
+  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.
+function getOwnPropertyDescriptor(state, prop) {
+  var owner = source(state);
+  var desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+  if (desc) {
+    desc.writable = true;
+    desc.configurable = !Array.isArray(owner) || prop !== "length";
+  }
+  return desc;
+}
+function markChanged(state) {
+  if (!state.modified) {
+    state.modified = true;
+    state.copy = assign(shallowCopy(state.base), state.drafts);
+    state.drafts = null;
+    if (state.parent) markChanged(state.parent);
+  }
+}
+//# sourceMappingURL=proxy.js.map

package/es/proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.js","names":["assign","each","has","is","isDraftable","isDraft","shallowCopy","DRAFT_STATE","ImmerScope","willFinalize","createProxy","base","parent","scope","current","state","modified","finalized","assigned","draft","drafts","copy","revoke","_ref","Array","isArray","Proxy","revocable","arrayTraps","objectTraps","proxy","push","get","target","prop","source","ownKeys","Reflect","set","deleteProperty","getOwnPropertyDescriptor","defineProperty","Error","getPrototypeOf","Object","setPrototypeOf","key","fn","arguments","apply","isNaN","parseInt","call","value","peek","desc","baseValue","isUnchanged","markChanged","undefined","owner","writable","configurable"],"sources":["../proxy.js"],"sourcesContent":["\"use strict\"\nimport {\n    assign,\n    each,\n    has,\n    is,\n    isDraftable,\n    isDraft,\n    shallowCopy,\n    DRAFT_STATE\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\n// Do nothing before being finalized.\nexport function willFinalize() {}\n\nexport function createProxy(base, parent) {\n    const scope = parent ? parent.scope : ImmerScope.current\n    const state = {\n        // Track which produce call this is associated with.\n        scope,\n        // True for both shallow and deep changes.\n        modified: false,\n        // Used during finalization.\n        finalized: false,\n        // Track which properties have been assigned (true) or deleted (false).\n        assigned: {},\n        // The parent draft state.\n        parent,\n        // The base state.\n        base,\n        // The base proxy.\n        draft: null,\n        // Any property proxies.\n        drafts: {},\n        // The base copy with any updated values.\n        copy: null,\n        // Called by the `produce` function.\n        revoke: null\n    }\n\n    const {revoke, proxy} = Array.isArray(base)\n        ? // [state] is used for arrays, to make sure the proxy is array-ish and not violate invariants,\n          // although state itself is an object\n          Proxy.revocable([state], arrayTraps)\n        : Proxy.revocable(state, objectTraps)\n\n    state.draft = proxy\n    state.revoke = revoke\n\n    scope.drafts.push(proxy)\n    return proxy\n}\n\nconst objectTraps = {\n    get,\n    has(target, prop) {\n        return prop in source(target)\n    },\n    ownKeys(target) {\n        return Reflect.ownKeys(source(target))\n    },\n    set,\n    deleteProperty,\n    getOwnPropertyDescriptor,\n    defineProperty() {\n        throw new Error(\"Object.defineProperty() cannot be used on an Immer draft\") // prettier-ignore\n    },\n    getPrototypeOf(target) {\n        return Object.getPrototypeOf(target.base)\n    },\n    setPrototypeOf() {\n        throw new Error(\"Object.setPrototypeOf() cannot be used on an Immer draft\") // prettier-ignore\n    }\n}\n\nconst arrayTraps = {}\neach(objectTraps, (key, fn) => {\n    arrayTraps[key] = function() {\n        arguments[0] = arguments[0][0]\n        return fn.apply(this, arguments)\n    }\n})\narrayTraps.deleteProperty = function(state, prop) {\n    if (isNaN(parseInt(prop))) {\n        throw new Error(\"Immer only supports deleting array indices\") // prettier-ignore\n    }\n    return objectTraps.deleteProperty.call(this, state[0], prop)\n}\narrayTraps.set = function(state, prop, value) {\n    if (prop !== \"length\" && isNaN(parseInt(prop))) {\n        throw new Error(\"Immer only supports setting array indices and the 'length' property\") // prettier-ignore\n    }\n    return objectTraps.set.call(this, state[0], prop, value)\n}\n\n// returns the object we should be reading the current value from, which is base, until some change has been made\nfunction source(state) {\n    return state.copy || state.base\n}\n\n// Access a property without creating an Immer draft.\nfunction peek(draft, prop) {\n    const state = draft[DRAFT_STATE]\n    const desc = Reflect.getOwnPropertyDescriptor(\n        state ? source(state) : draft,\n        prop\n    )\n    return desc && desc.value\n}\n\nfunction get(state, prop) {\n    if (prop === DRAFT_STATE) return state\n    let {drafts} = state\n\n    // Check for existing draft in unmodified state.\n    if (!state.modified && has(drafts, prop)) {\n        return drafts[prop]\n    }\n\n    const value = source(state)[prop]\n    if (state.finalized || !isDraftable(value)) {\n        return value\n    }\n\n    // Check for existing draft in modified state.\n    if (state.modified) {\n        // Assigned values are never drafted. This catches any drafts we created, too.\n        if (value !== peek(state.base, prop)) return value\n        // Store drafts on the copy (when one exists).\n        drafts = state.copy\n    }\n\n    return (drafts[prop] = createProxy(value, state))\n}\n\nfunction set(state, prop, value) {\n    if (!state.modified) {\n        const baseValue = peek(state.base, prop)\n        // Optimize based on value's truthiness. Truthy values are guaranteed to\n        // never be undefined, so we can avoid the `in` operator. Lastly, truthy\n        // values may be drafts, but falsy values are never drafts.\n        const isUnchanged = value\n            ? is(baseValue, value) || value === state.drafts[prop]\n            : is(baseValue, value) && prop in state.base\n        if (isUnchanged) return true\n        markChanged(state)\n    }\n    state.assigned[prop] = true\n    state.copy[prop] = value\n    return true\n}\n\nfunction deleteProperty(state, prop) {\n    // The `undefined` check is a fast path for pre-existing keys.\n    if (peek(state.base, prop) !== undefined || prop in state.base) {\n        state.assigned[prop] = false\n        markChanged(state)\n    }\n    if (state.copy) delete state.copy[prop]\n    return true\n}\n\n// Note: We never coerce `desc.value` into an Immer draft, because we can't make\n// the same guarantee in ES5 mode.\nfunction getOwnPropertyDescriptor(state, prop) {\n    const owner = source(state)\n    const desc = Reflect.getOwnPropertyDescriptor(owner, prop)\n    if (desc) {\n        desc.writable = true\n        desc.configurable = !Array.isArray(owner) || prop !== \"length\"\n    }\n    return desc\n}\n\nfunction markChanged(state) {\n    if (!state.modified) {\n        state.modified = true\n        state.copy = assign(shallowCopy(state.base), state.drafts)\n        state.drafts = null\n        if (state.parent) markChanged(state.parent)\n    }\n}\n"],"mappings":"AAAA,YAAY;;AACZ,SACIA,MAAM,EACNC,IAAI,EACJC,GAAG,EACHC,EAAE,EACFC,WAAW,EACXC,OAAO,EACPC,WAAW,EACXC,WAAW;AAEf,SAAQC,UAAU;;AAElB;AACA,OAAO,SAASC,YAAYA,CAAA,EAAG,CAAC;AAEhC,OAAO,SAASC,WAAWA,CAACC,IAAI,EAAEC,MAAM,EAAE;EACtC,IAAMC,KAAK,GAAGD,MAAM,GAAGA,MAAM,CAACC,KAAK,GAAGL,UAAU,CAACM,OAAO;EACxD,IAAMC,KAAK,GAAG;IACV;IACAF,KAAK;IACL;IACAG,QAAQ,EAAE,KAAK;IACf;IACAC,SAAS,EAAE,KAAK;IAChB;IACAC,QAAQ,EAAE,CAAC,CAAC;IACZ;IACAN,MAAM;IACN;IACAD,IAAI;IACJ;IACAQ,KAAK,EAAE,IAAI;IACX;IACAC,MAAM,EAAE,CAAC,CAAC;IACV;IACAC,IAAI,EAAE,IAAI;IACV;IACAC,MAAM,EAAE;EACZ,CAAC;EAED,IAAAC,IAAA,GAAwBC,KAAK,CAACC,OAAO,CAACd,IAAI,CAAC;IACrC;IACA;IACAe,KAAK,CAACC,SAAS,CAAC,CAACZ,KAAK,CAAC,EAAEa,UAAU,CAAC,GACpCF,KAAK,CAACC,SAAS,CAACZ,KAAK,EAAEc,WAAW,CAAC;IAJlCP,MAAM,GAAAC,IAAA,CAAND,MAAM;IAAEQ,KAAK,GAAAP,IAAA,CAALO,KAAK;EAMpBf,KAAK,CAACI,KAAK,GAAGW,KAAK;EACnBf,KAAK,CAACO,MAAM,GAAGA,MAAM;EAErBT,KAAK,CAACO,MAAM,CAACW,IAAI,CAACD,KAAK,CAAC;EACxB,OAAOA,KAAK;AAChB;AAEA,IAAMD,WAAW,GAAG;EAChBG,GAAG;EACH9B,GAAGA,CAAC+B,MAAM,EAAEC,IAAI,EAAE;IACd,OAAOA,IAAI,IAAIC,MAAM,CAACF,MAAM,CAAC;EACjC,CAAC;EACDG,OAAOA,CAACH,MAAM,EAAE;IACZ,OAAOI,OAAO,CAACD,OAAO,CAACD,MAAM,CAACF,MAAM,CAAC,CAAC;EAC1C,CAAC;EACDK,GAAG;EACHC,cAAc;EACdC,wBAAwB;EACxBC,cAAcA,CAAA,EAAG;IACb,MAAM,IAAIC,KAAK,CAAC,0DAA0D,CAAC,EAAC;EAChF,CAAC;;EACDC,cAAcA,CAACV,MAAM,EAAE;IACnB,OAAOW,MAAM,CAACD,cAAc,CAACV,MAAM,CAACtB,IAAI,CAAC;EAC7C,CAAC;EACDkC,cAAcA,CAAA,EAAG;IACb,MAAM,IAAIH,KAAK,CAAC,0DAA0D,CAAC,EAAC;EAChF;AACJ,CAAC;;AAED,IAAMd,UAAU,GAAG,CAAC,CAAC;AACrB3B,IAAI,CAAC4B,WAAW,EAAE,CAACiB,GAAG,EAAEC,EAAE,KAAK;EAC3BnB,UAAU,CAACkB,GAAG,CAAC,GAAG,YAAW;IACzBE,SAAS,CAAC,CAAC,CAAC,GAAGA,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,OAAOD,EAAE,CAACE,KAAK,CAAC,IAAI,EAAED,SAAS,CAAC;EACpC,CAAC;AACL,CAAC,CAAC;AACFpB,UAAU,CAACW,cAAc,GAAG,UAASxB,KAAK,EAAEmB,IAAI,EAAE;EAC9C,IAAIgB,KAAK,CAACC,QAAQ,CAACjB,IAAI,CAAC,CAAC,EAAE;IACvB,MAAM,IAAIQ,KAAK,CAAC,4CAA4C,CAAC,EAAC;EAClE;;EACA,OAAOb,WAAW,CAACU,cAAc,CAACa,IAAI,CAAC,IAAI,EAAErC,KAAK,CAAC,CAAC,CAAC,EAAEmB,IAAI,CAAC;AAChE,CAAC;AACDN,UAAU,CAACU,GAAG,GAAG,UAASvB,KAAK,EAAEmB,IAAI,EAAEmB,KAAK,EAAE;EAC1C,IAAInB,IAAI,KAAK,QAAQ,IAAIgB,KAAK,CAACC,QAAQ,CAACjB,IAAI,CAAC,CAAC,EAAE;IAC5C,MAAM,IAAIQ,KAAK,CAAC,qEAAqE,CAAC,EAAC;EAC3F;;EACA,OAAOb,WAAW,CAACS,GAAG,CAACc,IAAI,CAAC,IAAI,EAAErC,KAAK,CAAC,CAAC,CAAC,EAAEmB,IAAI,EAAEmB,KAAK,CAAC;AAC5D,CAAC;;AAED;AACA,SAASlB,MAAMA,CAACpB,KAAK,EAAE;EACnB,OAAOA,KAAK,CAACM,IAAI,IAAIN,KAAK,CAACJ,IAAI;AACnC;;AAEA;AACA,SAAS2C,IAAIA,CAACnC,KAAK,EAAEe,IAAI,EAAE;EACvB,IAAMnB,KAAK,GAAGI,KAAK,CAACZ,WAAW,CAAC;EAChC,IAAMgD,IAAI,GAAGlB,OAAO,CAACG,wBAAwB,CACzCzB,KAAK,GAAGoB,MAAM,CAACpB,KAAK,CAAC,GAAGI,KAAK,EAC7Be,IAAI,CACP;EACD,OAAOqB,IAAI,IAAIA,IAAI,CAACF,KAAK;AAC7B;AAEA,SAASrB,GAAGA,CAACjB,KAAK,EAAEmB,IAAI,EAAE;EACtB,IAAIA,IAAI,KAAK3B,WAAW,EAAE,OAAOQ,KAAK;EACtC,IAAKK,MAAM,GAAIL,KAAK,CAAfK,MAAM;;EAEX;EACA,IAAI,CAACL,KAAK,CAACC,QAAQ,IAAId,GAAG,CAACkB,MAAM,EAAEc,IAAI,CAAC,EAAE;IACtC,OAAOd,MAAM,CAACc,IAAI,CAAC;EACvB;EAEA,IAAMmB,KAAK,GAAGlB,MAAM,CAACpB,KAAK,CAAC,CAACmB,IAAI,CAAC;EACjC,IAAInB,KAAK,CAACE,SAAS,IAAI,CAACb,WAAW,CAACiD,KAAK,CAAC,EAAE;IACxC,OAAOA,KAAK;EAChB;;EAEA;EACA,IAAItC,KAAK,CAACC,QAAQ,EAAE;IAChB;IACA,IAAIqC,KAAK,KAAKC,IAAI,CAACvC,KAAK,CAACJ,IAAI,EAAEuB,IAAI,CAAC,EAAE,OAAOmB,KAAK;IAClD;IACAjC,MAAM,GAAGL,KAAK,CAACM,IAAI;EACvB;EAEA,OAAQD,MAAM,CAACc,IAAI,CAAC,GAAGxB,WAAW,CAAC2C,KAAK,EAAEtC,KAAK,CAAC;AACpD;AAEA,SAASuB,GAAGA,CAACvB,KAAK,EAAEmB,IAAI,EAAEmB,KAAK,EAAE;EAC7B,IAAI,CAACtC,KAAK,CAACC,QAAQ,EAAE;IACjB,IAAMwC,SAAS,GAAGF,IAAI,CAACvC,KAAK,CAACJ,IAAI,EAAEuB,IAAI,CAAC;IACxC;IACA;IACA;IACA,IAAMuB,WAAW,GAAGJ,KAAK,GACnBlD,EAAE,CAACqD,SAAS,EAAEH,KAAK,CAAC,IAAIA,KAAK,KAAKtC,KAAK,CAACK,MAAM,CAACc,IAAI,CAAC,GACpD/B,EAAE,CAACqD,SAAS,EAAEH,KAAK,CAAC,IAAInB,IAAI,IAAInB,KAAK,CAACJ,IAAI;IAChD,IAAI8C,WAAW,EAAE,OAAO,IAAI;IAC5BC,WAAW,CAAC3C,KAAK,CAAC;EACtB;EACAA,KAAK,CAACG,QAAQ,CAACgB,IAAI,CAAC,GAAG,IAAI;EAC3BnB,KAAK,CAACM,IAAI,CAACa,IAAI,CAAC,GAAGmB,KAAK;EACxB,OAAO,IAAI;AACf;AAEA,SAASd,cAAcA,CAACxB,KAAK,EAAEmB,IAAI,EAAE;EACjC;EACA,IAAIoB,IAAI,CAACvC,KAAK,CAACJ,IAAI,EAAEuB,IAAI,CAAC,KAAKyB,SAAS,IAAIzB,IAAI,IAAInB,KAAK,CAACJ,IAAI,EAAE;IAC5DI,KAAK,CAACG,QAAQ,CAACgB,IAAI,CAAC,GAAG,KAAK;IAC5BwB,WAAW,CAAC3C,KAAK,CAAC;EACtB;EACA,IAAIA,KAAK,CAACM,IAAI,EAAE,OAAON,KAAK,CAACM,IAAI,CAACa,IAAI,CAAC;EACvC,OAAO,IAAI;AACf;;AAEA;AACA;AACA,SAASM,wBAAwBA,CAACzB,KAAK,EAAEmB,IAAI,EAAE;EAC3C,IAAM0B,KAAK,GAAGzB,MAAM,CAACpB,KAAK,CAAC;EAC3B,IAAMwC,IAAI,GAAGlB,OAAO,CAACG,wBAAwB,CAACoB,KAAK,EAAE1B,IAAI,CAAC;EAC1D,IAAIqB,IAAI,EAAE;IACNA,IAAI,CAACM,QAAQ,GAAG,IAAI;IACpBN,IAAI,CAACO,YAAY,GAAG,CAACtC,KAAK,CAACC,OAAO,CAACmC,KAAK,CAAC,IAAI1B,IAAI,KAAK,QAAQ;EAClE;EACA,OAAOqB,IAAI;AACf;AAEA,SAASG,WAAWA,CAAC3C,KAAK,EAAE;EACxB,IAAI,CAACA,KAAK,CAACC,QAAQ,EAAE;IACjBD,KAAK,CAACC,QAAQ,GAAG,IAAI;IACrBD,KAAK,CAACM,IAAI,GAAGrB,MAAM,CAACM,WAAW,CAACS,KAAK,CAACJ,IAAI,CAAC,EAAEI,KAAK,CAACK,MAAM,CAAC;IAC1DL,KAAK,CAACK,MAAM,GAAG,IAAI;IACnB,IAAIL,KAAK,CAACH,MAAM,EAAE8C,WAAW,CAAC3C,KAAK,CAACH,MAAM,CAAC;EAC/C;AACJ"}

package/es/scope.js

@@ -0,0 +1,42 @@
+import { DRAFT_STATE } from "./common";
+
+/** Each scope represents a `produce` call. */
+export class ImmerScope {
+  constructor(parent) {
+    this.drafts = [];
+    this.parent = parent;
+
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    this.canAutoFreeze = true;
+
+    // To avoid prototype lookups:
+    this.patches = null;
+  }
+  usePatches(patchListener) {
+    if (patchListener) {
+      this.patches = [];
+      this.inversePatches = [];
+      this.patchListener = patchListener;
+    }
+  }
+  revoke(keepAlive) {
+    this.leave();
+    keepAlive || this.drafts.forEach(revoke);
+    this.drafts = null; // Make draft-related methods throw.
+  }
+
+  leave() {
+    if (this === ImmerScope.current) {
+      ImmerScope.current = this.parent;
+    }
+  }
+}
+ImmerScope.current = null;
+ImmerScope.enter = function () {
+  return this.current = new ImmerScope(this.current);
+};
+function revoke(draft) {
+  draft[DRAFT_STATE].revoke();
+}
+//# sourceMappingURL=scope.js.map

package/es/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.js","names":["DRAFT_STATE","ImmerScope","constructor","parent","drafts","canAutoFreeze","patches","usePatches","patchListener","inversePatches","revoke","keepAlive","leave","forEach","current","enter","draft"],"sources":["../scope.js"],"sourcesContent":["import {DRAFT_STATE} from \"./common\"\n\n/** Each scope represents a `produce` call. */\nexport class ImmerScope {\n    constructor(parent) {\n        this.drafts = []\n        this.parent = parent\n\n        // Whenever the modified draft contains a draft from another scope, we\n        // need to prevent auto-freezing so the unowned draft can be finalized.\n        this.canAutoFreeze = true\n\n        // To avoid prototype lookups:\n        this.patches = null\n    }\n    usePatches(patchListener) {\n        if (patchListener) {\n            this.patches = []\n            this.inversePatches = []\n            this.patchListener = patchListener\n        }\n    }\n    revoke(keepAlive) {\n        this.leave()\n        keepAlive || this.drafts.forEach(revoke)\n        this.drafts = null // Make draft-related methods throw.\n    }\n    leave() {\n        if (this === ImmerScope.current) {\n            ImmerScope.current = this.parent\n        }\n    }\n}\n\nImmerScope.current = null\nImmerScope.enter = function() {\n    return (this.current = new ImmerScope(this.current))\n}\n\nfunction revoke(draft) {\n    draft[DRAFT_STATE].revoke()\n}\n"],"mappings":"AAAA,SAAQA,WAAW;;AAEnB;AACA,OAAO,MAAMC,UAAU,CAAC;EACpBC,WAAWA,CAACC,MAAM,EAAE;IAChB,IAAI,CAACC,MAAM,GAAG,EAAE;IAChB,IAAI,CAACD,MAAM,GAAGA,MAAM;;IAEpB;IACA;IACA,IAAI,CAACE,aAAa,GAAG,IAAI;;IAEzB;IACA,IAAI,CAACC,OAAO,GAAG,IAAI;EACvB;EACAC,UAAUA,CAACC,aAAa,EAAE;IACtB,IAAIA,aAAa,EAAE;MACf,IAAI,CAACF,OAAO,GAAG,EAAE;MACjB,IAAI,CAACG,cAAc,GAAG,EAAE;MACxB,IAAI,CAACD,aAAa,GAAGA,aAAa;IACtC;EACJ;EACAE,MAAMA,CAACC,SAAS,EAAE;IACd,IAAI,CAACC,KAAK,EAAE;IACZD,SAAS,IAAI,IAAI,CAACP,MAAM,CAACS,OAAO,CAACH,MAAM,CAAC;IACxC,IAAI,CAACN,MAAM,GAAG,IAAI,EAAC;EACvB;;EACAQ,KAAKA,CAAA,EAAG;IACJ,IAAI,IAAI,KAAKX,UAAU,CAACa,OAAO,EAAE;MAC7Bb,UAAU,CAACa,OAAO,GAAG,IAAI,CAACX,MAAM;IACpC;EACJ;AACJ;AAEAF,UAAU,CAACa,OAAO,GAAG,IAAI;AACzBb,UAAU,CAACc,KAAK,GAAG,YAAW;EAC1B,OAAQ,IAAI,CAACD,OAAO,GAAG,IAAIb,UAAU,CAAC,IAAI,CAACa,OAAO,CAAC;AACvD,CAAC;AAED,SAASJ,MAAMA,CAACM,KAAK,EAAE;EACnBA,KAAK,CAAChB,WAAW,CAAC,CAACU,MAAM,EAAE;AAC/B"}

package/lib/common.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assign = exports.NOTHING = exports.DRAFT_STATE = exports.DRAFTABLE = void 0;
+exports.each = each;
+exports.has = has;
+exports.is = is;
+exports.isDraft = isDraft;
+exports.isDraftable = isDraftable;
+exports.isEnumerable = isEnumerable;
+exports.original = original;
+exports.ownKeys = void 0;
+exports.shallowCopy = shallowCopy;
+var NOTHING = typeof Symbol !== "undefined" ? Symbol("immer-nothing") : {
+  ["immer-nothing"]: true
+};
+exports.NOTHING = NOTHING;
+var DRAFTABLE = typeof Symbol !== "undefined" && Symbol.for ? Symbol.for("immer-draftable") : "__$immer_draftable";
+exports.DRAFTABLE = DRAFTABLE;
+var DRAFT_STATE = typeof Symbol !== "undefined" && Symbol.for ? Symbol.for("immer-state") : "__$immer_state";
+exports.DRAFT_STATE = DRAFT_STATE;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  var proto = Object.getPrototypeOf(value);
+  if (!proto || proto === Object.prototype) return true;
+  return !!value[DRAFTABLE] || !!value.constructor[DRAFTABLE];
+}
+function original(value) {
+  if (value && value[DRAFT_STATE]) {
+    return value[DRAFT_STATE].base;
+  }
+  // otherwise return undefined
+}
+
+var assign = Object.assign || function assign(target, value) {
+  for (var key in value) {
+    if (has(value, key)) {
+      target[key] = value[key];
+    }
+  }
+  return target;
+};
+exports.assign = assign;
+var ownKeys = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? obj => Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)) : Object.getOwnPropertyNames;
+exports.ownKeys = ownKeys;
+function shallowCopy(base) {
+  var invokeGetters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (Array.isArray(base)) return base.slice();
+  var clone = Object.create(Object.getPrototypeOf(base));
+  ownKeys(base).forEach(key => {
+    if (key === DRAFT_STATE) {
+      return; // Never copy over draft state.
+    }
+
+    var desc = Object.getOwnPropertyDescriptor(base, key);
+    var value = desc.value;
+    if (desc.get) {
+      if (!invokeGetters) {
+        throw new Error("Immer drafts cannot have computed properties");
+      }
+      value = desc.get.call(base);
+    }
+    if (desc.enumerable) {
+      clone[key] = value;
+    } else {
+      Object.defineProperty(clone, key, {
+        value,
+        writable: true,
+        configurable: true
+      });
+    }
+  });
+  return clone;
+}
+function each(value, cb) {
+  if (Array.isArray(value)) {
+    for (var i = 0; i < value.length; i++) cb(i, value[i], value);
+  } else {
+    ownKeys(value).forEach(key => cb(key, value[key], value));
+  }
+}
+function isEnumerable(base, prop) {
+  var desc = Object.getOwnPropertyDescriptor(base, prop);
+  return !!desc && desc.enumerable;
+}
+function has(thing, prop) {
+  return Object.prototype.hasOwnProperty.call(thing, prop);
+}
+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;
+  }
+}
+//# sourceMappingURL=common.js.map