mobx 6.12.5 → 6.13.1

package/dist/mobx.umd.development.js

@@ -268,100 +268,88 @@
       });
       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 getFlag(flags, mask) {
+      return !!(flags & mask);
     }
-    function _inheritsLoose(subClass, superClass) {
-      subClass.prototype = Object.create(superClass.prototype);
-      subClass.prototype.constructor = subClass;
-      _setPrototypeOf(subClass, superClass);
+    function setFlag(flags, mask, newValue) {
+      if (newValue) {
+        flags |= mask;
+      } else {
+        flags &= ~mask;
+      }
+      return flags;
     }
-    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");
@@ -434,8 +422,6 @@
 
     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.
@@ -445,17 +431,17 @@
           name_ =  "Atom@" + getNextId() ;
         }
         this.name_ = void 0;
-        this.isPendingUnobservation = false;
-        this.isBeingObserved = false;
+        this.flags_ = 0;
         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
+      // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
       var _proto = Atom.prototype;
       _proto.onBO = function onBO() {
         if (this.onBOL) {
@@ -489,8 +475,35 @@
       _proto.toString = function toString() {
         return this.name_;
       };
-      return Atom;
+      return _createClass(Atom, [{
+        key: "isBeingObserved",
+        get: function get() {
+          return getFlag(this.flags_, Atom.isBeingObservedMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Atom.isBeingObservedMask_, newValue);
+        }
+      }, {
+        key: "isPendingUnobservation",
+        get: function get() {
+          return getFlag(this.flags_, Atom.isPendingUnobservationMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Atom.isPendingUnobservationMask_, newValue);
+        }
+      }, {
+        key: "diffValue",
+        get: function get() {
+          return getFlag(this.flags_, Atom.diffValueMask_) ? 1 : 0;
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Atom.diffValueMask_, newValue === 1 ? true : false);
+        }
+      }]);
     }();
+    Atom.isBeingObservedMask_ = 1;
+    Atom.isPendingUnobservationMask_ = 2;
+    Atom.diffValueMask_ = 4;
     var isAtom = /*#__PURE__*/createInstanceofPredicate("Atom", Atom);
     function createAtom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {
       if (onBecomeObservedHandler === void 0) {
@@ -637,7 +650,6 @@
       }
       return 0 /* MakeResult.Cancel */;
     }
-
     function extend_(adm, key, descriptor, proxyTrap) {
       die("'" + this.annotationType_ + "' can only be used with 'makeObservable'");
     }
@@ -670,12 +682,10 @@
         // 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);
@@ -773,18 +783,15 @@
           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);
@@ -861,7 +868,6 @@
     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_, {
@@ -909,7 +915,6 @@
     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);
@@ -1329,11 +1334,8 @@
       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) {
@@ -1362,7 +1364,7 @@
           // 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_
@@ -1370,6 +1372,7 @@
         }
         return _this;
       }
+      _inheritsLoose(ObservableValue, _Atom);
       var _proto = ObservableValue.prototype;
       _proto.dehanceValue = function dehanceValue(value) {
         if (this.dehancer !== undefined) {
@@ -1461,25 +1464,13 @@
       _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);
-    }
-    function setFlag(flags, mask, newValue) {
-      if (newValue) {
-        flags |= mask;
-      } else {
-        flags &= ~mask;
-      }
-      return flags;
-    }
     /**
      * A node in the state dependency root that observes other nodes, and can be observed itself.
      *
@@ -1499,13 +1490,7 @@
      *
      * 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.
        *
@@ -1521,9 +1506,10 @@
       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;
         this.lastAccessedBy_ = 0;
         this.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;
@@ -1533,6 +1519,7 @@
         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;
@@ -1714,10 +1701,10 @@
       _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_);
@@ -1749,13 +1736,21 @@
         set: function set(newValue) {
           this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue);
         }
+      }, {
+        key: "diffValue",
+        get: function get() {
+          return getFlag(this.flags_, ComputedValue.diffValueMask_) ? 1 : 0;
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, ComputedValue.diffValueMask_, newValue === 1 ? true : false);
+        }
       }]);
-      return ComputedValue;
     }();
     ComputedValue.isComputingMask_ = 1;
     ComputedValue.isRunningSetterMask_ = 2;
     ComputedValue.isBeingObservedMask_ = 4;
     ComputedValue.isPendingUnobservationMask_ = 8;
+    ComputedValue.diffValueMask_ = 16;
     var isComputedValue = /*#__PURE__*/createInstanceofPredicate("ComputedValue", ComputedValue);
 
     var IDerivationState_;
