mobx 6.12.5 → 6.13.1

package/dist/mobx.cjs.development.js

@@ -266,100 +266,88 @@ 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 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");
@@ -432,8 +420,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.
@@ -443,17 +429,17 @@ var Atom = /*#__PURE__*/function () {
       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) {
@@ -487,8 +473,35 @@ var Atom = /*#__PURE__*/function () {
   _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) {
@@ -635,7 +648,6 @@ function make_(adm, key) {
   }
   return 0 /* MakeResult.Cancel */;
 }
-
 function extend_(adm, key, descriptor, proxyTrap) {
   die("'" + this.annotationType_ + "' can only be used with 'makeObservable'");
 }
@@ -668,12 +680,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);
@@ -771,18 +781,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);
@@ -859,7 +866,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_, {
@@ -907,7 +913,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);
@@ -1327,11 +1332,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) {
@@ -1360,7 +1362,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_
@@ -1368,6 +1370,7 @@ var ObservableValue = /*#__PURE__*/function (_Atom) {
     }
     return _this;
   }
+  _inheritsLoose(ObservableValue, _Atom);
   var _proto = ObservableValue.prototype;
   _proto.dehanceValue = function dehanceValue(value) {
     if (this.dehancer !== undefined) {
@@ -1459,25 +1462,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);
-}
-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.
  *
@@ -1497,13 +1488,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.
    *
@@ -1519,9 +1504,10 @@ 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;
     this.lastAccessedBy_ = 0;
     this.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;
@@ -1531,6 +1517,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;
@@ -1712,10 +1699,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_);
@@ -1747,13 +1734,21 @@ var ComputedValue = /*#__PURE__*/function () {
     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_;
@@ -1787,7 +1782,6 @@ var CaughtException = function CaughtException(cause) {
   this.cause = cause;
   // Empty
 };
-
 function isCaughtException(e) {
   return e instanceof CaughtException;
 }
@@ -1851,7 +1845,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
@@ -1924,8 +1917,8 @@ function bindDependencies(derivation) {
     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;
       }
@@ -1945,18 +1938,18 @@ function bindDependencies(derivation) {
   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);
     }
   }
@@ -2022,28 +2015,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;
@@ -2140,7 +2218,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");
@@ -2153,7 +2230,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");
@@ -2291,7 +2367,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) {
@@ -2315,8 +2390,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() ;
@@ -2326,15 +2399,12 @@ 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;
     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_;
@@ -2346,29 +2416,26 @@ var Reaction = /*#__PURE__*/function () {
     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_,
@@ -2384,11 +2451,10 @@ var Reaction = /*#__PURE__*/function () {
     }
   };
   _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;
@@ -2399,14 +2465,14 @@ var Reaction = /*#__PURE__*/function () {
         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);
     }
@@ -2449,9 +2515,9 @@ var Reaction = /*#__PURE__*/function () {
     });
   };
   _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);
@@ -2463,9 +2529,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;
   };
@@ -2478,8 +2544,53 @@ var Reaction = /*#__PURE__*/function () {
     }
     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 () {
@@ -2517,7 +2628,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_();
@@ -2645,7 +2755,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 +2784,7 @@ function autorun(view, opts) {
         isScheduled = true;
         scheduler(function () {
           isScheduled = false;
-          if (!reaction.isDisposed_) {
+          if (!reaction.isDisposed) {
             reaction.track(reactionRunner);
           }
         });
@@ -2684,7 +2794,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);
@@ -2698,7 +2808,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;
   }
@@ -2728,7 +2838,7 @@ function reaction(expression, effect, opts) {
   }, opts.onError, opts.requiresObservable);
   function reactionRunner() {
     isScheduled = false;
-    if (r.isDisposed_) {
+    if (r.isDisposed) {
       return;
     }
     var changed = false;
@@ -2747,7 +2857,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);
@@ -2956,7 +3066,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) {
@@ -2974,7 +3083,6 @@ var flow = /*#__PURE__*/Object.assign(function flow(arg1, arg2) {
         rejector(e); // there could be a throwing finally block
       }
     });
-
     return promise;
   };
   res.isMobXFlow = true;
@@ -2989,7 +3097,6 @@ function cancelPromise(promise) {
 function flowResult(result) {
   return result; // just tricking TypeScript :)
 }
-
 function isFlow(fn) {
   return (fn == null ? void 0 : fn.isMobXFlow) === true;
 }
@@ -3358,7 +3465,7 @@ function _when(predicate, effect, opts) {
   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);
@@ -3411,10 +3518,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;
@@ -3631,8 +3738,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() ;
@@ -3641,6 +3746,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;
@@ -3761,7 +3867,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);
@@ -3861,6 +3966,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
         });
@@ -4076,17 +4182,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) {
@@ -4100,6 +4201,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;
@@ -4188,7 +4290,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);
@@ -4238,7 +4340,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();
@@ -4307,7 +4409,7 @@ var ObservableMap = /*#__PURE__*/function () {
       }
     });
   };
-  _proto[_Symbol$iterator] = function () {
+  _proto[Symbol.iterator] = function () {
     return this.entries();
   };
   _proto.forEach = function forEach(callback, thisArg) {
@@ -4461,19 +4563,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);
@@ -4493,10 +4594,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;
@@ -4567,7 +4665,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));
@@ -4673,6 +4770,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)) {
@@ -4711,22 +4849,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);
@@ -5126,7 +5263,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();
@@ -5164,7 +5301,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 = {
@@ -5205,7 +5342,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) {
@@ -5227,7 +5364,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();
   };
@@ -5289,7 +5426,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
@@ -5369,8 +5506,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) {
@@ -5382,8 +5518,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);
@@ -5391,11 +5527,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();
@@ -5408,7 +5545,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({
@@ -5423,7 +5560,7 @@ var LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringT
       }
     });
   };
-  _createClass(LegacyObservableArray, [{
+  return _createClass(LegacyObservableArray, [{
     key: "length",
     get: function get() {
       return this[$mobx].getArrayLength_();
@@ -5432,13 +5569,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];