mobx 4.9.4 → 4.13.0

package/lib/mobx.module.js

@@ -1,4 +1,4 @@
-/** MobX - (c) Michel Weststrate 2015, 2016 - MIT Licensed */
+/** MobX - (c) Michel Weststrate 2015 - 2018 - MIT Licensed */
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -15,9 +15,12 @@ and limitations under the License.
 ***************************************************************************** */
 /* global Reflect, Promise */
 
-var extendStatics = Object.setPrototypeOf ||
-    ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-    function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
 
 function __extends(d, b) {
     extendStatics(d, b);
@@ -25,30 +28,17 @@ function __extends(d, b) {
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
 
-var __assign = Object.assign || function __assign(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-    }
-    return t;
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
 };
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 function __read(o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -72,35 +62,35 @@ function __spread() {
     return ar;
 }
 
-var OBFUSCATED_ERROR$$1 = "An invariant failed, however the error is obfuscated because this is an production build.";
-var EMPTY_ARRAY$$1 = [];
-Object.freeze(EMPTY_ARRAY$$1);
-var EMPTY_OBJECT$$1 = {};
-Object.freeze(EMPTY_OBJECT$$1);
-function getGlobal$$1() {
+var OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is an production build.";
+var EMPTY_ARRAY = [];
+Object.freeze(EMPTY_ARRAY);
+var EMPTY_OBJECT = {};
+Object.freeze(EMPTY_OBJECT);
+function getGlobal() {
     return typeof window !== "undefined" ? window : global;
 }
-function getNextId$$1() {
-    return ++globalState$$1.mobxGuid;
+function getNextId() {
+    return ++globalState.mobxGuid;
 }
-function fail$$1(message) {
-    invariant$$1(false, message);
+function fail(message) {
+    invariant(false, message);
     throw "X"; // unreachable
 }
-function invariant$$1(check, message) {
+function invariant(check, message) {
     if (!check)
-        throw new Error("[mobx] " + (message || OBFUSCATED_ERROR$$1));
+        throw new Error("[mobx] " + (message || OBFUSCATED_ERROR));
 }
 /**
  * Prints a deprecation message, but only one time.
  * Returns false if the deprecated message was already printed before
  */
 var deprecatedMessages = [];
-function deprecated$$1(msg, thing) {
+function deprecated(msg, thing) {
     if (process.env.NODE_ENV === "production")
         return false;
     if (thing) {
-        return deprecated$$1("'" + msg + "', use '" + thing + "' instead.");
+        return deprecated("'" + msg + "', use '" + thing + "' instead.");
     }
     if (deprecatedMessages.indexOf(msg) !== -1)
         return false;
@@ -111,7 +101,7 @@ function deprecated$$1(msg, thing) {
 /**
  * Makes sure that the provided function is invoked at most once.
  */
-function once$$1(func) {
+function once(func) {
     var invoked = false;
     return function () {
         if (invoked)
@@ -120,8 +110,8 @@ function once$$1(func) {
         return func.apply(this, arguments);
     };
 }
-var noop$$1 = function () { };
-function unique$$1(list) {
+var noop = function () { };
+function unique(list) {
     var res = [];
     list.forEach(function (item) {
         if (res.indexOf(item) === -1)
@@ -129,21 +119,21 @@ function unique$$1(list) {
     });
     return res;
 }
-function isObject$$1(value) {
+function isObject(value) {
     return value !== null && typeof value === "object";
 }
-function isPlainObject$$1(value) {
+function isPlainObject(value) {
     if (value === null || typeof value !== "object")
         return false;
     var proto = Object.getPrototypeOf(value);
     return proto === Object.prototype || proto === null;
 }
-function makeNonEnumerable$$1(object, propNames) {
+function makeNonEnumerable(object, propNames) {
     for (var i = 0; i < propNames.length; i++) {
-        addHiddenProp$$1(object, propNames[i], object[propNames[i]]);
+        addHiddenProp(object, propNames[i], object[propNames[i]]);
     }
 }
-function addHiddenProp$$1(object, propName, value) {
+function addHiddenProp(object, propName, value) {
     Object.defineProperty(object, propName, {
         enumerable: false,
         writable: true,
@@ -151,7 +141,7 @@ function addHiddenProp$$1(object, propName, value) {
         value: value
     });
 }
-function addHiddenFinalProp$$1(object, propName, value) {
+function addHiddenFinalProp(object, propName, value) {
     Object.defineProperty(object, propName, {
         enumerable: false,
         writable: false,
@@ -159,52 +149,52 @@ function addHiddenFinalProp$$1(object, propName, value) {
         value: value
     });
 }
-function isPropertyConfigurable$$1(object, prop) {
+function isPropertyConfigurable(object, prop) {
     var descriptor = Object.getOwnPropertyDescriptor(object, prop);
     return !descriptor || (descriptor.configurable !== false && descriptor.writable !== false);
 }
-function assertPropertyConfigurable$$1(object, prop) {
-    if (process.env.NODE_ENV !== "production" && !isPropertyConfigurable$$1(object, prop))
-        fail$$1("Cannot make property '" + prop + "' observable, it is not configurable and writable in the target object");
+function assertPropertyConfigurable(object, prop) {
+    if (process.env.NODE_ENV !== "production" && !isPropertyConfigurable(object, prop))
+        fail("Cannot make property '" + prop + "' observable, it is not configurable and writable in the target object");
 }
-function createInstanceofPredicate$$1(name, clazz) {
+function createInstanceofPredicate(name, clazz) {
     var propName = "isMobX" + name;
     clazz.prototype[propName] = true;
     return function (x) {
-        return isObject$$1(x) && x[propName] === true;
+        return isObject(x) && x[propName] === true;
     };
 }
-function areBothNaN$$1(a, b) {
+function areBothNaN(a, b) {
     return typeof a === "number" && typeof b === "number" && isNaN(a) && isNaN(b);
 }
 /**
  * Returns whether the argument is an array, disregarding observability.
  */
-function isArrayLike$$1(x) {
-    return Array.isArray(x) || isObservableArray$$1(x);
+function isArrayLike(x) {
+    return Array.isArray(x) || isObservableArray(x);
 }
-function isES6Map$$1(thing) {
-    if (getGlobal$$1().Map !== undefined && thing instanceof getGlobal$$1().Map)
+function isES6Map(thing) {
+    if (getGlobal().Map !== undefined && thing instanceof getGlobal().Map)
         return true;
     return false;
 }
-function isES6Set$$1(thing) {
+function isES6Set(thing) {
     return thing instanceof Set;
 }
-function getMapLikeKeys$$1(map) {
-    if (isPlainObject$$1(map))
+function getMapLikeKeys(map) {
+    if (isPlainObject(map))
         return Object.keys(map);
     if (Array.isArray(map))
         return map.map(function (_a) {
             var _b = __read(_a, 1), key = _b[0];
             return key;
         });
-    if (isES6Map$$1(map) || isObservableMap$$1(map))
-        return iteratorToArray$$1(map.keys());
-    return fail$$1("Cannot get keys from '" + map + "'");
+    if (isES6Map(map) || isObservableMap(map))
+        return iteratorToArray(map.keys());
+    return fail("Cannot get keys from '" + map + "'");
 }
 // use Array.from in Mobx 5
-function iteratorToArray$$1(it) {
+function iteratorToArray(it) {
     var res = [];
     while (true) {
         var r = it.next();
@@ -214,26 +204,25 @@ function iteratorToArray$$1(it) {
     }
     return res;
 }
-function primitiveSymbol$$1() {
+function primitiveSymbol() {
     // es-disable-next-line
     return (typeof Symbol === "function" && Symbol.toPrimitive) || "@@toPrimitive";
 }
-function toPrimitive$$1(value) {
+function toPrimitive(value) {
     return value === null ? null : typeof value === "object" ? "" + value : value;
 }
 
-function iteratorSymbol$$1() {
+function iteratorSymbol() {
     return (typeof Symbol === "function" && Symbol.iterator) || "@@iterator";
 }
-
-function declareIterator$$1(prototType, iteratorFactory) {
-    addHiddenFinalProp$$1(prototType, iteratorSymbol$$1(), iteratorFactory);
+function declareIterator(prototType, iteratorFactory) {
+    addHiddenFinalProp(prototType, iteratorSymbol(), iteratorFactory);
 }
-function makeIterable$$1(iterator) {
-    iterator[iteratorSymbol$$1()] = self;
+function makeIterable(iterator) {
+    iterator[iteratorSymbol()] = self;
     return iterator;
 }
-function toStringTagSymbol$$1() {
+function toStringTagSymbol() {
     return (typeof Symbol === "function" && Symbol.toStringTag) || "@@toStringTag";
 }
 function self() {
@@ -246,13 +235,13 @@ function self() {
  * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used
  * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.
  */
-var Atom$$1 = /** @class */ (function () {
+var Atom = /** @class */ (function () {
     /**
      * 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.
      */
-    function Atom$$1(name) {
-        if (name === void 0) { name = "Atom@" + getNextId$$1(); }
+    function Atom(name) {
+        if (name === void 0) { name = "Atom@" + getNextId(); }
         this.name = name;
         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;
@@ -262,39 +251,39 @@ var Atom$$1 = /** @class */ (function () {
         this.lastAccessedBy = 0;
         this.lowestObserverState = IDerivationState.NOT_TRACKING;
     }
-    Atom$$1.prototype.onBecomeUnobserved = function () {
+    Atom.prototype.onBecomeUnobserved = function () {
         // noop
     };
-    Atom$$1.prototype.onBecomeObserved = function () {
+    Atom.prototype.onBecomeObserved = function () {
         /* noop */
     };
     /**
      * Invoke this method to notify mobx that your atom has been used somehow.
      * Returns true if there is currently a reactive context.
      */
-    Atom$$1.prototype.reportObserved = function () {
-        return reportObserved$$1(this);
+    Atom.prototype.reportObserved = function () {
+        return reportObserved(this);
     };
     /**
      * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.
      */
-    Atom$$1.prototype.reportChanged = function () {
-        startBatch$$1();
-        propagateChanged$$1(this);
-        endBatch$$1();
+    Atom.prototype.reportChanged = function () {
+        startBatch();
+        propagateChanged(this);
+        endBatch();
     };
-    Atom$$1.prototype.toString = function () {
+    Atom.prototype.toString = function () {
         return this.name;
     };
-    return Atom$$1;
+    return Atom;
 }());
-var isAtom$$1 = createInstanceofPredicate$$1("Atom", Atom$$1);
-function createAtom$$1(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {
-    if (onBecomeObservedHandler === void 0) { onBecomeObservedHandler = noop$$1; }
-    if (onBecomeUnobservedHandler === void 0) { onBecomeUnobservedHandler = noop$$1; }
-    var atom = new Atom$$1(name);
-    onBecomeObserved$$1(atom, onBecomeObservedHandler);
-    onBecomeUnobserved$$1(atom, onBecomeUnobservedHandler);
+var isAtom = createInstanceofPredicate("Atom", Atom);
+function createAtom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {
+    if (onBecomeObservedHandler === void 0) { onBecomeObservedHandler = noop; }
+    if (onBecomeUnobservedHandler === void 0) { onBecomeUnobservedHandler = noop; }
+    var atom = new Atom(name);
+    onBecomeObserved(atom, onBecomeObservedHandler);
+    onBecomeUnobserved(atom, onBecomeUnobservedHandler);
     return atom;
 }
 
@@ -302,12 +291,12 @@ function identityComparer(a, b) {
     return a === b;
 }
 function structuralComparer(a, b) {
-    return deepEqual$$1(a, b);
+    return deepEqual(a, b);
 }
 function defaultComparer(a, b) {
-    return areBothNaN$$1(a, b) || identityComparer(a, b);
+    return areBothNaN(a, b) || identityComparer(a, b);
 }
-var comparer$$1 = {
+var comparer = {
     identity: identityComparer,
     structural: structuralComparer,
     default: defaultComparer
@@ -322,31 +311,31 @@ function createPropertyInitializerDescriptor(prop, enumerable) {
             configurable: true,
             enumerable: enumerable,
             get: function () {
-                initializeInstance$$1(this);
+                initializeInstance(this);
                 return this[prop];
             },
             set: function (value) {
-                initializeInstance$$1(this);
+                initializeInstance(this);
                 this[prop] = value;
             }
         }));
 }
-function initializeInstance$$1(target) {
+function initializeInstance(target) {
     if (target.__mobxDidRunLazyInitializers === true)
         return;
     var decorators = target.__mobxDecorators;
     if (decorators) {
-        addHiddenProp$$1(target, "__mobxDidRunLazyInitializers", true);
+        addHiddenProp(target, "__mobxDidRunLazyInitializers", true);
         for (var key in decorators) {
             var d = decorators[key];
             d.propertyCreator(target, d.prop, d.descriptor, d.decoratorTarget, d.decoratorArguments);
         }
     }
 }
-function createPropDecorator$$1(propertyInitiallyEnumerable, propertyCreator) {
+function createPropDecorator(propertyInitiallyEnumerable, propertyCreator) {
     return function decoratorFactory() {
         var decoratorArguments;
-        var decorator = function decorate$$1(target, prop, descriptor, applyImmediately
+        var decorator = function decorate(target, prop, descriptor, applyImmediately
         // This is a special parameter to signal the direct application of a decorator, allow extendObservable to skip the entire type decoration part,
         // as the instance to apply the decorator to equals the target
         ) {
@@ -354,11 +343,11 @@ function createPropDecorator$$1(propertyInitiallyEnumerable, propertyCreator) {
                 propertyCreator(target, prop, descriptor, target, decoratorArguments);
                 return null;
             }
-            if (process.env.NODE_ENV !== "production" && !quacksLikeADecorator$$1(arguments))
-                fail$$1("This function is a decorator, but it wasn't invoked like a decorator");
+            if (process.env.NODE_ENV !== "production" && !quacksLikeADecorator(arguments))
+                fail("This function is a decorator, but it wasn't invoked like a decorator");
             if (!Object.prototype.hasOwnProperty.call(target, "__mobxDecorators")) {
                 var inheritedDecorators = target.__mobxDecorators;
-                addHiddenProp$$1(target, "__mobxDecorators", __assign({}, inheritedDecorators));
+                addHiddenProp(target, "__mobxDecorators", __assign({}, inheritedDecorators));
             }
             target.__mobxDecorators[prop] = {
                 prop: prop,
@@ -369,9 +358,9 @@ function createPropDecorator$$1(propertyInitiallyEnumerable, propertyCreator) {
             };
             return createPropertyInitializerDescriptor(prop, propertyInitiallyEnumerable);
         };
-        if (quacksLikeADecorator$$1(arguments)) {
+        if (quacksLikeADecorator(arguments)) {
             // @decorator
-            decoratorArguments = EMPTY_ARRAY$$1;
+            decoratorArguments = EMPTY_ARRAY;
             return decorator.apply(null, arguments);
         }
         else {
@@ -381,65 +370,65 @@ function createPropDecorator$$1(propertyInitiallyEnumerable, propertyCreator) {
         }
     };
 }
-function quacksLikeADecorator$$1(args) {
+function quacksLikeADecorator(args) {
     return (((args.length === 2 || args.length === 3) && typeof args[1] === "string") ||
         (args.length === 4 && args[3] === true));
 }
 
-function deepEnhancer$$1(v, _, name) {
+function deepEnhancer(v, _, name) {
     // it is an observable already, done
-    if (isObservable$$1(v))
+    if (isObservable(v))
         return v;
     // something that can be converted and mutated?
     if (Array.isArray(v))
-        return observable$$1.array(v, { name: name });
-    if (isPlainObject$$1(v))
-        return observable$$1.object(v, undefined, { name: name });
-    if (isES6Map$$1(v))
-        return observable$$1.map(v, { name: name });
-    if (isES6Set$$1(v))
-        return observable$$1.set(v, { name: name });
+        return observable.array(v, { name: name });
+    if (isPlainObject(v))
+        return observable.object(v, undefined, { name: name });
+    if (isES6Map(v))
+        return observable.map(v, { name: name });
+    if (isES6Set(v))
+        return observable.set(v, { name: name });
     return v;
 }
-function shallowEnhancer$$1(v, _, name) {
+function shallowEnhancer(v, _, name) {
     if (v === undefined || v === null)
         return v;
-    if (isObservableObject$$1(v) || isObservableArray$$1(v) || isObservableMap$$1(v) || isObservableSet$$1(v))
+    if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v) || isObservableSet(v))
         return v;
     if (Array.isArray(v))
-        return observable$$1.array(v, { name: name, deep: false });
-    if (isPlainObject$$1(v))
-        return observable$$1.object(v, undefined, { name: name, deep: false });
-    if (isES6Map$$1(v))
-        return observable$$1.map(v, { name: name, deep: false });
-    if (isES6Set$$1(v))
-        return observable$$1.set(v, { name: name, deep: false });
-    return fail$$1(process.env.NODE_ENV !== "production" &&
+        return observable.array(v, { name: name, deep: false });
+    if (isPlainObject(v))
+        return observable.object(v, undefined, { name: name, deep: false });
+    if (isES6Map(v))
+        return observable.map(v, { name: name, deep: false });
+    if (isES6Set(v))
+        return observable.set(v, { name: name, deep: false });
+    return fail(process.env.NODE_ENV !== "production" &&
         "The shallow modifier / decorator can only used in combination with arrays, objects, maps and sets");
 }
-function referenceEnhancer$$1(newValue) {
+function referenceEnhancer(newValue) {
     // never turn into an observable
     return newValue;
 }
-function refStructEnhancer$$1(v, oldValue, name) {
-    if (process.env.NODE_ENV !== "production" && isObservable$$1(v))
+function refStructEnhancer(v, oldValue, name) {
+    if (process.env.NODE_ENV !== "production" && isObservable(v))
         throw "observable.struct should not be used with observable values";
-    if (deepEqual$$1(v, oldValue))
+    if (deepEqual(v, oldValue))
         return oldValue;
     return v;
 }
 
-function createDecoratorForEnhancer$$1(enhancer) {
-    var decorator = createPropDecorator$$1(true, function (target, propertyName, descriptor, _decoratorTarget, decoratorArgs) {
+function createDecoratorForEnhancer(enhancer) {
+    var decorator = createPropDecorator(true, function (target, propertyName, descriptor, _decoratorTarget, decoratorArgs) {
         if (process.env.NODE_ENV !== "production") {
-            invariant$$1(!descriptor || !descriptor.get, "@observable cannot be used on getter (property \"" + propertyName + "\"), use @computed instead.");
+            invariant(!descriptor || !descriptor.get, "@observable cannot be used on getter (property \"" + propertyName + "\"), use @computed instead.");
         }
         var initialValue = descriptor
             ? descriptor.initializer
                 ? descriptor.initializer.call(target)
                 : descriptor.value
             : undefined;
-        defineObservableProperty$$1(target, propertyName, initialValue, enhancer);
+        defineObservableProperty(target, propertyName, initialValue, enhancer);
     });
     var res = 
     // Extra process checks, as this happens during module initialization
@@ -448,7 +437,7 @@ function createDecoratorForEnhancer$$1(enhancer) {
             // This wrapper function is just to detect illegal decorator invocations, deprecate in a next version
             // and simply return the created prop decorator
             if (arguments.length < 2)
-                return fail$$1("Incorrect decorator invocation. @observable decorator doesn't expect any arguments");
+                return fail("Incorrect decorator invocation. @observable decorator doesn't expect any arguments");
             return decorator.apply(null, arguments);
         }
         : decorator;
@@ -458,30 +447,30 @@ function createDecoratorForEnhancer$$1(enhancer) {
 
 // Predefined bags of create observable options, to avoid allocating temporarily option objects
 // in the majority of cases
-var defaultCreateObservableOptions$$1 = {
+var defaultCreateObservableOptions = {
     deep: true,
     name: undefined,
     defaultDecorator: undefined
 };
-var shallowCreateObservableOptions$$1 = {
+var shallowCreateObservableOptions = {
     deep: false,
     name: undefined,
     defaultDecorator: undefined
 };
-Object.freeze(defaultCreateObservableOptions$$1);
-Object.freeze(shallowCreateObservableOptions$$1);
+Object.freeze(defaultCreateObservableOptions);
+Object.freeze(shallowCreateObservableOptions);
 function assertValidOption(key) {
     if (!/^(deep|name|equals|defaultDecorator)$/.test(key))
-        fail$$1("invalid option for (extend)observable: " + key);
+        fail("invalid option for (extend)observable: " + key);
 }
-function asCreateObservableOptions$$1(thing) {
+function asCreateObservableOptions(thing) {
     if (thing === null || thing === undefined)
-        return defaultCreateObservableOptions$$1;
+        return defaultCreateObservableOptions;
     if (typeof thing === "string")
         return { name: thing, deep: true };
     if (process.env.NODE_ENV !== "production") {
         if (typeof thing !== "object")
-            return fail$$1("expected options object");
+            return fail("expected options object");
         Object.keys(thing).forEach(assertValidOption);
     }
     return thing;
@@ -490,13 +479,13 @@ function getEnhancerFromOptions(options) {
     return options.defaultDecorator
         ? options.defaultDecorator.enhancer
         : options.deep === false
-            ? referenceEnhancer$$1
-            : deepEnhancer$$1;
+            ? referenceEnhancer
+            : deepEnhancer;
 }
-var deepDecorator$$1 = createDecoratorForEnhancer$$1(deepEnhancer$$1);
-var shallowDecorator = createDecoratorForEnhancer$$1(shallowEnhancer$$1);
-var refDecorator$$1 = createDecoratorForEnhancer$$1(referenceEnhancer$$1);
-var refStructDecorator = createDecoratorForEnhancer$$1(refStructEnhancer$$1);
+var deepDecorator = createDecoratorForEnhancer(deepEnhancer);
+var shallowDecorator = createDecoratorForEnhancer(shallowEnhancer);
+var refDecorator = createDecoratorForEnhancer(referenceEnhancer);
+var refStructDecorator = createDecoratorForEnhancer(refStructEnhancer);
 /**
  * Turns an object, array or function into a reactive structure.
  * @param v the value which should become observable.
@@ -504,145 +493,145 @@ var refStructDecorator = createDecoratorForEnhancer$$1(refStructEnhancer$$1);
 function createObservable(v, arg2, arg3) {
     // @observable someProp;
     if (typeof arguments[1] === "string") {
-        return deepDecorator$$1.apply(null, arguments);
+        return deepDecorator.apply(null, arguments);
     }
     // it is an observable already, done
-    if (isObservable$$1(v))
+    if (isObservable(v))
         return v;
     // something that can be converted and mutated?
-    var res = isPlainObject$$1(v)
-        ? observable$$1.object(v, arg2, arg3)
+    var res = isPlainObject(v)
+        ? observable.object(v, arg2, arg3)
         : Array.isArray(v)
-            ? observable$$1.array(v, arg2)
-            : isES6Map$$1(v)
-                ? observable$$1.map(v, arg2)
-                : isES6Set$$1(v)
-                    ? observable$$1.set(v, arg2)
+            ? observable.array(v, arg2)
+            : isES6Map(v)
+                ? observable.map(v, arg2)
+                : isES6Set(v)
+                    ? observable.set(v, arg2)
                     : v;
     // this value could be converted to a new observable data structure, return it
     if (res !== v)
         return res;
     // otherwise, just box it
-    fail$$1(process.env.NODE_ENV !== "production" &&
+    fail(process.env.NODE_ENV !== "production" &&
         "The provided value could not be converted into an observable. If you want just create an observable reference to the object use 'observable.box(value)'");
 }
 var observableFactories = {
     box: function (value, options) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("box");
-        var o = asCreateObservableOptions$$1(options);
-        return new ObservableValue$$1(value, getEnhancerFromOptions(o), o.name, true, o.equals);
+        var o = asCreateObservableOptions(options);
+        return new ObservableValue(value, getEnhancerFromOptions(o), o.name, true, o.equals);
     },
     shallowBox: function (value, name) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("shallowBox");
-        deprecated$$1("observable.shallowBox", "observable.box(value, { deep: false })");
-        return observable$$1.box(value, { name: name, deep: false });
+        deprecated("observable.shallowBox", "observable.box(value, { deep: false })");
+        return observable.box(value, { name: name, deep: false });
     },
     array: function (initialValues, options) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("array");
-        var o = asCreateObservableOptions$$1(options);
-        return new ObservableArray$$1(initialValues, getEnhancerFromOptions(o), o.name);
+        var o = asCreateObservableOptions(options);
+        return new ObservableArray(initialValues, getEnhancerFromOptions(o), o.name);
     },
     shallowArray: function (initialValues, name) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("shallowArray");
-        deprecated$$1("observable.shallowArray", "observable.array(values, { deep: false })");
-        return observable$$1.array(initialValues, { name: name, deep: false });
+        deprecated("observable.shallowArray", "observable.array(values, { deep: false })");
+        return observable.array(initialValues, { name: name, deep: false });
     },
     map: function (initialValues, options) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("map");
-        var o = asCreateObservableOptions$$1(options);
-        return new ObservableMap$$1(initialValues, getEnhancerFromOptions(o), o.name);
+        var o = asCreateObservableOptions(options);
+        return new ObservableMap(initialValues, getEnhancerFromOptions(o), o.name);
     },
     shallowMap: function (initialValues, name) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("shallowMap");
-        deprecated$$1("observable.shallowMap", "observable.map(values, { deep: false })");
-        return observable$$1.map(initialValues, { name: name, deep: false });
+        deprecated("observable.shallowMap", "observable.map(values, { deep: false })");
+        return observable.map(initialValues, { name: name, deep: false });
     },
     set: function (initialValues, options) {
         if (arguments.length > 2)
             incorrectlyUsedAsDecorator("set");
-        var o = asCreateObservableOptions$$1(options);
-        return new ObservableSet$$1(initialValues, getEnhancerFromOptions(o), o.name);
+        var o = asCreateObservableOptions(options);
+        return new ObservableSet(initialValues, getEnhancerFromOptions(o), o.name);
     },
     object: function (props, decorators, options) {
         if (typeof arguments[1] === "string")
             incorrectlyUsedAsDecorator("object");
-        var o = asCreateObservableOptions$$1(options);
-        return extendObservable$$1({}, props, decorators, o);
+        var o = asCreateObservableOptions(options);
+        return extendObservable({}, props, decorators, o);
     },
     shallowObject: function (props, name) {
         if (typeof arguments[1] === "string")
             incorrectlyUsedAsDecorator("shallowObject");
-        deprecated$$1("observable.shallowObject", "observable.object(values, {}, { deep: false })");
-        return observable$$1.object(props, {}, { name: name, deep: false });
+        deprecated("observable.shallowObject", "observable.object(values, {}, { deep: false })");
+        return observable.object(props, {}, { name: name, deep: false });
     },
-    ref: refDecorator$$1,
+    ref: refDecorator,
     shallow: shallowDecorator,
-    deep: deepDecorator$$1,
+    deep: deepDecorator,
     struct: refStructDecorator
 };
-var observable$$1 = createObservable;
+var observable = createObservable;
 // weird trick to keep our typings nicely with our funcs, and still extend the observable function
-Object.keys(observableFactories).forEach(function (name) { return (observable$$1[name] = observableFactories[name]); });
+Object.keys(observableFactories).forEach(function (name) { return (observable[name] = observableFactories[name]); });
 function incorrectlyUsedAsDecorator(methodName) {
-    fail$$1(
+    fail(
     // process.env.NODE_ENV !== "production" &&
     "Expected one or two arguments to observable." + methodName + ". Did you accidentally try to use observable." + methodName + " as decorator?");
 }
 
-var computedDecorator$$1 = createPropDecorator$$1(false, function (instance, propertyName, descriptor, decoratorTarget, decoratorArgs) {
-    var get$$1 = descriptor.get, set$$1 = descriptor.set; // initialValue is the descriptor for get / set props
+var computedDecorator = createPropDecorator(false, function (instance, propertyName, descriptor, decoratorTarget, decoratorArgs) {
+    var get = descriptor.get, set = descriptor.set; // initialValue is the descriptor for get / set props
     // Optimization: faster on decorator target or instance? Assuming target
     // Optimization: find out if declaring on instance isn't just faster. (also makes the property descriptor simpler). But, more memory usage..
     // Forcing instance now, fixes hot reloadig issues on React Native:
     var options = decoratorArgs[0] || {};
-    defineComputedProperty$$1(instance, propertyName, __assign({ get: get$$1, set: set$$1 }, options));
+    defineComputedProperty(instance, propertyName, __assign({ get: get, set: set }, options));
 });
-var computedStructDecorator = computedDecorator$$1({ equals: comparer$$1.structural });
+var computedStructDecorator = computedDecorator({ equals: comparer.structural });
 /**
  * Decorator for class properties: @computed get value() { return expr; }.
  * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
  */
-var computed$$1 = function computed$$1(arg1, arg2, arg3) {
+var computed = function computed(arg1, arg2, arg3) {
     if (typeof arg2 === "string") {
         // @computed
-        return computedDecorator$$1.apply(null, arguments);
+        return computedDecorator.apply(null, arguments);
     }
     if (arg1 !== null && typeof arg1 === "object" && arguments.length === 1) {
         // @computed({ options })
-        return computedDecorator$$1.apply(null, arguments);
+        return computedDecorator.apply(null, arguments);
     }
     // computed(expr, options?)
     if (process.env.NODE_ENV !== "production") {
-        invariant$$1(typeof arg1 === "function", "First argument to `computed` should be an expression.");
-        invariant$$1(arguments.length < 3, "Computed takes one or two arguments if used as function");
+        invariant(typeof arg1 === "function", "First argument to `computed` should be an expression.");
+        invariant(arguments.length < 3, "Computed takes one or two arguments if used as function");
     }
     var opts = typeof arg2 === "object" ? arg2 : {};
     opts.get = arg1;
     opts.set = typeof arg2 === "function" ? arg2 : opts.set;
     opts.name = opts.name || arg1.name || ""; /* for generated name */
-    return new ComputedValue$$1(opts);
+    return new ComputedValue(opts);
 };
-computed$$1.struct = computedStructDecorator;
+computed.struct = computedStructDecorator;
 
-function createAction$$1(actionName, fn) {
+function createAction(actionName, fn) {
     if (process.env.NODE_ENV !== "production") {
-        invariant$$1(typeof fn === "function", "`action` can only be invoked on functions");
+        invariant(typeof fn === "function", "`action` can only be invoked on functions");
         if (typeof actionName !== "string" || !actionName)
-            fail$$1("actions should have valid names, got: '" + actionName + "'");
+            fail("actions should have valid names, got: '" + actionName + "'");
     }
     var res = function () {
-        return executeAction$$1(actionName, fn, this, arguments);
+        return executeAction(actionName, fn, this, arguments);
     };
     res.isMobxAction = true;
     return res;
 }
-function executeAction$$1(actionName, fn, scope, args) {
+function executeAction(actionName, fn, scope, args) {
     var runInfo = startAction(actionName, fn, scope, args);
     var shouldSupressReactionError = true;
     try {
@@ -652,9 +641,9 @@ function executeAction$$1(actionName, fn, scope, args) {
     }
     finally {
         if (shouldSupressReactionError) {
-            globalState$$1.suppressReactionErrors = shouldSupressReactionError;
+            globalState.suppressReactionErrors = shouldSupressReactionError;
             endAction(runInfo);
-            globalState$$1.suppressReactionErrors = false;
+            globalState.suppressReactionErrors = false;
         }
         else {
             endAction(runInfo);
@@ -662,7 +651,7 @@ function executeAction$$1(actionName, fn, scope, args) {
     }
 }
 function startAction(actionName, fn, scope, args) {
-    var notifySpy = isSpyEnabled$$1() && !!actionName;
+    var notifySpy = isSpyEnabled() && !!actionName;
     var startTime = 0;
     if (notifySpy) {
         startTime = Date.now();
@@ -671,16 +660,16 @@ function startAction(actionName, fn, scope, args) {
         if (l > 0)
             for (var i = 0; i < l; i++)
                 flattendArgs[i] = args[i];
-        spyReportStart$$1({
+        spyReportStart({
             type: "action",
             name: actionName,
             object: scope,
             arguments: flattendArgs
         });
     }
-    var prevDerivation = untrackedStart$$1();
-    startBatch$$1();
-    var prevAllowStateChanges = allowStateChangesStart$$1(true);
+    var prevDerivation = untrackedStart();
+    startBatch();
+    var prevAllowStateChanges = allowStateChangesStart(true);
     return {
         prevDerivation: prevDerivation,
         prevAllowStateChanges: prevAllowStateChanges,
@@ -689,74 +678,74 @@ function startAction(actionName, fn, scope, args) {
     };
 }
 function endAction(runInfo) {
-    allowStateChangesEnd$$1(runInfo.prevAllowStateChanges);
-    endBatch$$1();
-    untrackedEnd$$1(runInfo.prevDerivation);
+    allowStateChangesEnd(runInfo.prevAllowStateChanges);
+    endBatch();
+    untrackedEnd(runInfo.prevDerivation);
     if (runInfo.notifySpy)
-        spyReportEnd$$1({ time: Date.now() - runInfo.startTime });
+        spyReportEnd({ time: Date.now() - runInfo.startTime });
 }
-function allowStateChanges$$1(allowStateChanges$$1, func) {
-    var prev = allowStateChangesStart$$1(allowStateChanges$$1);
+function allowStateChanges(allowStateChanges, func) {
+    var prev = allowStateChangesStart(allowStateChanges);
     var res;
     try {
         res = func();
     }
     finally {
-        allowStateChangesEnd$$1(prev);
+        allowStateChangesEnd(prev);
     }
     return res;
 }
-function allowStateChangesStart$$1(allowStateChanges$$1) {
-    var prev = globalState$$1.allowStateChanges;
-    globalState$$1.allowStateChanges = allowStateChanges$$1;
+function allowStateChangesStart(allowStateChanges) {
+    var prev = globalState.allowStateChanges;
+    globalState.allowStateChanges = allowStateChanges;
     return prev;
 }
-function allowStateChangesEnd$$1(prev) {
-    globalState$$1.allowStateChanges = prev;
+function allowStateChangesEnd(prev) {
+    globalState.allowStateChanges = prev;
 }
-function allowStateChangesInsideComputed$$1(func) {
-    var prev = globalState$$1.computationDepth;
-    globalState$$1.computationDepth = 0;
+function allowStateChangesInsideComputed(func) {
+    var prev = globalState.computationDepth;
+    globalState.computationDepth = 0;
     var res;
     try {
         res = func();
     }
     finally {
-        globalState$$1.computationDepth = prev;
+        globalState.computationDepth = prev;
     }
     return res;
 }
 
-var ObservableValue$$1 = /** @class */ (function (_super) {
-    __extends(ObservableValue$$1, _super);
-    function ObservableValue$$1(value, enhancer, name, notifySpy, equals) {
-        if (name === void 0) { name = "ObservableValue@" + getNextId$$1(); }
+var ObservableValue = /** @class */ (function (_super) {
+    __extends(ObservableValue, _super);
+    function ObservableValue(value, enhancer, name, notifySpy, equals) {
+        if (name === void 0) { name = "ObservableValue@" + getNextId(); }
         if (notifySpy === void 0) { notifySpy = true; }
-        if (equals === void 0) { equals = comparer$$1.default; }
+        if (equals === void 0) { equals = comparer.default; }
         var _this = _super.call(this, name) || this;
         _this.enhancer = enhancer;
         _this.name = name;
         _this.equals = equals;
         _this.hasUnreportedChange = false;
         _this.value = enhancer(value, undefined, name);
-        if (notifySpy && isSpyEnabled$$1()) {
+        if (notifySpy && isSpyEnabled()) {
             // only notify spy if this is a stand-alone observable
-            spyReport$$1({ type: "create", name: _this.name, newValue: "" + _this.value });
+            spyReport({ type: "create", name: _this.name, newValue: "" + _this.value });
         }
         return _this;
     }
-    ObservableValue$$1.prototype.dehanceValue = function (value) {
+    ObservableValue.prototype.dehanceValue = function (value) {
         if (this.dehancer !== undefined)
             return this.dehancer(value);
         return value;
     };
-    ObservableValue$$1.prototype.set = function (newValue) {
+    ObservableValue.prototype.set = function (newValue) {
         var oldValue = this.value;
         newValue = this.prepareNewValue(newValue);
-        if (newValue !== globalState$$1.UNCHANGED) {
-            var notifySpy = isSpyEnabled$$1();
+        if (newValue !== globalState.UNCHANGED) {
+            var notifySpy = isSpyEnabled();
             if (notifySpy) {
-                spyReportStart$$1({
+                spyReportStart({
                     type: "update",
                     name: this.name,
                     newValue: newValue,
@@ -765,31 +754,31 @@ var ObservableValue$$1 = /** @class */ (function (_super) {
             }
             this.setNewValue(newValue);
             if (notifySpy)
-                spyReportEnd$$1();
+                spyReportEnd();
         }
     };
-    ObservableValue$$1.prototype.prepareNewValue = function (newValue) {
-        checkIfStateModificationsAreAllowed$$1(this);
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+    ObservableValue.prototype.prepareNewValue = function (newValue) {
+        checkIfStateModificationsAreAllowed(this);
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 object: this,
                 type: "update",
                 newValue: newValue
             });
             if (!change)
-                return globalState$$1.UNCHANGED;
+                return globalState.UNCHANGED;
             newValue = change.newValue;
         }
         // apply modifier
         newValue = this.enhancer(newValue, this.value, this.name);
-        return this.equals(this.value, newValue) ? globalState$$1.UNCHANGED : newValue;
+        return this.equals(this.value, newValue) ? globalState.UNCHANGED : newValue;
     };
-    ObservableValue$$1.prototype.setNewValue = function (newValue) {
+    ObservableValue.prototype.setNewValue = function (newValue) {
         var oldValue = this.value;
         this.value = newValue;
         this.reportChanged();
-        if (hasListeners$$1(this)) {
-            notifyListeners$$1(this, {
+        if (hasListeners(this)) {
+            notifyListeners(this, {
                 type: "update",
                 object: this,
                 newValue: newValue,
@@ -797,14 +786,14 @@ var ObservableValue$$1 = /** @class */ (function (_super) {
             });
         }
     };
-    ObservableValue$$1.prototype.get = function () {
+    ObservableValue.prototype.get = function () {
         this.reportObserved();
         return this.dehanceValue(this.value);
     };
-    ObservableValue$$1.prototype.intercept = function (handler) {
-        return registerInterceptor$$1(this, handler);
+    ObservableValue.prototype.intercept = function (handler) {
+        return registerInterceptor(this, handler);
     };
-    ObservableValue$$1.prototype.observe = function (listener, fireImmediately) {
+    ObservableValue.prototype.observe = function (listener, fireImmediately) {
         if (fireImmediately)
             listener({
                 object: this,
@@ -812,21 +801,21 @@ var ObservableValue$$1 = /** @class */ (function (_super) {
                 newValue: this.value,
                 oldValue: undefined
             });
-        return registerListener$$1(this, listener);
+        return registerListener(this, listener);
     };
-    ObservableValue$$1.prototype.toJSON = function () {
+    ObservableValue.prototype.toJSON = function () {
         return this.get();
     };
-    ObservableValue$$1.prototype.toString = function () {
+    ObservableValue.prototype.toString = function () {
         return this.name + "[" + this.value + "]";
     };
-    ObservableValue$$1.prototype.valueOf = function () {
-        return toPrimitive$$1(this.get());
+    ObservableValue.prototype.valueOf = function () {
+        return toPrimitive(this.get());
     };
-    return ObservableValue$$1;
-}(Atom$$1));
-ObservableValue$$1.prototype[primitiveSymbol$$1()] = ObservableValue$$1.prototype.valueOf;
-var isObservableValue$$1 = createInstanceofPredicate$$1("ObservableValue", ObservableValue$$1);
+    return ObservableValue;
+}(Atom));
+ObservableValue.prototype[primitiveSymbol()] = ObservableValue.prototype.valueOf;
+var isObservableValue = createInstanceofPredicate("ObservableValue", ObservableValue);
 
 /**
  * A node in the state dependency root that observes other nodes, and can be observed itself.
@@ -847,7 +836,7 @@ var isObservableValue$$1 = createInstanceofPredicate$$1("ObservableValue", Obser
  *
  * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
  */
-var ComputedValue$$1 = /** @class */ (function () {
+var ComputedValue = /** @class */ (function () {
     /**
      * Create a new computed value based on a function expression.
      *
@@ -860,7 +849,7 @@ var ComputedValue$$1 = /** @class */ (function () {
      * don't want to notify observers if it is structurally the same.
      * This is useful for working with vectors, mouse coordinates etc.
      */
-    function ComputedValue$$1(options) {
+    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
@@ -873,66 +862,66 @@ var ComputedValue$$1 = /** @class */ (function () {
         this.lastAccessedBy = 0;
         this.lowestObserverState = IDerivationState.UP_TO_DATE;
         this.unboundDepsCount = 0;
-        this.__mapid = "#" + getNextId$$1();
-        this.value = new CaughtException$$1(null);
+        this.__mapid = "#" + getNextId();
+        this.value = new CaughtException(null);
         this.isComputing = false; // to check for cycles
         this.isRunningSetter = false;
-        this.isTracing = TraceMode$$1.NONE;
+        this.isTracing = TraceMode.NONE;
         if (process.env.NODE_ENV !== "production" && !options.get)
-            return fail$$1("missing option for computed: get");
+            return fail("missing option for computed: get");
         this.derivation = options.get;
-        this.name = options.name || "ComputedValue@" + getNextId$$1();
+        this.name = options.name || "ComputedValue@" + getNextId();
         if (options.set)
-            this.setter = createAction$$1(this.name + "-setter", options.set);
+            this.setter = createAction(this.name + "-setter", options.set);
         this.equals =
             options.equals ||
                 (options.compareStructural || options.struct
-                    ? comparer$$1.structural
-                    : comparer$$1.default);
+                    ? comparer.structural
+                    : comparer.default);
         this.scope = options.context;
         this.requiresReaction = !!options.requiresReaction;
         this.keepAlive = !!options.keepAlive;
     }
-    ComputedValue$$1.prototype.onBecomeStale = function () {
-        propagateMaybeChanged$$1(this);
+    ComputedValue.prototype.onBecomeStale = function () {
+        propagateMaybeChanged(this);
     };
-    ComputedValue$$1.prototype.onBecomeUnobserved = function () { };
-    ComputedValue$$1.prototype.onBecomeObserved = function () { };
+    ComputedValue.prototype.onBecomeUnobserved = function () { };
+    ComputedValue.prototype.onBecomeObserved = function () { };
     /**
      * Returns the current value of this computed value.
      * Will evaluate its computation first if needed.
      */
-    ComputedValue$$1.prototype.get = function () {
+    ComputedValue.prototype.get = function () {
         if (this.isComputing)
-            fail$$1("Cycle detected in computation " + this.name + ": " + this.derivation);
-        if (globalState$$1.inBatch === 0 && this.observers.length === 0 && !this.keepAlive) {
-            if (shouldCompute$$1(this)) {
+            fail("Cycle detected in computation " + this.name + ": " + this.derivation);
+        if (globalState.inBatch === 0 && this.observers.length === 0 && !this.keepAlive) {
+            if (shouldCompute(this)) {
                 this.warnAboutUntrackedRead();
-                startBatch$$1(); // See perf test 'computed memoization'
+                startBatch(); // See perf test 'computed memoization'
                 this.value = this.computeValue(false);
-                endBatch$$1();
+                endBatch();
             }
         }
         else {
-            reportObserved$$1(this);
-            if (shouldCompute$$1(this))
+            reportObserved(this);
+            if (shouldCompute(this))
                 if (this.trackAndCompute())
-                    propagateChangeConfirmed$$1(this);
+                    propagateChangeConfirmed(this);
         }
         var result = this.value;
-        if (isCaughtException$$1(result))
+        if (isCaughtException(result))
             throw result.cause;
         return result;
     };
-    ComputedValue$$1.prototype.peek = function () {
+    ComputedValue.prototype.peek = function () {
         var res = this.computeValue(false);
-        if (isCaughtException$$1(res))
+        if (isCaughtException(res))
             throw res.cause;
         return res;
     };
-    ComputedValue$$1.prototype.set = function (value) {
+    ComputedValue.prototype.set = function (value) {
         if (this.setter) {
-            invariant$$1(!this.isRunningSetter, "The setter of computed value '" + this.name + "' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?");
+            invariant(!this.isRunningSetter, "The setter of computed value '" + this.name + "' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?");
             this.isRunningSetter = true;
             try {
                 this.setter.call(this.scope, value);
@@ -942,12 +931,12 @@ var ComputedValue$$1 = /** @class */ (function () {
             }
         }
         else
-            invariant$$1(false, process.env.NODE_ENV !== "production" &&
+            invariant(false, process.env.NODE_ENV !== "production" &&
                 "[ComputedValue '" + this.name + "'] It is not possible to assign a new value to a computed value.");
     };
-    ComputedValue$$1.prototype.trackAndCompute = function () {
-        if (isSpyEnabled$$1()) {
-            spyReport$$1({
+    ComputedValue.prototype.trackAndCompute = function () {
+        if (isSpyEnabled()) {
+            spyReport({
                 object: this.scope,
                 type: "compute",
                 name: this.name
@@ -958,23 +947,23 @@ var ComputedValue$$1 = /** @class */ (function () {
         /* see #1208 */ this.dependenciesState === IDerivationState.NOT_TRACKING;
         var newValue = this.computeValue(true);
         var changed = wasSuspended ||
-            isCaughtException$$1(oldValue) ||
-            isCaughtException$$1(newValue) ||
+            isCaughtException(oldValue) ||
+            isCaughtException(newValue) ||
             !this.equals(oldValue, newValue);
         if (changed) {
             this.value = newValue;
         }
         return changed;
     };
-    ComputedValue$$1.prototype.computeValue = function (track) {
+    ComputedValue.prototype.computeValue = function (track) {
         this.isComputing = true;
-        globalState$$1.computationDepth++;
+        globalState.computationDepth++;
         var res;
         if (track) {
-            res = trackDerivedFunction$$1(this, this.derivation, this.scope);
+            res = trackDerivedFunction(this, this.derivation, this.scope);
         }
         else {
-            if (globalState$$1.disableErrorBoundaries === true) {
+            if (globalState.disableErrorBoundaries === true) {
                 res = this.derivation.call(this.scope);
             }
             else {
@@ -982,102 +971,102 @@ var ComputedValue$$1 = /** @class */ (function () {
                     res = this.derivation.call(this.scope);
                 }
                 catch (e) {
-                    res = new CaughtException$$1(e);
+                    res = new CaughtException(e);
                 }
             }
         }
-        globalState$$1.computationDepth--;
+        globalState.computationDepth--;
         this.isComputing = false;
         return res;
     };
-    ComputedValue$$1.prototype.suspend = function () {
+    ComputedValue.prototype.suspend = function () {
         if (!this.keepAlive) {
-            clearObserving$$1(this);
+            clearObserving(this);
             this.value = undefined; // don't hold on to computed value!
         }
     };
-    ComputedValue$$1.prototype.observe = function (listener, fireImmediately) {
+    ComputedValue.prototype.observe = function (listener, fireImmediately) {
         var _this = this;
         var firstTime = true;
         var prevValue = undefined;
-        return autorun$$1(function () {
+        return autorun(function () {
             var newValue = _this.get();
             if (!firstTime || fireImmediately) {
-                var prevU = untrackedStart$$1();
+                var prevU = untrackedStart();
                 listener({
                     type: "update",
                     object: _this,
                     newValue: newValue,
                     oldValue: prevValue
                 });
-                untrackedEnd$$1(prevU);
+                untrackedEnd(prevU);
             }
             firstTime = false;
             prevValue = newValue;
         });
     };
-    ComputedValue$$1.prototype.warnAboutUntrackedRead = function () {
+    ComputedValue.prototype.warnAboutUntrackedRead = function () {
         if (process.env.NODE_ENV === "production")
             return;
         if (this.requiresReaction === true) {
-            fail$$1("[mobx] Computed value " + this.name + " is read outside a reactive context");
+            fail("[mobx] Computed value " + this.name + " is read outside a reactive context");
         }
-        if (this.isTracing !== TraceMode$$1.NONE) {
+        if (this.isTracing !== TraceMode.NONE) {
             console.log("[mobx.trace] '" + this.name + "' is being read outside a reactive context. Doing a full recompute");
         }
-        if (globalState$$1.computedRequiresReaction) {
+        if (globalState.computedRequiresReaction) {
             console.warn("[mobx] Computed value " + this.name + " is being read outside a reactive context. Doing a full recompute");
         }
     };
-    ComputedValue$$1.prototype.toJSON = function () {
+    ComputedValue.prototype.toJSON = function () {
         return this.get();
     };
-    ComputedValue$$1.prototype.toString = function () {
+    ComputedValue.prototype.toString = function () {
         return this.name + "[" + this.derivation.toString() + "]";
     };
-    ComputedValue$$1.prototype.valueOf = function () {
-        return toPrimitive$$1(this.get());
+    ComputedValue.prototype.valueOf = function () {
+        return toPrimitive(this.get());
     };
-    return ComputedValue$$1;
+    return ComputedValue;
 }());
-ComputedValue$$1.prototype[primitiveSymbol$$1()] = ComputedValue$$1.prototype.valueOf;
-var isComputedValue$$1 = createInstanceofPredicate$$1("ComputedValue", ComputedValue$$1);
+ComputedValue.prototype[primitiveSymbol()] = ComputedValue.prototype.valueOf;
+var isComputedValue = createInstanceofPredicate("ComputedValue", ComputedValue);
 
 var IDerivationState;
-(function (IDerivationState$$1) {
+(function (IDerivationState) {
     // before being run or (outside batch and not being observed)
     // at this point derivation is not holding any data about dependency tree
-    IDerivationState$$1[IDerivationState$$1["NOT_TRACKING"] = -1] = "NOT_TRACKING";
+    IDerivationState[IDerivationState["NOT_TRACKING"] = -1] = "NOT_TRACKING";
     // no shallow dependency changed since last computation
     // won't recalculate derivation
     // this is what makes mobx fast
-    IDerivationState$$1[IDerivationState$$1["UP_TO_DATE"] = 0] = "UP_TO_DATE";
+    IDerivationState[IDerivationState["UP_TO_DATE"] = 0] = "UP_TO_DATE";
     // some deep dependency changed, but don't know if shallow dependency changed
     // will require to check first if UP_TO_DATE or POSSIBLY_STALE
     // currently only ComputedValue will propagate POSSIBLY_STALE
     //
     // having this state is second big optimization:
     // don't have to recompute on every dependency change, but only when it's needed
-    IDerivationState$$1[IDerivationState$$1["POSSIBLY_STALE"] = 1] = "POSSIBLY_STALE";
+    IDerivationState[IDerivationState["POSSIBLY_STALE"] = 1] = "POSSIBLY_STALE";
     // A shallow dependency has changed since last computation and the derivation
     // will need to recompute when it's needed next.
-    IDerivationState$$1[IDerivationState$$1["STALE"] = 2] = "STALE";
+    IDerivationState[IDerivationState["STALE"] = 2] = "STALE";
 })(IDerivationState || (IDerivationState = {}));
-var TraceMode$$1;
-(function (TraceMode$$1) {
-    TraceMode$$1[TraceMode$$1["NONE"] = 0] = "NONE";
-    TraceMode$$1[TraceMode$$1["LOG"] = 1] = "LOG";
-    TraceMode$$1[TraceMode$$1["BREAK"] = 2] = "BREAK";
-})(TraceMode$$1 || (TraceMode$$1 = {}));
-var CaughtException$$1 = /** @class */ (function () {
-    function CaughtException$$1(cause) {
+var TraceMode;
+(function (TraceMode) {
+    TraceMode[TraceMode["NONE"] = 0] = "NONE";
+    TraceMode[TraceMode["LOG"] = 1] = "LOG";
+    TraceMode[TraceMode["BREAK"] = 2] = "BREAK";
+})(TraceMode || (TraceMode = {}));
+var CaughtException = /** @class */ (function () {
+    function CaughtException(cause) {
         this.cause = cause;
         // Empty
     }
-    return CaughtException$$1;
+    return CaughtException;
 }());
-function isCaughtException$$1(e) {
-    return e instanceof CaughtException$$1;
+function isCaughtException(e) {
+    return e instanceof CaughtException;
 }
 /**
  * Finds out whether any dependency of the derivation has actually changed.
@@ -1090,7 +1079,7 @@ function isCaughtException$$1(e) {
  * dependencies of the derivation doesn't change then the derivation should run the same way
  * up until accessing x-th dependency.
  */
-function shouldCompute$$1(derivation) {
+function shouldCompute(derivation) {
     switch (derivation.dependenciesState) {
         case IDerivationState.UP_TO_DATE:
             return false;
@@ -1098,12 +1087,12 @@ function shouldCompute$$1(derivation) {
         case IDerivationState.STALE:
             return true;
         case IDerivationState.POSSIBLY_STALE: {
-            var prevUntracked = untrackedStart$$1(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.
+            var prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.
             var obs = derivation.observing, l = obs.length;
             for (var i = 0; i < l; i++) {
                 var obj = obs[i];
-                if (isComputedValue$$1(obj)) {
-                    if (globalState$$1.disableErrorBoundaries) {
+                if (isComputedValue(obj)) {
+                    if (globalState.disableErrorBoundaries) {
                         obj.get();
                     }
                     else {
@@ -1112,7 +1101,7 @@ function shouldCompute$$1(derivation) {
                         }
                         catch (e) {
                             // we are not interested in the value *or* exception at this moment, but if there is one, notify all
-                            untrackedEnd$$1(prevUntracked);
+                            untrackedEnd(prevUntracked);
                             return true;
                         }
                     }
@@ -1120,13 +1109,13 @@ function shouldCompute$$1(derivation) {
                     // and `derivation` is an observer of `obj`
                     // invariantShouldCompute(derivation)
                     if (derivation.dependenciesState === IDerivationState.STALE) {
-                        untrackedEnd$$1(prevUntracked);
+                        untrackedEnd(prevUntracked);
                         return true;
                     }
                 }
             }
-            changeDependenciesStateTo0$$1(derivation);
-            untrackedEnd$$1(prevUntracked);
+            changeDependenciesStateTo0(derivation);
+            untrackedEnd(prevUntracked);
             return false;
         }
     }
@@ -1140,19 +1129,19 @@ function shouldCompute$$1(derivation) {
 //     )
 //         fail("Illegal dependency state")
 // }
-function isComputingDerivation$$1() {
-    return globalState$$1.trackingDerivation !== null; // filter out actions inside computations
+function isComputingDerivation() {
+    return globalState.trackingDerivation !== null; // filter out actions inside computations
 }
-function checkIfStateModificationsAreAllowed$$1(atom) {
-    var hasObservers$$1 = atom.observers.length > 0;
+function checkIfStateModificationsAreAllowed(atom) {
+    var hasObservers = atom.observers.length > 0;
     // Should never be possible to change an observed observable from inside computed, see #798
-    if (globalState$$1.computationDepth > 0 && hasObservers$$1)
-        fail$$1(process.env.NODE_ENV !== "production" &&
+    if (globalState.computationDepth > 0 && hasObservers)
+        fail(process.env.NODE_ENV !== "production" &&
             "Computed values are not allowed to cause side effects by changing observables that are already being observed. Tried to modify: " + atom.name);
     // Should not be possible to change observed state outside strict mode, except during initialization, see #563
-    if (!globalState$$1.allowStateChanges && (hasObservers$$1 || globalState$$1.enforceActions === "strict"))
-        fail$$1(process.env.NODE_ENV !== "production" &&
-            (globalState$$1.enforceActions
+    if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === "strict"))
+        fail(process.env.NODE_ENV !== "production" &&
+            (globalState.enforceActions
                 ? "Since strict-mode is enabled, changing observed observable values outside actions is not allowed. Please wrap the code in an `action` if this change is intended. Tried to modify: "
                 : "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, the render function of a React component? Tried to modify: ") +
                 atom.name);
@@ -1162,17 +1151,17 @@ function checkIfStateModificationsAreAllowed$$1(atom) {
  * The tracking information is stored on the `derivation` object and the derivation is registered
  * as observer of any of the accessed observables.
  */
-function trackDerivedFunction$$1(derivation, f, context) {
+function trackDerivedFunction(derivation, f, context) {
     // pre allocate array allocation + room for variation in deps
     // array will be trimmed by bindDependencies
-    changeDependenciesStateTo0$$1(derivation);
+    changeDependenciesStateTo0(derivation);
     derivation.newObserving = new Array(derivation.observing.length + 100);
     derivation.unboundDepsCount = 0;
-    derivation.runId = ++globalState$$1.runId;
-    var prevTracking = globalState$$1.trackingDerivation;
-    globalState$$1.trackingDerivation = derivation;
+    derivation.runId = ++globalState.runId;
+    var prevTracking = globalState.trackingDerivation;
+    globalState.trackingDerivation = derivation;
     var result;
-    if (globalState$$1.disableErrorBoundaries === true) {
+    if (globalState.disableErrorBoundaries === true) {
         result = f.call(context);
     }
     else {
@@ -1180,10 +1169,10 @@ function trackDerivedFunction$$1(derivation, f, context) {
             result = f.call(context);
         }
         catch (e) {
-            result = new CaughtException$$1(e);
+            result = new CaughtException(e);
         }
     }
-    globalState$$1.trackingDerivation = prevTracking;
+    globalState.trackingDerivation = prevTracking;
     bindDependencies(derivation);
     return result;
 }
@@ -1224,7 +1213,7 @@ function bindDependencies(derivation) {
     while (l--) {
         var dep = prevObserving[l];
         if (dep.diffValue === 0) {
-            removeObserver$$1(dep, derivation);
+            removeObserver(dep, derivation);
         }
         dep.diffValue = 0;
     }
@@ -1235,7 +1224,7 @@ function bindDependencies(derivation) {
         var dep = observing[i0];
         if (dep.diffValue === 1) {
             dep.diffValue = 0;
-            addObserver$$1(dep, derivation);
+            addObserver(dep, derivation);
         }
     }
     // Some new observed derivations may become stale during this derivation computation
@@ -1245,34 +1234,34 @@ function bindDependencies(derivation) {
         derivation.onBecomeStale();
     }
 }
-function clearObserving$$1(derivation) {
+function clearObserving(derivation) {
     // invariant(globalState.inBatch > 0, "INTERNAL ERROR clearObserving should be called only inside batch");
     var obs = derivation.observing;
     derivation.observing = [];
     var i = obs.length;
     while (i--)
-        removeObserver$$1(obs[i], derivation);
+        removeObserver(obs[i], derivation);
     derivation.dependenciesState = IDerivationState.NOT_TRACKING;
 }
-function untracked$$1(action$$1) {
-    var prev = untrackedStart$$1();
-    var res = action$$1();
-    untrackedEnd$$1(prev);
+function untracked(action) {
+    var prev = untrackedStart();
+    var res = action();
+    untrackedEnd(prev);
     return res;
 }
-function untrackedStart$$1() {
-    var prev = globalState$$1.trackingDerivation;
-    globalState$$1.trackingDerivation = null;
+function untrackedStart() {
+    var prev = globalState.trackingDerivation;
+    globalState.trackingDerivation = null;
     return prev;
 }
-function untrackedEnd$$1(prev) {
-    globalState$$1.trackingDerivation = prev;
+function untrackedEnd(prev) {
+    globalState.trackingDerivation = prev;
 }
 /**
  * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0
  *
  */
-function changeDependenciesStateTo0$$1(derivation) {
+function changeDependenciesStateTo0(derivation) {
     if (derivation.dependenciesState === IDerivationState.UP_TO_DATE)
         return;
     derivation.dependenciesState = IDerivationState.UP_TO_DATE;
@@ -1294,8 +1283,8 @@ var persistentKeys = [
     "runId",
     "UNCHANGED"
 ];
-var MobXGlobals$$1 = /** @class */ (function () {
-    function MobXGlobals$$1() {
+var MobXGlobals = /** @class */ (function () {
+    function MobXGlobals() {
         /**
          * MobXGlobals version.
          * MobX compatiblity with other versions loaded in memory as long as this version matches.
@@ -1366,6 +1355,11 @@ var MobXGlobals$$1 = /** @class */ (function () {
          * Warn if computed values are accessed outside a reactive context
          */
         this.computedRequiresReaction = false;
+        /**
+         * Allows overwriting of computed properties, useful in tests but not prod as it can cause
+         * memory leaks. See https://github.com/mobxjs/mobx/issues/1867
+         */
+        this.computedConfigurable = false;
         /*
          * Don't catch and rethrow exceptions. This is useful for inspecting the state of
          * the stack when an exception occurs while debugging.
@@ -1377,23 +1371,23 @@ var MobXGlobals$$1 = /** @class */ (function () {
          */
         this.suppressReactionErrors = false;
     }
-    return MobXGlobals$$1;
+    return MobXGlobals;
 }());
 var canMergeGlobalState = true;
 var isolateCalled = false;
-var globalState$$1 = (function () {
-    var global = getGlobal$$1();
+var globalState = (function () {
+    var global = getGlobal();
     if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals)
         canMergeGlobalState = false;
-    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals$$1().version)
+    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version)
         canMergeGlobalState = false;
     if (!canMergeGlobalState) {
         setTimeout(function () {
             if (!isolateCalled) {
-                fail$$1("There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`");
+                fail("There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`");
             }
         }, 1);
-        return new MobXGlobals$$1();
+        return new MobXGlobals();
     }
     else if (global.__mobxGlobals) {
         global.__mobxInstanceCount += 1;
@@ -1403,41 +1397,41 @@ var globalState$$1 = (function () {
     }
     else {
         global.__mobxInstanceCount = 1;
-        return (global.__mobxGlobals = new MobXGlobals$$1());
+        return (global.__mobxGlobals = new MobXGlobals());
     }
 })();
-function isolateGlobalState$$1() {
-    if (globalState$$1.pendingReactions.length ||
-        globalState$$1.inBatch ||
-        globalState$$1.isRunningReactions)
-        fail$$1("isolateGlobalState should be called before MobX is running any reactions");
+function isolateGlobalState() {
+    if (globalState.pendingReactions.length ||
+        globalState.inBatch ||
+        globalState.isRunningReactions)
+        fail("isolateGlobalState should be called before MobX is running any reactions");
     isolateCalled = true;
     if (canMergeGlobalState) {
-        if (--getGlobal$$1().__mobxInstanceCount === 0)
-            getGlobal$$1().__mobxGlobals = undefined;
-        globalState$$1 = new MobXGlobals$$1();
+        if (--getGlobal().__mobxInstanceCount === 0)
+            getGlobal().__mobxGlobals = undefined;
+        globalState = new MobXGlobals();
     }
 }
-function getGlobalState$$1() {
-    return globalState$$1;
+function getGlobalState() {
+    return globalState;
 }
 /**
  * For testing purposes only; this will break the internal state of existing observables,
  * but can be used to get back at a stable state after throwing errors
  */
-function resetGlobalState$$1() {
-    var defaultGlobals = new MobXGlobals$$1();
+function resetGlobalState() {
+    var defaultGlobals = new MobXGlobals();
     for (var key in defaultGlobals)
         if (persistentKeys.indexOf(key) === -1)
-            globalState$$1[key] = defaultGlobals[key];
-    globalState$$1.allowStateChanges = !globalState$$1.enforceActions;
+            globalState[key] = defaultGlobals[key];
+    globalState.allowStateChanges = !globalState.enforceActions;
 }
 
-function hasObservers$$1(observable$$1) {
-    return observable$$1.observers && observable$$1.observers.length > 0;
+function hasObservers(observable) {
+    return observable.observers && observable.observers.length > 0;
 }
-function getObservers$$1(observable$$1) {
-    return observable$$1.observers;
+function getObservers(observable) {
+    return observable.observers;
 }
 // function invariantObservers(observable: IObservable) {
 //     const list = observable.observers
@@ -1456,34 +1450,34 @@ function getObservers$$1(observable$$1) {
 //         "INTERNAL ERROR there is no junk in map"
 //     )
 // }
-function addObserver$$1(observable$$1, node) {
+function addObserver(observable, node) {
     // invariant(node.dependenciesState !== -1, "INTERNAL ERROR, can add only dependenciesState !== -1");
     // invariant(observable._observers.indexOf(node) === -1, "INTERNAL ERROR add already added node");
     // invariantObservers(observable);
-    var l = observable$$1.observers.length;
+    var l = observable.observers.length;
     if (l) {
         // because object assignment is relatively expensive, let's not store data about index 0.
-        observable$$1.observersIndexes[node.__mapid] = l;
+        observable.observersIndexes[node.__mapid] = l;
     }
-    observable$$1.observers[l] = node;
-    if (observable$$1.lowestObserverState > node.dependenciesState)
-        observable$$1.lowestObserverState = node.dependenciesState;
+    observable.observers[l] = node;
+    if (observable.lowestObserverState > node.dependenciesState)
+        observable.lowestObserverState = node.dependenciesState;
     // invariantObservers(observable);
     // invariant(observable._observers.indexOf(node) !== -1, "INTERNAL ERROR didn't add node");
 }
-function removeObserver$$1(observable$$1, 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");
     // invariantObservers(observable);
-    if (observable$$1.observers.length === 1) {
+    if (observable.observers.length === 1) {
         // deleting last observer
-        observable$$1.observers.length = 0;
-        queueForUnobservation$$1(observable$$1);
+        observable.observers.length = 0;
+        queueForUnobservation(observable);
     }
     else {
         // deleting from _observersIndexes is straight forward, to delete from _observers, let's swap `node` with last element
-        var list = observable$$1.observers;
-        var map = observable$$1.observersIndexes;
+        var list = observable.observers;
+        var map = observable.observersIndexes;
         var filler = list.pop(); // get last element, which should fill the place of `node`, so the array doesn't have holes
         if (filler !== node) {
             // otherwise node was the last element, which already got removed from array
@@ -1502,11 +1496,11 @@ function removeObserver$$1(observable$$1, node) {
     // invariantObservers(observable);
     // invariant(observable._observers.indexOf(node) === -1, "INTERNAL ERROR remove already removed node2");
 }
-function queueForUnobservation$$1(observable$$1) {
-    if (observable$$1.isPendingUnobservation === false) {
+function queueForUnobservation(observable) {
+    if (observable.isPendingUnobservation === false) {
         // invariant(observable._observers.length === 0, "INTERNAL ERROR, should only queue for unobservation unobserved observables");
-        observable$$1.isPendingUnobservation = true;
-        globalState$$1.pendingUnobservations.push(observable$$1);
+        observable.isPendingUnobservation = true;
+        globalState.pendingUnobservations.push(observable);
     }
 }
 /**
@@ -1514,53 +1508,53 @@ function queueForUnobservation$$1(observable$$1) {
  * During a batch `onBecomeUnobserved` will be called at most once per observable.
  * Avoids unnecessary recalculations.
  */
-function startBatch$$1() {
-    globalState$$1.inBatch++;
+function startBatch() {
+    globalState.inBatch++;
 }
-function endBatch$$1() {
-    if (--globalState$$1.inBatch === 0) {
-        runReactions$$1();
+function endBatch() {
+    if (--globalState.inBatch === 0) {
+        runReactions();
         // the batch is actually about to finish, all unobserving should happen here.
-        var list = globalState$$1.pendingUnobservations;
+        var list = globalState.pendingUnobservations;
         for (var i = 0; i < list.length; i++) {
-            var observable$$1 = list[i];
-            observable$$1.isPendingUnobservation = false;
-            if (observable$$1.observers.length === 0) {
-                if (observable$$1.isBeingObserved) {
+            var observable = list[i];
+            observable.isPendingUnobservation = false;
+            if (observable.observers.length === 0) {
+                if (observable.isBeingObserved) {
                     // if this observable had reactive observers, trigger the hooks
-                    observable$$1.isBeingObserved = false;
-                    observable$$1.onBecomeUnobserved();
+                    observable.isBeingObserved = false;
+                    observable.onBecomeUnobserved();
                 }
-                if (observable$$1 instanceof ComputedValue$$1) {
+                if (observable instanceof ComputedValue) {
                     // computed values are automatically teared down when the last observer leaves
                     // this process happens recursively, this computed might be the last observabe of another, etc..
-                    observable$$1.suspend();
+                    observable.suspend();
                 }
             }
         }
-        globalState$$1.pendingUnobservations = [];
+        globalState.pendingUnobservations = [];
     }
 }
-function reportObserved$$1(observable$$1) {
-    var derivation = globalState$$1.trackingDerivation;
+function reportObserved(observable) {
+    var derivation = globalState.trackingDerivation;
     if (derivation !== null) {
         /**
          * Simple optimization, give each derivation run an unique id (runId)
          * Check if last time this observable was accessed the same runId is used
          * if this is the case, the relation is already known
          */
-        if (derivation.runId !== observable$$1.lastAccessedBy) {
-            observable$$1.lastAccessedBy = derivation.runId;
-            derivation.newObserving[derivation.unboundDepsCount++] = observable$$1;
-            if (!observable$$1.isBeingObserved) {
-                observable$$1.isBeingObserved = true;
-                observable$$1.onBecomeObserved();
+        if (derivation.runId !== observable.lastAccessedBy) {
+            observable.lastAccessedBy = derivation.runId;
+            derivation.newObserving[derivation.unboundDepsCount++] = observable;
+            if (!observable.isBeingObserved) {
+                observable.isBeingObserved = true;
+                observable.onBecomeObserved();
             }
         }
         return true;
     }
-    else if (observable$$1.observers.length === 0 && globalState$$1.inBatch > 0) {
-        queueForUnobservation$$1(observable$$1);
+    else if (observable.observers.length === 0 && globalState.inBatch > 0) {
+        queueForUnobservation(observable);
     }
     return false;
 }
@@ -1585,18 +1579,18 @@ function reportObserved$$1(observable$$1) {
  * Also most basic use cases should be ok
  */
 // Called by Atom when its value changes
-function propagateChanged$$1(observable$$1) {
+function propagateChanged(observable) {
     // invariantLOS(observable, "changed start");
-    if (observable$$1.lowestObserverState === IDerivationState.STALE)
+    if (observable.lowestObserverState === IDerivationState.STALE)
         return;
-    observable$$1.lowestObserverState = IDerivationState.STALE;
-    var observers = observable$$1.observers;
+    observable.lowestObserverState = IDerivationState.STALE;
+    var observers = observable.observers;
     var i = observers.length;
     while (i--) {
         var d = observers[i];
         if (d.dependenciesState === IDerivationState.UP_TO_DATE) {
-            if (d.isTracing !== TraceMode$$1.NONE) {
-                logTraceInfo(d, observable$$1);
+            if (d.isTracing !== TraceMode.NONE) {
+                logTraceInfo(d, observable);
             }
             d.onBecomeStale();
         }
@@ -1605,12 +1599,12 @@ function propagateChanged$$1(observable$$1) {
     // invariantLOS(observable, "changed end");
 }
 // Called by ComputedValue when it recalculate and its value changed
-function propagateChangeConfirmed$$1(observable$$1) {
+function propagateChangeConfirmed(observable) {
     // invariantLOS(observable, "confirmed start");
-    if (observable$$1.lowestObserverState === IDerivationState.STALE)
+    if (observable.lowestObserverState === IDerivationState.STALE)
         return;
-    observable$$1.lowestObserverState = IDerivationState.STALE;
-    var observers = observable$$1.observers;
+    observable.lowestObserverState = IDerivationState.STALE;
+    var observers = observable.observers;
     var i = observers.length;
     while (i--) {
         var d = observers[i];
@@ -1618,37 +1612,37 @@ function propagateChangeConfirmed$$1(observable$$1) {
             d.dependenciesState = IDerivationState.STALE;
         else if (d.dependenciesState === IDerivationState.UP_TO_DATE // this happens during computing of `d`, just keep lowestObserverState up to date.
         )
-            observable$$1.lowestObserverState = IDerivationState.UP_TO_DATE;
+            observable.lowestObserverState = IDerivationState.UP_TO_DATE;
     }
     // invariantLOS(observable, "confirmed end");
 }
 // Used by computed when its dependency changed, but we don't wan't to immediately recompute.
-function propagateMaybeChanged$$1(observable$$1) {
+function propagateMaybeChanged(observable) {
     // invariantLOS(observable, "maybe start");
-    if (observable$$1.lowestObserverState !== IDerivationState.UP_TO_DATE)
+    if (observable.lowestObserverState !== IDerivationState.UP_TO_DATE)
         return;
-    observable$$1.lowestObserverState = IDerivationState.POSSIBLY_STALE;
-    var observers = observable$$1.observers;
+    observable.lowestObserverState = IDerivationState.POSSIBLY_STALE;
+    var observers = observable.observers;
     var i = observers.length;
     while (i--) {
         var d = observers[i];
         if (d.dependenciesState === IDerivationState.UP_TO_DATE) {
             d.dependenciesState = IDerivationState.POSSIBLY_STALE;
-            if (d.isTracing !== TraceMode$$1.NONE) {
-                logTraceInfo(d, observable$$1);
+            if (d.isTracing !== TraceMode.NONE) {
+                logTraceInfo(d, observable);
             }
             d.onBecomeStale();
         }
     }
     // invariantLOS(observable, "maybe end");
 }
-function logTraceInfo(derivation, observable$$1) {
-    console.log("[mobx.trace] '" + derivation.name + "' is invalidated due to a change in: '" + observable$$1.name + "'");
-    if (derivation.isTracing === TraceMode$$1.BREAK) {
+function logTraceInfo(derivation, observable) {
+    console.log("[mobx.trace] '" + derivation.name + "' is invalidated due to a change in: '" + observable.name + "'");
+    if (derivation.isTracing === TraceMode.BREAK) {
         var lines = [];
-        printDepTree(getDependencyTree$$1(derivation), lines, 1);
+        printDepTree(getDependencyTree(derivation), lines, 1);
         // prettier-ignore
-        new Function("debugger;\n/*\nTracing '" + derivation.name + "'\n\nYou are entering this break point because derivation '" + derivation.name + "' is being traced and '" + observable$$1.name + "' is now forcing it to update.\nJust follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update\nThe stackframe you are looking for is at least ~6-8 stack-frames up.\n\n" + (derivation instanceof ComputedValue$$1 ? derivation.derivation.toString().replace(/[*]\//g, "/") : "") + "\n\nThe dependencies for this derivation are:\n\n" + lines.join("\n") + "\n*/\n    ")();
+        new Function("debugger;\n/*\nTracing '" + derivation.name + "'\n\nYou are entering this break point because derivation '" + derivation.name + "' is being traced and '" + observable.name + "' is now forcing it to update.\nJust follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update\nThe stackframe you are looking for is at least ~6-8 stack-frames up.\n\n" + (derivation instanceof ComputedValue ? derivation.derivation.toString().replace(/[*]\//g, "/") : "") + "\n\nThe dependencies for this derivation are:\n\n" + lines.join("\n") + "\n*/\n    ")();
     }
 }
 function printDepTree(tree, lines, depth) {
@@ -1661,9 +1655,9 @@ function printDepTree(tree, lines, depth) {
         tree.dependencies.forEach(function (child) { return printDepTree(child, lines, depth + 1); });
 }
 
-var Reaction$$1 = /** @class */ (function () {
-    function Reaction$$1(name, onInvalidate, errorHandler) {
-        if (name === void 0) { name = "Reaction@" + getNextId$$1(); }
+var Reaction = /** @class */ (function () {
+    function Reaction(name, onInvalidate, errorHandler) {
+        if (name === void 0) { name = "Reaction@" + getNextId(); }
         this.name = name;
         this.onInvalidate = onInvalidate;
         this.errorHandler = errorHandler;
@@ -1673,40 +1667,40 @@ var Reaction$$1 = /** @class */ (function () {
         this.diffValue = 0;
         this.runId = 0;
         this.unboundDepsCount = 0;
-        this.__mapid = "#" + getNextId$$1();
+        this.__mapid = "#" + getNextId();
         this.isDisposed = false;
         this._isScheduled = false;
         this._isTrackPending = false;
         this._isRunning = false;
-        this.isTracing = TraceMode$$1.NONE;
+        this.isTracing = TraceMode.NONE;
     }
-    Reaction$$1.prototype.onBecomeStale = function () {
+    Reaction.prototype.onBecomeStale = function () {
         this.schedule();
     };
-    Reaction$$1.prototype.schedule = function () {
+    Reaction.prototype.schedule = function () {
         if (!this._isScheduled) {
             this._isScheduled = true;
-            globalState$$1.pendingReactions.push(this);
-            runReactions$$1();
+            globalState.pendingReactions.push(this);
+            runReactions();
         }
     };
-    Reaction$$1.prototype.isScheduled = function () {
+    Reaction.prototype.isScheduled = function () {
         return this._isScheduled;
     };
     /**
      * internal, use schedule() if you intend to kick off a reaction
      */
-    Reaction$$1.prototype.runReaction = function () {
+    Reaction.prototype.runReaction = function () {
         if (!this.isDisposed) {
-            startBatch$$1();
+            startBatch();
             this._isScheduled = false;
-            if (shouldCompute$$1(this)) {
+            if (shouldCompute(this)) {
                 this._isTrackPending = true;
                 try {
                     this.onInvalidate();
-                    if (this._isTrackPending && isSpyEnabled$$1()) {
+                    if (this._isTrackPending && isSpyEnabled()) {
                         // onInvalidate didn't trigger track right away..
-                        spyReport$$1({
+                        spyReport({
                             name: this.name,
                             type: "scheduled-reaction"
                         });
@@ -1716,94 +1710,94 @@ var Reaction$$1 = /** @class */ (function () {
                     this.reportExceptionInDerivation(e);
                 }
             }
-            endBatch$$1();
+            endBatch();
         }
     };
-    Reaction$$1.prototype.track = function (fn) {
-        startBatch$$1();
-        var notify = isSpyEnabled$$1();
+    Reaction.prototype.track = function (fn) {
+        startBatch();
+        var notify = isSpyEnabled();
         var startTime;
         if (notify) {
             startTime = Date.now();
-            spyReportStart$$1({
+            spyReportStart({
                 name: this.name,
                 type: "reaction"
             });
         }
         this._isRunning = true;
-        var result = trackDerivedFunction$$1(this, fn, undefined);
+        var result = trackDerivedFunction(this, fn, undefined);
         this._isRunning = false;
         this._isTrackPending = false;
         if (this.isDisposed) {
             // disposed during last run. Clean up everything that was bound after the dispose call.
-            clearObserving$$1(this);
+            clearObserving(this);
         }
-        if (isCaughtException$$1(result))
+        if (isCaughtException(result))
             this.reportExceptionInDerivation(result.cause);
         if (notify) {
-            spyReportEnd$$1({
+            spyReportEnd({
                 time: Date.now() - startTime
             });
         }
-        endBatch$$1();
+        endBatch();
     };
-    Reaction$$1.prototype.reportExceptionInDerivation = function (error) {
+    Reaction.prototype.reportExceptionInDerivation = function (error) {
         var _this = this;
         if (this.errorHandler) {
             this.errorHandler(error, this);
             return;
         }
-        if (globalState$$1.disableErrorBoundaries)
+        if (globalState.disableErrorBoundaries)
             throw error;
         var message = "[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '" + this + "'";
-        if (globalState$$1.suppressReactionErrors) {
+        if (globalState.suppressReactionErrors) {
             console.warn("[mobx] (error in reaction '" + this.name + "' suppressed, fix error of causing action below)"); // prettier-ignore
         }
         else {
             console.error(message, error);
             /** If debugging brought you here, please, read the above message :-). Tnx! */
         }
-        if (isSpyEnabled$$1()) {
-            spyReport$$1({
+        if (isSpyEnabled()) {
+            spyReport({
                 type: "error",
                 name: this.name,
                 message: message,
                 error: "" + error
             });
         }
-        globalState$$1.globalReactionErrorHandlers.forEach(function (f) { return f(error, _this); });
+        globalState.globalReactionErrorHandlers.forEach(function (f) { return f(error, _this); });
     };
-    Reaction$$1.prototype.dispose = function () {
+    Reaction.prototype.dispose = function () {
         if (!this.isDisposed) {
             this.isDisposed = true;
             if (!this._isRunning) {
                 // if disposed while running, clean up later. Maybe not optimal, but rare case
-                startBatch$$1();
-                clearObserving$$1(this);
-                endBatch$$1();
+                startBatch();
+                clearObserving(this);
+                endBatch();
             }
         }
     };
-    Reaction$$1.prototype.getDisposer = function () {
+    Reaction.prototype.getDisposer = function () {
         var r = this.dispose.bind(this);
         r.$mobx = this;
         return r;
     };
-    Reaction$$1.prototype.toString = function () {
+    Reaction.prototype.toString = function () {
         return "Reaction[" + this.name + "]";
     };
-    Reaction$$1.prototype.trace = function (enterBreakPoint) {
+    Reaction.prototype.trace = function (enterBreakPoint) {
         if (enterBreakPoint === void 0) { enterBreakPoint = false; }
-        trace$$1(this, enterBreakPoint);
+        trace(this, enterBreakPoint);
     };
-    return Reaction$$1;
+    return Reaction;
 }());
-function onReactionError$$1(handler) {
-    globalState$$1.globalReactionErrorHandlers.push(handler);
+function onReactionError(handler) {
+    globalState.globalReactionErrorHandlers.push(handler);
     return function () {
-        var idx = globalState$$1.globalReactionErrorHandlers.indexOf(handler);
+        var idx = globalState.globalReactionErrorHandlers.indexOf(handler);
         if (idx >= 0)
-            globalState$$1.globalReactionErrorHandlers.splice(idx, 1);
+            globalState.globalReactionErrorHandlers.splice(idx, 1);
     };
 }
 /**
@@ -1813,15 +1807,15 @@ function onReactionError$$1(handler) {
  */
 var MAX_REACTION_ITERATIONS = 100;
 var reactionScheduler = function (f) { return f(); };
-function runReactions$$1() {
+function runReactions() {
     // Trampolining, if runReactions are already running, new reactions will be picked up
-    if (globalState$$1.inBatch > 0 || globalState$$1.isRunningReactions)
+    if (globalState.inBatch > 0 || globalState.isRunningReactions)
         return;
     reactionScheduler(runReactionsHelper);
 }
 function runReactionsHelper() {
-    globalState$$1.isRunningReactions = true;
-    var allReactions = globalState$$1.pendingReactions;
+    globalState.isRunningReactions = true;
+    var allReactions = globalState.pendingReactions;
     var iterations = 0;
     // While running reactions, new reactions might be triggered.
     // Hence we work with two variables and check whether
@@ -1836,57 +1830,57 @@ function runReactionsHelper() {
         for (var i = 0, l = remainingReactions.length; i < l; i++)
             remainingReactions[i].runReaction();
     }
-    globalState$$1.isRunningReactions = false;
+    globalState.isRunningReactions = false;
 }
-var isReaction$$1 = createInstanceofPredicate$$1("Reaction", Reaction$$1);
-function setReactionScheduler$$1(fn) {
+var isReaction = createInstanceofPredicate("Reaction", Reaction);
+function setReactionScheduler(fn) {
     var baseScheduler = reactionScheduler;
     reactionScheduler = function (f) { return fn(function () { return baseScheduler(f); }); };
 }
 
-function isSpyEnabled$$1() {
-    return !!globalState$$1.spyListeners.length;
+function isSpyEnabled() {
+    return !!globalState.spyListeners.length;
 }
-function spyReport$$1(event) {
-    if (!globalState$$1.spyListeners.length)
+function spyReport(event) {
+    if (!globalState.spyListeners.length)
         return;
-    var listeners = globalState$$1.spyListeners;
+    var listeners = globalState.spyListeners;
     for (var i = 0, l = listeners.length; i < l; i++)
         listeners[i](event);
 }
-function spyReportStart$$1(event) {
+function spyReportStart(event) {
     var change = __assign({}, event, { spyReportStart: true });
-    spyReport$$1(change);
+    spyReport(change);
 }
 var END_EVENT = { spyReportEnd: true };
-function spyReportEnd$$1(change) {
+function spyReportEnd(change) {
     if (change)
-        spyReport$$1(__assign({}, change, { spyReportEnd: true }));
+        spyReport(__assign({}, change, { spyReportEnd: true }));
     else
-        spyReport$$1(END_EVENT);
+        spyReport(END_EVENT);
 }
-function spy$$1(listener) {
-    globalState$$1.spyListeners.push(listener);
-    return once$$1(function () {
-        globalState$$1.spyListeners = globalState$$1.spyListeners.filter(function (l) { return l !== listener; });
+function spy(listener) {
+    globalState.spyListeners.push(listener);
+    return once(function () {
+        globalState.spyListeners = globalState.spyListeners.filter(function (l) { return l !== listener; });
     });
 }
 
 function dontReassignFields() {
-    fail$$1(process.env.NODE_ENV !== "production" && "@action fields are not reassignable");
+    fail(process.env.NODE_ENV !== "production" && "@action fields are not reassignable");
 }
-function namedActionDecorator$$1(name) {
+function namedActionDecorator(name) {
     return function (target, prop, descriptor) {
         if (descriptor) {
             if (process.env.NODE_ENV !== "production" && descriptor.get !== undefined) {
-                return fail$$1("@action cannot be used with getters");
+                return fail("@action cannot be used with getters");
             }
             // babel / typescript
             // @action method() { }
             if (descriptor.value) {
                 // typescript
                 return {
-                    value: createAction$$1(name, descriptor.value),
+                    value: createAction(name, descriptor.value),
                     enumerable: false,
                     configurable: true,
                     writable: true // for typescript, this must be writable, otherwise it cannot inherit :/ (see inheritable actions test)
@@ -1900,15 +1894,15 @@ function namedActionDecorator$$1(name) {
                 writable: true,
                 initializer: function () {
                     // N.B: we can't immediately invoke initializer; this would be wrong
-                    return createAction$$1(name, initializer_1.call(this));
+                    return createAction(name, initializer_1.call(this));
                 }
             };
         }
         // bound instance methods
-        return actionFieldDecorator$$1(name).apply(this, arguments);
+        return actionFieldDecorator(name).apply(this, arguments);
     };
 }
-function actionFieldDecorator$$1(name) {
+function actionFieldDecorator(name) {
     // Simple property that writes on first invocation to the current instance
     return function (target, prop, descriptor) {
         Object.defineProperty(target, prop, {
@@ -1918,14 +1912,14 @@ function actionFieldDecorator$$1(name) {
                 return undefined;
             },
             set: function (value) {
-                addHiddenProp$$1(this, prop, action$$1(name, value));
+                addHiddenProp(this, prop, action(name, value));
             }
         });
     };
 }
-function boundActionDecorator$$1(target, propertyName, descriptor, applyToInstance) {
+function boundActionDecorator(target, propertyName, descriptor, applyToInstance) {
     if (applyToInstance === true) {
-        defineBoundAction$$1(target, propertyName, descriptor.value);
+        defineBoundAction(target, propertyName, descriptor.value);
         return null;
     }
     if (descriptor) {
@@ -1936,7 +1930,7 @@ function boundActionDecorator$$1(target, propertyName, descriptor, applyToInstan
             configurable: true,
             enumerable: false,
             get: function () {
-                defineBoundAction$$1(this, propertyName, descriptor.value || descriptor.initializer.call(this));
+                defineBoundAction(this, propertyName, descriptor.value || descriptor.initializer.call(this));
                 return this[propertyName];
             },
             set: dontReassignFields
@@ -1947,7 +1941,7 @@ function boundActionDecorator$$1(target, propertyName, descriptor, applyToInstan
         enumerable: false,
         configurable: true,
         set: function (v) {
-            defineBoundAction$$1(this, propertyName, v);
+            defineBoundAction(this, propertyName, v);
         },
         get: function () {
             return undefined;
@@ -1955,42 +1949,42 @@ function boundActionDecorator$$1(target, propertyName, descriptor, applyToInstan
     };
 }
 
-var action$$1 = function action$$1(arg1, arg2, arg3, arg4) {
+var action = function action(arg1, arg2, arg3, arg4) {
     // action(fn() {})
     if (arguments.length === 1 && typeof arg1 === "function")
-        return createAction$$1(arg1.name || "<unnamed action>", arg1);
+        return createAction(arg1.name || "<unnamed action>", arg1);
     // action("name", fn() {})
     if (arguments.length === 2 && typeof arg2 === "function")
-        return createAction$$1(arg1, arg2);
+        return createAction(arg1, arg2);
     // @action("name") fn() {}
     if (arguments.length === 1 && typeof arg1 === "string")
-        return namedActionDecorator$$1(arg1);
+        return namedActionDecorator(arg1);
     // @action fn() {}
     if (arg4 === true) {
         // apply to instance immediately
-        arg1[arg2] = createAction$$1(arg1.name || arg2, arg3.value);
+        arg1[arg2] = createAction(arg1.name || arg2, arg3.value);
     }
     else {
-        return namedActionDecorator$$1(arg2).apply(null, arguments);
+        return namedActionDecorator(arg2).apply(null, arguments);
     }
 };
-action$$1.bound = boundActionDecorator$$1;
-function runInAction$$1(arg1, arg2) {
+action.bound = boundActionDecorator;
+function runInAction(arg1, arg2) {
     // TODO: deprecate?
     var actionName = typeof arg1 === "string" ? arg1 : arg1.name || "<unnamed action>";
     var fn = typeof arg1 === "function" ? arg1 : arg2;
     if (process.env.NODE_ENV !== "production") {
-        invariant$$1(typeof fn === "function" && fn.length === 0, "`runInAction` expects a function without arguments");
+        invariant(typeof fn === "function" && fn.length === 0, "`runInAction` expects a function without arguments");
         if (typeof actionName !== "string" || !actionName)
-            fail$$1("actions should have valid names, got: '" + actionName + "'");
+            fail("actions should have valid names, got: '" + actionName + "'");
     }
-    return executeAction$$1(actionName, fn, this, undefined);
+    return executeAction(actionName, fn, this, undefined);
 }
-function isAction$$1(thing) {
+function isAction(thing) {
     return typeof thing === "function" && thing.isMobxAction === true;
 }
-function defineBoundAction$$1(target, propertyName, fn) {
-    addHiddenProp$$1(target, propertyName, createAction$$1(propertyName, fn.bind(target)));
+function defineBoundAction(target, propertyName, fn) {
+    addHiddenProp(target, propertyName, createAction(propertyName, fn.bind(target)));
 }
 
 /**
@@ -1999,18 +1993,18 @@ function defineBoundAction$$1(target, propertyName, fn) {
  * @param view The reactive view
  * @returns disposer function, which can be used to stop the view from being updated in the future.
  */
-function autorun$$1(view, opts) {
-    if (opts === void 0) { opts = EMPTY_OBJECT$$1; }
+function autorun(view, opts) {
+    if (opts === void 0) { opts = EMPTY_OBJECT; }
     if (process.env.NODE_ENV !== "production") {
-        invariant$$1(typeof view === "function", "Autorun expects a function as first argument");
-        invariant$$1(isAction$$1(view) === false, "Autorun does not accept actions since actions are untrackable");
+        invariant(typeof view === "function", "Autorun expects a function as first argument");
+        invariant(isAction(view) === false, "Autorun does not accept actions since actions are untrackable");
     }
-    var name = (opts && opts.name) || view.name || "Autorun@" + getNextId$$1();
+    var name = (opts && opts.name) || view.name || "Autorun@" + getNextId();
     var runSync = !opts.scheduler && !opts.delay;
-    var reaction$$1;
+    var reaction;
     if (runSync) {
         // normal autorun
-        reaction$$1 = new Reaction$$1(name, function () {
+        reaction = new Reaction(name, function () {
             this.track(reactionRunner);
         }, opts.onError);
     }
@@ -2018,22 +2012,22 @@ function autorun$$1(view, opts) {
         var scheduler_1 = createSchedulerFromOptions(opts);
         // debounced autorun
         var isScheduled_1 = false;
-        reaction$$1 = new Reaction$$1(name, function () {
+        reaction = new Reaction(name, function () {
             if (!isScheduled_1) {
                 isScheduled_1 = true;
                 scheduler_1(function () {
                     isScheduled_1 = false;
-                    if (!reaction$$1.isDisposed)
-                        reaction$$1.track(reactionRunner);
+                    if (!reaction.isDisposed)
+                        reaction.track(reactionRunner);
                 });
             }
         }, opts.onError);
     }
     function reactionRunner() {
-        view(reaction$$1);
+        view(reaction);
     }
-    reaction$$1.schedule();
-    return reaction$$1.getDisposer();
+    reaction.schedule();
+    return reaction.getDisposer();
 }
 var run = function (f) { return f(); };
 function createSchedulerFromOptions(opts) {
@@ -2043,27 +2037,27 @@ function createSchedulerFromOptions(opts) {
             ? function (f) { return setTimeout(f, opts.delay); }
             : run;
 }
-function reaction$$1(expression, effect, opts) {
-    if (opts === void 0) { opts = EMPTY_OBJECT$$1; }
+function reaction(expression, effect, opts) {
+    if (opts === void 0) { opts = EMPTY_OBJECT; }
     if (typeof opts === "boolean") {
         opts = { fireImmediately: opts };
-        deprecated$$1("Using fireImmediately as argument is deprecated. Use '{ fireImmediately: true }' instead");
+        deprecated("Using fireImmediately as argument is deprecated. Use '{ fireImmediately: true }' instead");
     }
     if (process.env.NODE_ENV !== "production") {
-        invariant$$1(typeof expression === "function", "First argument to reaction should be a function");
-        invariant$$1(typeof opts === "object", "Third argument of reactions should be an object");
+        invariant(typeof expression === "function", "First argument to reaction should be a function");
+        invariant(typeof opts === "object", "Third argument of reactions should be an object");
     }
-    var name = opts.name || "Reaction@" + getNextId$$1();
-    var effectAction = action$$1(name, opts.onError ? wrapErrorHandler(opts.onError, effect) : effect);
+    var name = opts.name || "Reaction@" + getNextId();
+    var effectAction = action(name, opts.onError ? wrapErrorHandler(opts.onError, effect) : effect);
     var runSync = !opts.scheduler && !opts.delay;
     var scheduler = createSchedulerFromOptions(opts);
     var firstTime = true;
     var isScheduled = false;
     var value;
     var equals = opts.compareStructural
-        ? comparer$$1.structural
-        : opts.equals || comparer$$1.default;
-    var r = new Reaction$$1(name, function () {
+        ? comparer.structural
+        : opts.equals || comparer.default;
+    var r = new Reaction(name, function () {
         if (firstTime || runSync) {
             reactionRunner();
         }
@@ -2103,18 +2097,18 @@ function wrapErrorHandler(errorHandler, baseFn) {
     };
 }
 
-function onBecomeObserved$$1(thing, arg2, arg3) {
+function onBecomeObserved(thing, arg2, arg3) {
     return interceptHook("onBecomeObserved", thing, arg2, arg3);
 }
-function onBecomeUnobserved$$1(thing, arg2, arg3) {
+function onBecomeUnobserved(thing, arg2, arg3) {
     return interceptHook("onBecomeUnobserved", thing, arg2, arg3);
 }
 function interceptHook(hook, thing, arg2, arg3) {
-    var atom = typeof arg2 === "string" ? getAtom$$1(thing, arg2) : getAtom$$1(thing);
+    var atom = typeof arg2 === "string" ? getAtom(thing, arg2) : getAtom(thing);
     var cb = typeof arg2 === "string" ? arg3 : arg2;
     var orig = atom[hook];
     if (typeof orig !== "function")
-        return fail$$1(process.env.NODE_ENV !== "production" && "Not an atom that can be (un)observed");
+        return fail(process.env.NODE_ENV !== "production" && "Not an atom that can be (un)observed");
     atom[hook] = function () {
         orig.call(this);
         cb.call(this);
@@ -2124,14 +2118,14 @@ function interceptHook(hook, thing, arg2, arg3) {
     };
 }
 
-function configure$$1(options) {
-    var enforceActions = options.enforceActions, computedRequiresReaction = options.computedRequiresReaction, disableErrorBoundaries = options.disableErrorBoundaries, arrayBuffer = options.arrayBuffer, reactionScheduler = options.reactionScheduler;
+function configure(options) {
+    var enforceActions = options.enforceActions, computedRequiresReaction = options.computedRequiresReaction, computedConfigurable = options.computedConfigurable, disableErrorBoundaries = options.disableErrorBoundaries, arrayBuffer = options.arrayBuffer, reactionScheduler = options.reactionScheduler;
     if (options.isolateGlobalState === true) {
-        isolateGlobalState$$1();
+        isolateGlobalState();
     }
     if (enforceActions !== undefined) {
         if (typeof enforceActions === "boolean" || enforceActions === "strict")
-            deprecated$$1("Deprecated value for 'enforceActions', use 'false' => '\"never\"', 'true' => '\"observed\"', '\"strict\"' => \"'always'\" instead");
+            deprecated("Deprecated value for 'enforceActions', use 'false' => '\"never\"', 'true' => '\"observed\"', '\"strict\"' => \"'always'\" instead");
         var ea = void 0;
         switch (enforceActions) {
             case true:
@@ -2147,30 +2141,33 @@ function configure$$1(options) {
                 ea = "strict";
                 break;
             default:
-                fail$$1("Invalid value for 'enforceActions': '" + enforceActions + "', expected 'never', 'always' or 'observed'");
+                fail("Invalid value for 'enforceActions': '" + enforceActions + "', expected 'never', 'always' or 'observed'");
         }
-        globalState$$1.enforceActions = ea;
-        globalState$$1.allowStateChanges = ea === true || ea === "strict" ? false : true;
+        globalState.enforceActions = ea;
+        globalState.allowStateChanges = ea === true || ea === "strict" ? false : true;
     }
     if (computedRequiresReaction !== undefined) {
-        globalState$$1.computedRequiresReaction = !!computedRequiresReaction;
+        globalState.computedRequiresReaction = !!computedRequiresReaction;
+    }
+    if (computedConfigurable !== undefined) {
+        globalState.computedConfigurable = !!computedConfigurable;
     }
     if (disableErrorBoundaries !== undefined) {
         if (disableErrorBoundaries === true)
             console.warn("WARNING: Debug feature only. MobX will NOT recover from errors if this is on.");
-        globalState$$1.disableErrorBoundaries = !!disableErrorBoundaries;
+        globalState.disableErrorBoundaries = !!disableErrorBoundaries;
     }
     if (typeof arrayBuffer === "number") {
-        reserveArrayBuffer$$1(arrayBuffer);
+        reserveArrayBuffer(arrayBuffer);
     }
     if (reactionScheduler) {
-        setReactionScheduler$$1(reactionScheduler);
+        setReactionScheduler(reactionScheduler);
     }
 }
 
-function decorate$$1(thing, decorators) {
-    if (process.env.NODE_ENV !== "production" && !isPlainObject$$1(decorators))
-        fail$$1("Decorators should be a key value map");
+function decorate(thing, decorators) {
+    if (process.env.NODE_ENV !== "production" && !isPlainObject(decorators))
+        fail("Decorators should be a key value map");
     var target = typeof thing === "function" ? thing.prototype : thing;
     var _loop_1 = function (prop) {
         var propertyDecorators = decorators[prop];
@@ -2179,7 +2176,7 @@ function decorate$$1(thing, decorators) {
         }
         // prettier-ignore
         if (process.env.NODE_ENV !== "production" && !propertyDecorators.every(function (decorator) { return typeof decorator === "function"; }))
-            fail$$1("Decorate: expected a decorator function or array of decorator functions for '" + prop + "'");
+            fail("Decorate: expected a decorator function or array of decorator functions for '" + prop + "'");
         var descriptor = Object.getOwnPropertyDescriptor(target, prop);
         var newDescriptor = propertyDecorators.reduce(function (accDescriptor, decorator) { return decorator(target, prop, accDescriptor); }, descriptor);
         if (newDescriptor)
@@ -2191,42 +2188,42 @@ function decorate$$1(thing, decorators) {
     return thing;
 }
 
-function extendShallowObservable$$1(target, properties, decorators) {
-    deprecated$$1("'extendShallowObservable' is deprecated, use 'extendObservable(target, props, { deep: false })' instead");
-    return extendObservable$$1(target, properties, decorators, shallowCreateObservableOptions$$1);
+function extendShallowObservable(target, properties, decorators) {
+    deprecated("'extendShallowObservable' is deprecated, use 'extendObservable(target, props, { deep: false })' instead");
+    return extendObservable(target, properties, decorators, shallowCreateObservableOptions);
 }
-function extendObservable$$1(target, properties, decorators, options) {
+function extendObservable(target, properties, decorators, options) {
     if (process.env.NODE_ENV !== "production") {
-        invariant$$1(arguments.length >= 2 && arguments.length <= 4, "'extendObservable' expected 2-4 arguments");
-        invariant$$1(typeof target === "object", "'extendObservable' expects an object as first argument");
-        invariant$$1(!isObservableMap$$1(target), "'extendObservable' should not be used on maps, use map.merge instead");
-        invariant$$1(!isObservable$$1(properties), "Extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540");
+        invariant(arguments.length >= 2 && arguments.length <= 4, "'extendObservable' expected 2-4 arguments");
+        invariant(typeof target === "object", "'extendObservable' expects an object as first argument");
+        invariant(!isObservableMap(target), "'extendObservable' should not be used on maps, use map.merge instead");
+        invariant(!isObservable(properties), "Extending an object with another observable (object) is not supported. Please construct an explicit propertymap, using `toJS` if need. See issue #540");
         if (decorators)
             for (var key in decorators)
                 if (!(key in properties))
-                    fail$$1("Trying to declare a decorator for unspecified property '" + key + "'");
+                    fail("Trying to declare a decorator for unspecified property '" + key + "'");
     }
-    options = asCreateObservableOptions$$1(options);
-    var defaultDecorator = options.defaultDecorator || (options.deep === false ? refDecorator$$1 : deepDecorator$$1);
-    initializeInstance$$1(target);
-    asObservableObject$$1(target, options.name, defaultDecorator.enhancer); // make sure object is observable, even without initial props
-    startBatch$$1();
+    options = asCreateObservableOptions(options);
+    var defaultDecorator = options.defaultDecorator || (options.deep === false ? refDecorator : deepDecorator);
+    initializeInstance(target);
+    asObservableObject(target, options.name, defaultDecorator.enhancer); // make sure object is observable, even without initial props
+    startBatch();
     try {
         for (var key in properties) {
             var descriptor = Object.getOwnPropertyDescriptor(properties, key);
             if (process.env.NODE_ENV !== "production") {
                 if (Object.getOwnPropertyDescriptor(target, key))
-                    fail$$1("'extendObservable' can only be used to introduce new properties. Use 'set' or 'decorate' instead. The property '" + key + "' already exists on '" + target + "'");
-                if (isComputed$$1(descriptor.value))
-                    fail$$1("Passing a 'computed' as initial property value is no longer supported by extendObservable. Use a getter or decorator instead");
+                    fail("'extendObservable' can only be used to introduce new properties. Use 'set' or 'decorate' instead. The property '" + key + "' already exists on '" + target + "'");
+                if (isComputed(descriptor.value))
+                    fail("Passing a 'computed' as initial property value is no longer supported by extendObservable. Use a getter or decorator instead");
             }
             var decorator = decorators && key in decorators
                 ? decorators[key]
                 : descriptor.get
-                    ? computedDecorator$$1
+                    ? computedDecorator
                     : defaultDecorator;
             if (process.env.NODE_ENV !== "production" && typeof decorator !== "function")
-                return fail$$1("Not a valid decorator for '" + key + "', got: " + decorator);
+                return fail("Not a valid decorator for '" + key + "', got: " + decorator);
             var resultDescriptor = decorator(target, key, descriptor, true);
             if (resultDescriptor // otherwise, assume already applied, due to `applyToInstance`
             )
@@ -2234,45 +2231,45 @@ function extendObservable$$1(target, properties, decorators, options) {
         }
     }
     finally {
-        endBatch$$1();
+        endBatch();
     }
     return target;
 }
 
-function getDependencyTree$$1(thing, property) {
-    return nodeToDependencyTree(getAtom$$1(thing, property));
+function getDependencyTree(thing, property) {
+    return nodeToDependencyTree(getAtom(thing, property));
 }
 function nodeToDependencyTree(node) {
     var result = {
         name: node.name
     };
     if (node.observing && node.observing.length > 0)
-        result.dependencies = unique$$1(node.observing).map(nodeToDependencyTree);
+        result.dependencies = unique(node.observing).map(nodeToDependencyTree);
     return result;
 }
-function getObserverTree$$1(thing, property) {
-    return nodeToObserverTree(getAtom$$1(thing, property));
+function getObserverTree(thing, property) {
+    return nodeToObserverTree(getAtom(thing, property));
 }
 function nodeToObserverTree(node) {
     var result = {
         name: node.name
     };
-    if (hasObservers$$1(node))
-        result.observers = getObservers$$1(node).map(nodeToObserverTree);
+    if (hasObservers(node))
+        result.observers = getObservers(node).map(nodeToObserverTree);
     return result;
 }
 
 var generatorId = 0;
-function flow$$1(generator) {
+function flow(generator) {
     if (arguments.length !== 1)
-        fail$$1(process.env.NODE_ENV && "Flow expects one 1 argument and cannot be used as decorator");
+        fail(!!process.env.NODE_ENV && "Flow expects one 1 argument and cannot be used as decorator");
     var name = generator.name || "<unnamed flow>";
     // Implementation based on https://github.com/tj/co/blob/master/index.js
     return function () {
         var ctx = this;
         var args = arguments;
         var runId = ++generatorId;
-        var gen = action$$1(name + " - runid: " + runId + " - init", generator).apply(ctx, args);
+        var gen = action(name + " - runid: " + runId + " - init", generator).apply(ctx, args);
         var rejector;
         var pendingPromise = undefined;
         var res = new Promise(function (resolve, reject) {
@@ -2282,7 +2279,7 @@ function flow$$1(generator) {
                 pendingPromise = undefined;
                 var ret;
                 try {
-                    ret = action$$1(name + " - runid: " + runId + " - yield " + stepId++, gen.next).call(gen, res);
+                    ret = action(name + " - runid: " + runId + " - yield " + stepId++, gen.next).call(gen, res);
                 }
                 catch (e) {
                     return reject(e);
@@ -2293,7 +2290,7 @@ function flow$$1(generator) {
                 pendingPromise = undefined;
                 var ret;
                 try {
-                    ret = action$$1(name + " - runid: " + runId + " - yield " + stepId++, gen.throw).call(gen, err);
+                    ret = action(name + " - runid: " + runId + " - yield " + stepId++, gen.throw).call(gen, err);
                 }
                 catch (e) {
                     return reject(e);
@@ -2313,7 +2310,7 @@ function flow$$1(generator) {
             }
             onFulfilled(undefined); // kick off the process
         });
-        res.cancel = action$$1(name + " - runid: " + runId + " - cancel", function () {
+        res.cancel = action(name + " - runid: " + runId + " - cancel", function () {
             try {
                 if (pendingPromise)
                     cancelPromise(pendingPromise);
@@ -2321,7 +2318,7 @@ function flow$$1(generator) {
                 var res_1 = gen.return();
                 // eat anything that promise would do, it's cancelled!
                 var yieldedPromise = Promise.resolve(res_1.value);
-                yieldedPromise.then(noop$$1, noop$$1);
+                yieldedPromise.then(noop, noop);
                 cancelPromise(yieldedPromise); // maybe it can be cancelled :)
                 // reject our original promise
                 rejector(new Error("FLOW_CANCELLED"));
@@ -2338,66 +2335,66 @@ function cancelPromise(promise) {
         promise.cancel();
 }
 
-function interceptReads$$1(thing, propOrHandler, handler) {
+function interceptReads(thing, propOrHandler, handler) {
     var target;
-    if (isObservableMap$$1(thing) || isObservableArray$$1(thing) || isObservableValue$$1(thing)) {
-        target = getAdministration$$1(thing);
+    if (isObservableMap(thing) || isObservableArray(thing) || isObservableValue(thing)) {
+        target = getAdministration(thing);
     }
-    else if (isObservableObject$$1(thing)) {
+    else if (isObservableObject(thing)) {
         if (typeof propOrHandler !== "string")
-            return fail$$1(process.env.NODE_ENV !== "production" &&
+            return fail(process.env.NODE_ENV !== "production" &&
                 "InterceptReads can only be used with a specific property, not with an object in general");
-        target = getAdministration$$1(thing, propOrHandler);
+        target = getAdministration(thing, propOrHandler);
     }
     else {
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "Expected observable map, object or array as first array");
     }
     if (target.dehancer !== undefined)
-        return fail$$1(process.env.NODE_ENV !== "production" && "An intercept reader was already established");
+        return fail(process.env.NODE_ENV !== "production" && "An intercept reader was already established");
     target.dehancer = typeof propOrHandler === "function" ? propOrHandler : handler;
     return function () {
         target.dehancer = undefined;
     };
 }
 
-function intercept$$1(thing, propOrHandler, handler) {
+function intercept(thing, propOrHandler, handler) {
     if (typeof handler === "function")
         return interceptProperty(thing, propOrHandler, handler);
     else
         return interceptInterceptable(thing, propOrHandler);
 }
 function interceptInterceptable(thing, handler) {
-    return getAdministration$$1(thing).intercept(handler);
+    return getAdministration(thing).intercept(handler);
 }
 function interceptProperty(thing, property, handler) {
-    return getAdministration$$1(thing, property).intercept(handler);
+    return getAdministration(thing, property).intercept(handler);
 }
 
-function _isComputed$$1(value, property) {
+function _isComputed(value, property) {
     if (value === null || value === undefined)
         return false;
     if (property !== undefined) {
-        if (isObservableObject$$1(value) === false)
+        if (isObservableObject(value) === false)
             return false;
         if (!value.$mobx.values[property])
             return false;
-        var atom = getAtom$$1(value, property);
-        return isComputedValue$$1(atom);
+        var atom = getAtom(value, property);
+        return isComputedValue(atom);
     }
-    return isComputedValue$$1(value);
+    return isComputedValue(value);
 }
-function isComputed$$1(value) {
+function isComputed(value) {
     if (arguments.length > 1)
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "isComputed expects only 1 argument. Use isObservableProp to inspect the observability of a property");
-    return _isComputed$$1(value);
+    return _isComputed(value);
 }
-function isComputedProp$$1(value, propName) {
+function isComputedProp(value, propName) {
     if (typeof propName !== "string")
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "isComputed expected a property name as second argument");
-    return _isComputed$$1(value, propName);
+    return _isComputed(value, propName);
 }
 
 function _isObservable(value, property) {
@@ -2405,194 +2402,196 @@ function _isObservable(value, property) {
         return false;
     if (property !== undefined) {
         if (process.env.NODE_ENV !== "production" &&
-            (isObservableMap$$1(value) || isObservableArray$$1(value)))
-            return fail$$1("isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.");
-        if (isObservableObject$$1(value)) {
+            (isObservableMap(value) || isObservableArray(value)))
+            return fail("isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.");
+        if (isObservableObject(value)) {
             var o = value.$mobx;
             return o.values && !!o.values[property];
         }
         return false;
     }
     // For first check, see #701
-    return (isObservableObject$$1(value) ||
+    return (isObservableObject(value) ||
         !!value.$mobx ||
-        isAtom$$1(value) ||
-        isReaction$$1(value) ||
-        isComputedValue$$1(value));
+        isAtom(value) ||
+        isReaction(value) ||
+        isComputedValue(value));
 }
-function isObservable$$1(value) {
+function isObservable(value) {
     if (arguments.length !== 1)
-        fail$$1(process.env.NODE_ENV !== "production" &&
+        fail(process.env.NODE_ENV !== "production" &&
             "isObservable expects only 1 argument. Use isObservableProp to inspect the observability of a property");
     return _isObservable(value);
 }
-function isObservableProp$$1(value, propName) {
+function isObservableProp(value, propName) {
     if (typeof propName !== "string")
-        return fail$$1(process.env.NODE_ENV !== "production" && "expected a property name as second argument");
+        return fail(process.env.NODE_ENV !== "production" && "expected a property name as second argument");
     return _isObservable(value, propName);
 }
 
-function keys$$1(obj) {
-    if (isObservableObject$$1(obj)) {
+function keys(obj) {
+    if (isObservableObject(obj)) {
         return obj.$mobx.getKeys();
     }
-    if (isObservableMap$$1(obj)) {
+    if (isObservableMap(obj)) {
         return obj._keys.slice();
     }
-    if (isObservableSet$$1(obj)) {
-        return iteratorToArray$$1(obj.keys());
+    if (isObservableSet(obj)) {
+        return iteratorToArray(obj.keys());
     }
-    if (isObservableArray$$1(obj)) {
+    if (isObservableArray(obj)) {
         return obj.map(function (_, index) { return index; });
     }
-    return fail$$1(process.env.NODE_ENV !== "production" &&
+    return fail(process.env.NODE_ENV !== "production" &&
         "'keys()' can only be used on observable objects, arrays, sets and maps");
 }
-function values$$1(obj) {
-    if (isObservableObject$$1(obj)) {
-        return keys$$1(obj).map(function (key) { return obj[key]; });
+function values(obj) {
+    if (isObservableObject(obj)) {
+        return keys(obj).map(function (key) { return obj[key]; });
     }
-    if (isObservableMap$$1(obj)) {
-        return keys$$1(obj).map(function (key) { return obj.get(key); });
+    if (isObservableMap(obj)) {
+        return keys(obj).map(function (key) { return obj.get(key); });
     }
-    if (isObservableSet$$1(obj)) {
-        return iteratorToArray$$1(obj.values());
+    if (isObservableSet(obj)) {
+        return iteratorToArray(obj.values());
     }
-    if (isObservableArray$$1(obj)) {
+    if (isObservableArray(obj)) {
         return obj.slice();
     }
-    return fail$$1(process.env.NODE_ENV !== "production" &&
+    return fail(process.env.NODE_ENV !== "production" &&
         "'values()' can only be used on observable objects, arrays, sets and maps");
 }
-function entries$$1(obj) {
-    if (isObservableObject$$1(obj)) {
-        return keys$$1(obj).map(function (key) { return [key, obj[key]]; });
+function entries(obj) {
+    if (isObservableObject(obj)) {
+        return keys(obj).map(function (key) { return [key, obj[key]]; });
     }
-    if (isObservableMap$$1(obj)) {
-        return keys$$1(obj).map(function (key) { return [key, obj.get(key)]; });
+    if (isObservableMap(obj)) {
+        return keys(obj).map(function (key) { return [key, obj.get(key)]; });
     }
-    if (isObservableSet$$1(obj)) {
-        return iteratorToArray$$1(obj.entries());
+    if (isObservableSet(obj)) {
+        return iteratorToArray(obj.entries());
     }
-    if (isObservableArray$$1(obj)) {
+    if (isObservableArray(obj)) {
         return obj.map(function (key, index) { return [index, key]; });
     }
-    return fail$$1(process.env.NODE_ENV !== "production" &&
+    return fail(process.env.NODE_ENV !== "production" &&
         "'entries()' can only be used on observable objects, arrays and maps");
 }
-function set$$1(obj, key, value) {
-    if (arguments.length === 2) {
-        startBatch$$1();
+function set(obj, key, value) {
+    if (arguments.length === 2 && !isObservableSet(obj)) {
+        startBatch();
         var values_1 = key;
         try {
             for (var key_1 in values_1)
-                set$$1(obj, key_1, values_1[key_1]);
+                set(obj, key_1, values_1[key_1]);
         }
         finally {
-            endBatch$$1();
+            endBatch();
         }
         return;
     }
-    if (isObservableObject$$1(obj)) {
+    if (isObservableObject(obj)) {
         var adm = obj.$mobx;
         var existingObservable = adm.values[key];
         if (existingObservable) {
             adm.write(obj, key, value);
         }
         else {
-            defineObservableProperty$$1(obj, key, value, adm.defaultEnhancer);
+            defineObservableProperty(obj, key, value, adm.defaultEnhancer);
         }
     }
-    else if (isObservableMap$$1(obj)) {
+    else if (isObservableMap(obj)) {
         obj.set(key, value);
     }
-    else if (isObservableArray$$1(obj)) {
+    else if (isObservableSet(obj)) {
+        obj.add(key);
+    }
+    else if (isObservableArray(obj)) {
         if (typeof key !== "number")
             key = parseInt(key, 10);
-        invariant$$1(key >= 0, "Not a valid index: '" + key + "'");
-        startBatch$$1();
+        invariant(key >= 0, "Not a valid index: '" + key + "'");
+        startBatch();
         if (key >= obj.length)
             obj.length = key + 1;
         obj[key] = value;
-        endBatch$$1();
+        endBatch();
     }
     else {
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "'set()' can only be used on observable objects, arrays and maps");
     }
 }
-function remove$$1(obj, key) {
-    if (isObservableObject$$1(obj)) {
-        
+function remove(obj, key) {
+    if (isObservableObject(obj)) {
         obj.$mobx.remove(key);
     }
-    else if (isObservableMap$$1(obj)) {
+    else if (isObservableMap(obj)) {
         obj.delete(key);
     }
-    else if (isObservableSet$$1(obj)) {
+    else if (isObservableSet(obj)) {
         obj.delete(key);
     }
-    else if (isObservableArray$$1(obj)) {
+    else if (isObservableArray(obj)) {
         if (typeof key !== "number")
             key = parseInt(key, 10);
-        invariant$$1(key >= 0, "Not a valid index: '" + key + "'");
+        invariant(key >= 0, "Not a valid index: '" + key + "'");
         obj.splice(key, 1);
     }
     else {
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "'remove()' can only be used on observable objects, arrays and maps");
     }
 }
-function has$$1(obj, key) {
-    if (isObservableObject$$1(obj)) {
+function has(obj, key) {
+    if (isObservableObject(obj)) {
         // return keys(obj).indexOf(key) >= 0
-        var adm = getAdministration$$1(obj);
+        var adm = getAdministration(obj);
         adm.getKeys(); // make sure we get notified of key changes, but for performance, use the values map to look up existence
         return !!adm.values[key];
     }
-    else if (isObservableMap$$1(obj)) {
+    else if (isObservableMap(obj)) {
         return obj.has(key);
     }
-    else if (isObservableSet$$1(obj)) {
+    else if (isObservableSet(obj)) {
         return obj.has(key);
     }
-    else if (isObservableArray$$1(obj)) {
+    else if (isObservableArray(obj)) {
         return key >= 0 && key < obj.length;
     }
     else {
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "'has()' can only be used on observable objects, arrays and maps");
     }
 }
-function get$$1(obj, key) {
-    if (!has$$1(obj, key))
+function get(obj, key) {
+    if (!has(obj, key))
         return undefined;
-    if (isObservableObject$$1(obj)) {
+    if (isObservableObject(obj)) {
         return obj[key];
     }
-    else if (isObservableMap$$1(obj)) {
+    else if (isObservableMap(obj)) {
         return obj.get(key);
     }
-    else if (isObservableArray$$1(obj)) {
+    else if (isObservableArray(obj)) {
         return obj[key];
     }
     else {
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "'get()' can only be used on observable objects, arrays and maps");
     }
 }
 
-function observe$$1(thing, propOrCb, cbOrFire, fireImmediately) {
+function observe(thing, propOrCb, cbOrFire, fireImmediately) {
     if (typeof cbOrFire === "function")
         return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately);
     else
         return observeObservable(thing, propOrCb, cbOrFire);
 }
 function observeObservable(thing, listener, fireImmediately) {
-    return getAdministration$$1(thing).observe(listener, fireImmediately);
+    return getAdministration(thing).observe(listener, fireImmediately);
 }
 function observeObservableProperty(thing, property, listener, fireImmediately) {
-    return getAdministration$$1(thing, property).observe(listener, fireImmediately);
+    return getAdministration(thing, property).observe(listener, fireImmediately);
 }
 
 var defaultOptions = {
@@ -2606,7 +2605,7 @@ function cache(map, key, value, options) {
     return value;
 }
 function toJSHelper(source, options, __alreadySeen) {
-    if (!options.recurseEverything && !isObservable$$1(source))
+    if (!options.recurseEverything && !isObservable(source))
         return source;
     if (typeof source !== "object")
         return source;
@@ -2616,16 +2615,16 @@ function toJSHelper(source, options, __alreadySeen) {
     // Directly return the Date object itself if contained in the observable
     if (source instanceof Date)
         return source;
-    if (isObservableValue$$1(source))
+    if (isObservableValue(source))
         return toJSHelper(source.get(), options, __alreadySeen);
     // make sure we track the keys of the object
-    if (isObservable$$1(source))
-        keys$$1(source);
+    if (isObservable(source))
+        keys(source);
     var detectCycles = options.detectCycles === true;
     if (detectCycles && source !== null && __alreadySeen.has(source)) {
         return __alreadySeen.get(source);
     }
-    if (isObservableArray$$1(source) || Array.isArray(source)) {
+    if (isObservableArray(source) || Array.isArray(source)) {
         var res_1 = cache(__alreadySeen, source, [], options);
         var toAdd = source.map(function (value) { return toJSHelper(value, options, __alreadySeen); });
         res_1.length = toAdd.length;
@@ -2633,7 +2632,7 @@ function toJSHelper(source, options, __alreadySeen) {
             res_1[i] = toAdd[i];
         return res_1;
     }
-    if (isObservableSet$$1(source) || Object.getPrototypeOf(source) === Set.prototype) {
+    if (isObservableSet(source) || Object.getPrototypeOf(source) === Set.prototype) {
         if (options.exportMapsAsObjects === false) {
             var res_2 = cache(__alreadySeen, source, new Set(), options);
             source.forEach(function (value) {
@@ -2649,7 +2648,7 @@ function toJSHelper(source, options, __alreadySeen) {
             return res_3;
         }
     }
-    if (isObservableMap$$1(source) || Object.getPrototypeOf(source) === Map.prototype) {
+    if (isObservableMap(source) || Object.getPrototypeOf(source) === Map.prototype) {
         if (options.exportMapsAsObjects === false) {
             var res_4 = cache(__alreadySeen, source, new Map(), options);
             source.forEach(function (value, key) {
@@ -2672,7 +2671,7 @@ function toJSHelper(source, options, __alreadySeen) {
     }
     return res;
 }
-function toJS$$1(source, options) {
+function toJS(source, options) {
     // backward compatibility
     if (typeof options === "boolean")
         options = { detectCycles: options };
@@ -2688,7 +2687,7 @@ function toJS$$1(source, options) {
     return toJSHelper(source, options, __alreadySeen);
 }
 
-function trace$$1() {
+function trace() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
@@ -2698,22 +2697,22 @@ function trace$$1() {
         enterBreakPoint = args.pop();
     var derivation = getAtomFromArgs(args);
     if (!derivation) {
-        return fail$$1(process.env.NODE_ENV !== "production" &&
+        return fail(process.env.NODE_ENV !== "production" &&
             "'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly");
     }
-    if (derivation.isTracing === TraceMode$$1.NONE) {
+    if (derivation.isTracing === TraceMode.NONE) {
         console.log("[mobx.trace] '" + derivation.name + "' tracing enabled");
     }
-    derivation.isTracing = enterBreakPoint ? TraceMode$$1.BREAK : TraceMode$$1.LOG;
+    derivation.isTracing = enterBreakPoint ? TraceMode.BREAK : TraceMode.LOG;
 }
 function getAtomFromArgs(args) {
     switch (args.length) {
         case 0:
-            return globalState$$1.trackingDerivation;
+            return globalState.trackingDerivation;
         case 1:
-            return getAtom$$1(args[0]);
+            return getAtom(args[0]);
         case 2:
-            return getAtom$$1(args[0], args[1]);
+            return getAtom(args[0], args[1]);
     }
 }
 
@@ -2724,18 +2723,18 @@ function getAtomFromArgs(args) {
  * @param action a function that updates some reactive state
  * @returns any value that was returned by the 'action' parameter.
  */
-function transaction$$1(action$$1, thisArg) {
+function transaction(action, thisArg) {
     if (thisArg === void 0) { thisArg = undefined; }
-    startBatch$$1();
+    startBatch();
     try {
-        return action$$1.apply(thisArg);
+        return action.apply(thisArg);
     }
     finally {
-        endBatch$$1();
+        endBatch();
     }
 }
 
-function when$$1(predicate, arg1, arg2) {
+function when(predicate, arg1, arg2) {
     if (arguments.length === 1 || (arg1 && typeof arg1 === "object"))
         return whenPromise(predicate, arg1);
     return _when(predicate, arg1, arg2 || {});
@@ -2754,9 +2753,9 @@ function _when(predicate, effect, opts) {
             }
         }, opts.timeout);
     }
-    opts.name = opts.name || "When@" + getNextId$$1();
-    var effectAction = createAction$$1(opts.name + "-effect", effect);
-    var disposer = autorun$$1(function (r) {
+    opts.name = opts.name || "When@" + getNextId();
+    var effectAction = createAction(opts.name + "-effect", effect);
+    var disposer = autorun(function (r) {
         if (predicate()) {
             r.dispose();
             if (timeoutHandle)
@@ -2768,7 +2767,7 @@ function _when(predicate, effect, opts) {
 }
 function whenPromise(predicate, opts) {
     if (process.env.NODE_ENV !== "production" && opts && opts.onError)
-        return fail$$1("the options 'onError' and 'promise' cannot be combined");
+        return fail("the options 'onError' and 'promise' cannot be combined");
     var cancel;
     var res = new Promise(function (resolve, reject) {
         var disposer = _when(predicate, resolve, __assign({}, opts, { onError: reject }));
@@ -2781,50 +2780,50 @@ function whenPromise(predicate, opts) {
     return res;
 }
 
-function hasInterceptors$$1(interceptable) {
+function hasInterceptors(interceptable) {
     return interceptable.interceptors !== undefined && interceptable.interceptors.length > 0;
 }
-function registerInterceptor$$1(interceptable, handler) {
+function registerInterceptor(interceptable, handler) {
     var interceptors = interceptable.interceptors || (interceptable.interceptors = []);
     interceptors.push(handler);
-    return once$$1(function () {
+    return once(function () {
         var idx = interceptors.indexOf(handler);
         if (idx !== -1)
             interceptors.splice(idx, 1);
     });
 }
-function interceptChange$$1(interceptable, change) {
-    var prevU = untrackedStart$$1();
+function interceptChange(interceptable, change) {
+    var prevU = untrackedStart();
     try {
         var interceptors = interceptable.interceptors;
         if (interceptors)
             for (var i = 0, l = interceptors.length; i < l; i++) {
                 change = interceptors[i](change);
-                invariant$$1(!change || change.type, "Intercept handlers should return nothing or a change object");
+                invariant(!change || change.type, "Intercept handlers should return nothing or a change object");
                 if (!change)
                     break;
             }
         return change;
     }
     finally {
-        untrackedEnd$$1(prevU);
+        untrackedEnd(prevU);
     }
 }
 
-function hasListeners$$1(listenable) {
+function hasListeners(listenable) {
     return listenable.changeListeners !== undefined && listenable.changeListeners.length > 0;
 }
-function registerListener$$1(listenable, handler) {
+function registerListener(listenable, handler) {
     var listeners = listenable.changeListeners || (listenable.changeListeners = []);
     listeners.push(handler);
-    return once$$1(function () {
+    return once(function () {
         var idx = listeners.indexOf(handler);
         if (idx !== -1)
             listeners.splice(idx, 1);
     });
 }
-function notifyListeners$$1(listenable, change) {
-    var prevU = untrackedStart$$1();
+function notifyListeners(listenable, change) {
+    var prevU = untrackedStart();
     var listeners = listenable.changeListeners;
     if (!listeners)
         return;
@@ -2832,7 +2831,7 @@ function notifyListeners$$1(listenable, change) {
     for (var i = 0, l = listeners.length; i < l; i++) {
         listeners[i](change);
     }
-    untrackedEnd$$1(prevU);
+    untrackedEnd(prevU);
 }
 
 var MAX_SPLICE_SIZE = 10000; // See e.g. https://github.com/mobxjs/mobx/issues/859
@@ -2855,10 +2854,10 @@ var safariPrototypeSetterInheritanceBug = (function () {
  */
 var OBSERVABLE_ARRAY_BUFFER_SIZE = 0;
 // Typescript workaround to make sure ObservableArray extends Array
-var StubArray$$1 = /** @class */ (function () {
-    function StubArray$$1() {
+var StubArray = /** @class */ (function () {
+    function StubArray() {
     }
-    return StubArray$$1;
+    return StubArray;
 }());
 function inherit(ctor, proto) {
     if (typeof Object["setPrototypeOf"] !== "undefined") {
@@ -2871,12 +2870,11 @@ function inherit(ctor, proto) {
         ctor["prototype"] = proto;
     }
 }
-inherit(StubArray$$1, Array.prototype);
+inherit(StubArray, Array.prototype);
 // Weex freeze Array.prototype
 // Make them writeable and configurable in prototype chain
 // https://github.com/alibaba/weex/pull/1529
 if (Object.isFrozen(Array)) {
-    
     [
         "constructor",
         "push",
@@ -2891,7 +2889,7 @@ if (Object.isFrozen(Array)) {
         "reverse",
         "sort"
     ].forEach(function (key) {
-        Object.defineProperty(StubArray$$1.prototype, key, {
+        Object.defineProperty(StubArray.prototype, key, {
             configurable: true,
             writable: true,
             value: Array.prototype[key]
@@ -2904,7 +2902,7 @@ var ObservableArrayAdministration = /** @class */ (function () {
         this.owned = owned;
         this.values = [];
         this.lastKnownLength = 0;
-        this.atom = new Atom$$1(name || "ObservableArray@" + getNextId$$1());
+        this.atom = new Atom(name || "ObservableArray@" + getNextId());
         this.enhancer = function (newV, oldV) { return enhancer(newV, oldV, name + "[..]"); };
     }
     ObservableArrayAdministration.prototype.dehanceValue = function (value) {
@@ -2912,13 +2910,13 @@ var ObservableArrayAdministration = /** @class */ (function () {
             return this.dehancer(value);
         return value;
     };
-    ObservableArrayAdministration.prototype.dehanceValues = function (values$$1) {
-        if (this.dehancer !== undefined && values$$1.length > 0)
-            return values$$1.map(this.dehancer);
-        return values$$1;
+    ObservableArrayAdministration.prototype.dehanceValues = function (values) {
+        if (this.dehancer !== undefined && values.length > 0)
+            return values.map(this.dehancer);
+        return values;
     };
     ObservableArrayAdministration.prototype.intercept = function (handler) {
-        return registerInterceptor$$1(this, handler);
+        return registerInterceptor(this, handler);
     };
     ObservableArrayAdministration.prototype.observe = function (listener, fireImmediately) {
         if (fireImmediately === void 0) { fireImmediately = false; }
@@ -2933,7 +2931,7 @@ var ObservableArrayAdministration = /** @class */ (function () {
                 removedCount: 0
             });
         }
-        return registerListener$$1(this, listener);
+        return registerListener(this, listener);
     };
     ObservableArrayAdministration.prototype.getArrayLength = function () {
         this.atom.reportObserved();
@@ -2960,11 +2958,11 @@ var ObservableArrayAdministration = /** @class */ (function () {
             throw new Error("[mobx] Modification exception: the internal structure of an observable array was changed. Did you use peek() to change it?");
         this.lastKnownLength += delta;
         if (delta > 0 && oldLength + delta + 1 > OBSERVABLE_ARRAY_BUFFER_SIZE)
-            reserveArrayBuffer$$1(oldLength + delta + 1);
+            reserveArrayBuffer(oldLength + delta + 1);
     };
     ObservableArrayAdministration.prototype.spliceWithArray = function (index, deleteCount, newItems) {
         var _this = this;
-        checkIfStateModificationsAreAllowed$$1(this.atom);
+        checkIfStateModificationsAreAllowed(this.atom);
         var length = this.values.length;
         if (index === undefined)
             index = 0;
@@ -2979,9 +2977,9 @@ var ObservableArrayAdministration = /** @class */ (function () {
         else
             deleteCount = Math.max(0, Math.min(deleteCount, length - index));
         if (newItems === undefined)
-            newItems = EMPTY_ARRAY$$1;
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+            newItems = EMPTY_ARRAY;
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 object: this.array,
                 type: "splice",
                 index: index,
@@ -2989,7 +2987,7 @@ var ObservableArrayAdministration = /** @class */ (function () {
                 added: newItems
             });
             if (!change)
-                return EMPTY_ARRAY$$1;
+                return EMPTY_ARRAY;
             deleteCount = change.removedCount;
             newItems = change.added;
         }
@@ -3016,8 +3014,8 @@ var ObservableArrayAdministration = /** @class */ (function () {
         }
     };
     ObservableArrayAdministration.prototype.notifyArrayChildUpdate = function (index, newValue, oldValue) {
-        var notifySpy = !this.owned && isSpyEnabled$$1();
-        var notify = hasListeners$$1(this);
+        var notifySpy = !this.owned && isSpyEnabled();
+        var notify = hasListeners(this);
         var change = notify || notifySpy
             ? {
                 object: this.array,
@@ -3028,16 +3026,16 @@ var ObservableArrayAdministration = /** @class */ (function () {
             }
             : null;
         if (notifySpy)
-            spyReportStart$$1(__assign({}, change, { name: this.atom.name }));
+            spyReportStart(__assign({}, change, { name: this.atom.name }));
         this.atom.reportChanged();
         if (notify)
-            notifyListeners$$1(this, change);
+            notifyListeners(this, change);
         if (notifySpy)
-            spyReportEnd$$1();
+            spyReportEnd();
     };
     ObservableArrayAdministration.prototype.notifyArraySplice = function (index, added, removed) {
-        var notifySpy = !this.owned && isSpyEnabled$$1();
-        var notify = hasListeners$$1(this);
+        var notifySpy = !this.owned && isSpyEnabled();
+        var notify = hasListeners(this);
         var change = notify || notifySpy
             ? {
                 object: this.array,
@@ -3050,28 +3048,28 @@ var ObservableArrayAdministration = /** @class */ (function () {
             }
             : null;
         if (notifySpy)
-            spyReportStart$$1(__assign({}, change, { name: this.atom.name }));
+            spyReportStart(__assign({}, change, { name: this.atom.name }));
         this.atom.reportChanged();
         // conform: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/observe
         if (notify)
-            notifyListeners$$1(this, change);
+            notifyListeners(this, change);
         if (notifySpy)
-            spyReportEnd$$1();
+            spyReportEnd();
     };
     return ObservableArrayAdministration;
 }());
-var ObservableArray$$1 = /** @class */ (function (_super) {
-    __extends(ObservableArray$$1, _super);
-    function ObservableArray$$1(initialValues, enhancer, name, owned) {
-        if (name === void 0) { name = "ObservableArray@" + getNextId$$1(); }
+var ObservableArray = /** @class */ (function (_super) {
+    __extends(ObservableArray, _super);
+    function ObservableArray(initialValues, enhancer, name, owned) {
+        if (name === void 0) { name = "ObservableArray@" + getNextId(); }
         if (owned === void 0) { owned = false; }
         var _this = _super.call(this) || this;
         var adm = new ObservableArrayAdministration(name, enhancer, _this, owned);
-        addHiddenFinalProp$$1(_this, "$mobx", adm);
+        addHiddenFinalProp(_this, "$mobx", adm);
         if (initialValues && initialValues.length) {
-            var prev = allowStateChangesStart$$1(true);
+            var prev = allowStateChangesStart(true);
             _this.spliceWithArray(0, 0, initialValues);
-            allowStateChangesEnd$$1(prev);
+            allowStateChangesEnd(prev);
         }
         if (safariPrototypeSetterInheritanceBug) {
             // Seems that Safari won't use numeric prototype setter untill any * numeric property is
@@ -3080,55 +3078,55 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         }
         return _this;
     }
-    ObservableArray$$1.prototype.intercept = function (handler) {
+    ObservableArray.prototype.intercept = function (handler) {
         return this.$mobx.intercept(handler);
     };
-    ObservableArray$$1.prototype.observe = function (listener, fireImmediately) {
+    ObservableArray.prototype.observe = function (listener, fireImmediately) {
         if (fireImmediately === void 0) { fireImmediately = false; }
         return this.$mobx.observe(listener, fireImmediately);
     };
-    ObservableArray$$1.prototype.clear = function () {
+    ObservableArray.prototype.clear = function () {
         return this.splice(0);
     };
-    ObservableArray$$1.prototype.concat = function () {
+    ObservableArray.prototype.concat = function () {
         var arrays = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             arrays[_i] = arguments[_i];
         }
         this.$mobx.atom.reportObserved();
-        return Array.prototype.concat.apply(this.peek(), arrays.map(function (a) { return (isObservableArray$$1(a) ? a.peek() : a); }));
+        return Array.prototype.concat.apply(this.peek(), arrays.map(function (a) { return (isObservableArray(a) ? a.peek() : a); }));
     };
-    ObservableArray$$1.prototype.replace = function (newItems) {
+    ObservableArray.prototype.replace = function (newItems) {
         return this.$mobx.spliceWithArray(0, this.$mobx.values.length, newItems);
     };
     /**
      * Converts this array back to a (shallow) javascript structure.
      * For a deep clone use mobx.toJS
      */
-    ObservableArray$$1.prototype.toJS = function () {
+    ObservableArray.prototype.toJS = function () {
         return this.slice();
     };
-    ObservableArray$$1.prototype.toJSON = function () {
+    ObservableArray.prototype.toJSON = function () {
         // Used by JSON.stringify
         return this.toJS();
     };
-    ObservableArray$$1.prototype.peek = function () {
+    ObservableArray.prototype.peek = function () {
         this.$mobx.atom.reportObserved();
         return this.$mobx.dehanceValues(this.$mobx.values);
     };
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
-    ObservableArray$$1.prototype.find = function (predicate, thisArg, fromIndex) {
+    ObservableArray.prototype.find = function (predicate, thisArg, fromIndex) {
         if (fromIndex === void 0) { fromIndex = 0; }
         if (arguments.length === 3)
-            deprecated$$1("The array.find fromIndex argument to find will not be supported anymore in the next major");
+            deprecated("The array.find fromIndex argument to find will not be supported anymore in the next major");
         var idx = this.findIndex.apply(this, arguments);
         return idx === -1 ? undefined : this.get(idx);
     };
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex
-    ObservableArray$$1.prototype.findIndex = function (predicate, thisArg, fromIndex) {
+    ObservableArray.prototype.findIndex = function (predicate, thisArg, fromIndex) {
         if (fromIndex === void 0) { fromIndex = 0; }
         if (arguments.length === 3)
-            deprecated$$1("The array.findIndex fromIndex argument to find will not be supported anymore in the next major");
+            deprecated("The array.findIndex fromIndex argument to find will not be supported anymore in the next major");
         var items = this.peek(), l = items.length;
         for (var i = fromIndex; i < l; i++)
             if (predicate.call(thisArg, items[i], i, this))
@@ -3141,7 +3139,7 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
      * Because the have side effects, they should not be used in computed function,
      * and for that reason the do not call dependencyState.notifyObserved
      */
-    ObservableArray$$1.prototype.splice = function (index, deleteCount) {
+    ObservableArray.prototype.splice = function (index, deleteCount) {
         var newItems = [];
         for (var _i = 2; _i < arguments.length; _i++) {
             newItems[_i - 2] = arguments[_i];
@@ -3156,10 +3154,10 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         }
         return this.$mobx.spliceWithArray(index, deleteCount, newItems);
     };
-    ObservableArray$$1.prototype.spliceWithArray = function (index, deleteCount, newItems) {
+    ObservableArray.prototype.spliceWithArray = function (index, deleteCount, newItems) {
         return this.$mobx.spliceWithArray(index, deleteCount, newItems);
     };
-    ObservableArray$$1.prototype.push = function () {
+    ObservableArray.prototype.push = function () {
         var items = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             items[_i] = arguments[_i];
@@ -3168,13 +3166,13 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         adm.spliceWithArray(adm.values.length, 0, items);
         return adm.values.length;
     };
-    ObservableArray$$1.prototype.pop = function () {
+    ObservableArray.prototype.pop = function () {
         return this.splice(Math.max(this.$mobx.values.length - 1, 0), 1)[0];
     };
-    ObservableArray$$1.prototype.shift = function () {
+    ObservableArray.prototype.shift = function () {
         return this.splice(0, 1)[0];
     };
-    ObservableArray$$1.prototype.unshift = function () {
+    ObservableArray.prototype.unshift = function () {
         var items = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             items[_i] = arguments[_i];
@@ -3183,20 +3181,20 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         adm.spliceWithArray(0, 0, items);
         return adm.values.length;
     };
-    ObservableArray$$1.prototype.reverse = function () {
+    ObservableArray.prototype.reverse = function () {
         // reverse by default mutates in place before returning the result
         // which makes it both a 'derivation' and a 'mutation'.
         // so we deviate from the default and just make it an dervitation
         var clone = this.slice();
         return clone.reverse.apply(clone, arguments);
     };
-    ObservableArray$$1.prototype.sort = function (compareFn) {
+    ObservableArray.prototype.sort = function (compareFn) {
         // sort by default mutates in place before returning the result
         // which goes against all good practices. Let's not change the array in place!
         var clone = this.slice();
         return clone.sort.apply(clone, arguments);
     };
-    ObservableArray$$1.prototype.remove = function (value) {
+    ObservableArray.prototype.remove = function (value) {
         var idx = this.$mobx.dehanceValues(this.$mobx.values).indexOf(value);
         if (idx > -1) {
             this.splice(idx, 1);
@@ -3204,8 +3202,8 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         }
         return false;
     };
-    ObservableArray$$1.prototype.move = function (fromIndex, toIndex) {
-        deprecated$$1("observableArray.move is deprecated, use .slice() & .replace() instead");
+    ObservableArray.prototype.move = function (fromIndex, toIndex) {
+        deprecated("observableArray.move is deprecated, use .slice() & .replace() instead");
         function checkIndex(index) {
             if (index < 0) {
                 throw new Error("[mobx.array] Index out of bounds: " + index + " is negative");
@@ -3236,7 +3234,7 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         this.replace(newItems);
     };
     // See #734, in case property accessors are unreliable...
-    ObservableArray$$1.prototype.get = function (index) {
+    ObservableArray.prototype.get = function (index) {
         var impl = this.$mobx;
         if (impl) {
             if (index < impl.values.length) {
@@ -3248,15 +3246,15 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
         return undefined;
     };
     // See #734, in case property accessors are unreliable...
-    ObservableArray$$1.prototype.set = function (index, newValue) {
+    ObservableArray.prototype.set = function (index, newValue) {
         var adm = this.$mobx;
-        var values$$1 = adm.values;
-        if (index < values$$1.length) {
+        var values = adm.values;
+        if (index < values.length) {
             // update at index in range
-            checkIfStateModificationsAreAllowed$$1(adm.atom);
-            var oldValue = values$$1[index];
-            if (hasInterceptors$$1(adm)) {
-                var change = interceptChange$$1(adm, {
+            checkIfStateModificationsAreAllowed(adm.atom);
+            var oldValue = values[index];
+            if (hasInterceptors(adm)) {
+                var change = interceptChange(adm, {
                     type: "update",
                     object: this,
                     index: index,
@@ -3269,27 +3267,26 @@ var ObservableArray$$1 = /** @class */ (function (_super) {
             newValue = adm.enhancer(newValue, oldValue);
             var changed = newValue !== oldValue;
             if (changed) {
-                values$$1[index] = newValue;
+                values[index] = newValue;
                 adm.notifyArrayChildUpdate(index, newValue, oldValue);
             }
         }
-        else if (index === values$$1.length) {
+        else if (index === values.length) {
             // add a new item
             adm.spliceWithArray(index, 0, [newValue]);
         }
         else {
             // out of bounds
-            throw new Error("[mobx.array] Index out of bounds, " + index + " is larger than " + values$$1.length);
+            throw new Error("[mobx.array] Index out of bounds, " + index + " is larger than " + values.length);
         }
     };
-    return ObservableArray$$1;
-}(StubArray$$1));
-declareIterator$$1(ObservableArray$$1.prototype, function () {
-    
+    return ObservableArray;
+}(StubArray));
+declareIterator(ObservableArray.prototype, function () {
     this.$mobx.atom.reportObserved();
     var self = this;
     var nextIndex = 0;
-    return makeIterable$$1({
+    return makeIterable({
         next: function () {
             return nextIndex < self.length
                 ? { value: self[nextIndex++], done: false }
@@ -3297,7 +3294,7 @@ declareIterator$$1(ObservableArray$$1.prototype, function () {
         }
     });
 });
-Object.defineProperty(ObservableArray$$1.prototype, "length", {
+Object.defineProperty(ObservableArray.prototype, "length", {
     enumerable: false,
     configurable: true,
     get: function () {
@@ -3307,7 +3304,7 @@ Object.defineProperty(ObservableArray$$1.prototype, "length", {
         this.$mobx.setArrayLength(newLength);
     }
 });
-addHiddenProp$$1(ObservableArray$$1.prototype, toStringTagSymbol$$1(), "Array");
+addHiddenProp(ObservableArray.prototype, toStringTagSymbol(), "Array");
 [
     "every",
     "filter",
@@ -3324,15 +3321,15 @@ addHiddenProp$$1(ObservableArray$$1.prototype, toStringTagSymbol$$1(), "Array");
     "toLocaleString"
 ].forEach(function (funcName) {
     var baseFunc = Array.prototype[funcName];
-    invariant$$1(typeof baseFunc === "function", "Base function not defined on Array prototype: '" + funcName + "'");
-    addHiddenProp$$1(ObservableArray$$1.prototype, funcName, function () {
+    invariant(typeof baseFunc === "function", "Base function not defined on Array prototype: '" + funcName + "'");
+    addHiddenProp(ObservableArray.prototype, funcName, function () {
         return baseFunc.apply(this.peek(), arguments);
     });
 });
 /**
  * We don't want those to show up in `for (const key in ar)` ...
  */
-makeNonEnumerable$$1(ObservableArray$$1.prototype, [
+makeNonEnumerable(ObservableArray.prototype, [
     "constructor",
     "intercept",
     "observe",
@@ -3374,28 +3371,28 @@ function createArrayEntryDescriptor(index) {
     };
 }
 function createArrayBufferItem(index) {
-    Object.defineProperty(ObservableArray$$1.prototype, "" + index, createArrayEntryDescriptor(index));
+    Object.defineProperty(ObservableArray.prototype, "" + index, createArrayEntryDescriptor(index));
 }
-function reserveArrayBuffer$$1(max) {
+function reserveArrayBuffer(max) {
     for (var index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max; index++)
         createArrayBufferItem(index);
     OBSERVABLE_ARRAY_BUFFER_SIZE = max;
 }
-reserveArrayBuffer$$1(1000);
-var isObservableArrayAdministration = createInstanceofPredicate$$1("ObservableArrayAdministration", ObservableArrayAdministration);
-function isObservableArray$$1(thing) {
-    return isObject$$1(thing) && isObservableArrayAdministration(thing.$mobx);
+reserveArrayBuffer(1000);
+var isObservableArrayAdministration = createInstanceofPredicate("ObservableArrayAdministration", ObservableArrayAdministration);
+function isObservableArray(thing) {
+    return isObject(thing) && isObservableArrayAdministration(thing.$mobx);
 }
 
 var ObservableMapMarker = {};
-var ObservableMap$$1 = /** @class */ (function () {
-    function ObservableMap$$1(initialData, enhancer, name) {
-        if (enhancer === void 0) { enhancer = deepEnhancer$$1; }
-        if (name === void 0) { name = "ObservableMap@" + getNextId$$1(); }
+var ObservableMap = /** @class */ (function () {
+    function ObservableMap(initialData, enhancer, name) {
+        if (enhancer === void 0) { enhancer = deepEnhancer; }
+        if (name === void 0) { name = "ObservableMap@" + getNextId(); }
         this.enhancer = enhancer;
         this.name = name;
         this.$mobx = ObservableMapMarker;
-        this._keys = new ObservableArray$$1(undefined, referenceEnhancer$$1, this.name + ".keys()", true);
+        this._keys = (new ObservableArray(undefined, referenceEnhancer, this.name + ".keys()", true));
         if (typeof Map !== "function") {
             throw new Error("mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js");
         }
@@ -3403,18 +3400,26 @@ var ObservableMap$$1 = /** @class */ (function () {
         this._hasMap = new Map();
         this.merge(initialData);
     }
-    ObservableMap$$1.prototype._has = function (key) {
+    ObservableMap.prototype._has = function (key) {
         return this._data.has(key);
     };
-    ObservableMap$$1.prototype.has = function (key) {
-        if (this._hasMap.has(key))
-            return this._hasMap.get(key).get();
-        return this._updateHasMapEntry(key, false).get();
+    ObservableMap.prototype.has = function (key) {
+        var _this = this;
+        if (!globalState.trackingDerivation)
+            return this._has(key);
+        var entry = this._hasMap.get(key);
+        if (!entry) {
+            // todo: replace with atom (breaking change)
+            var newEntry = (entry = new ObservableValue(this._has(key), referenceEnhancer, this.name + "." + stringifyKey(key) + "?", false));
+            this._hasMap.set(key, newEntry);
+            onBecomeUnobserved(newEntry, function () { return _this._hasMap.delete(key); });
+        }
+        return entry.get();
     };
-    ObservableMap$$1.prototype.set = function (key, value) {
+    ObservableMap.prototype.set = function (key, value) {
         var hasKey = this._has(key);
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 type: hasKey ? "update" : "add",
                 object: this,
                 newValue: value,
@@ -3432,10 +3437,10 @@ var ObservableMap$$1 = /** @class */ (function () {
         }
         return this;
     };
-    ObservableMap$$1.prototype.delete = function (key) {
+    ObservableMap.prototype.delete = function (key) {
         var _this = this;
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 type: "delete",
                 object: this,
                 name: key
@@ -3444,8 +3449,8 @@ var ObservableMap$$1 = /** @class */ (function () {
                 return false;
         }
         if (this._has(key)) {
-            var notifySpy = isSpyEnabled$$1();
-            var notify = hasListeners$$1(this);
+            var notifySpy = isSpyEnabled();
+            var notify = hasListeners(this);
             var change = notify || notifySpy
                 ? {
                     type: "delete",
@@ -3455,69 +3460,63 @@ var ObservableMap$$1 = /** @class */ (function () {
                 }
                 : null;
             if (notifySpy)
-                spyReportStart$$1(__assign({}, change, { name: this.name, key: key }));
-            transaction$$1(function () {
+                spyReportStart(__assign({}, change, { name: this.name, key: key }));
+            transaction(function () {
                 _this._keys.remove(key);
                 _this._updateHasMapEntry(key, false);
-                var observable$$1 = _this._data.get(key);
-                observable$$1.setNewValue(undefined);
+                var observable = _this._data.get(key);
+                observable.setNewValue(undefined);
                 _this._data.delete(key);
             });
             if (notify)
-                notifyListeners$$1(this, change);
+                notifyListeners(this, change);
             if (notifySpy)
-                spyReportEnd$$1();
+                spyReportEnd();
             return true;
         }
         return false;
     };
-    ObservableMap$$1.prototype._updateHasMapEntry = function (key, value) {
-        // optimization; don't fill the hasMap if we are not observing, or remove entry if there are no observers anymore
+    ObservableMap.prototype._updateHasMapEntry = function (key, value) {
         var entry = this._hasMap.get(key);
         if (entry) {
             entry.setNewValue(value);
         }
-        else {
-            entry = new ObservableValue$$1(value, referenceEnhancer$$1, this.name + "." + stringifyKey(key) + "?", false);
-            this._hasMap.set(key, entry);
-        }
-        return entry;
     };
-    ObservableMap$$1.prototype._updateValue = function (key, newValue) {
-        var observable$$1 = this._data.get(key);
-        newValue = observable$$1.prepareNewValue(newValue);
-        if (newValue !== globalState$$1.UNCHANGED) {
-            var notifySpy = isSpyEnabled$$1();
-            var notify = hasListeners$$1(this);
+    ObservableMap.prototype._updateValue = function (key, newValue) {
+        var observable = this._data.get(key);
+        newValue = observable.prepareNewValue(newValue);
+        if (newValue !== globalState.UNCHANGED) {
+            var notifySpy = isSpyEnabled();
+            var notify = hasListeners(this);
             var change = notify || notifySpy
                 ? {
                     type: "update",
                     object: this,
-                    oldValue: observable$$1.value,
+                    oldValue: observable.value,
                     name: key,
                     newValue: newValue
                 }
                 : null;
             if (notifySpy)
-                spyReportStart$$1(__assign({}, change, { name: this.name, key: key }));
-            observable$$1.setNewValue(newValue);
+                spyReportStart(__assign({}, change, { name: this.name, key: key }));
+            observable.setNewValue(newValue);
             if (notify)
-                notifyListeners$$1(this, change);
+                notifyListeners(this, change);
             if (notifySpy)
-                spyReportEnd$$1();
+                spyReportEnd();
         }
     };
-    ObservableMap$$1.prototype._addValue = function (key, newValue) {
+    ObservableMap.prototype._addValue = function (key, newValue) {
         var _this = this;
-        transaction$$1(function () {
-            var observable$$1 = new ObservableValue$$1(newValue, _this.enhancer, _this.name + "." + stringifyKey(key), false);
-            _this._data.set(key, observable$$1);
-            newValue = observable$$1.value; // value might have been changed
+        transaction(function () {
+            var observable = new ObservableValue(newValue, _this.enhancer, _this.name + "." + stringifyKey(key), false);
+            _this._data.set(key, observable);
+            newValue = observable.value; // value might have been changed
             _this._updateHasMapEntry(key, true);
             _this._keys.push(key);
         });
-        var notifySpy = isSpyEnabled$$1();
-        var notify = hasListeners$$1(this);
+        var notifySpy = isSpyEnabled();
+        var notify = hasListeners(this);
         var change = notify || notifySpy
             ? {
                 type: "add",
@@ -3527,30 +3526,30 @@ var ObservableMap$$1 = /** @class */ (function () {
             }
             : null;
         if (notifySpy)
-            spyReportStart$$1(__assign({}, change, { name: this.name, key: key }));
+            spyReportStart(__assign({}, change, { name: this.name, key: key }));
         if (notify)
-            notifyListeners$$1(this, change);
+            notifyListeners(this, change);
         if (notifySpy)
-            spyReportEnd$$1();
+            spyReportEnd();
     };
-    ObservableMap$$1.prototype.get = function (key) {
+    ObservableMap.prototype.get = function (key) {
         if (this.has(key))
             return this.dehanceValue(this._data.get(key).get());
         return this.dehanceValue(undefined);
     };
-    ObservableMap$$1.prototype.dehanceValue = function (value) {
+    ObservableMap.prototype.dehanceValue = function (value) {
         if (this.dehancer !== undefined) {
             return this.dehancer(value);
         }
         return value;
     };
-    ObservableMap$$1.prototype.keys = function () {
-        return this._keys[iteratorSymbol$$1()]();
+    ObservableMap.prototype.keys = function () {
+        return this._keys[iteratorSymbol()]();
     };
-    ObservableMap$$1.prototype.values = function () {
+    ObservableMap.prototype.values = function () {
         var self = this;
         var nextIndex = 0;
-        return makeIterable$$1({
+        return makeIterable({
             next: function () {
                 return nextIndex < self._keys.length
                     ? { value: self.get(self._keys[nextIndex++]), done: false }
@@ -3558,10 +3557,10 @@ var ObservableMap$$1 = /** @class */ (function () {
             }
         });
     };
-    ObservableMap$$1.prototype.entries = function () {
+    ObservableMap.prototype.entries = function () {
         var self = this;
         var nextIndex = 0;
-        return makeIterable$$1({
+        return makeIterable({
             next: function () {
                 if (nextIndex < self._keys.length) {
                     var key = self._keys[nextIndex++];
@@ -3574,58 +3573,58 @@ var ObservableMap$$1 = /** @class */ (function () {
             }
         });
     };
-    ObservableMap$$1.prototype.forEach = function (callback, thisArg) {
+    ObservableMap.prototype.forEach = function (callback, thisArg) {
         var _this = this;
         this._keys.forEach(function (key) { return callback.call(thisArg, _this.get(key), key, _this); });
     };
     /** Merge another object into this object, returns this. */
-    ObservableMap$$1.prototype.merge = function (other) {
+    ObservableMap.prototype.merge = function (other) {
         var _this = this;
-        if (isObservableMap$$1(other)) {
+        if (isObservableMap(other)) {
             other = other.toJS();
         }
-        transaction$$1(function () {
-            if (isPlainObject$$1(other))
+        transaction(function () {
+            if (isPlainObject(other))
                 Object.keys(other).forEach(function (key) { return _this.set(key, other[key]); });
             else if (Array.isArray(other))
                 other.forEach(function (_a) {
                     var _b = __read(_a, 2), key = _b[0], value = _b[1];
                     return _this.set(key, value);
                 });
-            else if (isES6Map$$1(other)) {
+            else if (isES6Map(other)) {
                 if (other.constructor !== Map)
-                    fail$$1("Cannot initialize from classes that inherit from Map: " + other.constructor.name); // prettier-ignore
+                    fail("Cannot initialize from classes that inherit from Map: " + other.constructor.name); // prettier-ignore
                 else
                     other.forEach(function (value, key) { return _this.set(key, value); });
             }
             else if (other !== null && other !== undefined)
-                fail$$1("Cannot initialize map from " + other);
+                fail("Cannot initialize map from " + other);
         });
         return this;
     };
-    ObservableMap$$1.prototype.clear = function () {
+    ObservableMap.prototype.clear = function () {
         var _this = this;
-        transaction$$1(function () {
-            untracked$$1(function () {
+        transaction(function () {
+            untracked(function () {
                 _this._keys.slice().forEach(function (key) { return _this.delete(key); });
             });
         });
     };
-    ObservableMap$$1.prototype.replace = function (values$$1) {
+    ObservableMap.prototype.replace = function (values) {
         var _this = this;
-        transaction$$1(function () {
+        transaction(function () {
             // grab all the keys that are present in the new map but not present in the current map
             // and delete them from the map, then merge the new map
             // this will cause reactions only on changed values
-            var newKeys = getMapLikeKeys$$1(values$$1);
+            var newKeys = getMapLikeKeys(values);
             var oldKeys = _this._keys;
             var missingKeys = oldKeys.filter(function (k) { return newKeys.indexOf(k) === -1; });
             missingKeys.forEach(function (k) { return _this.delete(k); });
-            _this.merge(values$$1);
+            _this.merge(values);
         });
         return this;
     };
-    Object.defineProperty(ObservableMap$$1.prototype, "size", {
+    Object.defineProperty(ObservableMap.prototype, "size", {
         get: function () {
             return this._keys.length;
         },
@@ -3637,7 +3636,7 @@ var ObservableMap$$1 = /** @class */ (function () {
      * Note that all the keys being stringified.
      * If there are duplicating keys after converting them to strings, behaviour is undetermined.
      */
-    ObservableMap$$1.prototype.toPOJO = function () {
+    ObservableMap.prototype.toPOJO = function () {
         var _this = this;
         var res = {};
         this._keys.forEach(function (key) { return (res[typeof key === "symbol" ? key : stringifyKey(key)] = _this.get(key)); });
@@ -3647,17 +3646,17 @@ var ObservableMap$$1 = /** @class */ (function () {
      * Returns a shallow non observable object clone of this map.
      * Note that the values migth still be observable. For a deep clone use mobx.toJS.
      */
-    ObservableMap$$1.prototype.toJS = function () {
+    ObservableMap.prototype.toJS = function () {
         var _this = this;
         var res = new Map();
         this._keys.forEach(function (key) { return res.set(key, _this.get(key)); });
         return res;
     };
-    ObservableMap$$1.prototype.toJSON = function () {
+    ObservableMap.prototype.toJSON = function () {
         // Used by JSON.stringify
         return this.toPOJO();
     };
-    ObservableMap$$1.prototype.toString = function () {
+    ObservableMap.prototype.toString = function () {
         var _this = this;
         return (this.name +
             "[{ " +
@@ -3669,15 +3668,15 @@ var ObservableMap$$1 = /** @class */ (function () {
      * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
      * for callback details
      */
-    ObservableMap$$1.prototype.observe = function (listener, fireImmediately) {
+    ObservableMap.prototype.observe = function (listener, fireImmediately) {
         process.env.NODE_ENV !== "production" &&
-            invariant$$1(fireImmediately !== true, "`observe` doesn't support fireImmediately=true in combination with maps.");
-        return registerListener$$1(this, listener);
+            invariant(fireImmediately !== true, "`observe` doesn't support fireImmediately=true in combination with maps.");
+        return registerListener(this, listener);
     };
-    ObservableMap$$1.prototype.intercept = function (handler) {
-        return registerInterceptor$$1(this, handler);
+    ObservableMap.prototype.intercept = function (handler) {
+        return registerInterceptor(this, handler);
     };
-    return ObservableMap$$1;
+    return ObservableMap;
 }());
 function stringifyKey(key) {
     if (key && key.toString)
@@ -3685,22 +3684,22 @@ function stringifyKey(key) {
     else
         return new String(key).toString();
 }
-declareIterator$$1(ObservableMap$$1.prototype, function () {
+declareIterator(ObservableMap.prototype, function () {
     return this.entries();
 });
-addHiddenFinalProp$$1(ObservableMap$$1.prototype, toStringTagSymbol$$1(), "Map");
+addHiddenFinalProp(ObservableMap.prototype, toStringTagSymbol(), "Map");
 /* 'var' fixes small-build issue */
-var isObservableMap$$1 = createInstanceofPredicate$$1("ObservableMap", ObservableMap$$1);
+var isObservableMap = createInstanceofPredicate("ObservableMap", ObservableMap);
 
 var ObservableSetMarker = {};
-var ObservableSet$$1 = /** @class */ (function () {
-    function ObservableSet$$1(initialData, enhancer, name) {
-        if (enhancer === void 0) { enhancer = deepEnhancer$$1; }
-        if (name === void 0) { name = "ObservableSet@" + getNextId$$1(); }
+var ObservableSet = /** @class */ (function () {
+    function ObservableSet(initialData, enhancer, name) {
+        if (enhancer === void 0) { enhancer = deepEnhancer; }
+        if (name === void 0) { name = "ObservableSet@" + getNextId(); }
         this.name = name;
         this.$mobx = ObservableSetMarker;
         this._data = new Set();
-        this._atom = createAtom$$1(this.name);
+        this._atom = createAtom(this.name);
         if (typeof Set !== "function") {
             throw new Error("mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js");
         }
@@ -3709,29 +3708,29 @@ var ObservableSet$$1 = /** @class */ (function () {
             this.replace(initialData);
         }
     }
-    ObservableSet$$1.prototype.dehanceValue = function (value) {
+    ObservableSet.prototype.dehanceValue = function (value) {
         if (this.dehancer !== undefined) {
             return this.dehancer(value);
         }
         return value;
     };
-    ObservableSet$$1.prototype.clear = function () {
+    ObservableSet.prototype.clear = function () {
         var _this = this;
-        transaction$$1(function () {
-            untracked$$1(function () {
+        transaction(function () {
+            untracked(function () {
                 _this._data.forEach(function (value) {
                     _this.delete(value);
                 });
             });
         });
     };
-    ObservableSet$$1.prototype.forEach = function (callbackFn, thisArg) {
+    ObservableSet.prototype.forEach = function (callbackFn, thisArg) {
         var _this = this;
         this._data.forEach(function (value) {
             callbackFn.call(thisArg, value, value, _this);
         });
     };
-    Object.defineProperty(ObservableSet$$1.prototype, "size", {
+    Object.defineProperty(ObservableSet.prototype, "size", {
         get: function () {
             this._atom.reportObserved();
             return this._data.size;
@@ -3739,11 +3738,11 @@ var ObservableSet$$1 = /** @class */ (function () {
         enumerable: true,
         configurable: true
     });
-    ObservableSet$$1.prototype.add = function (value) {
+    ObservableSet.prototype.add = function (value) {
         var _this = this;
-        checkIfStateModificationsAreAllowed$$1(this._atom);
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+        checkIfStateModificationsAreAllowed(this._atom);
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 type: "add",
                 object: this,
                 newValue: value
@@ -3754,12 +3753,12 @@ var ObservableSet$$1 = /** @class */ (function () {
             // changed by interceptor. Same applies for other Set and Map api's.
         }
         if (!this.has(value)) {
-            transaction$$1(function () {
+            transaction(function () {
                 _this._data.add(_this.enhancer(value, undefined));
                 _this._atom.reportChanged();
             });
-            var notifySpy = isSpyEnabled$$1();
-            var notify = hasListeners$$1(this);
+            var notifySpy = isSpyEnabled();
+            var notify = hasListeners(this);
             var change = notify || notifySpy
                 ? {
                     type: "add",
@@ -3768,18 +3767,18 @@ var ObservableSet$$1 = /** @class */ (function () {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart$$1(change);
+                spyReportStart(change);
             if (notify)
-                notifyListeners$$1(this, change);
+                notifyListeners(this, change);
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportEnd$$1();
+                spyReportEnd();
         }
         return this;
     };
-    ObservableSet$$1.prototype.delete = function (value) {
+    ObservableSet.prototype.delete = function (value) {
         var _this = this;
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 type: "delete",
                 object: this,
                 oldValue: value
@@ -3788,8 +3787,8 @@ var ObservableSet$$1 = /** @class */ (function () {
                 return false;
         }
         if (this.has(value)) {
-            var notifySpy = isSpyEnabled$$1();
-            var notify = hasListeners$$1(this);
+            var notifySpy = isSpyEnabled();
+            var notify = hasListeners(this);
             var change = notify || notifySpy
                 ? {
                     type: "delete",
@@ -3798,54 +3797,54 @@ var ObservableSet$$1 = /** @class */ (function () {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart$$1(__assign({}, change, { name: this.name }));
-            transaction$$1(function () {
+                spyReportStart(__assign({}, change, { name: this.name }));
+            transaction(function () {
                 _this._atom.reportChanged();
                 _this._data.delete(value);
             });
             if (notify)
-                notifyListeners$$1(this, change);
+                notifyListeners(this, change);
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportEnd$$1();
+                spyReportEnd();
             return true;
         }
         return false;
     };
-    ObservableSet$$1.prototype.has = function (value) {
+    ObservableSet.prototype.has = function (value) {
         this._atom.reportObserved();
         return this._data.has(this.dehanceValue(value));
     };
-    ObservableSet$$1.prototype.entries = function () {
+    ObservableSet.prototype.entries = function () {
         var nextIndex = 0;
-        var keys$$1 = iteratorToArray$$1(this.keys());
-        var values$$1 = iteratorToArray$$1(this.values());
-        return makeIterable$$1({
+        var keys = iteratorToArray(this.keys());
+        var values = iteratorToArray(this.values());
+        return makeIterable({
             next: function () {
                 var index = nextIndex;
                 nextIndex += 1;
-                return index < values$$1.length
-                    ? { value: [keys$$1[index], values$$1[index]], done: false }
+                return index < values.length
+                    ? { value: [keys[index], values[index]], done: false }
                     : { done: true };
             }
         });
     };
-    ObservableSet$$1.prototype.keys = function () {
+    ObservableSet.prototype.keys = function () {
         return this.values();
     };
-    ObservableSet$$1.prototype.values = function () {
+    ObservableSet.prototype.values = function () {
         this._atom.reportObserved();
         var self = this;
         var nextIndex = 0;
         var observableValues;
         if (this._data.values !== undefined) {
-            observableValues = iteratorToArray$$1(this._data.values());
+            observableValues = iteratorToArray(this._data.values());
         }
         else {
             // There is no values function in IE11
             observableValues = [];
             this._data.forEach(function (e) { return observableValues.push(e); });
         }
-        return makeIterable$$1({
+        return makeIterable({
             next: function () {
                 return nextIndex < observableValues.length
                     ? { value: self.dehanceValue(observableValues[nextIndex++]), done: false }
@@ -3853,57 +3852,57 @@ var ObservableSet$$1 = /** @class */ (function () {
             }
         });
     };
-    ObservableSet$$1.prototype.replace = function (other) {
+    ObservableSet.prototype.replace = function (other) {
         var _this = this;
-        if (isObservableSet$$1(other)) {
+        if (isObservableSet(other)) {
             other = other.toJS();
         }
-        transaction$$1(function () {
+        transaction(function () {
             if (Array.isArray(other)) {
                 _this.clear();
                 other.forEach(function (value) { return _this.add(value); });
             }
-            else if (isES6Set$$1(other)) {
+            else if (isES6Set(other)) {
                 _this.clear();
                 other.forEach(function (value) { return _this.add(value); });
             }
             else if (other !== null && other !== undefined) {
-                fail$$1("Cannot initialize set from " + other);
+                fail("Cannot initialize set from " + other);
             }
         });
         return this;
     };
-    ObservableSet$$1.prototype.observe = function (listener, fireImmediately) {
+    ObservableSet.prototype.observe = function (listener, fireImmediately) {
         // TODO 'fireImmediately' can be true?
         process.env.NODE_ENV !== "production" &&
-            invariant$$1(fireImmediately !== true, "`observe` doesn't support fireImmediately=true in combination with sets.");
-        return registerListener$$1(this, listener);
+            invariant(fireImmediately !== true, "`observe` doesn't support fireImmediately=true in combination with sets.");
+        return registerListener(this, listener);
     };
-    ObservableSet$$1.prototype.intercept = function (handler) {
-        return registerInterceptor$$1(this, handler);
+    ObservableSet.prototype.intercept = function (handler) {
+        return registerInterceptor(this, handler);
     };
-    ObservableSet$$1.prototype.toJS = function () {
+    ObservableSet.prototype.toJS = function () {
         return new Set(this);
     };
-    ObservableSet$$1.prototype.toString = function () {
-        return this.name + "[ " + iteratorToArray$$1(this.keys()).join(", ") + " ]";
+    ObservableSet.prototype.toString = function () {
+        return this.name + "[ " + iteratorToArray(this.keys()).join(", ") + " ]";
     };
-    return ObservableSet$$1;
+    return ObservableSet;
 }());
-declareIterator$$1(ObservableSet$$1.prototype, function () {
+declareIterator(ObservableSet.prototype, function () {
     return this.values();
 });
-addHiddenFinalProp$$1(ObservableSet$$1.prototype, toStringTagSymbol$$1(), "Set");
-var isObservableSet$$1 = createInstanceofPredicate$$1("ObservableSet", ObservableSet$$1);
+addHiddenFinalProp(ObservableSet.prototype, toStringTagSymbol(), "Set");
+var isObservableSet = createInstanceofPredicate("ObservableSet", ObservableSet);
 
-var ObservableObjectAdministration$$1 = /** @class */ (function () {
-    function ObservableObjectAdministration$$1(target, name, defaultEnhancer) {
+var ObservableObjectAdministration = /** @class */ (function () {
+    function ObservableObjectAdministration(target, name, defaultEnhancer) {
         this.target = target;
         this.name = name;
         this.defaultEnhancer = defaultEnhancer;
         this.values = {};
     }
-    ObservableObjectAdministration$$1.prototype.read = function (owner, key) {
+    ObservableObjectAdministration.prototype.read = function (owner, key) {
         if (process.env.NODE_ENV === "production" && this.target !== owner) {
             this.illegalAccess(owner, key);
             if (!this.values[key])
@@ -3911,19 +3910,19 @@ var ObservableObjectAdministration$$1 = /** @class */ (function () {
         }
         return this.values[key].get();
     };
-    ObservableObjectAdministration$$1.prototype.write = function (owner, key, newValue) {
+    ObservableObjectAdministration.prototype.write = function (owner, key, newValue) {
         var instance = this.target;
         if (process.env.NODE_ENV === "production" && instance !== owner) {
             this.illegalAccess(owner, key);
         }
-        var observable$$1 = this.values[key];
-        if (observable$$1 instanceof ComputedValue$$1) {
-            observable$$1.set(newValue);
+        var observable = this.values[key];
+        if (observable instanceof ComputedValue) {
+            observable.set(newValue);
             return;
         }
         // intercept
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 type: "update",
                 object: instance,
                 name: key,
@@ -3933,35 +3932,35 @@ var ObservableObjectAdministration$$1 = /** @class */ (function () {
                 return;
             newValue = change.newValue;
         }
-        newValue = observable$$1.prepareNewValue(newValue);
+        newValue = observable.prepareNewValue(newValue);
         // notify spy & observers
-        if (newValue !== globalState$$1.UNCHANGED) {
-            var notify = hasListeners$$1(this);
-            var notifySpy = isSpyEnabled$$1();
+        if (newValue !== globalState.UNCHANGED) {
+            var notify = hasListeners(this);
+            var notifySpy = isSpyEnabled();
             var change = notify || notifySpy
                 ? {
                     type: "update",
                     object: instance,
-                    oldValue: observable$$1.value,
+                    oldValue: observable.value,
                     name: key,
                     newValue: newValue
                 }
                 : null;
             if (notifySpy)
-                spyReportStart$$1(__assign({}, change, { name: this.name, key: key }));
-            observable$$1.setNewValue(newValue);
+                spyReportStart(__assign({}, change, { name: this.name, key: key }));
+            observable.setNewValue(newValue);
             if (notify)
-                notifyListeners$$1(this, change);
+                notifyListeners(this, change);
             if (notifySpy)
-                spyReportEnd$$1();
+                spyReportEnd();
         }
     };
-    ObservableObjectAdministration$$1.prototype.remove = function (key) {
+    ObservableObjectAdministration.prototype.remove = function (key) {
         if (!this.values[key])
             return;
         var target = this.target;
-        if (hasInterceptors$$1(this)) {
-            var change = interceptChange$$1(this, {
+        if (hasInterceptors(this)) {
+            var change = interceptChange(this, {
                 object: target,
                 name: key,
                 type: "remove"
@@ -3970,9 +3969,9 @@ var ObservableObjectAdministration$$1 = /** @class */ (function () {
                 return;
         }
         try {
-            startBatch$$1();
-            var notify = hasListeners$$1(this);
-            var notifySpy = isSpyEnabled$$1();
+            startBatch();
+            var notify = hasListeners(this);
+            var notifySpy = isSpyEnabled();
             var oldValue = this.values[key].get();
             if (this.keys)
                 this.keys.remove(key);
@@ -3987,17 +3986,17 @@ var ObservableObjectAdministration$$1 = /** @class */ (function () {
                 }
                 : null;
             if (notifySpy)
-                spyReportStart$$1(__assign({}, change, { name: this.name, key: key }));
+                spyReportStart(__assign({}, change, { name: this.name, key: key }));
             if (notify)
-                notifyListeners$$1(this, change);
+                notifyListeners(this, change);
             if (notifySpy)
-                spyReportEnd$$1();
+                spyReportEnd();
         }
         finally {
-            endBatch$$1();
+            endBatch();
         }
     };
-    ObservableObjectAdministration$$1.prototype.illegalAccess = function (owner, propName) {
+    ObservableObjectAdministration.prototype.illegalAccess = function (owner, propName) {
         /**
          * This happens if a property is accessed through the prototype chain, but the property was
          * declared directly as own property on the prototype.
@@ -4024,44 +4023,44 @@ var ObservableObjectAdministration$$1 = /** @class */ (function () {
      * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
      * for callback details
      */
-    ObservableObjectAdministration$$1.prototype.observe = function (callback, fireImmediately) {
+    ObservableObjectAdministration.prototype.observe = function (callback, fireImmediately) {
         process.env.NODE_ENV !== "production" &&
-            invariant$$1(fireImmediately !== true, "`observe` doesn't support the fire immediately property for observable objects.");
-        return registerListener$$1(this, callback);
+            invariant(fireImmediately !== true, "`observe` doesn't support the fire immediately property for observable objects.");
+        return registerListener(this, callback);
     };
-    ObservableObjectAdministration$$1.prototype.intercept = function (handler) {
-        return registerInterceptor$$1(this, handler);
+    ObservableObjectAdministration.prototype.intercept = function (handler) {
+        return registerInterceptor(this, handler);
     };
-    ObservableObjectAdministration$$1.prototype.getKeys = function () {
+    ObservableObjectAdministration.prototype.getKeys = function () {
         var _this = this;
         if (this.keys === undefined) {
-            this.keys = (new ObservableArray$$1(Object.keys(this.values).filter(function (key) { return _this.values[key] instanceof ObservableValue$$1; }), referenceEnhancer$$1, "keys(" + this.name + ")", true));
+            this.keys = (new ObservableArray(Object.keys(this.values).filter(function (key) { return _this.values[key] instanceof ObservableValue; }), referenceEnhancer, "keys(" + this.name + ")", true));
         }
         return this.keys.slice();
     };
-    return ObservableObjectAdministration$$1;
+    return ObservableObjectAdministration;
 }());
-function asObservableObject$$1(target, name, defaultEnhancer) {
+function asObservableObject(target, name, defaultEnhancer) {
     if (name === void 0) { name = ""; }
-    if (defaultEnhancer === void 0) { defaultEnhancer = deepEnhancer$$1; }
+    if (defaultEnhancer === void 0) { defaultEnhancer = deepEnhancer; }
     var adm = target.$mobx;
     if (adm)
         return adm;
     process.env.NODE_ENV !== "production" &&
-        invariant$$1(Object.isExtensible(target), "Cannot make the designated object observable; it is not extensible");
-    if (!isPlainObject$$1(target))
-        name = (target.constructor.name || "ObservableObject") + "@" + getNextId$$1();
+        invariant(Object.isExtensible(target), "Cannot make the designated object observable; it is not extensible");
+    if (!isPlainObject(target))
+        name = (target.constructor.name || "ObservableObject") + "@" + getNextId();
     if (!name)
-        name = "ObservableObject@" + getNextId$$1();
-    adm = new ObservableObjectAdministration$$1(target, name, defaultEnhancer);
-    addHiddenFinalProp$$1(target, "$mobx", adm);
+        name = "ObservableObject@" + getNextId();
+    adm = new ObservableObjectAdministration(target, name, defaultEnhancer);
+    addHiddenFinalProp(target, "$mobx", adm);
     return adm;
 }
-function defineObservableProperty$$1(target, propName, newValue, enhancer) {
-    var adm = asObservableObject$$1(target);
-    assertPropertyConfigurable$$1(target, propName);
-    if (hasInterceptors$$1(adm)) {
-        var change = interceptChange$$1(adm, {
+function defineObservableProperty(target, propName, newValue, enhancer) {
+    var adm = asObservableObject(target);
+    assertPropertyConfigurable(target, propName);
+    if (hasInterceptors(adm)) {
+        var change = interceptChange(adm, {
             object: target,
             name: propName,
             type: "add",
@@ -4071,24 +4070,24 @@ function defineObservableProperty$$1(target, propName, newValue, enhancer) {
             return;
         newValue = change.newValue;
     }
-    var observable$$1 = (adm.values[propName] = new ObservableValue$$1(newValue, enhancer, adm.name + "." + propName, false));
-    newValue = observable$$1.value; // observableValue might have changed it
-    Object.defineProperty(target, propName, generateObservablePropConfig$$1(propName));
+    var observable = (adm.values[propName] = new ObservableValue(newValue, enhancer, adm.name + "." + propName, false));
+    newValue = observable.value; // observableValue might have changed it
+    Object.defineProperty(target, propName, generateObservablePropConfig(propName));
     if (adm.keys)
         adm.keys.push(propName);
     notifyPropertyAddition(adm, target, propName, newValue);
 }
-function defineComputedProperty$$1(target, // which objects holds the observable and provides `this` context?
+function defineComputedProperty(target, // which objects holds the observable and provides `this` context?
 propName, options) {
-    var adm = asObservableObject$$1(target);
+    var adm = asObservableObject(target);
     options.name = adm.name + "." + propName;
     options.context = target;
-    adm.values[propName] = new ComputedValue$$1(options);
-    Object.defineProperty(target, propName, generateComputedPropConfig$$1(propName));
+    adm.values[propName] = new ComputedValue(options);
+    Object.defineProperty(target, propName, generateComputedPropConfig(propName));
 }
 var observablePropertyConfigs = Object.create(null);
 var computedPropertyConfigs = Object.create(null);
-function generateObservablePropConfig$$1(propName) {
+function generateObservablePropConfig(propName) {
     return (observablePropertyConfigs[propName] ||
         (observablePropertyConfigs[propName] = {
             configurable: true,
@@ -4106,15 +4105,15 @@ function getAdministrationForComputedPropOwner(owner) {
     if (!adm) {
         // because computed props are declared on proty,
         // the current instance might not have been initialized yet
-        initializeInstance$$1(owner);
+        initializeInstance(owner);
         return owner.$mobx;
     }
     return adm;
 }
-function generateComputedPropConfig$$1(propName) {
+function generateComputedPropConfig(propName) {
     return (computedPropertyConfigs[propName] ||
         (computedPropertyConfigs[propName] = {
-            configurable: false,
+            configurable: globalState.computedConfigurable,
             enumerable: false,
             get: function () {
                 return getAdministrationForComputedPropOwner(this).read(this, propName);
@@ -4125,8 +4124,8 @@ function generateComputedPropConfig$$1(propName) {
         }));
 }
 function notifyPropertyAddition(adm, object, key, newValue) {
-    var notify = hasListeners$$1(adm);
-    var notifySpy = isSpyEnabled$$1();
+    var notify = hasListeners(adm);
+    var notifySpy = isSpyEnabled();
     var change = notify || notifySpy
         ? {
             type: "add",
@@ -4136,96 +4135,96 @@ function notifyPropertyAddition(adm, object, key, newValue) {
         }
         : null;
     if (notifySpy)
-        spyReportStart$$1(__assign({}, change, { name: adm.name, key: key }));
+        spyReportStart(__assign({}, change, { name: adm.name, key: key }));
     if (notify)
-        notifyListeners$$1(adm, change);
+        notifyListeners(adm, change);
     if (notifySpy)
-        spyReportEnd$$1();
+        spyReportEnd();
 }
-var isObservableObjectAdministration = createInstanceofPredicate$$1("ObservableObjectAdministration", ObservableObjectAdministration$$1);
-function isObservableObject$$1(thing) {
-    if (isObject$$1(thing)) {
+var isObservableObjectAdministration = createInstanceofPredicate("ObservableObjectAdministration", ObservableObjectAdministration);
+function isObservableObject(thing) {
+    if (isObject(thing)) {
         // Initializers run lazily when transpiling to babel, so make sure they are run...
-        initializeInstance$$1(thing);
+        initializeInstance(thing);
         return isObservableObjectAdministration(thing.$mobx);
     }
     return false;
 }
 
-function getAtom$$1(thing, property) {
+function getAtom(thing, property) {
     if (typeof thing === "object" && thing !== null) {
-        if (isObservableArray$$1(thing)) {
+        if (isObservableArray(thing)) {
             if (property !== undefined)
-                fail$$1(process.env.NODE_ENV !== "production" &&
+                fail(process.env.NODE_ENV !== "production" &&
                     "It is not possible to get index atoms from arrays");
             return thing.$mobx.atom;
         }
-        if (isObservableSet$$1(thing)) {
+        if (isObservableSet(thing)) {
             return thing.$mobx;
         }
-        if (isObservableMap$$1(thing)) {
+        if (isObservableMap(thing)) {
             var anyThing = thing;
             if (property === undefined)
-                return getAtom$$1(anyThing._keys);
-            var observable$$1 = anyThing._data.get(property) || anyThing._hasMap.get(property);
-            if (!observable$$1)
-                fail$$1(process.env.NODE_ENV !== "production" &&
-                    "the entry '" + property + "' does not exist in the observable map '" + getDebugName$$1(thing) + "'");
-            return observable$$1;
+                return getAtom(anyThing._keys);
+            var observable = anyThing._data.get(property) || anyThing._hasMap.get(property);
+            if (!observable)
+                fail(process.env.NODE_ENV !== "production" &&
+                    "the entry '" + property + "' does not exist in the observable map '" + getDebugName(thing) + "'");
+            return observable;
         }
         // Initializers run lazily when transpiling to babel, so make sure they are run...
-        initializeInstance$$1(thing);
+        initializeInstance(thing);
         if (property && !thing.$mobx)
             thing[property]; // See #1072
-        if (isObservableObject$$1(thing)) {
+        if (isObservableObject(thing)) {
             if (!property)
-                return fail$$1(process.env.NODE_ENV !== "production" && "please specify a property");
-            var observable$$1 = thing.$mobx.values[property];
-            if (!observable$$1)
-                fail$$1(process.env.NODE_ENV !== "production" &&
-                    "no observable property '" + property + "' found on the observable object '" + getDebugName$$1(thing) + "'");
-            return observable$$1;
-        }
-        if (isAtom$$1(thing) || isComputedValue$$1(thing) || isReaction$$1(thing)) {
+                return fail(process.env.NODE_ENV !== "production" && "please specify a property");
+            var observable = thing.$mobx.values[property];
+            if (!observable)
+                fail(process.env.NODE_ENV !== "production" &&
+                    "no observable property '" + property + "' found on the observable object '" + getDebugName(thing) + "'");
+            return observable;
+        }
+        if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {
             return thing;
         }
     }
     else if (typeof thing === "function") {
-        if (isReaction$$1(thing.$mobx)) {
+        if (isReaction(thing.$mobx)) {
             // disposer function
             return thing.$mobx;
         }
     }
-    return fail$$1(process.env.NODE_ENV !== "production" && "Cannot obtain atom from " + thing);
+    return fail(process.env.NODE_ENV !== "production" && "Cannot obtain atom from " + thing);
 }
-function getAdministration$$1(thing, property) {
+function getAdministration(thing, property) {
     if (!thing)
-        fail$$1("Expecting some object");
+        fail("Expecting some object");
     if (property !== undefined)
-        return getAdministration$$1(getAtom$$1(thing, property));
-    if (isAtom$$1(thing) || isComputedValue$$1(thing) || isReaction$$1(thing))
+        return getAdministration(getAtom(thing, property));
+    if (isAtom(thing) || isComputedValue(thing) || isReaction(thing))
         return thing;
-    if (isObservableMap$$1(thing) || isObservableSet$$1(thing))
+    if (isObservableMap(thing) || isObservableSet(thing))
         return thing;
     // Initializers run lazily when transpiling to babel, so make sure they are run...
-    initializeInstance$$1(thing);
+    initializeInstance(thing);
     if (thing.$mobx)
         return thing.$mobx;
-    fail$$1(process.env.NODE_ENV !== "production" && "Cannot obtain administration from " + thing);
+    fail(process.env.NODE_ENV !== "production" && "Cannot obtain administration from " + thing);
 }
-function getDebugName$$1(thing, property) {
+function getDebugName(thing, property) {
     var named;
     if (property !== undefined)
-        named = getAtom$$1(thing, property);
-    else if (isObservableObject$$1(thing) || isObservableMap$$1(thing) || isObservableSet$$1(thing))
-        named = getAdministration$$1(thing);
+        named = getAtom(thing, property);
+    else if (isObservableObject(thing) || isObservableMap(thing) || isObservableSet(thing))
+        named = getAdministration(thing);
     else
-        named = getAtom$$1(thing); // valid for arrays as well
+        named = getAtom(thing); // valid for arrays as well
     return named.name;
 }
 
 var toString = Object.prototype.toString;
-function deepEqual$$1(a, b) {
+function deepEqual(a, b) {
     return eq(a, b);
 }
 // Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289
@@ -4328,15 +4327,15 @@ function deepEq(a, b, aStack, bStack) {
     }
     else {
         // Deep compare objects.
-        var keys$$1 = Object.keys(a);
+        var keys = Object.keys(a);
         var key = void 0;
-        length = keys$$1.length;
+        length = keys.length;
         // Ensure that both objects contain the same number of properties before comparing deep equality.
         if (Object.keys(b).length !== length)
             return false;
         while (length--) {
             // Deep compare each member
-            key = keys$$1[length];
+            key = keys[length];
             if (!(has$1(b, key) && eq(a[key], b[key], aStack, bStack)))
                 return false;
         }
@@ -4347,12 +4346,12 @@ function deepEq(a, b, aStack, bStack) {
     return true;
 }
 function unwrap(a) {
-    if (isObservableArray$$1(a))
+    if (isObservableArray(a))
         return a.peek();
-    if (isES6Map$$1(a) || isObservableMap$$1(a))
-        return iteratorToArray$$1(a.entries());
-    if (isES6Set$$1(a) || isObservableSet$$1(a))
-        return iteratorToArray$$1(a.entries());
+    if (isES6Map(a) || isObservableMap(a))
+        return iteratorToArray(a.entries());
+    if (isES6Set(a) || isObservableSet(a))
+        return iteratorToArray(a.entries());
     return a;
 }
 function has$1(a, key) {
@@ -4397,26 +4396,24 @@ catch (e) {
         g.process = {};
     g.process.env = {};
 }
-
 (function () {
     function testCodeMinification() { }
     if (testCodeMinification.name !== "testCodeMinification" &&
         process.env.NODE_ENV !== "production" &&
         process.env.IGNORE_MOBX_MINIFY_WARNING !== "true") {
-        console.warn(
-        // Template literal(backtick) is used for fix issue with rollup-plugin-commonjs https://github.com/rollup/rollup-plugin-commonjs/issues/344
-        "[mobx] you are running a minified build, but 'process.env.NODE_ENV' was not set to 'production' in your bundler. This results in an unnecessarily large and slow bundle");
+        // trick so it doesn't get replaced
+        var varName = ["process", "env", "NODE_ENV"].join(".");
+        console.warn("[mobx] you are running a minified build, but '" + varName + "' was not set to 'production' in your bundler. This results in an unnecessarily large and slow bundle");
     }
 })();
 // forward compatibility with mobx, so that packages can easily support mobx 4 & 5
 var $mobx = "$mobx";
-// Devtools support
 if (typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "object") {
     // See: https://github.com/andykog/mobx-devtools/
     __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx({
-        spy: spy$$1,
+        spy: spy,
         extras: {
-            getDebugName: getDebugName$$1
+            getDebugName: getDebugName
         },
         $mobx: $mobx
     });
@@ -4456,11 +4453,11 @@ if (process.env.NODE_ENV !== "production" &&
         Object.defineProperty(module.exports, prop, {
             enumerable: false,
             get: function () {
-                fail$$1("'" + prop + "' is no longer part of the public MobX api. Please consult the changelog to find out where this functionality went");
+                fail("'" + prop + "' is no longer part of the public MobX api. Please consult the changelog to find out where this functionality went");
             },
             set: function () { }
         });
     });
 }
 
-export { $mobx, Reaction$$1 as Reaction, untracked$$1 as untracked, IDerivationState, createAtom$$1 as createAtom, spy$$1 as spy, comparer$$1 as comparer, isObservableObject$$1 as isObservableObject, isObservableValue$$1 as isBoxedObservable, isObservableArray$$1 as isObservableArray, ObservableMap$$1 as ObservableMap, isObservableMap$$1 as isObservableMap, ObservableSet$$1 as ObservableSet, isObservableSet$$1 as isObservableSet, transaction$$1 as transaction, observable$$1 as observable, computed$$1 as computed, isObservable$$1 as isObservable, isObservableProp$$1 as isObservableProp, isComputed$$1 as isComputed, isComputedProp$$1 as isComputedProp, extendObservable$$1 as extendObservable, extendShallowObservable$$1 as extendShallowObservable, observe$$1 as observe, intercept$$1 as intercept, autorun$$1 as autorun, reaction$$1 as reaction, when$$1 as when, action$$1 as action, isAction$$1 as isAction, runInAction$$1 as runInAction, keys$$1 as keys, values$$1 as values, entries$$1 as entries, set$$1 as set, remove$$1 as remove, has$$1 as has, get$$1 as get, decorate$$1 as decorate, configure$$1 as configure, onBecomeObserved$$1 as onBecomeObserved, onBecomeUnobserved$$1 as onBecomeUnobserved, flow$$1 as flow, toJS$$1 as toJS, trace$$1 as trace, getDependencyTree$$1 as getDependencyTree, getObserverTree$$1 as getObserverTree, resetGlobalState$$1 as _resetGlobalState, getGlobalState$$1 as _getGlobalState, getDebugName$$1 as getDebugName, getAtom$$1 as getAtom, getAdministration$$1 as _getAdministration, allowStateChanges$$1 as _allowStateChanges, allowStateChangesInsideComputed$$1 as _allowStateChangesInsideComputed, isArrayLike$$1 as isArrayLike, isComputingDerivation$$1 as _isComputingDerivation, onReactionError$$1 as onReactionError, interceptReads$$1 as _interceptReads };
+export { $mobx, IDerivationState, ObservableMap, ObservableSet, Reaction, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, action, autorun, comparer, computed, configure, createAtom, decorate, entries, extendObservable, extendShallowObservable, flow, get, getAtom, getDebugName, getDependencyTree, getObserverTree, has, intercept, isAction, isArrayLike, isObservableValue as isBoxedObservable, isComputed, isComputedProp, isObservable, isObservableArray, isObservableMap, isObservableObject, isObservableProp, isObservableSet, keys, observable, observe, onBecomeObserved, onBecomeUnobserved, onReactionError, reaction, remove, runInAction, set, spy, toJS, trace, transaction, untracked, values, when };