@@ -1789,7 +1784,6 @@
       this.cause = cause;
       // Empty
     };
-
     function isCaughtException(e) {
       return e instanceof CaughtException;
     }
@@ -1853,7 +1847,6 @@
     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
@@ -1926,8 +1919,8 @@
         l = derivation.unboundDepsCount_;
       for (var i = 0; i < l; i++) {
         var dep = observing[i];
-        if (dep.diffValue_ === 0) {
-          dep.diffValue_ = 1;
+        if (dep.diffValue === 0) {
+          dep.diffValue = 1;
           if (i0 !== i) {
             observing[i0] = dep;
           }
@@ -1947,18 +1940,18 @@
       l = prevObserving.length;
       while (l--) {
         var _dep = prevObserving[l];
-        if (_dep.diffValue_ === 0) {
+        if (_dep.diffValue === 0) {
           removeObserver(_dep, derivation);
         }
-        _dep.diffValue_ = 0;
+        _dep.diffValue = 0;
       }
       // Go through all new observables and check diffValue: (now it should be unique)
       //   0: it was set to 0 in last loop. don't need to do anything.
       //   1: it wasn't observed, let's observe it. set back to 0
       while (i0--) {
         var _dep2 = observing[i0];
-        if (_dep2.diffValue_ === 1) {
-          _dep2.diffValue_ = 0;
+        if (_dep2.diffValue === 1) {
+          _dep2.diffValue = 0;
           addObserver(_dep2, derivation);
         }
       }
@@ -2024,28 +2017,113 @@
      */
     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;
@@ -2142,7 +2220,6 @@
       // 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");
@@ -2155,7 +2232,6 @@
       // 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");
@@ -2293,7 +2369,6 @@
       });
       // 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) {
@@ -2317,8 +2392,6 @@
     }
 
     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() ;
@@ -2328,15 +2401,12 @@
         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;
         this.runId_ = 0;
         this.unboundDepsCount_ = 0;
-        this.isDisposed_ = false;
-        this.isScheduled_ = false;
-        this.isTrackPending_ = false;
-        this.isRunning_ = false;
+        this.flags_ = 0;
         this.isTracing_ = TraceMode.NONE;
         this.name_ = name_;
         this.onInvalidate_ = onInvalidate_;
@@ -2348,29 +2418,26 @@
         this.schedule_();
       };
       _proto.schedule_ = function schedule_() {
-        if (!this.isScheduled_) {
-          this.isScheduled_ = true;
+        if (!this.isScheduled) {
+          this.isScheduled = true;
           globalState.pendingReactions.push(this);
           runReactions();
         }
-      };
-      _proto.isScheduled = function isScheduled() {
-        return this.isScheduled_;
       }
       /**
        * internal, use schedule() if you intend to kick off a reaction
        */;
       _proto.runReaction_ = function runReaction_() {
-        if (!this.isDisposed_) {
+        if (!this.isDisposed) {
           startBatch();
-          this.isScheduled_ = false;
+          this.isScheduled = false;
           var prev = globalState.trackingContext;
           globalState.trackingContext = this;
           if (shouldCompute(this)) {
-            this.isTrackPending_ = true;
+            this.isTrackPending = true;
             try {
               this.onInvalidate_();
-              if ("development" !== "production" && this.isTrackPending_ && isSpyEnabled()) {
+              if ("development" !== "production" && this.isTrackPending && isSpyEnabled()) {
                 // onInvalidate didn't trigger track right away..
                 spyReport({
                   name: this.name_,
@@ -2386,11 +2453,10 @@
         }
       };
       _proto.track = function track(fn) {
-        if (this.isDisposed_) {
+        if (this.isDisposed) {
           return;
           // console.warn("Reaction already disposed") // Note: Not a warning / error in mobx 4 either
         }
-
         startBatch();
         var notify = isSpyEnabled();
         var startTime;
@@ -2401,14 +2467,14 @@
             type: "reaction"
           });
         }
-        this.isRunning_ = true;
+        this.isRunning = true;
         var prevReaction = globalState.trackingContext; // reactions could create reactions...
         globalState.trackingContext = this;
         var result = trackDerivedFunction(this, fn, undefined);
         globalState.trackingContext = prevReaction;
-        this.isRunning_ = false;
-        this.isTrackPending_ = false;
-        if (this.isDisposed_) {
+        this.isRunning = false;
+        this.isTrackPending = false;
+        if (this.isDisposed) {
           // disposed during last run. Clean up everything that was bound after the dispose call.
           clearObserving(this);
         }
@@ -2451,9 +2517,9 @@
         });
       };
       _proto.dispose = function dispose() {
-        if (!this.isDisposed_) {
-          this.isDisposed_ = true;
-          if (!this.isRunning_) {
+        if (!this.isDisposed) {
+          this.isDisposed = true;
+          if (!this.isRunning) {
             // if disposed while running, clean up later. Maybe not optimal, but rare case
             startBatch();
             clearObserving(this);
@@ -2465,9 +2531,9 @@
         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;
       };
@@ -2480,8 +2546,53 @@
         }
         trace(this, enterBreakPoint);
       };
-      return Reaction;
+      return _createClass(Reaction, [{
+        key: "isDisposed",
+        get: function get() {
+          return getFlag(this.flags_, Reaction.isDisposedMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Reaction.isDisposedMask_, newValue);
+        }
+      }, {
+        key: "isScheduled",
+        get: function get() {
+          return getFlag(this.flags_, Reaction.isScheduledMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Reaction.isScheduledMask_, newValue);
+        }
+      }, {
+        key: "isTrackPending",
+        get: function get() {
+          return getFlag(this.flags_, Reaction.isTrackPendingMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Reaction.isTrackPendingMask_, newValue);
+        }
+      }, {
+        key: "isRunning",
+        get: function get() {
+          return getFlag(this.flags_, Reaction.isRunningMask_);
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Reaction.isRunningMask_, newValue);
+        }
+      }, {
+        key: "diffValue",
+        get: function get() {
+          return getFlag(this.flags_, Reaction.diffValueMask_) ? 1 : 0;
+        },
+        set: function set(newValue) {
+          this.flags_ = setFlag(this.flags_, Reaction.diffValueMask_, newValue === 1 ? true : false);
+        }
+      }]);
     }();
+    Reaction.isDisposedMask_ = 1;
+    Reaction.isScheduledMask_ = 2;
+    Reaction.isTrackPendingMask_ = 4;
+    Reaction.isRunningMask_ = 8;
+    Reaction.diffValueMask_ = 16;
     function onReactionError(handler) {
       globalState.globalReactionErrorHandlers.push(handler);
       return function () {
@@ -2519,7 +2630,6 @@
           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_();
@@ -2647,7 +2757,7 @@
      * @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;
       }
@@ -2676,7 +2786,7 @@
             isScheduled = true;
             scheduler(function () {
               isScheduled = false;
-              if (!reaction.isDisposed_) {
+              if (!reaction.isDisposed) {
                 reaction.track(reactionRunner);
               }
             });
@@ -2686,7 +2796,7 @@
       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);
@@ -2700,7 +2810,7 @@
       } : 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;
       }
@@ -2730,7 +2840,7 @@
       }, opts.onError, opts.requiresObservable);
       function reactionRunner() {
         isScheduled = false;
-        if (r.isDisposed_) {
+        if (r.isDisposed) {
           return;
         }
         var changed = false;
@@ -2749,7 +2859,7 @@
         }
         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);
@@ -2958,7 +3068,6 @@
           }
           onFulfilled(undefined); // kick off the process
         });
