@qraft/asyncapi-plugin 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/_vendor/immer/dist/immer.cjs.development.js

@@ -1,2096 +0,0 @@
-import { __exports as immer_cjs_development } from '../../../_virtual/immer.cjs.development.js';
-
-var hasRequiredImmer_cjs_development;
-
-function requireImmer_cjs_development () {
-	if (hasRequiredImmer_cjs_development) return immer_cjs_development;
-	hasRequiredImmer_cjs_development = 1;
-
-	Object.defineProperty(immer_cjs_development, '__esModule', { value: true });
-
-	var _ref;
-
-	// Should be no imports here!
-	// Some things that should be evaluated before all else...
-	// We only want to know if non-polyfilled symbols are available
-	var hasSymbol = typeof Symbol !== "undefined" && typeof
-	/*#__PURE__*/
-	Symbol("x") === "symbol";
-	var hasMap = typeof Map !== "undefined";
-	var hasSet = typeof Set !== "undefined";
-	var hasProxies = typeof Proxy !== "undefined" && typeof Proxy.revocable !== "undefined" && typeof Reflect !== "undefined";
-	/**
-	 * The sentinel value returned by producers to replace the draft with undefined.
-	 */
-
-	var NOTHING = hasSymbol ?
-	/*#__PURE__*/
-	Symbol.for("immer-nothing") : (_ref = {}, _ref["immer-nothing"] = true, _ref);
-	/**
-	 * To let Immer treat your class instances as plain immutable objects
-	 * (albeit with a custom prototype), you must define either an instance property
-	 * or a static property on each of your custom classes.
-	 *
-	 * Otherwise, your class instance will never be drafted, which means it won't be
-	 * safe to mutate in a produce callback.
-	 */
-
-	var DRAFTABLE = hasSymbol ?
-	/*#__PURE__*/
-	Symbol.for("immer-draftable") : "__$immer_draftable";
-	var DRAFT_STATE = hasSymbol ?
-	/*#__PURE__*/
-	Symbol.for("immer-state") : "__$immer_state"; // Even a polyfilled Symbol might provide Symbol.iterator
-
-	var iteratorSymbol = typeof Symbol != "undefined" && Symbol.iterator || "@@iterator";
-
-	var errors = {
-	  0: "Illegal state",
-	  1: "Immer drafts cannot have computed properties",
-	  2: "This object has been frozen and should not be mutated",
-	  3: function _(data) {
-	    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
-	  },
-	  4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
-	  5: "Immer forbids circular references",
-	  6: "The first or second argument to `produce` must be a function",
-	  7: "The third argument to `produce` must be a function or undefined",
-	  8: "First argument to `createDraft` must be a plain object, an array, or an immerable object",
-	  9: "First argument to `finishDraft` must be a draft returned by `createDraft`",
-	  10: "The given draft is already finalized",
-	  11: "Object.defineProperty() cannot be used on an Immer draft",
-	  12: "Object.setPrototypeOf() cannot be used on an Immer draft",
-	  13: "Immer only supports deleting array indices",
-	  14: "Immer only supports setting array indices and the 'length' property",
-	  15: function _(path) {
-	    return "Cannot apply patch, path doesn't resolve: " + path;
-	  },
-	  16: 'Sets cannot have "replace" patches.',
-	  17: function _(op) {
-	    return "Unsupported patch operation: " + op;
-	  },
-	  18: function _(plugin) {
-	    return "The plugin for '" + plugin + "' has not been loaded into Immer. To enable the plugin, import and call `enable" + plugin + "()` when initializing your application.";
-	  },
-	  20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available",
-	  21: function _(thing) {
-	    return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '" + thing + "'";
-	  },
-	  22: function _(thing) {
-	    return "'current' expects a draft, got: " + thing;
-	  },
-	  23: function _(thing) {
-	    return "'original' expects a draft, got: " + thing;
-	  },
-	  24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed"
-	};
-	function die(error) {
-	  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	    args[_key - 1] = arguments[_key];
-	  }
-
-	  {
-	    var e = errors[error];
-	    var msg = !e ? "unknown error nr: " + error : typeof e === "function" ? e.apply(null, args) : e;
-	    throw new Error("[Immer] " + msg);
-	  }
-	}
-
-	/** Returns true if the given value is an Immer draft */
-
-	
-
-	function isDraft(value) {
-	  return !!value && !!value[DRAFT_STATE];
-	}
-	/** Returns true if the given value can be drafted by Immer */
-
-	
-
-	function isDraftable(value) {
-	  var _value$constructor;
-
-	  if (!value) return false;
-	  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor[DRAFTABLE]) || isMap(value) || isSet(value);
-	}
-	var objectCtorString =
-	/*#__PURE__*/
-	Object.prototype.constructor.toString();
-	
-
-	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_;
-	}
-	
-
-	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);
-	    });
-	  }
-	}
-	
-
-	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 */
-	  ;
-	}
-	
-
-	function has(thing, prop) {
-	  return getArchtype(thing) === 2
-	  /* Map */
-	  ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
-	}
-	
-
-	function get(thing, prop) {
-	  // @ts-ignore
-	  return getArchtype(thing) === 2
-	  /* Map */
-	  ? thing.get(prop) : thing[prop];
-	}
-	
-
-	function set(thing, propOrOldValue, value) {
-	  var t = getArchtype(thing);
-	  if (t === 2
-	  /* Map */
-	  ) thing.set(propOrOldValue, value);else if (t === 3
-	  /* Set */
-	  ) {
-	      thing.add(value);
-	    } else thing[propOrOldValue] = value;
-	}
-	
-
-	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;
-	  }
-	}
-	
-
-	function isMap(target) {
-	  return hasMap && target instanceof Map;
-	}
-	
-
-	function isSet(target) {
-	  return hasSet && target instanceof Set;
-	}
-	
-
-	function latest(state) {
-	  return state.copy_ || state.base_;
-	}
-	
-
-	function shallowCopy(base) {
-	  if (Array.isArray(base)) return Array.prototype.slice.call(base);
-	  var descriptors = getOwnPropertyDescriptors(base);
-	  delete descriptors[DRAFT_STATE];
-	  var keys = ownKeys(descriptors);
-
-	  for (var i = 0; i < keys.length; i++) {
-	    var key = keys[i];
-	    var desc = descriptors[key];
-
-	    if (desc.writable === false) {
-	      desc.writable = true;
-	      desc.configurable = true;
-	    } // like object.assign, we will read any _own_, get/set accessors. This helps in dealing
-	    // with libraries that trap values, like mobx or vue
-	    // unlike object.assign, non-enumerables will be copied as well
-
-
-	    if (desc.get || desc.set) descriptors[key] = {
-	      configurable: true,
-	      writable: true,
-	      enumerable: desc.enumerable,
-	      value: base[key]
-	    };
-	  }
-
-	  return Object.create(Object.getPrototypeOf(base), descriptors);
-	}
-	function freeze(obj, deep) {
-	  if (deep === void 0) {
-	    deep = false;
-	  }
-
-	  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
-
-	  if (getArchtype(obj) > 1
-	  /* Map or Set */
-	  ) {
-	      obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
-	    }
-
-	  Object.freeze(obj);
-	  if (deep) each(obj, function (key, value) {
-	    return freeze(value, true);
-	  }, true);
-	  return obj;
-	}
-
-	function dontMutateFrozenCollections() {
-	  die(2);
-	}
-
-	function isFrozen(obj) {
-	  if (obj == null || typeof obj !== "object") return true; // See #600, IE dies on non-objects in Object.isFrozen
-
-	  return Object.isFrozen(obj);
-	}
-
-	/** Plugin utilities */
-
-	var plugins = {};
-	function getPlugin(pluginKey) {
-	  var plugin = plugins[pluginKey];
-
-	  if (!plugin) {
-	    die(18, pluginKey);
-	  } // @ts-ignore
-
-
-	  return plugin;
-	}
-	function loadPlugin(pluginKey, implementation) {
-	  if (!plugins[pluginKey]) plugins[pluginKey] = implementation;
-	}
-
-	var currentScope;
-	function getCurrentScope() {
-	  if ( !currentScope) die(0);
-	  return currentScope;
-	}
-
-	function createScope(parent_, immer_) {
-	  return {
-	    drafts_: [],
-	    parent_: parent_,
-	    immer_: immer_,
-	    // Whenever the modified draft contains a draft from another scope, we
-	    // need to prevent auto-freezing so the unowned draft can be finalized.
-	    canAutoFreeze_: true,
-	    unfinalizedDrafts_: 0
-	  };
-	}
-
-	function usePatchesInScope(scope, patchListener) {
-	  if (patchListener) {
-	    getPlugin("Patches"); // assert we have the plugin
-
-	    scope.patches_ = [];
-	    scope.inversePatches_ = [];
-	    scope.patchListener_ = patchListener;
-	  }
-	}
-	function revokeScope(scope) {
-	  leaveScope(scope);
-	  scope.drafts_.forEach(revokeDraft); // @ts-ignore
-
-	  scope.drafts_ = null;
-	}
-	function leaveScope(scope) {
-	  if (scope === currentScope) {
-	    currentScope = scope.parent_;
-	  }
-	}
-	function enterScope(immer) {
-	  return currentScope = createScope(currentScope, immer);
-	}
-
-	function revokeDraft(draft) {
-	  var state = draft[DRAFT_STATE];
-	  if (state.type_ === 0
-	  /* ProxyObject */
-	  || state.type_ === 1
-	  /* ProxyArray */
-	  ) state.revoke_();else state.revoked_ = true;
-	}
-
-	function processResult(result, scope) {
-	  scope.unfinalizedDrafts_ = scope.drafts_.length;
-	  var baseDraft = scope.drafts_[0];
-	  var isReplaced = result !== undefined && result !== baseDraft;
-	  if (!scope.immer_.useProxies_) getPlugin("ES5").willFinalizeES5_(scope, result, isReplaced);
-
-	  if (isReplaced) {
-	    if (baseDraft[DRAFT_STATE].modified_) {
-	      revokeScope(scope);
-	      die(4);
-	    }
-
-	    if (isDraftable(result)) {
-	      // Finalize the result in case it contains (or is) a subset of the draft.
-	      result = finalize(scope, result);
-	      if (!scope.parent_) maybeFreeze(scope, result);
-	    }
-
-	    if (scope.patches_) {
-	      getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_);
-	    }
-	  } else {
-	    // Finalize the base draft.
-	    result = finalize(scope, baseDraft, []);
-	  }
-
-	  revokeScope(scope);
-
-	  if (scope.patches_) {
-	    scope.patchListener_(scope.patches_, scope.inversePatches_);
-	  }
-
-	  return result !== NOTHING ? result : undefined;
-	}
-
-	function finalize(rootScope, value, path) {
-	  // Don't recurse in tho recursive data structures
-	  if (isFrozen(value)) return value;
-	  var state = value[DRAFT_STATE]; // A plain object, might need freezing, might contain drafts
-
-	  if (!state) {
-	    each(value, function (key, childValue) {
-	      return finalizeProperty(rootScope, state, value, key, childValue, path);
-	    }, true // See #590, don't recurse into non-enumerable of non drafted objects
-	    );
-	    return value;
-	  } // Never finalize drafts owned by another scope.
-
-
-	  if (state.scope_ !== rootScope) return value; // Unmodified draft, return the (frozen) original
-
-	  if (!state.modified_) {
-	    maybeFreeze(rootScope, state.base_, true);
-	    return state.base_;
-	  } // Not finalized yet, let's do that now
-
-
-	  if (!state.finalized_) {
-	    state.finalized_ = true;
-	    state.scope_.unfinalizedDrafts_--;
-	    var result = // For ES5, create a good copy from the draft first, with added keys and without deleted keys.
-	    state.type_ === 4
-	    /* ES5Object */
-	    || state.type_ === 5
-	    /* ES5Array */
-	    ? state.copy_ = shallowCopy(state.draft_) : state.copy_; // Finalize all children of the copy
-	    // For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628
-	    // To preserve insertion order in all cases we then clear the set
-	    // And we let finalizeProperty know it needs to re-add non-draft children back to the target
-
-	    var resultEach = result;
-	    var isSet = false;
-
-	    if (state.type_ === 3
-	    /* Set */
-	    ) {
-	        resultEach = new Set(result);
-	        result.clear();
-	        isSet = true;
-	      }
-
-	    each(resultEach, function (key, childValue) {
-	      return finalizeProperty(rootScope, state, result, key, childValue, path, isSet);
-	    }); // everything inside is frozen, we can freeze here
-
-	    maybeFreeze(rootScope, result, false); // first time finalizing, let's create those patches
-
-	    if (path && rootScope.patches_) {
-	      getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
-	    }
-	  }
-
-	  return state.copy_;
-	}
-
-	function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
-	  if ( childValue === targetObject) die(5);
-
-	  if (isDraft(childValue)) {
-	    var path = rootPath && parentState && parentState.type_ !== 3
-	    /* Set */
-	    && // Set objects are atomic since they have no keys.
-	    !has(parentState.assigned_, prop) // Skip deep patches for assigned keys.
-	    ? rootPath.concat(prop) : undefined; // Drafts owned by `scope` are finalized here.
-
-	    var res = finalize(rootScope, childValue, path);
-	    set(targetObject, prop, res); // Drafts from another scope must prevented to be frozen
-	    // if we got a draft back from finalize, we're in a nested produce and shouldn't freeze
-
-	    if (isDraft(res)) {
-	      rootScope.canAutoFreeze_ = false;
-	    } else return;
-	  } else if (targetIsSet) {
-	    targetObject.add(childValue);
-	  } // Search new objects for unfinalized drafts. Frozen objects should never contain drafts.
-
-
-	  if (isDraftable(childValue) && !isFrozen(childValue)) {
-	    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
-	      // optimization: if an object is not a draft, and we don't have to
-	      // deepfreeze everything, and we are sure that no drafts are left in the remaining object
-	      // cause we saw and finalized all drafts already; we can stop visiting the rest of the tree.
-	      // This benefits especially adding large data tree's without further processing.
-	      // See add-data.js perf test
-	      return;
-	    }
-
-	    finalize(rootScope, childValue); // immer deep freezes plain objects, so if there is no parent state, we freeze as well
-
-	    if (!parentState || !parentState.scope_.parent_) maybeFreeze(rootScope, childValue);
-	  }
-	}
-
-	function maybeFreeze(scope, value, deep) {
-	  if (deep === void 0) {
-	    deep = false;
-	  }
-
-	  // we never freeze for a non-root scope; as it would prevent pruning for drafts inside wrapping objects
-	  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
-	    freeze(value, deep);
-	  }
-	}
-
-	/**
-	 * Returns a new draft of the `base` object.
-	 *
-	 * The second argument is the parent draft-state (used internally).
-	 */
-
-	function createProxyProxy(base, parent) {
-	  var isArray = Array.isArray(base);
-	  var state = {
-	    type_: isArray ? 1
-	    /* ProxyArray */
-	    : 0
-	    /* ProxyObject */
-	    ,
-	    // Track which produce call this is associated with.
-	    scope_: parent ? parent.scope_ : getCurrentScope(),
-	    // True for both shallow and deep changes.
-	    modified_: false,
-	    // Used during finalization.
-	    finalized_: false,
-	    // Track which properties have been assigned (true) or deleted (false).
-	    assigned_: {},
-	    // The parent draft state.
-	    parent_: parent,
-	    // The base state.
-	    base_: base,
-	    // The base proxy.
-	    draft_: null,
-	    // The base copy with any updated values.
-	    copy_: null,
-	    // Called by the `produce` function.
-	    revoke_: null,
-	    isManual_: false
-	  }; // the traps must target something, a bit like the 'real' base.
-	  // but also, we need to be able to determine from the target what the relevant state is
-	  // (to avoid creating traps per instance to capture the state in closure,
-	  // and to avoid creating weird hidden properties as well)
-	  // So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything)
-	  // Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb
-
-	  var target = state;
-	  var traps = objectTraps;
-
-	  if (isArray) {
-	    target = [state];
-	    traps = arrayTraps;
-	  }
-
-	  var _Proxy$revocable = Proxy.revocable(target, traps),
-	      revoke = _Proxy$revocable.revoke,
-	      proxy = _Proxy$revocable.proxy;
-
-	  state.draft_ = proxy;
-	  state.revoke_ = revoke;
-	  return proxy;
-	}
-	/**
-	 * Object drafts
-	 */
-
-	var objectTraps = {
-	  get: function get(state, prop) {
-	    if (prop === DRAFT_STATE) return state;
-	    var source = latest(state);
-
-	    if (!has(source, prop)) {
-	      // non-existing or non-own property...
-	      return readPropFromProto(state, source, prop);
-	    }
-
-	    var value = source[prop];
-
-	    if (state.finalized_ || !isDraftable(value)) {
-	      return value;
-	    } // Check for existing draft in modified state.
-	    // Assigned values are never drafted. This catches any drafts we created, too.
-
-
-	    if (value === peek(state.base_, prop)) {
-	      prepareCopy(state);
-	      return state.copy_[prop] = createProxy(state.scope_.immer_, value, state);
-	    }
-
-	    return value;
-	  },
-	  has: function has(state, prop) {
-	    return prop in latest(state);
-	  },
-	  ownKeys: function ownKeys(state) {
-	    return Reflect.ownKeys(latest(state));
-	  },
-	  set: function set(state, prop
-	  /* strictly not, but helps TS */
-	  , value) {
-	    var desc = getDescriptorFromProto(latest(state), prop);
-
-	    if (desc === null || desc === void 0 ? void 0 : desc.set) {
-	      // special case: if this write is captured by a setter, we have
-	      // to trigger it with the correct context
-	      desc.set.call(state.draft_, value);
-	      return true;
-	    }
-
-	    if (!state.modified_) {
-	      // the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change)
-	      // from setting an existing property with value undefined to undefined (which is not a change)
-	      var current = peek(latest(state), prop); // special case, if we assigning the original value to a draft, we can ignore the assignment
-
-	      var currentState = current === null || current === void 0 ? void 0 : current[DRAFT_STATE];
-
-	      if (currentState && currentState.base_ === value) {
-	        state.copy_[prop] = value;
-	        state.assigned_[prop] = false;
-	        return true;
-	      }
-
-	      if (is(value, current) && (value !== undefined || has(state.base_, prop))) return true;
-	      prepareCopy(state);
-	      markChanged(state);
-	    }
-
-	    if (state.copy_[prop] === value && ( // special case: handle new props with value 'undefined'
-	    value !== undefined || prop in state.copy_) || // special case: NaN
-	    Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true; // @ts-ignore
-
-	    state.copy_[prop] = value;
-	    state.assigned_[prop] = true;
-	    return true;
-	  },
-	  deleteProperty: function deleteProperty(state, prop) {
-	    // The `undefined` check is a fast path for pre-existing keys.
-	    if (peek(state.base_, prop) !== undefined || prop in state.base_) {
-	      state.assigned_[prop] = false;
-	      prepareCopy(state);
-	      markChanged(state);
-	    } else {
-	      // if an originally not assigned property was deleted
-	      delete state.assigned_[prop];
-	    } // @ts-ignore
-
-
-	    if (state.copy_) delete state.copy_[prop];
-	    return true;
-	  },
-	  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
-	  // the same guarantee in ES5 mode.
-	  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(state, prop) {
-	    var owner = latest(state);
-	    var desc = Reflect.getOwnPropertyDescriptor(owner, prop);
-	    if (!desc) return desc;
-	    return {
-	      writable: true,
-	      configurable: state.type_ !== 1
-	      /* ProxyArray */
-	      || prop !== "length",
-	      enumerable: desc.enumerable,
-	      value: owner[prop]
-	    };
-	  },
-	  defineProperty: function defineProperty() {
-	    die(11);
-	  },
-	  getPrototypeOf: function getPrototypeOf(state) {
-	    return Object.getPrototypeOf(state.base_);
-	  },
-	  setPrototypeOf: function setPrototypeOf() {
-	    die(12);
-	  }
-	};
-	/**
-	 * Array drafts
-	 */
-
-	var arrayTraps = {};
-	each(objectTraps, function (key, fn) {
-	  // @ts-ignore
-	  arrayTraps[key] = function () {
-	    arguments[0] = arguments[0][0];
-	    return fn.apply(this, arguments);
-	  };
-	});
-
-	arrayTraps.deleteProperty = function (state, prop) {
-	  if ( isNaN(parseInt(prop))) die(13); // @ts-ignore
-
-	  return arrayTraps.set.call(this, state, prop, undefined);
-	};
-
-	arrayTraps.set = function (state, prop, value) {
-	  if ( prop !== "length" && isNaN(parseInt(prop))) die(14);
-	  return objectTraps.set.call(this, state[0], prop, value, state[0]);
-	}; // Access a property without creating an Immer draft.
-
-
-	function peek(draft, prop) {
-	  var state = draft[DRAFT_STATE];
-	  var source = state ? latest(state) : draft;
-	  return source[prop];
-	}
-
-	function readPropFromProto(state, source, prop) {
-	  var _desc$get;
-
-	  var desc = getDescriptorFromProto(source, prop);
-	  return desc ? "value" in desc ? desc.value : // This is a very special case, if the prop is a getter defined by the
-	  // prototype, we should invoke it with the draft as context!
-	  (_desc$get = desc.get) === null || _desc$get === void 0 ? void 0 : _desc$get.call(state.draft_) : undefined;
-	}
-
-	function getDescriptorFromProto(source, prop) {
-	  // 'in' checks proto!
-	  if (!(prop in source)) return undefined;
-	  var proto = Object.getPrototypeOf(source);
-
-	  while (proto) {
-	    var desc = Object.getOwnPropertyDescriptor(proto, prop);
-	    if (desc) return desc;
-	    proto = Object.getPrototypeOf(proto);
-	  }
-
-	  return undefined;
-	}
-
-	function markChanged(state) {
-	  if (!state.modified_) {
-	    state.modified_ = true;
-
-	    if (state.parent_) {
-	      markChanged(state.parent_);
-	    }
-	  }
-	}
-	function prepareCopy(state) {
-	  if (!state.copy_) {
-	    state.copy_ = shallowCopy(state.base_);
-	  }
-	}
-
-	var Immer =
-	/*#__PURE__*/
-	function () {
-	  function Immer(config) {
-	    var _this = this;
-
-	    this.useProxies_ = hasProxies;
-	    this.autoFreeze_ = true;
-	    /**
-	     * The `produce` function takes a value and a "recipe function" (whose
-	     * return value often depends on the base state). The recipe function is
-	     * free to mutate its first argument however it wants. All mutations are
-	     * only ever applied to a __copy__ of the base state.
-	     *
-	     * Pass only a function to create a "curried producer" which relieves you
-	     * from passing the recipe function every time.
-	     *
-	     * Only plain objects and arrays are made mutable. All other objects are
-	     * considered uncopyable.
-	     *
-	     * Note: This function is __bound__ to its `Immer` instance.
-	     *
-	     * @param {any} base - the initial state
-	     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
-	     * @param {Function} patchListener - optional function that will be called with all the patches produced here
-	     * @returns {any} a new state, or the initial state if nothing was modified
-	     */
-
-	    this.produce = function (base, recipe, patchListener) {
-	      // curried invocation
-	      if (typeof base === "function" && typeof recipe !== "function") {
-	        var defaultBase = recipe;
-	        recipe = base;
-	        var self = _this;
-	        return function curriedProduce(base) {
-	          var _this2 = this;
-
-	          if (base === void 0) {
-	            base = defaultBase;
-	          }
-
-	          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	            args[_key - 1] = arguments[_key];
-	          }
-
-	          return self.produce(base, function (draft) {
-	            var _recipe;
-
-	            return (_recipe = recipe).call.apply(_recipe, [_this2, draft].concat(args));
-	          }); // prettier-ignore
-	        };
-	      }
-
-	      if (typeof recipe !== "function") die(6);
-	      if (patchListener !== undefined && typeof patchListener !== "function") die(7);
-	      var result; // Only plain objects, arrays, and "immerable classes" are drafted.
-
-	      if (isDraftable(base)) {
-	        var scope = enterScope(_this);
-	        var proxy = createProxy(_this, base, undefined);
-	        var hasError = true;
-
-	        try {
-	          result = recipe(proxy);
-	          hasError = false;
-	        } finally {
-	          // finally instead of catch + rethrow better preserves original stack
-	          if (hasError) revokeScope(scope);else leaveScope(scope);
-	        }
-
-	        if (typeof Promise !== "undefined" && result instanceof Promise) {
-	          return result.then(function (result) {
-	            usePatchesInScope(scope, patchListener);
-	            return processResult(result, scope);
-	          }, function (error) {
-	            revokeScope(scope);
-	            throw error;
-	          });
-	        }
-
-	        usePatchesInScope(scope, patchListener);
-	        return processResult(result, scope);
-	      } else if (!base || typeof base !== "object") {
-	        result = recipe(base);
-	        if (result === undefined) result = base;
-	        if (result === NOTHING) result = undefined;
-	        if (_this.autoFreeze_) freeze(result, true);
-
-	        if (patchListener) {
-	          var p = [];
-	          var ip = [];
-	          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
-	          patchListener(p, ip);
-	        }
-
-	        return result;
-	      } else die(21, base);
-	    };
-
-	    this.produceWithPatches = function (base, recipe) {
-	      // curried invocation
-	      if (typeof base === "function") {
-	        return function (state) {
-	          for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-	            args[_key2 - 1] = arguments[_key2];
-	          }
-
-	          return _this.produceWithPatches(state, function (draft) {
-	            return base.apply(void 0, [draft].concat(args));
-	          });
-	        };
-	      }
-
-	      var patches, inversePatches;
-
-	      var result = _this.produce(base, recipe, function (p, ip) {
-	        patches = p;
-	        inversePatches = ip;
-	      });
-
-	      if (typeof Promise !== "undefined" && result instanceof Promise) {
-	        return result.then(function (nextState) {
-	          return [nextState, patches, inversePatches];
-	        });
-	      }
-
-	      return [result, patches, inversePatches];
-	    };
-
-	    if (typeof (config === null || config === void 0 ? void 0 : config.useProxies) === "boolean") this.setUseProxies(config.useProxies);
-	    if (typeof (config === null || config === void 0 ? void 0 : config.autoFreeze) === "boolean") this.setAutoFreeze(config.autoFreeze);
-	  }
-
-	  var _proto = Immer.prototype;
-
-	  _proto.createDraft = function createDraft(base) {
-	    if (!isDraftable(base)) die(8);
-	    if (isDraft(base)) base = current(base);
-	    var scope = enterScope(this);
-	    var proxy = createProxy(this, base, undefined);
-	    proxy[DRAFT_STATE].isManual_ = true;
-	    leaveScope(scope);
-	    return proxy;
-	  };
-
-	  _proto.finishDraft = function finishDraft(draft, patchListener) {
-	    var state = draft && draft[DRAFT_STATE];
-
-	    {
-	      if (!state || !state.isManual_) die(9);
-	      if (state.finalized_) die(10);
-	    }
-
-	    var scope = state.scope_;
-	    usePatchesInScope(scope, patchListener);
-	    return processResult(undefined, scope);
-	  }
-	  /**
-	   * Pass true to automatically freeze all copies created by Immer.
-	   *
-	   * By default, auto-freezing is enabled.
-	   */
-	  ;
-
-	  _proto.setAutoFreeze = function setAutoFreeze(value) {
-	    this.autoFreeze_ = value;
-	  }
-	  /**
-	   * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
-	   * always faster than using ES5 proxies.
-	   *
-	   * By default, feature detection is used, so calling this is rarely necessary.
-	   */
-	  ;
-
-	  _proto.setUseProxies = function setUseProxies(value) {
-	    if (value && !hasProxies) {
-	      die(20);
-	    }
-
-	    this.useProxies_ = value;
-	  };
-
-	  _proto.applyPatches = function applyPatches(base, patches) {
-	    // If a patch replaces the entire state, take that replacement as base
-	    // before applying patches
-	    var i;
-
-	    for (i = patches.length - 1; i >= 0; i--) {
-	      var patch = patches[i];
-
-	      if (patch.path.length === 0 && patch.op === "replace") {
-	        base = patch.value;
-	        break;
-	      }
-	    } // If there was a patch that replaced the entire state, start from the
-	    // patch after that.
-
-
-	    if (i > -1) {
-	      patches = patches.slice(i + 1);
-	    }
-
-	    var applyPatchesImpl = getPlugin("Patches").applyPatches_;
-
-	    if (isDraft(base)) {
-	      // N.B: never hits if some patch a replacement, patches are never drafts
-	      return applyPatchesImpl(base, patches);
-	    } // Otherwise, produce a copy of the base state.
-
-
-	    return this.produce(base, function (draft) {
-	      return applyPatchesImpl(draft, patches);
-	    });
-	  };
-
-	  return Immer;
-	}();
-	function createProxy(immer, value, parent) {
-	  // precondition: createProxy should be guarded by isDraftable, so we know we can safely draft
-	  var draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : immer.useProxies_ ? createProxyProxy(value, parent) : getPlugin("ES5").createES5Proxy_(value, parent);
-	  var scope = parent ? parent.scope_ : getCurrentScope();
-	  scope.drafts_.push(draft);
-	  return draft;
-	}
-
-	function current(value) {
-	  if (!isDraft(value)) die(22, value);
-	  return currentImpl(value);
-	}
-
-	function currentImpl(value) {
-	  if (!isDraftable(value)) return value;
-	  var state = value[DRAFT_STATE];
-	  var copy;
-	  var archType = getArchtype(value);
-
-	  if (state) {
-	    if (!state.modified_ && (state.type_ < 4 || !getPlugin("ES5").hasChanges_(state))) return state.base_; // Optimization: avoid generating new drafts during copying
-
-	    state.finalized_ = true;
-	    copy = copyHelper(value, archType);
-	    state.finalized_ = false;
-	  } else {
-	    copy = copyHelper(value, archType);
-	  }
-
-	  each(copy, function (key, childValue) {
-	    if (state && get(state.base_, key) === childValue) return; // no need to copy or search in something that didn't change
-
-	    set(copy, key, currentImpl(childValue));
-	  }); // In the future, we might consider freezing here, based on the current settings
-
-	  return archType === 3
-	  /* Set */
-	  ? new Set(copy) : copy;
-	}
-
-	function copyHelper(value, archType) {
-	  // creates a shallow copy, even if it is a map or set
-	  switch (archType) {
-	    case 2
-	    /* Map */
-	    :
-	      return new Map(value);
-
-	    case 3
-	    /* Set */
-	    :
-	      // Set will be cloned as array temporarily, so that we can replace individual items
-	      return Array.from(value);
-	  }
-
-	  return shallowCopy(value);
-	}
-
-	function enableES5() {
-	  function willFinalizeES5_(scope, result, isReplaced) {
-	    if (!isReplaced) {
-	      if (scope.patches_) {
-	        markChangesRecursively(scope.drafts_[0]);
-	      } // This is faster when we don't care about which attributes changed.
-
-
-	      markChangesSweep(scope.drafts_);
-	    } // When a child draft is returned, look for changes.
-	    else if (isDraft(result) && result[DRAFT_STATE].scope_ === scope) {
-	        markChangesSweep(scope.drafts_);
-	      }
-	  }
-
-	  function createES5Draft(isArray, base) {
-	    if (isArray) {
-	      var draft = new Array(base.length);
-
-	      for (var i = 0; i < base.length; i++) {
-	        Object.defineProperty(draft, "" + i, proxyProperty(i, true));
-	      }
-
-	      return draft;
-	    } else {
-	      var _descriptors = getOwnPropertyDescriptors(base);
-
-	      delete _descriptors[DRAFT_STATE];
-	      var keys = ownKeys(_descriptors);
-
-	      for (var _i = 0; _i < keys.length; _i++) {
-	        var key = keys[_i];
-	        _descriptors[key] = proxyProperty(key, isArray || !!_descriptors[key].enumerable);
-	      }
-
-	      return Object.create(Object.getPrototypeOf(base), _descriptors);
-	    }
-	  }
-
-	  function createES5Proxy_(base, parent) {
-	    var isArray = Array.isArray(base);
-	    var draft = createES5Draft(isArray, base);
-	    var state = {
-	      type_: isArray ? 5
-	      /* ES5Array */
-	      : 4
-	      /* ES5Object */
-	      ,
-	      scope_: parent ? parent.scope_ : getCurrentScope(),
-	      modified_: false,
-	      finalized_: false,
-	      assigned_: {},
-	      parent_: parent,
-	      // base is the object we are drafting
-	      base_: base,
-	      // draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified)
-	      draft_: draft,
-	      copy_: null,
-	      revoked_: false,
-	      isManual_: false
-	    };
-	    Object.defineProperty(draft, DRAFT_STATE, {
-	      value: state,
-	      // enumerable: false <- the default
-	      writable: true
-	    });
-	    return draft;
-	  } // property descriptors are recycled to make sure we don't create a get and set closure per property,
-	  // but share them all instead
-
-
-	  var descriptors = {};
-
-	  function proxyProperty(prop, enumerable) {
-	    var desc = descriptors[prop];
-
-	    if (desc) {
-	      desc.enumerable = enumerable;
-	    } else {
-	      descriptors[prop] = desc = {
-	        configurable: true,
-	        enumerable: enumerable,
-	        get: function get() {
-	          var state = this[DRAFT_STATE];
-	          assertUnrevoked(state); // @ts-ignore
-
-	          return objectTraps.get(state, prop);
-	        },
-	        set: function set(value) {
-	          var state = this[DRAFT_STATE];
-	          assertUnrevoked(state); // @ts-ignore
-
-	          objectTraps.set(state, prop, value);
-	        }
-	      };
-	    }
-
-	    return desc;
-	  } // This looks expensive, but only proxies are visited, and only objects without known changes are scanned.
-
-
-	  function markChangesSweep(drafts) {
-	    // The natural order of drafts in the `scope` array is based on when they
-	    // were accessed. By processing drafts in reverse natural order, we have a
-	    // better chance of processing leaf nodes first. When a leaf node is known to
-	    // have changed, we can avoid any traversal of its ancestor nodes.
-	    for (var i = drafts.length - 1; i >= 0; i--) {
-	      var state = drafts[i][DRAFT_STATE];
-
-	      if (!state.modified_) {
-	        switch (state.type_) {
-	          case 5
-	          /* ES5Array */
-	          :
-	            if (hasArrayChanges(state)) markChanged(state);
-	            break;
-
-	          case 4
-	          /* ES5Object */
-	          :
-	            if (hasObjectChanges(state)) markChanged(state);
-	            break;
-	        }
-	      }
-	    }
-	  }
-
-	  function markChangesRecursively(object) {
-	    if (!object || typeof object !== "object") return;
-	    var state = object[DRAFT_STATE];
-	    if (!state) return;
-	    var base_ = state.base_,
-	        draft_ = state.draft_,
-	        assigned_ = state.assigned_,
-	        type_ = state.type_;
-
-	    if (type_ === 4
-	    /* ES5Object */
-	    ) {
-	        // Look for added keys.
-	        // probably there is a faster way to detect changes, as sweep + recurse seems to do some
-	        // unnecessary work.
-	        // also: probably we can store the information we detect here, to speed up tree finalization!
-	        each(draft_, function (key) {
-	          if (key === DRAFT_STATE) return; // The `undefined` check is a fast path for pre-existing keys.
-
-	          if (base_[key] === undefined && !has(base_, key)) {
-	            assigned_[key] = true;
-	            markChanged(state);
-	          } else if (!assigned_[key]) {
-	            // Only untouched properties trigger recursion.
-	            markChangesRecursively(draft_[key]);
-	          }
-	        }); // Look for removed keys.
-
-	        each(base_, function (key) {
-	          // The `undefined` check is a fast path for pre-existing keys.
-	          if (draft_[key] === undefined && !has(draft_, key)) {
-	            assigned_[key] = false;
-	            markChanged(state);
-	          }
-	        });
-	      } else if (type_ === 5
-	    /* ES5Array */
-	    ) {
-	        if (hasArrayChanges(state)) {
-	          markChanged(state);
-	          assigned_.length = true;
-	        }
-
-	        if (draft_.length < base_.length) {
-	          for (var i = draft_.length; i < base_.length; i++) {
-	            assigned_[i] = false;
-	          }
-	        } else {
-	          for (var _i2 = base_.length; _i2 < draft_.length; _i2++) {
-	            assigned_[_i2] = true;
-	          }
-	        } // Minimum count is enough, the other parts has been processed.
-
-
-	        var min = Math.min(draft_.length, base_.length);
-
-	        for (var _i3 = 0; _i3 < min; _i3++) {
-	          // Only untouched indices trigger recursion.
-	          if (!draft_.hasOwnProperty(_i3)) {
-	            assigned_[_i3] = true;
-	          }
-
-	          if (assigned_[_i3] === undefined) markChangesRecursively(draft_[_i3]);
-	        }
-	      }
-	  }
-
-	  function hasObjectChanges(state) {
-	    var base_ = state.base_,
-	        draft_ = state.draft_; // Search for added keys and changed keys. Start at the back, because
-	    // non-numeric keys are ordered by time of definition on the object.
-
-	    var keys = ownKeys(draft_);
-
-	    for (var i = keys.length - 1; i >= 0; i--) {
-	      var key = keys[i];
-	      if (key === DRAFT_STATE) continue;
-	      var baseValue = base_[key]; // The `undefined` check is a fast path for pre-existing keys.
-
-	      if (baseValue === undefined && !has(base_, key)) {
-	        return true;
-	      } // Once a base key is deleted, future changes go undetected, because its
-	      // descriptor is erased. This branch detects any missed changes.
-	      else {
-	          var value = draft_[key];
-
-	          var _state = value && value[DRAFT_STATE];
-
-	          if (_state ? _state.base_ !== baseValue : !is(value, baseValue)) {
-	            return true;
-	          }
-	        }
-	    } // At this point, no keys were added or changed.
-	    // Compare key count to determine if keys were deleted.
-
-
-	    var baseIsDraft = !!base_[DRAFT_STATE];
-	    return keys.length !== ownKeys(base_).length + (baseIsDraft ? 0 : 1); // + 1 to correct for DRAFT_STATE
-	  }
-
-	  function hasArrayChanges(state) {
-	    var draft_ = state.draft_;
-	    if (draft_.length !== state.base_.length) return true; // See #116
-	    // If we first shorten the length, our array interceptors will be removed.
-	    // If after that new items are added, result in the same original length,
-	    // those last items will have no intercepting property.
-	    // So if there is no own descriptor on the last position, we know that items were removed and added
-	    // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check
-	    // the last one
-	    // last descriptor can be not a trap, if the array was extended
-
-	    var descriptor = Object.getOwnPropertyDescriptor(draft_, draft_.length - 1); // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10)
-
-	    if (descriptor && !descriptor.get) return true; // if we miss a property, it has been deleted, so array probobaly changed
-
-	    for (var i = 0; i < draft_.length; i++) {
-	      if (!draft_.hasOwnProperty(i)) return true;
-	    } // For all other cases, we don't have to compare, as they would have been picked up by the index setters
-
-
-	    return false;
-	  }
-
-	  function hasChanges_(state) {
-	    return state.type_ === 4
-	    /* ES5Object */
-	    ? hasObjectChanges(state) : hasArrayChanges(state);
-	  }
-
-	  function assertUnrevoked(state
-	  /*ES5State | MapState | SetState*/
-	  ) {
-	    if (state.revoked_) die(3, JSON.stringify(latest(state)));
-	  }
-
-	  loadPlugin("ES5", {
-	    createES5Proxy_: createES5Proxy_,
-	    willFinalizeES5_: willFinalizeES5_,
-	    hasChanges_: hasChanges_
-	  });
-	}
-
-	function enablePatches() {
-	  var REPLACE = "replace";
-	  var ADD = "add";
-	  var REMOVE = "remove";
-
-	  function generatePatches_(state, basePath, patches, inversePatches) {
-	    switch (state.type_) {
-	      case 0
-	      /* ProxyObject */
-	      :
-	      case 4
-	      /* ES5Object */
-	      :
-	      case 2
-	      /* Map */
-	      :
-	        return generatePatchesFromAssigned(state, basePath, patches, inversePatches);
-
-	      case 5
-	      /* ES5Array */
-	      :
-	      case 1
-	      /* ProxyArray */
-	      :
-	        return generateArrayPatches(state, basePath, patches, inversePatches);
-
-	      case 3
-	      /* Set */
-	      :
-	        return generateSetPatches(state, basePath, patches, inversePatches);
-	    }
-	  }
-
-	  function generateArrayPatches(state, basePath, patches, inversePatches) {
-	    var base_ = state.base_,
-	        assigned_ = state.assigned_;
-	    var copy_ = state.copy_; // Reduce complexity by ensuring `base` is never longer.
-
-	    if (copy_.length < base_.length) {
-	      var _ref = [copy_, base_];
-	      base_ = _ref[0];
-	      copy_ = _ref[1];
-	      var _ref2 = [inversePatches, patches];
-	      patches = _ref2[0];
-	      inversePatches = _ref2[1];
-	    } // Process replaced indices.
-
-
-	    for (var i = 0; i < base_.length; i++) {
-	      if (assigned_[i] && copy_[i] !== base_[i]) {
-	        var path = basePath.concat([i]);
-	        patches.push({
-	          op: REPLACE,
-	          path: path,
-	          // Need to maybe clone it, as it can in fact be the original value
-	          // due to the base/copy inversion at the start of this function
-	          value: clonePatchValueIfNeeded(copy_[i])
-	        });
-	        inversePatches.push({
-	          op: REPLACE,
-	          path: path,
-	          value: clonePatchValueIfNeeded(base_[i])
-	        });
-	      }
-	    } // Process added indices.
-
-
-	    for (var _i = base_.length; _i < copy_.length; _i++) {
-	      var _path = basePath.concat([_i]);
-
-	      patches.push({
-	        op: ADD,
-	        path: _path,
-	        // Need to maybe clone it, as it can in fact be the original value
-	        // due to the base/copy inversion at the start of this function
-	        value: clonePatchValueIfNeeded(copy_[_i])
-	      });
-	    }
-
-	    if (base_.length < copy_.length) {
-	      inversePatches.push({
-	        op: REPLACE,
-	        path: basePath.concat(["length"]),
-	        value: base_.length
-	      });
-	    }
-	  } // This is used for both Map objects and normal objects.
-
-
-	  function generatePatchesFromAssigned(state, basePath, patches, inversePatches) {
-	    var base_ = state.base_,
-	        copy_ = state.copy_;
-	    each(state.assigned_, function (key, assignedValue) {
-	      var origValue = get(base_, key);
-	      var value = get(copy_, key);
-	      var op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD;
-	      if (origValue === value && op === REPLACE) return;
-	      var path = basePath.concat(key);
-	      patches.push(op === REMOVE ? {
-	        op: op,
-	        path: path
-	      } : {
-	        op: op,
-	        path: path,
-	        value: value
-	      });
-	      inversePatches.push(op === ADD ? {
-	        op: REMOVE,
-	        path: path
-	      } : op === REMOVE ? {
-	        op: ADD,
-	        path: path,
-	        value: clonePatchValueIfNeeded(origValue)
-	      } : {
-	        op: REPLACE,
-	        path: path,
-	        value: clonePatchValueIfNeeded(origValue)
-	      });
-	    });
-	  }
-
-	  function generateSetPatches(state, basePath, patches, inversePatches) {
-	    var base_ = state.base_,
-	        copy_ = state.copy_;
-	    var i = 0;
-	    base_.forEach(function (value) {
-	      if (!copy_.has(value)) {
-	        var path = basePath.concat([i]);
-	        patches.push({
-	          op: REMOVE,
-	          path: path,
-	          value: value
-	        });
-	        inversePatches.unshift({
-	          op: ADD,
-	          path: path,
-	          value: value
-	        });
-	      }
-
-	      i++;
-	    });
-	    i = 0;
-	    copy_.forEach(function (value) {
-	      if (!base_.has(value)) {
-	        var path = basePath.concat([i]);
-	        patches.push({
-	          op: ADD,
-	          path: path,
-	          value: value
-	        });
-	        inversePatches.unshift({
-	          op: REMOVE,
-	          path: path,
-	          value: value
-	        });
-	      }
-
-	      i++;
-	    });
-	  }
-
-	  function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) {
-	    patches.push({
-	      op: REPLACE,
-	      path: [],
-	      value: replacement === NOTHING ? undefined : replacement
-	    });
-	    inversePatches.push({
-	      op: REPLACE,
-	      path: [],
-	      value: baseValue
-	    });
-	  }
-
-	  function applyPatches_(draft, patches) {
-	    patches.forEach(function (patch) {
-	      var path = patch.path,
-	          op = patch.op;
-	      var base = draft;
-
-	      for (var i = 0; i < path.length - 1; i++) {
-	        var parentType = getArchtype(base);
-	        var p = path[i];
-
-	        if (typeof p !== "string" && typeof p !== "number") {
-	          p = "" + p;
-	        } // See #738, avoid prototype pollution
-
-
-	        if ((parentType === 0
-	        /* Object */
-	        || parentType === 1
-	        /* Array */
-	        ) && (p === "__proto__" || p === "constructor")) die(24);
-	        if (typeof base === "function" && p === "prototype") die(24);
-	        base = get(base, p);
-	        if (typeof base !== "object") die(15, path.join("/"));
-	      }
-
-	      var type = getArchtype(base);
-	      var value = deepClonePatchValue(patch.value); // used to clone patch to ensure original patch is not modified, see #411
-
-	      var key = path[path.length - 1];
-
-	      switch (op) {
-	        case REPLACE:
-	          switch (type) {
-	            case 2
-	            /* Map */
-	            :
-	              return base.set(key, value);
-
-	            /* istanbul ignore next */
-
-	            case 3
-	            /* Set */
-	            :
-	              die(16);
-
-	            default:
-	              // if value is an object, then it's assigned by reference
-	              // in the following add or remove ops, the value field inside the patch will also be modifyed
-	              // so we use value from the cloned patch
-	              // @ts-ignore
-	              return base[key] = value;
-	          }
-
-	        case ADD:
-	          switch (type) {
-	            case 1
-	            /* Array */
-	            :
-	              return key === "-" ? base.push(value) : base.splice(key, 0, value);
-
-	            case 2
-	            /* Map */
-	            :
-	              return base.set(key, value);
-
-	            case 3
-	            /* Set */
-	            :
-	              return base.add(value);
-
-	            default:
-	              return base[key] = value;
-	          }
-
-	        case REMOVE:
-	          switch (type) {
-	            case 1
-	            /* Array */
-	            :
-	              return base.splice(key, 1);
-
-	            case 2
-	            /* Map */
-	            :
-	              return base.delete(key);
-
-	            case 3
-	            /* Set */
-	            :
-	              return base.delete(patch.value);
-
-	            default:
-	              return delete base[key];
-	          }
-
-	        default:
-	          die(17, op);
-	      }
-	    });
-	    return draft;
-	  }
-
-	  function deepClonePatchValue(obj) {
-	    if (!isDraftable(obj)) return obj;
-	    if (Array.isArray(obj)) return obj.map(deepClonePatchValue);
-	    if (isMap(obj)) return new Map(Array.from(obj.entries()).map(function (_ref3) {
-	      var k = _ref3[0],
-	          v = _ref3[1];
-	      return [k, deepClonePatchValue(v)];
-	    }));
-	    if (isSet(obj)) return new Set(Array.from(obj).map(deepClonePatchValue));
-	    var cloned = Object.create(Object.getPrototypeOf(obj));
-
-	    for (var key in obj) {
-	      cloned[key] = deepClonePatchValue(obj[key]);
-	    }
-
-	    if (has(obj, DRAFTABLE)) cloned[DRAFTABLE] = obj[DRAFTABLE];
-	    return cloned;
-	  }
-
-	  function clonePatchValueIfNeeded(obj) {
-	    if (isDraft(obj)) {
-	      return deepClonePatchValue(obj);
-	    } else return obj;
-	  }
-
-	  loadPlugin("Patches", {
-	    applyPatches_: applyPatches_,
-	    generatePatches_: generatePatches_,
-	    generateReplacementPatches_: generateReplacementPatches_
-	  });
-	}
-
-	// types only!
-	function enableMapSet() {
-	  /* istanbul ignore next */
-	  var _extendStatics = function extendStatics(d, b) {
-	    _extendStatics = Object.setPrototypeOf || {
-	      __proto__: []
-	    } instanceof Array && function (d, b) {
-	      d.__proto__ = b;
-	    } || function (d, b) {
-	      for (var p in b) {
-	        if (b.hasOwnProperty(p)) d[p] = b[p];
-	      }
-	    };
-
-	    return _extendStatics(d, b);
-	  }; // Ugly hack to resolve #502 and inherit built in Map / Set
-
-
-	  function __extends(d, b) {
-	    _extendStatics(d, b);
-
-	    function __() {
-	      this.constructor = d;
-	    }
-
-	    d.prototype = ( // @ts-ignore
-	    __.prototype = b.prototype, new __());
-	  }
-
-	  var DraftMap = function (_super) {
-	    __extends(DraftMap, _super); // Create class manually, cause #502
-
-
-	    function DraftMap(target, parent) {
-	      this[DRAFT_STATE] = {
-	        type_: 2
-	        /* Map */
-	        ,
-	        parent_: parent,
-	        scope_: parent ? parent.scope_ : getCurrentScope(),
-	        modified_: false,
-	        finalized_: false,
-	        copy_: undefined,
-	        assigned_: undefined,
-	        base_: target,
-	        draft_: this,
-	        isManual_: false,
-	        revoked_: false
-	      };
-	      return this;
-	    }
-
-	    var p = DraftMap.prototype;
-	    Object.defineProperty(p, "size", {
-	      get: function get() {
-	        return latest(this[DRAFT_STATE]).size;
-	      } // enumerable: false,
-	      // configurable: true
-
-	    });
-
-	    p.has = function (key) {
-	      return latest(this[DRAFT_STATE]).has(key);
-	    };
-
-	    p.set = function (key, value) {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-
-	      if (!latest(state).has(key) || latest(state).get(key) !== value) {
-	        prepareMapCopy(state);
-	        markChanged(state);
-	        state.assigned_.set(key, true);
-	        state.copy_.set(key, value);
-	        state.assigned_.set(key, true);
-	      }
-
-	      return this;
-	    };
-
-	    p.delete = function (key) {
-	      if (!this.has(key)) {
-	        return false;
-	      }
-
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-	      prepareMapCopy(state);
-	      markChanged(state);
-
-	      if (state.base_.has(key)) {
-	        state.assigned_.set(key, false);
-	      } else {
-	        state.assigned_.delete(key);
-	      }
-
-	      state.copy_.delete(key);
-	      return true;
-	    };
-
-	    p.clear = function () {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-
-	      if (latest(state).size) {
-	        prepareMapCopy(state);
-	        markChanged(state);
-	        state.assigned_ = new Map();
-	        each(state.base_, function (key) {
-	          state.assigned_.set(key, false);
-	        });
-	        state.copy_.clear();
-	      }
-	    };
-
-	    p.forEach = function (cb, thisArg) {
-	      var _this = this;
-
-	      var state = this[DRAFT_STATE];
-	      latest(state).forEach(function (_value, key, _map) {
-	        cb.call(thisArg, _this.get(key), key, _this);
-	      });
-	    };
-
-	    p.get = function (key) {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-	      var value = latest(state).get(key);
-
-	      if (state.finalized_ || !isDraftable(value)) {
-	        return value;
-	      }
-
-	      if (value !== state.base_.get(key)) {
-	        return value; // either already drafted or reassigned
-	      } // despite what it looks, this creates a draft only once, see above condition
-
-
-	      var draft = createProxy(state.scope_.immer_, value, state);
-	      prepareMapCopy(state);
-	      state.copy_.set(key, draft);
-	      return draft;
-	    };
-
-	    p.keys = function () {
-	      return latest(this[DRAFT_STATE]).keys();
-	    };
-
-	    p.values = function () {
-	      var _this2 = this,
-	          _ref;
-
-	      var iterator = this.keys();
-	      return _ref = {}, _ref[iteratorSymbol] = function () {
-	        return _this2.values();
-	      }, _ref.next = function next() {
-	        var r = iterator.next();
-	        /* istanbul ignore next */
-
-	        if (r.done) return r;
-
-	        var value = _this2.get(r.value);
-
-	        return {
-	          done: false,
-	          value: value
-	        };
-	      }, _ref;
-	    };
-
-	    p.entries = function () {
-	      var _this3 = this,
-	          _ref2;
-
-	      var iterator = this.keys();
-	      return _ref2 = {}, _ref2[iteratorSymbol] = function () {
-	        return _this3.entries();
-	      }, _ref2.next = function next() {
-	        var r = iterator.next();
-	        /* istanbul ignore next */
-
-	        if (r.done) return r;
-
-	        var value = _this3.get(r.value);
-
-	        return {
-	          done: false,
-	          value: [r.value, value]
-	        };
-	      }, _ref2;
-	    };
-
-	    p[iteratorSymbol] = function () {
-	      return this.entries();
-	    };
-
-	    return DraftMap;
-	  }(Map);
-
-	  function proxyMap_(target, parent) {
-	    // @ts-ignore
-	    return new DraftMap(target, parent);
-	  }
-
-	  function prepareMapCopy(state) {
-	    if (!state.copy_) {
-	      state.assigned_ = new Map();
-	      state.copy_ = new Map(state.base_);
-	    }
-	  }
-
-	  var DraftSet = function (_super) {
-	    __extends(DraftSet, _super); // Create class manually, cause #502
-
-
-	    function DraftSet(target, parent) {
-	      this[DRAFT_STATE] = {
-	        type_: 3
-	        /* Set */
-	        ,
-	        parent_: parent,
-	        scope_: parent ? parent.scope_ : getCurrentScope(),
-	        modified_: false,
-	        finalized_: false,
-	        copy_: undefined,
-	        base_: target,
-	        draft_: this,
-	        drafts_: new Map(),
-	        revoked_: false,
-	        isManual_: false
-	      };
-	      return this;
-	    }
-
-	    var p = DraftSet.prototype;
-	    Object.defineProperty(p, "size", {
-	      get: function get() {
-	        return latest(this[DRAFT_STATE]).size;
-	      } // enumerable: true,
-
-	    });
-
-	    p.has = function (value) {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state); // bit of trickery here, to be able to recognize both the value, and the draft of its value
-
-	      if (!state.copy_) {
-	        return state.base_.has(value);
-	      }
-
-	      if (state.copy_.has(value)) return true;
-	      if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) return true;
-	      return false;
-	    };
-
-	    p.add = function (value) {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-
-	      if (!this.has(value)) {
-	        prepareSetCopy(state);
-	        markChanged(state);
-	        state.copy_.add(value);
-	      }
-
-	      return this;
-	    };
-
-	    p.delete = function (value) {
-	      if (!this.has(value)) {
-	        return false;
-	      }
-
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-	      prepareSetCopy(state);
-	      markChanged(state);
-	      return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) :
-	      /* istanbul ignore next */
-	      false);
-	    };
-
-	    p.clear = function () {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-
-	      if (latest(state).size) {
-	        prepareSetCopy(state);
-	        markChanged(state);
-	        state.copy_.clear();
-	      }
-	    };
-
-	    p.values = function () {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-	      prepareSetCopy(state);
-	      return state.copy_.values();
-	    };
-
-	    p.entries = function entries() {
-	      var state = this[DRAFT_STATE];
-	      assertUnrevoked(state);
-	      prepareSetCopy(state);
-	      return state.copy_.entries();
-	    };
-
-	    p.keys = function () {
-	      return this.values();
-	    };
-
-	    p[iteratorSymbol] = function () {
-	      return this.values();
-	    };
-
-	    p.forEach = function forEach(cb, thisArg) {
-	      var iterator = this.values();
-	      var result = iterator.next();
-
-	      while (!result.done) {
-	        cb.call(thisArg, result.value, result.value, this);
-	        result = iterator.next();
-	      }
-	    };
-
-	    return DraftSet;
-	  }(Set);
-
-	  function proxySet_(target, parent) {
-	    // @ts-ignore
-	    return new DraftSet(target, parent);
-	  }
-
-	  function prepareSetCopy(state) {
-	    if (!state.copy_) {
-	      // create drafts for all entries to preserve insertion order
-	      state.copy_ = new Set();
-	      state.base_.forEach(function (value) {
-	        if (isDraftable(value)) {
-	          var draft = createProxy(state.scope_.immer_, value, state);
-	          state.drafts_.set(value, draft);
-	          state.copy_.add(draft);
-	        } else {
-	          state.copy_.add(value);
-	        }
-	      });
-	    }
-	  }
-
-	  function assertUnrevoked(state
-	  /*ES5State | MapState | SetState*/
-	  ) {
-	    if (state.revoked_) die(3, JSON.stringify(latest(state)));
-	  }
-
-	  loadPlugin("MapSet", {
-	    proxyMap_: proxyMap_,
-	    proxySet_: proxySet_
-	  });
-	}
-
-	function enableAllPlugins() {
-	  enableES5();
-	  enableMapSet();
-	  enablePatches();
-	}
-
-	var immer =
-	/*#__PURE__*/
-	new Immer();
-	/**
-	 * The `produce` function takes a value and a "recipe function" (whose
-	 * return value often depends on the base state). The recipe function is
-	 * free to mutate its first argument however it wants. All mutations are
-	 * only ever applied to a __copy__ of the base state.
-	 *
-	 * Pass only a function to create a "curried producer" which relieves you
-	 * from passing the recipe function every time.
-	 *
-	 * Only plain objects and arrays are made mutable. All other objects are
-	 * considered uncopyable.
-	 *
-	 * Note: This function is __bound__ to its `Immer` instance.
-	 *
-	 * @param {any} base - the initial state
-	 * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified
-	 * @param {Function} patchListener - optional function that will be called with all the patches produced here
-	 * @returns {any} a new state, or the initial state if nothing was modified
-	 */
-
-	var produce = immer.produce;
-	/**
-	 * Like `produce`, but `produceWithPatches` always returns a tuple
-	 * [nextState, patches, inversePatches] (instead of just the next state)
-	 */
-
-	var produceWithPatches =
-	/*#__PURE__*/
-	immer.produceWithPatches.bind(immer);
-	/**
-	 * Pass true to automatically freeze all copies created by Immer.
-	 *
-	 * Always freeze by default, even in production mode
-	 */
-
-	var setAutoFreeze =
-	/*#__PURE__*/
-	immer.setAutoFreeze.bind(immer);
-	/**
-	 * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
-	 * always faster than using ES5 proxies.
-	 *
-	 * By default, feature detection is used, so calling this is rarely necessary.
-	 */
-
-	var setUseProxies =
-	/*#__PURE__*/
-	immer.setUseProxies.bind(immer);
-	/**
-	 * Apply an array of Immer patches to the first argument.
-	 *
-	 * This function is a producer, which means copy-on-write is in effect.
-	 */
-
-	var applyPatches =
-	/*#__PURE__*/
-	immer.applyPatches.bind(immer);
-	/**
-	 * Create an Immer draft from the given base state, which may be a draft itself.
-	 * The draft can be modified until you finalize it with the `finishDraft` function.
-	 */
-
-	var createDraft =
-	/*#__PURE__*/
-	immer.createDraft.bind(immer);
-	/**
-	 * Finalize an Immer draft from a `createDraft` call, returning the base state
-	 * (if no changes were made) or a modified copy. The draft must *not* be
-	 * mutated afterwards.
-	 *
-	 * Pass a function as the 2nd argument to generate Immer patches based on the
-	 * changes that were made.
-	 */
-
-	var finishDraft =
-	/*#__PURE__*/
-	immer.finishDraft.bind(immer);
-	/**
-	 * This function is actually a no-op, but can be used to cast an immutable type
-	 * to an draft type and make TypeScript happy
-	 *
-	 * @param value
-	 */
-
-	function castDraft(value) {
-	  return value;
-	}
-	/**
-	 * This function is actually a no-op, but can be used to cast a mutable type
-	 * to an immutable type and make TypeScript happy
-	 * @param value
-	 */
-
-	function castImmutable(value) {
-	  return value;
-	}
-
-	immer_cjs_development.Immer = Immer;
-	immer_cjs_development.applyPatches = applyPatches;
-	immer_cjs_development.castDraft = castDraft;
-	immer_cjs_development.castImmutable = castImmutable;
-	immer_cjs_development.createDraft = createDraft;
-	immer_cjs_development.current = current;
-	immer_cjs_development.default = produce;
-	immer_cjs_development.enableAllPlugins = enableAllPlugins;
-	immer_cjs_development.enableES5 = enableES5;
-	immer_cjs_development.enableMapSet = enableMapSet;
-	immer_cjs_development.enablePatches = enablePatches;
-	immer_cjs_development.finishDraft = finishDraft;
-	immer_cjs_development.freeze = freeze;
-	immer_cjs_development.immerable = DRAFTABLE;
-	immer_cjs_development.isDraft = isDraft;
-	immer_cjs_development.isDraftable = isDraftable;
-	immer_cjs_development.nothing = NOTHING;
-	immer_cjs_development.original = original;
-	immer_cjs_development.produce = produce;
-	immer_cjs_development.produceWithPatches = produceWithPatches;
-	immer_cjs_development.setAutoFreeze = setAutoFreeze;
-	immer_cjs_development.setUseProxies = setUseProxies;
-	
-	return immer_cjs_development;
-}
-
-export { requireImmer_cjs_development as __require };
-//# sourceMappingURL=immer.cjs.development.js.map