mobx 6.12.4 → 6.13.0

package/dist/mobx.esm.development.js

@@ -203,10 +203,16 @@ function createInstanceofPredicate(name, theClass) {
   };
 }
 function isES6Map(thing) {
-  return thing instanceof Map;
+  return thing != null && Object.prototype.toString.call(thing) === "[object Map]";
+}
+function isPlainES6Map(thing) {
+  var mapProto = Object.getPrototypeOf(thing);
+  var objectProto = Object.getPrototypeOf(mapProto);
+  var nullProto = Object.getPrototypeOf(objectProto);
+  return nullProto === null;
 }
 function isES6Set(thing) {
-  return thing instanceof Set;
+  return thing != null && Object.prototype.toString.call(thing) === "[object Set]";
 }
 var hasGetOwnPropertySymbols = typeof Object.getOwnPropertySymbols !== "undefined";
 /**
@@ -257,99 +263,76 @@ var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function get
   return res;
 };
 
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
-  }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
-}
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-  _setPrototypeOf(subClass, superClass);
-}
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
-}
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return self;
-}
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (it) return (it = it.call(o)).next.bind(it);
-  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-    if (it) o = it;
-    var i = 0;
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+    t && (r = t);
+    var o = 0;
     return function () {
-      if (i >= o.length) return {
-        done: true
-      };
-      return {
-        done: false,
-        value: o[i++]
+      return o >= r.length ? {
+        done: !0
+      } : {
+        done: !1,
+        value: r[o++]
       };
     };
   }
   throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
 }
 
 var storedAnnotationsSymbol = /*#__PURE__*/Symbol("mobx-stored-annotations");
@@ -422,8 +405,6 @@ function assert20223DecoratorType(context, types) {
 
 var $mobx = /*#__PURE__*/Symbol("mobx administration");
 var Atom = /*#__PURE__*/function () {
-  // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
-
   /**
    * Create a new atom. For debugging purposes it is recommended to give it a name.
    * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
@@ -434,16 +415,18 @@ var Atom = /*#__PURE__*/function () {
     }
     this.name_ = void 0;
     this.isPendingUnobservation = false;
+    // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
     this.isBeingObserved = false;
     this.observers_ = new Set();
     this.diffValue_ = 0;
     this.lastAccessedBy_ = 0;
     this.lowestObserverState_ = IDerivationState_.NOT_TRACKING_;
+    // onBecomeObservedListeners
     this.onBOL = void 0;
+    // onBecomeUnobservedListeners
     this.onBUOL = void 0;
     this.name_ = name_;
   }
-  // onBecomeObservedListeners
   var _proto = Atom.prototype;
   _proto.onBO = function onBO() {
     if (this.onBOL) {
@@ -625,7 +608,6 @@ function make_(adm, key) {
   }
   return 0 /* MakeResult.Cancel */;
 }
-
 function extend_(adm, key, descriptor, proxyTrap) {
   die("'" + this.annotationType_ + "' can only be used with 'makeObservable'");
 }
@@ -658,12 +640,10 @@ function make_$1(adm, key, descriptor, source) {
     // rest of the proto chain must be annotated already
     return 1 /* MakeResult.Break */;
   }
-
   var actionDescriptor = createActionDescriptor(adm, this, key, descriptor, false);
   defineProperty(source, key, actionDescriptor);
   return 2 /* MakeResult.Continue */;
 }
-
 function extend_$1(adm, key, descriptor, proxyTrap) {
   var actionDescriptor = createActionDescriptor(adm, this, key, descriptor);
   return adm.defineProperty_(key, actionDescriptor, proxyTrap);
@@ -761,18 +741,15 @@ function make_$2(adm, key, descriptor, source) {
       return 0 /* MakeResult.Cancel */;
     }
   }
-
   if (isFlow(descriptor.value)) {
     // A prototype could have been annotated already by other constructor,
     // rest of the proto chain must be annotated already
     return 1 /* MakeResult.Break */;
   }
-
   var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false, false);
   defineProperty(source, key, flowDescriptor);
   return 2 /* MakeResult.Continue */;
 }
-
 function extend_$2(adm, key, descriptor, proxyTrap) {
   var _this$options_2;
   var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, (_this$options_2 = this.options_) == null ? void 0 : _this$options_2.bound);