-
         promise.cancel = action(name + " - runid: " + runId + " - cancel", function () {
           try {
             if (pendingPromise) {
@@ -2976,7 +3085,6 @@
             rejector(e); // there could be a throwing finally block
           }
         });
-
         return promise;
       };
       res.isMobXFlow = true;
@@ -2991,7 +3099,6 @@
     function flowResult(result) {
       return result; // just tricking TypeScript :)
     }
-
     function isFlow(fn) {
       return (fn == null ? void 0 : fn.isMobXFlow) === true;
     }
@@ -3360,7 +3467,7 @@
       if (typeof opts.timeout === "number") {
         var error = new Error("WHEN_TIMEOUT");
         timeoutHandle = setTimeout(function () {
-          if (!disposer[$mobx].isDisposed_) {
+          if (!disposer[$mobx].isDisposed) {
             disposer();
             if (opts.onError) {
               opts.onError(error);
@@ -3413,10 +3520,10 @@
           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;
@@ -3633,8 +3740,6 @@
       }
     };
     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() ;
@@ -3643,6 +3748,7 @@
         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;
@@ -3763,7 +3869,6 @@
           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);
@@ -3863,6 +3968,7 @@
             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
             });
@@ -4078,17 +4184,12 @@
       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) {
@@ -4102,6 +4203,7 @@
         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;
@@ -4190,7 +4292,7 @@
           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);
