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

package/umd/index.js

@@ -0,0 +1,1134 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["VveImmer"] = factory();
+	else
+		root["VveImmer"] = factory();
+})(self, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 376:
+/***/ ((module) => {
+
+var __dirname = "/";
+(function(){var e={952:function(e){var t=e.exports={};var r;var n;function defaultSetTimout(){throw new Error("setTimeout has not been defined")}function defaultClearTimeout(){throw new Error("clearTimeout has not been defined")}(function(){try{if(typeof setTimeout==="function"){r=setTimeout}else{r=defaultSetTimout}}catch(e){r=defaultSetTimout}try{if(typeof clearTimeout==="function"){n=clearTimeout}else{n=defaultClearTimeout}}catch(e){n=defaultClearTimeout}})();function runTimeout(e){if(r===setTimeout){return setTimeout(e,0)}if((r===defaultSetTimout||!r)&&setTimeout){r=setTimeout;return setTimeout(e,0)}try{return r(e,0)}catch(t){try{return r.call(null,e,0)}catch(t){return r.call(this,e,0)}}}function runClearTimeout(e){if(n===clearTimeout){return clearTimeout(e)}if((n===defaultClearTimeout||!n)&&clearTimeout){n=clearTimeout;return clearTimeout(e)}try{return n(e)}catch(t){try{return n.call(null,e)}catch(t){return n.call(this,e)}}}var i=[];var o=false;var u;var a=-1;function cleanUpNextTick(){if(!o||!u){return}o=false;if(u.length){i=u.concat(i)}else{a=-1}if(i.length){drainQueue()}}function drainQueue(){if(o){return}var e=runTimeout(cleanUpNextTick);o=true;var t=i.length;while(t){u=i;i=[];while(++a<t){if(u){u[a].run()}}a=-1;t=i.length}u=null;o=false;runClearTimeout(e)}t.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1){for(var r=1;r<arguments.length;r++){t[r-1]=arguments[r]}}i.push(new Item(e,t));if(i.length===1&&!o){runTimeout(drainQueue)}};function Item(e,t){this.fun=e;this.array=t}Item.prototype.run=function(){this.fun.apply(null,this.array)};t.title="browser";t.browser=true;t.env={};t.argv=[];t.version="";t.versions={};function noop(){}t.on=noop;t.addListener=noop;t.once=noop;t.off=noop;t.removeListener=noop;t.removeAllListeners=noop;t.emit=noop;t.prependListener=noop;t.prependOnceListener=noop;t.listeners=function(e){return[]};t.binding=function(e){throw new Error("process.binding is not supported")};t.cwd=function(){return"/"};t.chdir=function(e){throw new Error("process.chdir is not supported")};t.umask=function(){return 0}}};var t={};function __nccwpck_require__(r){var n=t[r];if(n!==undefined){return n.exports}var i=t[r]={exports:{}};var o=true;try{e[r](i,i.exports,__nccwpck_require__);o=false}finally{if(o)delete t[r]}return i.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var r=__nccwpck_require__(952);module.exports=r})();
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+(() => {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  DRAFT_STATE: () => (/* reexport */ DRAFT_STATE),
+  Immer: () => (/* reexport */ Immer),
+  applyPatches: () => (/* binding */ src_applyPatches),
+  createDraft: () => (/* binding */ createDraft),
+  "default": () => (/* binding */ src),
+  finishDraft: () => (/* binding */ finishDraft),
+  immerable: () => (/* reexport */ DRAFTABLE),
+  isDraft: () => (/* reexport */ isDraft),
+  isDraftable: () => (/* reexport */ isDraftable),
+  nothing: () => (/* reexport */ NOTHING),
+  original: () => (/* reexport */ original),
+  produce: () => (/* binding */ produce),
+  setAutoFreeze: () => (/* binding */ setAutoFreeze),
+  setUseProxies: () => (/* binding */ setUseProxies)
+});
+
+// NAMESPACE OBJECT: ./src/es5.js
+var es5_namespaceObject = {};
+__webpack_require__.r(es5_namespaceObject);
+__webpack_require__.d(es5_namespaceObject, {
+  createProxy: () => (createProxy),
+  willFinalize: () => (willFinalize)
+});
+
+// NAMESPACE OBJECT: ./src/proxy.js
+var proxy_namespaceObject = {};
+__webpack_require__.r(proxy_namespaceObject);
+__webpack_require__.d(proxy_namespaceObject, {
+  createProxy: () => (proxy_createProxy),
+  willFinalize: () => (proxy_willFinalize)
+});
+
+;// CONCATENATED MODULE: ./src/common.js
+var NOTHING = typeof Symbol !== "undefined" ? Symbol("immer-nothing") : {
+  ["immer-nothing"]: true
+};
+var DRAFTABLE = typeof Symbol !== "undefined" && Symbol.for ? Symbol.for("immer-draftable") : "__$immer_draftable";
+var DRAFT_STATE = typeof Symbol !== "undefined" && Symbol.for ? Symbol.for("immer-state") : "__$immer_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 common_assign = Object.assign || function assign(target, value) {
+  for (var key in value) {
+    if (has(value, key)) {
+      target[key] = value[key];
+    }
+  }
+  return target;
+};
+var ownKeys = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? obj => Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)) : Object.getOwnPropertyNames;
+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;
+  }
+}
+;// CONCATENATED MODULE: ./src/scope.js
+
+
+/** Each scope represents a `produce` call. */
+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();
+}
+;// CONCATENATED MODULE: ./src/es5.js
+
+
+
+
+
+// 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 = {};
+var noop = () => {};
+function willFinalize(scope, result, isReplaced) {
+  scope.drafts.forEach(draft => {
+    draft[DRAFT_STATE].finalizing = true;
+  });
+  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 createProxy(base, parent) {
+  var isArray = Array.isArray(base);
+  var draft = clonePotentialDraft(base);
+  each(draft, prop => {
+    proxyProperty(draft, prop, isArray || isEnumerable(base, prop));
+  });
+
+  // See "proxy.js" for property documentation.
+  var scope = parent ? parent.scope : ImmerScope.current;
+  var state = {
+    scope,
+    modified: false,
+    finalizing: false,
+    // es5 only
+    finalized: false,
+    assigned: {},
+    parent,
+    base,
+    draft,
+    copy: null,
+    revoke: es5_revoke,
+    revoked: false // es5 only
+  };
+
+  createHiddenProperty(draft, DRAFT_STATE, state);
+  scope.drafts.push(draft);
+  return draft;
+}
+function es5_revoke() {
+  this.revoked = true;
+}
+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];
+  if (state && !state.finalizing) {
+    state.finalizing = true;
+    var value = draft[prop];
+    state.finalizing = false;
+    return value;
+  }
+  return draft[prop];
+}
+function get(state, prop) {
+  assertUnrevoked(state);
+  var value = peek(source(state), prop);
+  if (state.finalizing) return value;
+  // Create a draft if the value is unmodified.
+  if (value === peek(state.base, prop) && isDraftable(value)) {
+    prepareCopy(state);
+    return state.copy[prop] = createProxy(value, state);
+  }
+  return value;
+}
+function set(state, prop, value) {
+  assertUnrevoked(state);
+  state.assigned[prop] = true;
+  if (!state.modified) {
+    if (is(value, peek(source(state), prop))) return;
+    markChanged(state);
+    prepareCopy(state);
+  }
+  state.copy[prop] = value;
+}
+function markChanged(state) {
+  if (!state.modified) {
+    state.modified = true;
+    if (state.parent) markChanged(state.parent);
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy) state.copy = clonePotentialDraft(state.base);
+}
+function clonePotentialDraft(base) {
+  var state = base && base[DRAFT_STATE];
+  if (state) {
+    state.finalizing = true;
+    var draft = shallowCopy(state.draft, true);
+    state.finalizing = false;
+    return draft;
+  }
+  return shallowCopy(base);
+}
+function proxyProperty(draft, prop, enumerable) {
+  var desc = descriptors[prop];
+  if (desc) {
+    desc.enumerable = enumerable;
+  } else {
+    descriptors[prop] = desc = {
+      configurable: true,
+      enumerable,
+      get() {
+        return get(this[DRAFT_STATE], prop);
+      },
+      set(value) {
+        set(this[DRAFT_STATE], prop, value);
+      }
+    };
+  }
+  Object.defineProperty(draft, prop, desc);
+}
+function assertUnrevoked(state) {
+  if (state.revoked === true) throw new Error("Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + JSON.stringify(source(state)));
+}
+
+// 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) {
+      if (Array.isArray(state.base)) {
+        if (hasArrayChanges(state)) markChanged(state);
+      } else if (hasObjectChanges(state)) markChanged(state);
+    }
+  }
+}
+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;
+  if (!Array.isArray(object)) {
+    // Look for added keys.
+    Object.keys(draft).forEach(key => {
+      // 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.
+    Object.keys(base).forEach(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 (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 _i = base.length; _i < draft.length; _i++) assigned[_i] = true;
+    }
+    for (var _i2 = 0; _i2 < draft.length; _i2++) {
+      // Only untouched indices trigger recursion.
+      if (assigned[_i2] === undefined) markChangesRecursively(draft[_i2]);
+    }
+  }
+}
+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 = Object.keys(draft);
+  for (var i = keys.length - 1; i >= 0; i--) {
+    var key = keys[i];
+    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.
+  return keys.length !== Object.keys(base).length;
+}
+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
+  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;
+  // For all other cases, we don't have to compare, as they would have been picked up by the index setters
+  return false;
+}
+function createHiddenProperty(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value: value,
+    enumerable: false,
+    writable: true
+  });
+}
+;// CONCATENATED MODULE: ./src/proxy.js
+
+
+
+
+
+// Do nothing before being finalized.
+function proxy_willFinalize() {}
+function proxy_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: proxy_get,
+  has(target, prop) {
+    return prop in proxy_source(target);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(proxy_source(target));
+  },
+  set: proxy_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 proxy_source(state) {
+  return state.copy || state.base;
+}
+
+// Access a property without creating an Immer draft.
+function proxy_peek(draft, prop) {
+  var state = draft[DRAFT_STATE];
+  var desc = Reflect.getOwnPropertyDescriptor(state ? proxy_source(state) : draft, prop);
+  return desc && desc.value;
+}
+function proxy_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 = proxy_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 !== proxy_peek(state.base, prop)) return value;
+    // Store drafts on the copy (when one exists).
+    drafts = state.copy;
+  }
+  return drafts[prop] = proxy_createProxy(value, state);
+}
+function proxy_set(state, prop, value) {
+  if (!state.modified) {
+    var baseValue = proxy_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;
+    proxy_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 (proxy_peek(state.base, prop) !== undefined || prop in state.base) {
+    state.assigned[prop] = false;
+    proxy_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 = proxy_source(state);
+  var desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+  if (desc) {
+    desc.writable = true;
+    desc.configurable = !Array.isArray(owner) || prop !== "length";
+  }
+  return desc;
+}
+function proxy_markChanged(state) {
+  if (!state.modified) {
+    state.modified = true;
+    state.copy = common_assign(shallowCopy(state.base), state.drafts);
+    state.drafts = null;
+    if (state.parent) proxy_markChanged(state.parent);
+  }
+}
+;// CONCATENATED MODULE: ./src/patches.js
+
+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
+    });
+  });
+}
+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;
+}
+;// CONCATENATED MODULE: ./src/immer.js
+/* provided dependency */ var process = __webpack_require__(376);
+
+
+
+
+
+function verifyMinified() {}
+var configDefaults = {
+  useProxies: typeof Proxy !== "undefined" && typeof Reflect !== "undefined",
+  autoFreeze: typeof process !== "undefined" ? "production" !== "production" : verifyMinified.name === "verifyMinified",
+  onAssign: null,
+  onDelete: null,
+  onCopy: null
+};
+class Immer {
+  constructor(config) {
+    common_assign(this, configDefaults, config);
+    this.setUseProxies(this.useProxies);
+    this.produce = this.produce.bind(this);
+  }
+  produce(base, recipe, patchListener) {
+    // curried invocation
+    if (typeof base === "function" && typeof recipe !== "function") {
+      var defaultBase = recipe;
+      recipe = base;
+      var self = this;
+      return function curriedProduce() {
+        var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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, draft => recipe.call(this, draft, ...args)); // prettier-ignore
+      };
+    }
+
+    // prettier-ignore
+    {
+      if (typeof recipe !== "function") {
+        throw new Error("The first or second argument to `produce` must be a function");
+      }
+      if (patchListener !== undefined && typeof patchListener !== "function") {
+        throw new Error("The third argument to `produce` must be a function or undefined");
+      }
+    }
+    var result;
+
+    // Only plain objects, arrays, and "immerable classes" are drafted.
+    if (isDraftable(base)) {
+      var scope = ImmerScope.enter();
+      var proxy = this.createProxy(base);
+      var hasError = true;
+      try {
+        result = recipe(proxy);
+        hasError = false;
+      } finally {
+        // finally instead of catch + rethrow better preserves original stack
+        if (hasError) scope.revoke();else scope.leave();
+      }
+      if (result instanceof Promise) {
+        return result.then(result => {
+          scope.usePatches(patchListener);
+          return this.processResult(result, scope);
+        }, error => {
+          scope.revoke();
+          throw error;
+        });
+      }
+      scope.usePatches(patchListener);
+      return this.processResult(result, scope);
+    } else {
+      result = recipe(base);
+      if (result === undefined) return base;
+      return result !== NOTHING ? result : undefined;
+    }
+  }
+  createDraft(base) {
+    if (!isDraftable(base)) {
+      throw new Error("First argument to `createDraft` must be a plain object, an array, or an immerable object"); // prettier-ignore
+    }
+
+    var scope = ImmerScope.enter();
+    var proxy = this.createProxy(base, null);
+    proxy[DRAFT_STATE].isManual = true;
+    scope.leave();
+    return proxy;
+  }
+  finishDraft(draft, patchListener, keepAlive) {
+    var state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual) {
+      throw new Error("First argument to `finishDraft` must be a draft returned by `createDraft`"); // prettier-ignore
+    }
+
+    if (state.finalized) {
+      throw new Error("The given draft is already finalized"); // prettier-ignore
+    }
+
+    var scope = state.scope;
+    scope.usePatches(patchListener);
+    return this.processResult(undefined, scope, keepAlive);
+  }
+  setAutoFreeze(value) {
+    this.autoFreeze = value;
+  }
+  setUseProxies(value) {
+    this.useProxies = value;
+    common_assign(this, value ? proxy_namespaceObject : es5_namespaceObject);
+  }
+  applyPatches(base, patches) {
+    // Mutate the base state when a draft is passed.
+    if (isDraft(base)) {
+      return applyPatches(base, patches);
+    }
+    // Otherwise, produce a copy of the base state.
+    return this.produce(base, draft => applyPatches(draft, patches));
+  }
+  /** @internal */
+  processResult(result, scope, keepAlive) {
+    var baseDraft = scope.drafts[0];
+    var isReplaced = result !== undefined && result !== baseDraft;
+    this.willFinalize(scope, result, isReplaced);
+    if (isReplaced) {
+      if (baseDraft[DRAFT_STATE].modified) {
+        scope.revoke(keepAlive);
+        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
+      }
+
+      if (isDraftable(result)) {
+        // Finalize the result in case it contains (or is) a subset of the draft.
+        result = this.finalize(result, null, scope);
+      }
+      if (scope.patches) {
+        scope.patches.push({
+          op: "replace",
+          path: [],
+          value: result
+        });
+        scope.inversePatches.push({
+          op: "replace",
+          path: [],
+          value: baseDraft[DRAFT_STATE].base
+        });
+      }
+    } else {
+      // Finalize the base draft.
+      result = this.finalize(baseDraft, [], scope, keepAlive);
+    }
+    scope.revoke(keepAlive);
+    if (scope.patches) {
+      scope.patchListener(scope.patches, scope.inversePatches);
+    }
+    return result !== NOTHING ? result : undefined;
+  }
+  /**
+   * @internal
+   * Finalize a draft, returning either the unmodified base state or a modified
+   * copy of the base state.
+   */
+  finalize(draft, path, scope, keepAlive) {
+    var state = draft[DRAFT_STATE];
+    if (!state) {
+      if (Object.isFrozen(draft)) return draft;
+      return this.finalizeTree(draft, null, scope);
+    }
+    // Never finalize drafts owned by another scope.
+    if (state.scope !== scope) {
+      return draft;
+    }
+    if (!state.modified) {
+      return state.base;
+    }
+    if (!state.finalized) {
+      if (!keepAlive) state.finalized = true;
+      this.finalizeTree(state.draft, path, scope);
+      if (this.onDelete) {
+        // The `assigned` object is unreliable with ES5 drafts.
+        if (this.useProxies) {
+          var assigned = state.assigned;
+          for (var prop in assigned) {
+            if (!assigned[prop]) this.onDelete(state, prop);
+          }
+        } else {
+          var base = state.base,
+            copy = state.copy;
+          each(base, prop => {
+            if (!has(copy, prop)) this.onDelete(state, prop);
+          });
+        }
+      }
+      if (this.onCopy) {
+        this.onCopy(state);
+      }
+
+      // At this point, all descendants of `state.copy` have been finalized,
+      // so we can be sure that `scope.canAutoFreeze` is accurate.
+      if (this.autoFreeze && scope.canAutoFreeze) {
+        Object.freeze(state.copy);
+      }
+      if (path && scope.patches) {
+        generatePatches(state, path, scope.patches, scope.inversePatches);
+      }
+    }
+    return state.copy;
+  }
+  /**
+   * @internal
+   * Finalize all drafts in the given state tree.
+   */
+  finalizeTree(root, rootPath, scope) {
+    var state = root[DRAFT_STATE];
+    if (state) {
+      if (!this.useProxies) {
+        // Create the final copy, with added keys and without deleted keys.
+        state.copy = shallowCopy(state.draft, true);
+      }
+      root = state.copy;
+    }
+    var needPatches = !!rootPath && !!scope.patches;
+    var finalizeProperty = (prop, value, parent) => {
+      if (value === parent) {
+        throw Error("Immer forbids circular references");
+      }
+
+      // In the `finalizeTree` method, only the `root` object may be a draft.
+      var isDraftProp = !!state && parent === root;
+      if (isDraft(value)) {
+        var path = isDraftProp && needPatches && !state.assigned[prop] ? rootPath.concat(prop) : null;
+
+        // Drafts owned by `scope` are finalized here.
+        value = this.finalize(value, path, scope);
+
+        // Drafts from another scope must prevent auto-freezing.
+        if (isDraft(value)) {
+          scope.canAutoFreeze = false;
+        }
+
+        // Preserve non-enumerable properties.
+        if (Array.isArray(parent) || isEnumerable(parent, prop)) {
+          parent[prop] = value;
+        } else {
+          Object.defineProperty(parent, prop, {
+            value
+          });
+        }
+
+        // Unchanged drafts are never passed to the `onAssign` hook.
+        if (isDraftProp && value === state.base[prop]) return;
+      }
+      // Unchanged draft properties are ignored.
+      else if (isDraftProp && is(value, state.base[prop])) {
+        return;
+      }
+      // Search new objects for unfinalized drafts. Frozen objects should never contain drafts.
+      else if (isDraftable(value) && !Object.isFrozen(value)) {
+        each(value, finalizeProperty);
+      }
+      if (isDraftProp && this.onAssign) {
+        this.onAssign(state, prop, value);
+      }
+    };
+    each(root, finalizeProperty);
+    return root;
+  }
+}
+;// CONCATENATED MODULE: ./src/index.js
+
+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
+ */
+var produce = immer.produce;
+/* harmony default export */ var src = (produce);
+
+/**
+ * Pass true to automatically freeze all copies created by Immer.
+ *
+ * By default, auto-freezing is disabled in production.
+ */
+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.
+ */
+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.
+ */
+var src_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.
+ */
+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.
+ */
+var finishDraft = immer.finishDraft.bind(immer);
+
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=index.js.map