@@ -849,7 +826,6 @@ function createComputedAnnotation(name, options) {
 function make_$3(adm, key, descriptor) {
   return this.extend_(adm, key, descriptor, false) === null ? 0 /* MakeResult.Cancel */ : 1 /* MakeResult.Break */;
 }
-
 function extend_$3(adm, key, descriptor, proxyTrap) {
   assertComputedDescriptor(adm, this, key, descriptor);
   return adm.defineComputedProperty_(key, _extends({}, this.options_, {
@@ -897,7 +873,6 @@ function createObservableAnnotation(name, options) {
 function make_$4(adm, key, descriptor) {
   return this.extend_(adm, key, descriptor, false) === null ? 0 /* MakeResult.Cancel */ : 1 /* MakeResult.Break */;
 }
-
 function extend_$4(adm, key, descriptor, proxyTrap) {
   var _this$options_$enhanc, _this$options_;
   assertObservableDescriptor(adm, this, key, descriptor);
@@ -1317,11 +1292,8 @@ function allowStateChangesEnd(prev) {
   globalState.allowStateChanges = prev;
 }
 
-var _Symbol$toPrimitive;
 var CREATE = "create";
-_Symbol$toPrimitive = Symbol.toPrimitive;
 var ObservableValue = /*#__PURE__*/function (_Atom) {
-  _inheritsLoose(ObservableValue, _Atom);
   function ObservableValue(value, enhancer, name_, notifySpy, equals) {
     var _this;
     if (name_ === void 0) {
@@ -1350,7 +1322,7 @@ var ObservableValue = /*#__PURE__*/function (_Atom) {
       // only notify spy if this is a stand-alone observable
       spyReport({
         type: CREATE,
-        object: _assertThisInitialized(_this),
+        object: _this,
         observableKind: "value",
         debugObjectName: _this.name_,
         newValue: "" + _this.value_
@@ -1358,6 +1330,7 @@ var ObservableValue = /*#__PURE__*/function (_Atom) {
     }
     return _this;
   }
+  _inheritsLoose(ObservableValue, _Atom);
   var _proto = ObservableValue.prototype;
   _proto.dehanceValue = function dehanceValue(value) {
     if (this.dehancer !== undefined) {
@@ -1449,14 +1422,13 @@ var ObservableValue = /*#__PURE__*/function (_Atom) {
   _proto.valueOf = function valueOf() {
     return toPrimitive(this.get());
   };
-  _proto[_Symbol$toPrimitive] = function () {
+  _proto[Symbol.toPrimitive] = function () {
     return this.valueOf();
   };
   return ObservableValue;
 }(Atom);
 var isObservableValue = /*#__PURE__*/createInstanceofPredicate("ObservableValue", ObservableValue);
 
-var _Symbol$toPrimitive$1;
 function getFlag(flags, mask) {
   return !!(flags & mask);
 }
@@ -1487,13 +1459,7 @@ function setFlag(flags, mask, newValue) {
  *
  * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
  */
-_Symbol$toPrimitive$1 = Symbol.toPrimitive;
 var ComputedValue = /*#__PURE__*/function () {
-  // nodes we are looking at. Our value depends on these nodes
-  // during tracking it's an array with new observed observers
-
-  // N.B: unminified as it is used by MST
-
   /**
    * Create a new computed value based on a function expression.
    *
@@ -1509,7 +1475,9 @@ var ComputedValue = /*#__PURE__*/function () {
   function ComputedValue(options) {
     this.dependenciesState_ = IDerivationState_.NOT_TRACKING_;
     this.observing_ = [];
+    // nodes we are looking at. Our value depends on these nodes
     this.newObserving_ = null;
+    // during tracking it's an array with new observed observers
     this.observers_ = new Set();
     this.diffValue_ = 0;
     this.runId_ = 0;
@@ -1521,6 +1489,7 @@ var ComputedValue = /*#__PURE__*/function () {
     this.triggeredBy_ = void 0;
     this.flags_ = 0;
     this.derivation = void 0;
+    // N.B: unminified as it is used by MST
     this.setter_ = void 0;
     this.isTracing_ = TraceMode.NONE;
     this.scope_ = void 0;
@@ -1702,10 +1671,10 @@ var ComputedValue = /*#__PURE__*/function () {
   _proto.valueOf = function valueOf() {
     return toPrimitive(this.get());
   };
-  _proto[_Symbol$toPrimitive$1] = function () {
+  _proto[Symbol.toPrimitive] = function () {
     return this.valueOf();
   };
-  _createClass(ComputedValue, [{
+  return _createClass(ComputedValue, [{
     key: "isComputing",
     get: function get() {
       return getFlag(this.flags_, ComputedValue.isComputingMask_);
@@ -1738,7 +1707,6 @@ var ComputedValue = /*#__PURE__*/function () {
       this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue);
     }
   }]);
-  return ComputedValue;
 }();
 ComputedValue.isComputingMask_ = 1;
 ComputedValue.isRunningSetterMask_ = 2;
@@ -1777,7 +1745,6 @@ var CaughtException = function CaughtException(cause) {
   this.cause = cause;
   // Empty
 };
-
 function isCaughtException(e) {
   return e instanceof CaughtException;
 }
@@ -1841,7 +1808,6 @@ function shouldCompute(derivation) {
 function isComputingDerivation() {
   return globalState.trackingDerivation !== null; // filter out actions inside computations
 }
-
 function checkIfStateModificationsAreAllowed(atom) {
   var hasObservers = atom.observers_.size > 0;
   // Should not be possible to change observed state outside strict mode, except during initialization, see #563
@@ -2012,28 +1978,113 @@ function changeDependenciesStateTo0(derivation) {
  */
 var persistentKeys = ["mobxGuid", "spyListeners", "enforceActions", "computedRequiresReaction", "reactionRequiresObservable", "observableRequiresReaction", "allowStateReads", "disableErrorBoundaries", "runId", "UNCHANGED", "useProxies"];
 var MobXGlobals = function MobXGlobals() {
+  /**
+   * MobXGlobals version.
+   * MobX compatiblity with other versions loaded in memory as long as this version matches.
+   * It indicates that the global state still stores similar information
+   *
+   * N.B: this version is unrelated to the package version of MobX, and is only the version of the
+   * internal state storage of MobX, and can be the same across many different package versions
+   */
   this.version = 6;
+  /**
+   * globally unique token to signal unchanged
+   */
   this.UNCHANGED = {};
+  /**
+   * Currently running derivation
+   */
   this.trackingDerivation = null;
+  /**
+   * Currently running reaction. This determines if we currently have a reactive context.
+   * (Tracking derivation is also set for temporal tracking of computed values inside actions,
+   * but trackingReaction can only be set by a form of Reaction)
+   */
   this.trackingContext = null;
+  /**
+   * Each time a derivation is tracked, it is assigned a unique run-id
+   */
   this.runId = 0;
+  /**
+   * 'guid' for general purpose. Will be persisted amongst resets.
+   */
   this.mobxGuid = 0;
+  /**
+   * Are we in a batch block? (and how many of them)
+   */
   this.inBatch = 0;
+  /**
+   * Observables that don't have observers anymore, and are about to be
+   * suspended, unless somebody else accesses it in the same batch
+   *
+   * @type {IObservable[]}
+   */
   this.pendingUnobservations = [];
+  /**
+   * List of scheduled, not yet executed, reactions.
+   */
   this.pendingReactions = [];
+  /**
+   * Are we currently processing reactions?
+   */
   this.isRunningReactions = false;
+  /**
+   * Is it allowed to change observables at this point?
+   * In general, MobX doesn't allow that when running computations and React.render.
+   * To ensure that those functions stay pure.
+   */
   this.allowStateChanges = false;
+  /**
+   * Is it allowed to read observables at this point?
+   * Used to hold the state needed for `observableRequiresReaction`
+   */
   this.allowStateReads = true;
+  /**
+   * If strict mode is enabled, state changes are by default not allowed
+   */
   this.enforceActions = true;
+  /**
+   * Spy callbacks
+   */
   this.spyListeners = [];
+  /**
+   * Globally attached error handlers that react specifically to errors in reactions
+   */
   this.globalReactionErrorHandlers = [];
+  /**
+   * Warn if computed values are accessed outside a reactive context
+   */
   this.computedRequiresReaction = false;
+  /**
+   * (Experimental)
+   * Warn if you try to create to derivation / reactive context without accessing any observable.
+   */
   this.reactionRequiresObservable = false;
+  /**
+   * (Experimental)
+   * Warn if observables are accessed outside a reactive context
+   */
   this.observableRequiresReaction = false;
+  /*
+   * Don't catch and rethrow exceptions. This is useful for inspecting the state of
+   * the stack when an exception occurs while debugging.
+   */
   this.disableErrorBoundaries = false;
+  /*
+   * If true, we are already handling an exception in an action. Any errors in reactions should be suppressed, as
+   * they are not the cause, see: https://github.com/mobxjs/mobx/issues/1836
+   */
   this.suppressReactionErrors = false;
   this.useProxies = true;
+  /*
+   * print warnings about code that would fail if proxies weren't available
+   */
   this.verifyProxies = false;
+  /**
+   * False forces all object's descriptors to
+   * writable: true
+   * configurable: true
+   */
   this.safeDescriptors = true;
 };
 var canMergeGlobalState = true;
@@ -2130,7 +2181,6 @@ function addObserver(observable, node) {
   // invariantObservers(observable);
   // invariant(observable._observers.indexOf(node) !== -1, "INTERNAL ERROR didn't add node");
 }
-
 function removeObserver(observable, node) {
   // invariant(globalState.inBatch > 0, "INTERNAL ERROR, remove should be called only inside batch");
   // invariant(observable._observers.indexOf(node) !== -1, "INTERNAL ERROR remove already removed node");
@@ -2143,7 +2193,6 @@ function removeObserver(observable, node) {
   // invariantObservers(observable);
   // invariant(observable._observers.indexOf(node) === -1, "INTERNAL ERROR remove already removed node2");
 }
-
 function queueForUnobservation(observable) {
   if (observable.isPendingUnobservation === false) {
     // invariant(observable._observers.length === 0, "INTERNAL ERROR, should only queue for unobservation unobserved observables");
@@ -2281,7 +2330,6 @@ function propagateMaybeChanged(observable) {
   });
   // invariantLOS(observable, "maybe end");
 }
-
 function logTraceInfo(derivation, observable) {
   console.log("[mobx.trace] '" + derivation.name_ + "' is invalidated due to a change in: '" + observable.name_ + "'");
   if (derivation.isTracing_ === TraceMode.BREAK) {
@@ -2305,8 +2353,6 @@ function printDepTree(tree, lines, depth) {
 }
 
 var Reaction = /*#__PURE__*/function () {
-  // nodes we are looking at. Our value depends on these nodes
-
   function Reaction(name_, onInvalidate_, errorHandler_, requiresObservable_) {
     if (name_ === void 0) {
       name_ =  "Reaction@" + getNextId() ;
@@ -2316,6 +2362,7 @@ var Reaction = /*#__PURE__*/function () {
     this.errorHandler_ = void 0;
     this.requiresObservable_ = void 0;
     this.observing_ = [];
+    // nodes we are looking at. Our value depends on these nodes
     this.newObserving_ = [];
     this.dependenciesState_ = IDerivationState_.NOT_TRACKING_;
     this.diffValue_ = 0;
@@ -2378,7 +2425,6 @@ var Reaction = /*#__PURE__*/function () {
       return;
       // console.warn("Reaction already disposed") // Note: Not a warning / error in mobx 4 either
     }
-
     startBatch();
     var notify = isSpyEnabled();
     var startTime;
@@ -2453,9 +2499,9 @@ var Reaction = /*#__PURE__*/function () {
     var _this2 = this;
     var dispose = function dispose() {
       _this2.dispose();
-      abortSignal == null ? void 0 : abortSignal.removeEventListener == null ? void 0 : abortSignal.removeEventListener("abort", dispose);
+      abortSignal == null || abortSignal.removeEventListener == null || abortSignal.removeEventListener("abort", dispose);
     };
-    abortSignal == null ? void 0 : abortSignal.addEventListener == null ? void 0 : abortSignal.addEventListener("abort", dispose);
+    abortSignal == null || abortSignal.addEventListener == null || abortSignal.addEventListener("abort", dispose);
     dispose[$mobx] = this;
     return dispose;
   };
@@ -2507,7 +2553,6 @@ function runReactionsHelper() {
       console.error( "Reaction doesn't converge to a stable state after " + MAX_REACTION_ITERATIONS + " iterations." + (" Probably there is a cycle in the reactive function: " + allReactions[0]) );
       allReactions.splice(0); // clear reactions
     }
-
     var remainingReactions = allReactions.splice(0);
     for (var i = 0, l = remainingReactions.length; i < l; i++) {
       remainingReactions[i].runReaction_();
@@ -2635,7 +2680,7 @@ function isAction(thing) {
  * @returns disposer function, which can be used to stop the view from being updated in the future.
  */
 function autorun(view, opts) {
-  var _opts$name, _opts, _opts2, _opts2$signal, _opts3;
+  var _opts$name, _opts, _opts2, _opts3;
   if (opts === void 0) {
     opts = EMPTY_OBJECT;
   }
@@ -2674,7 +2719,7 @@ function autorun(view, opts) {
   function reactionRunner() {
     view(reaction);
   }
-  if (!((_opts2 = opts) != null && (_opts2$signal = _opts2.signal) != null && _opts2$signal.aborted)) {
+  if (!((_opts2 = opts) != null && (_opts2 = _opts2.signal) != null && _opts2.aborted)) {
     reaction.schedule_();
   }
   return reaction.getDisposer_((_opts3 = opts) == null ? void 0 : _opts3.signal);
@@ -2688,7 +2733,7 @@ function createSchedulerFromOptions(opts) {
   } : run;
 }
 function reaction(expression, effect, opts) {
-  var _opts$name2, _opts4, _opts4$signal, _opts5;
+  var _opts$name2, _opts4, _opts5;
   if (opts === void 0) {
     opts = EMPTY_OBJECT;
   }
@@ -2737,7 +2782,7 @@ function reaction(expression, effect, opts) {
     }
     firstTime = false;
   }
-  if (!((_opts4 = opts) != null && (_opts4$signal = _opts4.signal) != null && _opts4$signal.aborted)) {
+  if (!((_opts4 = opts) != null && (_opts4 = _opts4.signal) != null && _opts4.aborted)) {
     r.schedule_();
   }
   return r.getDisposer_((_opts5 = opts) == null ? void 0 : _opts5.signal);
@@ -2946,7 +2991,6 @@ var flow = /*#__PURE__*/Object.assign(function flow(arg1, arg2) {
       }
       onFulfilled(undefined); // kick off the process
     });
-
     promise.cancel = action(name + " - runid: " + runId + " - cancel", function () {
       try {
         if (pendingPromise) {
@@ -2964,7 +3008,6 @@ var flow = /*#__PURE__*/Object.assign(function flow(arg1, arg2) {
         rejector(e); // there could be a throwing finally block
       }
     });
-
     return promise;
   };
   res.isMobXFlow = true;
@@ -2979,7 +3022,6 @@ function cancelPromise(promise) {
 function flowResult(result) {
   return result; // just tricking TypeScript :)
 }
-
 function isFlow(fn) {
   return (fn == null ? void 0 : fn.isMobXFlow) === true;
 }
@@ -3401,10 +3443,10 @@ function whenPromise(predicate, opts) {
       disposer();
       reject(new Error("WHEN_ABORTED"));
     };
-    opts == null ? void 0 : (_opts$signal2 = opts.signal) == null ? void 0 : _opts$signal2.addEventListener == null ? void 0 : _opts$signal2.addEventListener("abort", abort);
+    opts == null || (_opts$signal2 = opts.signal) == null || _opts$signal2.addEventListener == null || _opts$signal2.addEventListener("abort", abort);
   })["finally"](function () {
     var _opts$signal3;
-    return opts == null ? void 0 : (_opts$signal3 = opts.signal) == null ? void 0 : _opts$signal3.removeEventListener == null ? void 0 : _opts$signal3.removeEventListener("abort", abort);
+    return opts == null || (_opts$signal3 = opts.signal) == null || _opts$signal3.removeEventListener == null ? void 0 : _opts$signal3.removeEventListener("abort", abort);
   });
   res.cancel = cancel;
   return res;
@@ -3621,8 +3663,6 @@ var arrayTraps = {
   }
 };
 var ObservableArrayAdministration = /*#__PURE__*/function () {
-  // this is the prop that gets proxied, so can't replace it!
-
   function ObservableArrayAdministration(name, enhancer, owned_, legacyMode_) {
     if (name === void 0) {
       name =  "ObservableArray@" + getNextId() ;
@@ -3631,6 +3671,7 @@ var ObservableArrayAdministration = /*#__PURE__*/function () {
     this.legacyMode_ = void 0;
     this.atom_ = void 0;
     this.values_ = [];
+    // this is the prop that gets proxied, so can't replace it!
     this.interceptors_ = void 0;
     this.changeListeners_ = void 0;
     this.enhancer_ = void 0;
@@ -3751,7 +3792,6 @@ var ObservableArrayAdministration = /*#__PURE__*/function () {
       var lengthDelta = newItems.length - deleteCount;
       this.updateArrayLength_(length, lengthDelta); // checks if internal array wasn't modified
     }
-
     var res = this.spliceItemsIntoValues_(index, deleteCount, newItems);
     if (deleteCount !== 0 || newItems.length !== 0) {
       this.notifyArraySplice_(index, newItems, res);
@@ -3851,6 +3891,7 @@ var ObservableArrayAdministration = /*#__PURE__*/function () {
         var change = interceptChange(this, {
           type: UPDATE,
           object: this.proxy_,
+          // since "this" is the real array we need to pass its proxy
           index: index,
           newValue: newValue
         });
@@ -4066,17 +4107,12 @@ function isObservableArray(thing) {
   return isObject(thing) && isObservableArrayAdministration(thing[$mobx]);
 }
 
-var _Symbol$iterator, _Symbol$toStringTag;
 var ObservableMapMarker = {};
 var ADD = "add";
 var DELETE = "delete";
 // just extend Map? See also https://gist.github.com/nestharus/13b4d74f2ef4a2f4357dbd3fc23c1e54
 // But: https://github.com/mobxjs/mobx/issues/1556
-_Symbol$iterator = Symbol.iterator;
-_Symbol$toStringTag = Symbol.toStringTag;
 var ObservableMap = /*#__PURE__*/function () {
-  // hasMap, not hashMap >-).
-
   function ObservableMap(initialData, enhancer_, name_) {
     var _this = this;
     if (enhancer_ === void 0) {
@@ -4090,6 +4126,7 @@ var ObservableMap = /*#__PURE__*/function () {
     this[$mobx] = ObservableMapMarker;
     this.data_ = void 0;
     this.hasMap_ = void 0;
+    // hasMap, not hashMap >-).
     this.keysAtom_ = void 0;
     this.interceptors_ = void 0;
     this.changeListeners_ = void 0;
@@ -4178,7 +4215,7 @@ var ObservableMap = /*#__PURE__*/function () {
       transaction(function () {
         var _this3$hasMap_$get;
         _this3.keysAtom_.reportChanged();
-        (_this3$hasMap_$get = _this3.hasMap_.get(key)) == null ? void 0 : _this3$hasMap_$get.setNewValue_(false);
+        (_this3$hasMap_$get = _this3.hasMap_.get(key)) == null || _this3$hasMap_$get.setNewValue_(false);
         var observable = _this3.data_.get(key);
         observable.setNewValue_(undefined);
         _this3.data_["delete"](key);
@@ -4228,7 +4265,7 @@ var ObservableMap = /*#__PURE__*/function () {
       var observable = new ObservableValue(newValue, _this4.enhancer_,  _this4.name_ + "." + stringifyKey(key) , false);
       _this4.data_.set(key, observable);
       newValue = observable.value_; // value might have been changed
-      (_this4$hasMap_$get = _this4.hasMap_.get(key)) == null ? void 0 : _this4$hasMap_$get.setNewValue_(true);
+      (_this4$hasMap_$get = _this4.hasMap_.get(key)) == null || _this4$hasMap_$get.setNewValue_(true);
       _this4.keysAtom_.reportChanged();
     });
     var notifySpy = isSpyEnabled();
@@ -4297,7 +4334,7 @@ var ObservableMap = /*#__PURE__*/function () {
       }
     });
   };
-  _proto[_Symbol$iterator] = function () {
+  _proto[Symbol.iterator] = function () {
     return this.entries();
   };
   _proto.forEach = function forEach(callback, thisArg) {
@@ -4326,7 +4363,7 @@ var ObservableMap = /*#__PURE__*/function () {
           return _this5.set(key, value);
         });
       } else if (isES6Map(other)) {
-        if (other.constructor !== Map) {
+        if (!isPlainES6Map(other)) {
           die(19, other);
         }
         other.forEach(function (value, key) {
@@ -4451,19 +4488,18 @@ var ObservableMap = /*#__PURE__*/function () {
   _proto.intercept_ = function intercept_(handler) {
     return registerInterceptor(this, handler);
   };
-  _createClass(ObservableMap, [{
+  return _createClass(ObservableMap, [{
     key: "size",
     get: function get() {
       this.keysAtom_.reportObserved();
       return this.data_.size;
     }
   }, {
-    key: _Symbol$toStringTag,
+    key: Symbol.toStringTag,
     get: function get() {
       return "Map";
     }
   }]);
-  return ObservableMap;
 }();
 // eslint-disable-next-line
 var isObservableMap = /*#__PURE__*/createInstanceofPredicate("ObservableMap", ObservableMap);
@@ -4483,10 +4519,7 @@ function convertToMap(dataStructure) {
   }
 }
 
-var _Symbol$iterator$1, _Symbol$toStringTag$1;
 var ObservableSetMarker = {};
-_Symbol$iterator$1 = Symbol.iterator;
-_Symbol$toStringTag$1 = Symbol.toStringTag;
 var ObservableSet = /*#__PURE__*/function () {
   function ObservableSet(initialData, enhancer, name_) {
     var _this = this;
@@ -4557,7 +4590,6 @@ var ObservableSet = /*#__PURE__*/function () {
       // ideally, value = change.value would be done here, so that values can be
       // changed by interceptor. Same applies for other Set and Map api's.
     }
-
     if (!this.has(value)) {
       transaction(function () {
         _this3.data_.add(_this3.enhancer_(value, undefined));
@@ -4663,6 +4695,47 @@ var ObservableSet = /*#__PURE__*/function () {
       }
     });
   };
+  _proto.intersection = function intersection(otherSet) {
+    if (isES6Set(otherSet)) {
+      return otherSet.intersection(this);
+    } else {
+      var dehancedSet = new Set(this);
+      return dehancedSet.intersection(otherSet);
+    }
+  };
+  _proto.union = function union(otherSet) {
+    if (isES6Set(otherSet)) {
+      return otherSet.union(this);
+    } else {
+      var dehancedSet = new Set(this);
+      return dehancedSet.union(otherSet);
+    }
+  };
+  _proto.difference = function difference(otherSet) {
+    return new Set(this).difference(otherSet);
+  };
+  _proto.symmetricDifference = function symmetricDifference(otherSet) {
+    if (isES6Set(otherSet)) {
+      return otherSet.symmetricDifference(this);
+    } else {
+      var dehancedSet = new Set(this);
+      return dehancedSet.symmetricDifference(otherSet);
+    }
+  };
+  _proto.isSubsetOf = function isSubsetOf(otherSet) {
+    return new Set(this).isSubsetOf(otherSet);
+  };
+  _proto.isSupersetOf = function isSupersetOf(otherSet) {
+    return new Set(this).isSupersetOf(otherSet);
+  };
+  _proto.isDisjointFrom = function isDisjointFrom(otherSet) {
+    if (isES6Set(otherSet)) {
+      return otherSet.isDisjointFrom(this);
+    } else {
+      var dehancedSet = new Set(this);
+      return dehancedSet.isDisjointFrom(otherSet);
+    }
+  };
   _proto.replace = function replace(other) {
     var _this5 = this;
     if (isObservableSet(other)) {
@@ -4701,22 +4774,21 @@ var ObservableSet = /*#__PURE__*/function () {
   _proto.toString = function toString() {
     return "[object ObservableSet]";
   };
-  _proto[_Symbol$iterator$1] = function () {
+  _proto[Symbol.iterator] = function () {
     return this.values();
   };
-  _createClass(ObservableSet, [{
+  return _createClass(ObservableSet, [{
     key: "size",
     get: function get() {
       this.atom_.reportObserved();
       return this.data_.size;
     }
   }, {
-    key: _Symbol$toStringTag$1,
+    key: Symbol.toStringTag,
     get: function get() {
       return "Set";
     }
   }]);
-  return ObservableSet;
 }();
 // eslint-disable-next-line
 var isObservableSet = /*#__PURE__*/createInstanceofPredicate("ObservableSet", ObservableSet);
@@ -5116,7 +5188,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     }
     // Delete
     try {
-      var _this$pendingKeys_, _this$pendingKeys_$ge;
+      var _this$pendingKeys_;
       startBatch();
       var notify = hasListeners(this);
       var notifySpy = "development" !== "production" && isSpyEnabled();
@@ -5154,7 +5226,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
       this.keysAtom_.reportChanged();
       // Notify "has" observers
       // "in" as it may still exist in proto
-      (_this$pendingKeys_ = this.pendingKeys_) == null ? void 0 : (_this$pendingKeys_$ge = _this$pendingKeys_.get(key)) == null ? void 0 : _this$pendingKeys_$ge.set(key in this.target_);
+      (_this$pendingKeys_ = this.pendingKeys_) == null || (_this$pendingKeys_ = _this$pendingKeys_.get(key)) == null || _this$pendingKeys_.set(key in this.target_);
       // Notify spies/listeners
       if (notify || notifySpy) {
         var _change2 = {
@@ -5195,7 +5267,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
     return registerInterceptor(this, handler);
   };
   _proto.notifyPropertyAddition_ = function notifyPropertyAddition_(key, value) {
-    var _this$pendingKeys_2, _this$pendingKeys_2$g;
+    var _this$pendingKeys_2;
     var notify = hasListeners(this);
     var notifySpy =  isSpyEnabled();
     if (notify || notifySpy) {
@@ -5217,7 +5289,7 @@ var ObservableObjectAdministration = /*#__PURE__*/function () {
         spyReportEnd();
       }
     }
-    (_this$pendingKeys_2 = this.pendingKeys_) == null ? void 0 : (_this$pendingKeys_2$g = _this$pendingKeys_2.get(key)) == null ? void 0 : _this$pendingKeys_2$g.set(true);
+    (_this$pendingKeys_2 = this.pendingKeys_) == null || (_this$pendingKeys_2 = _this$pendingKeys_2.get(key)) == null || _this$pendingKeys_2.set(true);
     // Notify "keys/entries/values" observers
     this.keysAtom_.reportChanged();
   };
@@ -5279,7 +5351,7 @@ function recordAnnotationApplied(adm, annotation, key) {
     adm.appliedAnnotations_[key] = annotation;
   }
   // Remove applied decorator annotation so we don't try to apply it again in subclass constructor
-  (_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null ? true : delete _adm$target_$storedAn[key];
+  (_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null || delete _adm$target_$storedAn[key];
 }
 function assertAnnotable(adm, annotation, key) {
   // Valid annotation
@@ -5359,8 +5431,7 @@ inherit(StubArray, Array.prototype);
 // Weex proto freeze protection was here,
 // but it is unclear why the hack is need as MobX never changed the prototype
 // anyway, so removed it in V6
-var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringTag, _Symbol$iterator) {
-  _inheritsLoose(LegacyObservableArray, _StubArray);
+var LegacyObservableArray = /*#__PURE__*/function (_StubArray) {
   function LegacyObservableArray(initialValues, enhancer, name, owned) {
     var _this;
     if (name === void 0) {
@@ -5372,8 +5443,8 @@ var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringT
     _this = _StubArray.call(this) || this;
     initObservable(function () {
       var adm = new ObservableArrayAdministration(name, enhancer, owned, true);
-      adm.proxy_ = _assertThisInitialized(_this);
-      addHiddenFinalProp(_assertThisInitialized(_this), $mobx, adm);
+      adm.proxy_ = _this;
+      addHiddenFinalProp(_this, $mobx, adm);
       if (initialValues && initialValues.length) {
         // @ts-ignore
         _this.spliceWithArray(0, 0, initialValues);
@@ -5381,11 +5452,12 @@ var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringT
       if (safariPrototypeSetterInheritanceBug) {
         // Seems that Safari won't use numeric prototype setter until any * numeric property is
         // defined on the instance. After that it works fine, even if this property is deleted.
-        Object.defineProperty(_assertThisInitialized(_this), "0", ENTRY_0);
+        Object.defineProperty(_this, "0", ENTRY_0);
       }
     });
     return _this;
   }
+  _inheritsLoose(LegacyObservableArray, _StubArray);
   var _proto = LegacyObservableArray.prototype;
   _proto.concat = function concat() {
     this[$mobx].atom_.reportObserved();
@@ -5398,7 +5470,7 @@ var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringT
       return isObservableArray(a) ? a.slice() : a;
     }));
   };
-  _proto[_Symbol$iterator] = function () {
+  _proto[Symbol.iterator] = function () {
     var self = this;
     var nextIndex = 0;
     return makeIterable({
@@ -5413,7 +5485,7 @@ var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringT
       }
     });
   };
-  _createClass(LegacyObservableArray, [{
+  return _createClass(LegacyObservableArray, [{
     key: "length",
     get: function get() {
       return this[$mobx].getArrayLength_();
@@ -5422,13 +5494,12 @@ var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringT
       this[$mobx].setArrayLength_(newLength);
     }
   }, {
-    key: _Symbol$toStringTag,
+    key: Symbol.toStringTag,
     get: function get() {
       return "Array";
     }
   }]);
-  return LegacyObservableArray;
-}(StubArray, Symbol.toStringTag, Symbol.iterator);
+}(StubArray);
 Object.entries(arrayExtensions).forEach(function (_ref) {
   var prop = _ref[0],
     fn = _ref[1];