@@ -4240,7 +4342,7 @@
           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();
@@ -4309,7 +4411,7 @@
           }
         });
       };
-      _proto[_Symbol$iterator] = function () {
+      _proto[Symbol.iterator] = function () {
         return this.entries();
       };
       _proto.forEach = function forEach(callback, thisArg) {
@@ -4463,19 +4565,18 @@
       _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);
@@ -4495,10 +4596,7 @@
       }
     }
 
-    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;
@@ -4569,7 +4667,6 @@
           // 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));
@@ -4675,6 +4772,47 @@
           }
         });
       };
+      _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)) {
@@ -4713,22 +4851,21 @@
       _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);
@@ -5128,7 +5265,7 @@
         }
         // Delete
         try {
-          var _this$pendingKeys_, _this$pendingKeys_$ge;
+          var _this$pendingKeys_;
           startBatch();
           var notify = hasListeners(this);
           var notifySpy = "development" !== "production" && isSpyEnabled();
@@ -5166,7 +5303,7 @@
           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 = {
@@ -5207,7 +5344,7 @@
         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) {
@@ -5229,7 +5366,7 @@
             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();
       };
@@ -5291,7 +5428,7 @@
         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
@@ -5371,8 +5508,7 @@
     // 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) {
@@ -5384,8 +5520,8 @@
         _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);
@@ -5393,11 +5529,12 @@
           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();
@@ -5410,7 +5547,7 @@
           return isObservableArray(a) ? a.slice() : a;
         }));
       };
-      _proto[_Symbol$iterator] = function () {
+      _proto[Symbol.iterator] = function () {
         var self = this;
         var nextIndex = 0;
         return makeIterable({
@@ -5425,7 +5562,7 @@
           }
         });
       };
-      _createClass(LegacyObservableArray, [{
+      return _createClass(LegacyObservableArray, [{
         key: "length",
         get: function get() {
           return this[$mobx].getArrayLength_();
@@ -5434,13 +5571,12 @@
           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];