mobx 6.12.4 → 6.13.0

package/dist/mobx.umd.development.js

@@ -209,10 +209,16 @@
       };
     }
     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";
     /**
@@ -263,99 +269,76 @@
       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");
@@ -428,8 +411,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.
@@ -440,16 +421,18 @@
         }
         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) {
@@ -631,7 +614,6 @@
       }
       return 0 /* MakeResult.Cancel */;
     }
-
     function extend_(adm, key, descriptor, proxyTrap) {
       die("'" + this.annotationType_ + "' can only be used with 'makeObservable'");
     }
@@ -664,12 +646,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);
@@ -767,18 +747,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);
@@ -855,7 +832,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_, {
@@ -903,7 +879,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);
@@ -1323,11 +1298,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) {
@@ -1356,7 +1328,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_
@@ -1364,6 +1336,7 @@
         }
         return _this;
       }
+      _inheritsLoose(ObservableValue, _Atom);
       var _proto = ObservableValue.prototype;
       _proto.dehanceValue = function dehanceValue(value) {
         if (this.dehancer !== undefined) {
@@ -1455,14 +1428,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);
     }
@@ -1493,13 +1465,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.
        *
@@ -1515,7 +1481,9 @@
       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;
@@ -1527,6 +1495,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;
@@ -1708,10 +1677,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_);
@@ -1744,7 +1713,6 @@
           this.flags_ = setFlag(this.flags_, ComputedValue.isPendingUnobservationMask_, newValue);
         }
       }]);
-      return ComputedValue;
     }();
     ComputedValue.isComputingMask_ = 1;
     ComputedValue.isRunningSetterMask_ = 2;
@@ -1783,7 +1751,6 @@
       this.cause = cause;
       // Empty
     };
-
     function isCaughtException(e) {
       return e instanceof CaughtException;
     }
@@ -1847,7 +1814,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
@@ -2018,28 +1984,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;
@@ -2136,7 +2187,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");
@@ -2149,7 +2199,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");
@@ -2287,7 +2336,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) {
@@ -2311,8 +2359,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() ;
@@ -2322,6 +2368,7 @@
         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;
@@ -2384,7 +2431,6 @@
           return;
           // console.warn("Reaction already disposed") // Note: Not a warning / error in mobx 4 either
         }
-
         startBatch();
         var notify = isSpyEnabled();
         var startTime;
@@ -2459,9 +2505,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;
       };
@@ -2513,7 +2559,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_();
@@ -2641,7 +2686,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;
       }
@@ -2680,7 +2725,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);
@@ -2694,7 +2739,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;
       }
@@ -2743,7 +2788,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);
@@ -2952,7 +2997,6 @@
           }
           onFulfilled(undefined); // kick off the process
         });
-
         promise.cancel = action(name + " - runid: " + runId + " - cancel", function () {
           try {
             if (pendingPromise) {
@@ -2970,7 +3014,6 @@
             rejector(e); // there could be a throwing finally block
           }
         });
-
         return promise;
       };
       res.isMobXFlow = true;
@@ -2985,7 +3028,6 @@
     function flowResult(result) {
       return result; // just tricking TypeScript :)
     }
-
     function isFlow(fn) {
       return (fn == null ? void 0 : fn.isMobXFlow) === true;
     }
@@ -3407,10 +3449,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;
@@ -3627,8 +3669,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() ;
@@ -3637,6 +3677,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;
@@ -3757,7 +3798,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);
@@ -3857,6 +3897,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
             });
@@ -4072,17 +4113,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) {
@@ -4096,6 +4132,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;
@@ -4184,7 +4221,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);
@@ -4234,7 +4271,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();
@@ -4303,7 +4340,7 @@
           }
         });
       };
-      _proto[_Symbol$iterator] = function () {
+      _proto[Symbol.iterator] = function () {
         return this.entries();
       };
       _proto.forEach = function forEach(callback, thisArg) {
@@ -4332,7 +4369,7 @@
               return _this5.set(key, value);
             });
           } else if (isES6Map(other)) {
-            if (other.constructor !== Map) {
+            if (!isPlainES6Map(other)) {
               die(19, other);
             }
             other.forEach(function (value, key) {
@@ -4457,19 +4494,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);
@@ -4489,10 +4525,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;
@@ -4563,7 +4596,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));
@@ -4669,6 +4701,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)) {
@@ -4707,22 +4780,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);
@@ -5122,7 +5194,7 @@
         }
         // Delete
         try {
-          var _this$pendingKeys_, _this$pendingKeys_$ge;
+          var _this$pendingKeys_;
           startBatch();
           var notify = hasListeners(this);
           var notifySpy = "development" !== "production" && isSpyEnabled();
@@ -5160,7 +5232,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 = {
@@ -5201,7 +5273,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) {
@@ -5223,7 +5295,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();
       };
@@ -5285,7 +5357,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
@@ -5365,8 +5437,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) {
@@ -5378,8 +5449,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);
@@ -5387,11 +5458,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();
@@ -5404,7 +5476,7 @@
           return isObservableArray(a) ? a.slice() : a;
         }));
       };
-      _proto[_Symbol$iterator] = function () {
+      _proto[Symbol.iterator] = function () {
         var self = this;
         var nextIndex = 0;
         return makeIterable({
@@ -5419,7 +5491,7 @@
           }
         });
       };
-      _createClass(LegacyObservableArray, [{
+      return _createClass(LegacyObservableArray, [{
         key: "length",
         get: function get() {
           return this[$mobx].getArrayLength_();
@@ -5428,13 +5500,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];