mobx 5.14.1 → 5.15.2

package/README.md

@@ -79,7 +79,8 @@ _Tip: Consider using the faster and smaller ES6 build if targetting a modern env
     -   LearnCode.academy MobX tutorial [Part I: MobX + React is AWESOME (7m)](https://www.youtube.com/watch?v=_q50BXqkAfI) [Part II: Computed Values and Nested/Referenced Observables (12m.)](https://www.youtube.com/watch?v=nYvNqKrl69s)
     -   [Screencast: intro to MobX](https://www.youtube.com/watch?v=K8dr8BMU7-8) - 8m
     -   [Talk: State Management Is Easy, React Amsterdam 2016 conf](https://www.youtube.com/watch?v=ApmSsu3qnf0&feature=youtu.be) ([slides](https://speakerdeck.com/mweststrate/state-management-is-easy-introduction-to-mobx))
--   [Boilerplates and related projects](http://mobxjs.github.io/mobx/faq/boilerplates.html)
+-   Boilerplates [MobX awesome list](https://github.com/mobxjs/awesome-mobx#boilerplates)
+-   Related projects [MobX awesome list](https://github.com/mobxjs/awesome-mobx#related-projects-and-utilities)
 -   More tutorials, blogs, videos, and other helpful resources can be found on the [MobX awesome list](https://github.com/mobxjs/awesome-mobx#awesome-mobx)
 
 ## Introduction
@@ -312,11 +313,13 @@ And finally, kudos to all the people that believed in, tried, validated and even
 ## Further resources and documentation
 
 -   <img src="docs/assets/book.jpg" height="80px"/> [The MobX book](https://books.google.nl/books?id=ALFmDwAAQBAJ&pg=PP1&lpg=PP1&dq=michel+weststrate+mobx+quick+start+guide:+supercharge+the+client+state+in+your+react+apps+with+mobx&source=bl&ots=D460fxti0F&sig=ivDGTxsPNwlOjLHrpKF1nweZFl8&hl=nl&sa=X&ved=2ahUKEwiwl8XO--ncAhWPmbQKHWOYBqIQ6AEwAnoECAkQAQ#v=onepage&q=michel%20weststrate%20mobx%20quick%20start%20guide%3A%20supercharge%20the%20client%20state%20in%20your%20react%20apps%20with%20mobx&f=false) by Pavan Podila and Michel Weststrate (which despite its name is in-depth!)
--   [MobX homepage](http://mobxjs.github.io/mobx/faq/blogs.html)
+-   [MobX homepage](http://mobxjs.github.io)
 -   [API overview](http://mobxjs.github.io/mobx/refguide/api.html)
--   [Tutorials, Blogs & Videos](http://mobxjs.github.io/mobx/faq/blogs.html)
--   [Boilerplates](http://mobxjs.github.io/mobx/faq/boilerplates.html)
--   [Related projects](http://mobxjs.github.io/mobx/faq/related.html)
+-   [Tutorials](https://github.com/mobxjs/awesome-mobx#tutorials)
+-   [Blogs](https://github.com/mobxjs/awesome-mobx#blogs)
+-   [Videos](https://github.com/mobxjs/awesome-mobx#videos)
+-   [Boilerplates](https://github.com/mobxjs/awesome-mobx#boilerplates)
+-   [MobX awesome list](https://github.com/mobxjs/awesome-mobx#awesome-mobx)
 
 ## What others are saying...
 

package/lib/api/action.d.ts

@@ -1,19 +1,7 @@
 import { IAction } from "../internal";
 export interface IActionFactory {
-    <A1, R, T extends (a1: A1) => R>(fn: T): T & IAction;
-    <A1, A2, R, T extends (a1: A1, a2: A2) => R>(fn: T): T & IAction;
-    <A1, A2, A3, R, T extends (a1: A1, a2: A2, a3: A3) => R>(fn: T): T & IAction;
-    <A1, A2, A3, A4, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4) => R>(fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => R>(fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, A6, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a6: A6) => R>(fn: T): T & IAction;
-    <A1, R, T extends (a1: A1) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, R, T extends (a1: A1, a2: A2) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, R, T extends (a1: A1, a2: A2, a3: A3) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, A4, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, A6, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a6: A6) => R>(name: string, fn: T): T & IAction;
-    <T extends Function>(fn: T): T & IAction;
-    <T extends Function>(name: string, fn: T): T & IAction;
+    <T extends Function | null | undefined>(fn: T): T & IAction;
+    <T extends Function | null | undefined>(name: string, fn: T): T & IAction;
     (customName: string): (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor) => void;
     (target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
     bound(target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;

package/lib/api/flow.d.ts

@@ -1,12 +1,9 @@
+export declare function FlowCancellationError(): void;
+export declare namespace FlowCancellationError {
+    var prototype: any;
+}
+export declare function isFlowCancellationError(error: Error): boolean;
 export declare type CancellablePromise<T> = Promise<T> & {
     cancel(): void;
 };
-export interface FlowYield {
-    "!!flowYield": undefined;
-}
-export interface FlowReturn<T> {
-    "!!flowReturn": T;
-}
-export declare type FlowReturnType<R> = IfAllAreFlowYieldThenVoid<R extends FlowReturn<infer FR> ? FR extends Promise<infer FRP> ? FRP : FR : R extends Promise<any> ? FlowYield : R>;
-export declare type IfAllAreFlowYieldThenVoid<R> = Exclude<R, FlowYield> extends never ? void : Exclude<R, FlowYield>;
-export declare function flow<R, Args extends any[]>(generator: (...args: Args) => IterableIterator<R>): (...args: Args) => CancellablePromise<FlowReturnType<R>>;
+export declare function flow<R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;

package/lib/core/computedvalue.d.ts

@@ -38,7 +38,7 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     newObserving: null;
     isBeingObserved: boolean;
     isPendingUnobservation: boolean;
-    observers: Set<any>;
+    observers: Set<IDerivation>;
     diffValue: number;
     runId: number;
     lastAccessedBy: number;
@@ -92,4 +92,4 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     valueOf(): T;
     [Symbol.toPrimitive](): T;
 }
-export declare const isComputedValue: (x: any) => x is ComputedValue<{}>;
+export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;

package/lib/core/globalstate.d.ts

@@ -96,6 +96,7 @@ export declare class MobXGlobals {
     disableErrorBoundaries: boolean;
     suppressReactionErrors: boolean;
 }
+export declare function getGlobal(): any;
 export declare let globalState: MobXGlobals;
 export declare function isolateGlobalState(): void;
 export declare function getGlobalState(): any;
@@ -104,4 +105,3 @@ export declare function getGlobalState(): any;
  * but can be used to get back at a stable state after throwing errors
  */
 export declare function resetGlobalState(): void;
-export declare function getGlobal(): any;

package/lib/mobx.d.ts

@@ -15,4 +15,4 @@
  * - utils/   Utility stuff.
  *
  */
-export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, IDerivation, untracked, IDerivationState, IAtom, createAtom, IAction, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, IObservableObject, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, Lambda, isArrayLike, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction } from "./internal";
+export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, IDerivation, untracked, IDerivationState, IAtom, createAtom, IAction, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, IObservableObject, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, FlowCancellationError, isFlowCancellationError, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, Lambda, isArrayLike, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd } from "./internal";

package/lib/mobx.es6.js

@@ -1,5 +1,5 @@
 /** MobX - (c) Michel Weststrate 2015 - 2019 - MIT Licensed */
-const OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is an production build.";
+const OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is a production build.";
 const EMPTY_ARRAY = [];
 Object.freeze(EMPTY_ARRAY);
 const EMPTY_OBJECT = {};
@@ -241,7 +241,9 @@ function initializeInstance(target) {
     const decorators = target[mobxPendingDecorators];
     if (decorators) {
         addHiddenProp(target, mobxDidRunLazyInitializersSymbol, true);
-        for (let key in decorators) {
+        // Build property key array from both strings and symbols
+        const keys = [...Object.getOwnPropertySymbols(decorators), ...Object.keys(decorators)];
+        for (const key of keys) {
             const d = decorators[key];
             d.propertyCreator(target, d.prop, d.descriptor, d.decoratorTarget, d.decoratorArguments);
         }
@@ -286,7 +288,8 @@ function createPropDecorator(propertyInitiallyEnumerable, propertyCreator) {
     };
 }
 function quacksLikeADecorator(args) {
-    return (((args.length === 2 || args.length === 3) && typeof args[1] === "string") ||
+    return (((args.length === 2 || args.length === 3) &&
+        (typeof args[1] === "string" || typeof args[1] === "symbol")) ||
         (args.length === 4 && args[3] === true));
 }
 
@@ -403,7 +406,7 @@ function getEnhancerFromOptions(options) {
  */
 function createObservable(v, arg2, arg3) {
     // @observable someProp;
-    if (typeof arguments[1] === "string") {
+    if (typeof arguments[1] === "string" || typeof arguments[1] === "symbol") {
         return deepDecorator.apply(null, arguments);
     }
     // it is an observable already, done
@@ -570,6 +573,8 @@ function shouldCompute(derivation) {
         case IDerivationState.STALE:
             return true;
         case IDerivationState.POSSIBLY_STALE: {
+            // state propagation can occur outside of action/reactive context #2195
+            const prevAllowStateReads = allowStateReadsStart(true);
             const prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.
             const obs = derivation.observing, l = obs.length;
             for (let i = 0; i < l; i++) {
@@ -585,6 +590,7 @@ function shouldCompute(derivation) {
                         catch (e) {
                             // we are not interested in the value *or* exception at this moment, but if there is one, notify all
                             untrackedEnd(prevUntracked);
+                            allowStateReadsEnd(prevAllowStateReads);
                             return true;
                         }
                     }
@@ -593,12 +599,14 @@ function shouldCompute(derivation) {
                     // invariantShouldCompute(derivation)
                     if (derivation.dependenciesState === IDerivationState.STALE) {
                         untrackedEnd(prevUntracked);
+                        allowStateReadsEnd(prevAllowStateReads);
                         return true;
                     }
                 }
             }
             changeDependenciesStateTo0(derivation);
             untrackedEnd(prevUntracked);
+            allowStateReadsEnd(prevAllowStateReads);
             return false;
         }
     }
@@ -1041,8 +1049,7 @@ class ComputedValue {
         this.isComputing = false; // to check for cycles
         this.isRunningSetter = false;
         this.isTracing = TraceMode.NONE;
-        if (process.env.NODE_ENV !== "production" && !options.get)
-            throw "[mobx] missing option for computed: get";
+        invariant(options.get, "missing option for computed: get");
         this.derivation = options.get;
         this.name = options.name || "ComputedValue@" + getNextId();
         if (options.set)
@@ -1333,6 +1340,19 @@ class MobXGlobals {
         this.suppressReactionErrors = false;
     }
 }
+const mockGlobal = {};
+function getGlobal() {
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    return mockGlobal;
+}
 let canMergeGlobalState = true;
 let isolateCalled = false;
 let globalState = (function () {
@@ -1386,16 +1406,6 @@ function resetGlobalState() {
             globalState[key] = defaultGlobals[key];
     globalState.allowStateChanges = !globalState.enforceActions;
 }
-const mockGlobal = {};
-function getGlobal() {
-    if (typeof window !== "undefined") {
-        return window;
-    }
-    if (typeof global !== "undefined") {
-        return global;
-    }
-    return mockGlobal;
-}
 
 function hasObservers(observable) {
     return observable.observers && observable.observers.size > 0;
@@ -1810,7 +1820,7 @@ function spyReport(event) {
 function spyReportStart(event) {
     if (process.env.NODE_ENV === "production")
         return;
-    const change = Object.assign({}, event, { spyReportStart: true });
+    const change = Object.assign(Object.assign({}, event), { spyReportStart: true });
     spyReport(change);
 }
 const END_EVENT = { spyReportEnd: true };
@@ -1818,7 +1828,7 @@ function spyReportEnd(change) {
     if (process.env.NODE_ENV === "production")
         return;
     if (change)
-        spyReport(Object.assign({}, change, { spyReportEnd: true }));
+        spyReport(Object.assign(Object.assign({}, change), { spyReportEnd: true }));
     else
         spyReport(END_EVENT);
 }
@@ -2195,8 +2205,6 @@ function extendObservableObjectWithProperties(target, properties, decorators, de
             if (process.env.NODE_ENV !== "production") {
                 if (!isPlainObject(properties))
                     fail(`'extendObservabe' only accepts plain objects as second argument`);
-                if (Object.getOwnPropertyDescriptor(target, key))
-                    fail(`'extendObservable' can only be used to introduce new properties. Use 'set' or 'decorate' instead. The property '${stringifyKey(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`);
             }
@@ -2242,9 +2250,16 @@ function nodeToObserverTree(node) {
 }
 
 let generatorId = 0;
+function FlowCancellationError() {
+    this.message = "FLOW_CANCELLED";
+}
+FlowCancellationError.prototype = Object.create(Error.prototype);
+function isFlowCancellationError(error) {
+    return error instanceof FlowCancellationError;
+}
 function flow(generator) {
     if (arguments.length !== 1)
-        fail(!!process.env.NODE_ENV && `Flow expects one 1 argument and cannot be used as decorator`);
+        fail(!!process.env.NODE_ENV && `Flow expects 1 argument and cannot be used as decorator`);
     const name = generator.name || "<unnamed flow>";
     // Implementation based on https://github.com/tj/co/blob/master/index.js
     return function () {
@@ -2297,13 +2312,13 @@ function flow(generator) {
                 if (pendingPromise)
                     cancelPromise(pendingPromise);
                 // Finally block can return (or yield) stuff..
-                const res = gen.return();
+                const res = gen.return(undefined);
                 // eat anything that promise would do, it's cancelled!
                 const yieldedPromise = Promise.resolve(res.value);
                 yieldedPromise.then(noop, noop);
                 cancelPromise(yieldedPromise); // maybe it can be cancelled :)
                 // reject our original promise
-                rejector(new Error("FLOW_CANCELLED"));
+                rejector(new FlowCancellationError());
             }
             catch (e) {
                 rejector(e); // there could be a throwing finally block
@@ -2745,7 +2760,7 @@ function whenPromise(predicate, opts) {
         return fail(`the options 'onError' and 'promise' cannot be combined`);
     let cancel;
     const res = new Promise((resolve, reject) => {
-        let disposer = _when(predicate, resolve, Object.assign({}, opts, { onError: reject }));
+        let disposer = _when(predicate, resolve, Object.assign(Object.assign({}, opts), { onError: reject }));
         cancel = () => {
             disposer();
             reject("WHEN_CANCELLED");
@@ -3057,7 +3072,7 @@ class ObservableArrayAdministration {
         // The reason why this is on right hand side here (and not above), is this way the uglifier will drop it, but it won't
         // cause any runtime overhead in development mode without NODE_ENV set, unless spying is enabled
         if (notifySpy && process.env.NODE_ENV !== "production")
-            spyReportStart(Object.assign({}, change, { name: this.atom.name }));
+            spyReportStart(Object.assign(Object.assign({}, change), { name: this.atom.name }));
         this.atom.reportChanged();
         if (notify)
             notifyListeners(this, change);
@@ -3079,7 +3094,7 @@ class ObservableArrayAdministration {
             }
             : null;
         if (notifySpy && process.env.NODE_ENV !== "production")
-            spyReportStart(Object.assign({}, change, { name: this.atom.name }));
+            spyReportStart(Object.assign(Object.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)
@@ -3330,7 +3345,7 @@ class ObservableMap {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart(Object.assign({}, change, { name: this.name, key }));
+                spyReportStart(Object.assign(Object.assign({}, change), { name: this.name, key }));
             transaction(() => {
                 this._keysAtom.reportChanged();
                 this._updateHasMapEntry(key, false);
@@ -3368,7 +3383,7 @@ class ObservableMap {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart(Object.assign({}, change, { name: this.name, key }));
+                spyReportStart(Object.assign(Object.assign({}, change), { name: this.name, key }));
             observable.setNewValue(newValue);
             if (notify)
                 notifyListeners(this, change);
@@ -3396,7 +3411,7 @@ class ObservableMap {
             }
             : null;
         if (notifySpy && process.env.NODE_ENV !== "production")
-            spyReportStart(Object.assign({}, change, { name: this.name, key }));
+            spyReportStart(Object.assign(Object.assign({}, change), { name: this.name, key }));
         if (notify)
             notifyListeners(this, change);
         if (notifySpy && process.env.NODE_ENV !== "production")
@@ -3644,7 +3659,7 @@ class ObservableSet {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart(Object.assign({}, change, { name: this.name }));
+                spyReportStart(Object.assign(Object.assign({}, change), { name: this.name }));
             transaction(() => {
                 this._atom.reportChanged();
                 this._data.delete(value);
@@ -3776,7 +3791,7 @@ class ObservableObjectAdministration {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart(Object.assign({}, change, { name: this.name, key }));
+                spyReportStart(Object.assign(Object.assign({}, change), { name: this.name, key }));
             observable.setNewValue(newValue);
             if (notify)
                 notifyListeners(this, change);
@@ -3865,7 +3880,7 @@ class ObservableObjectAdministration {
                 }
                 : null;
             if (notifySpy && process.env.NODE_ENV !== "production")
-                spyReportStart(Object.assign({}, change, { name: this.name, key }));
+                spyReportStart(Object.assign(Object.assign({}, change), { name: this.name, key }));
             if (notify)
                 notifyListeners(this, change);
             if (notifySpy && process.env.NODE_ENV !== "production")
@@ -3922,7 +3937,7 @@ class ObservableObjectAdministration {
             }
             : null;
         if (notifySpy && process.env.NODE_ENV !== "production")
-            spyReportStart(Object.assign({}, change, { name: this.name, key }));
+            spyReportStart(Object.assign(Object.assign({}, change), { name: this.name, key }));
         if (notify)
             notifyListeners(this, change);
         if (notifySpy && process.env.NODE_ENV !== "production")
@@ -4098,9 +4113,6 @@ function eq(a, b, depth, aStack, bStack) {
     const type = typeof a;
     if (type !== "function" && type !== "object" && typeof b != "object")
         return false;
-    // Unwrap any wrapped objects.
-    a = unwrap(a);
-    b = unwrap(b);
     // Compare `[[Class]]` names.
     const className = toString.call(a);
     if (className !== toString.call(b))
@@ -4128,7 +4140,18 @@ function eq(a, b, depth, aStack, bStack) {
             return +a === +b;
         case "[object Symbol]":
             return (typeof Symbol !== "undefined" && Symbol.valueOf.call(a) === Symbol.valueOf.call(b));
+        case "[object Map]":
+        case "[object Set]":
+            // Maps and Sets are unwrapped to arrays of entry-pairs, adding an incidental level.
+            // Hide this extra level by increasing the depth.
+            if (depth >= 0) {
+                depth++;
+            }
+            break;
     }
+    // Unwrap any wrapped objects.
+    a = unwrap(a);
+    b = unwrap(b);
     const areArrays = className === "[object Array]";
     if (!areArrays) {
         if (typeof a != "object" || typeof b != "object")
@@ -4281,4 +4304,4 @@ if (typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === "object") {
     });
 }
 
-export { $mobx, IDerivationState, ObservableMap, ObservableSet, Reaction, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, _endAction, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, _startAction, action, autorun, comparer, computed, configure, createAtom, decorate, entries, extendObservable, 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 };
+export { $mobx, FlowCancellationError, IDerivationState, ObservableMap, ObservableSet, Reaction, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, allowStateReadsEnd as _allowStateReadsEnd, allowStateReadsStart as _allowStateReadsStart, _endAction, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, _startAction, action, autorun, comparer, computed, configure, createAtom, decorate, entries, extendObservable, flow, get, getAtom, getDebugName, getDependencyTree, getObserverTree, has, intercept, isAction, isArrayLike, isObservableValue as isBoxedObservable, isComputed, isComputedProp, isFlowCancellationError, isObservable, isObservableArray, isObservableMap, isObservableObject, isObservableProp, isObservableSet, keys, observable, observe, onBecomeObserved, onBecomeUnobserved, onReactionError, reaction, remove, runInAction, set, spy, toJS, trace, transaction, untracked, values, when };