mobx 6.3.13 → 6.4.0

package/dist/types/observablemap.d.ts

@@ -58,9 +58,9 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     [Symbol.iterator](): IterableIterator<IMapEntry<K, V>>;
     forEach(callback: (value: V, key: K, object: Map<K, V>) => void, thisArg?: any): void;
     /** Merge another object into this object, returns this. */
-    merge(other: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
+    merge(other?: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;
     clear(): void;
-    replace(values: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
+    replace(values: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;
     get size(): number;
     toString(): string;
     toJSON(): [K, V][];

package/dist/utils/utils.d.ts

@@ -30,7 +30,7 @@ export declare function isGenerator(obj: any): boolean;
 export declare function addHiddenProp(object: any, propName: PropertyKey, value: any): void;
 export declare function addHiddenFinalProp(object: any, propName: PropertyKey, value: any): void;
 export declare function createInstanceofPredicate<T>(name: string, theClass: new (...args: any[]) => T): (x: any) => x is T;
-export declare function isES6Map(thing: any): boolean;
+export declare function isES6Map(thing: any): thing is Map<any, any>;
 export declare function isES6Set(thing: any): thing is Set<any>;
 /**
  * Returns the following: own enumerable keys and symbols.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.3.13",
+    "version": "6.4.0",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/api/action.ts

@@ -45,10 +45,13 @@ export interface IActionFactory extends Annotation, PropertyDecorator {
 function createActionFactory(autoAction: boolean): IActionFactory {
     const res: IActionFactory = function action(arg1, arg2?): any {
         // action(fn() {})
-        if (isFunction(arg1))
+        if (isFunction(arg1)) {
             return createAction(arg1.name || DEFAULT_ACTION_NAME, arg1, autoAction)
+        }
         // action("name", fn() {})
-        if (isFunction(arg2)) return createAction(arg1, arg2, autoAction)
+        if (isFunction(arg2)) {
+            return createAction(arg1, arg2, autoAction)
+        }
         // @action
         if (isStringish(arg2)) {
             return storeAnnotation(arg1, arg2, autoAction ? autoActionAnnotation : actionAnnotation)
@@ -63,7 +66,9 @@ function createActionFactory(autoAction: boolean): IActionFactory {
             )
         }
 
-        if (__DEV__) die("Invalid arguments for `action`")
+        if (__DEV__) {
+            die("Invalid arguments for `action`")
+        }
     } as IActionFactory
     return res
 }

package/src/api/annotation.ts

@@ -32,8 +32,7 @@ export type AnnotationMapEntry =
 // declare annotations for private/ protected members, see #2339
 export type AnnotationsMap<T, AdditionalFields extends PropertyKey> = {
     [P in Exclude<keyof T, "toString">]?: AnnotationMapEntry
-} &
-    Record<AdditionalFields, AnnotationMapEntry>
+} & Record<AdditionalFields, AnnotationMapEntry>
 
 export function isAnnotation(thing: any) {
     return (

package/src/api/autorun.ts

@@ -38,8 +38,12 @@ export function autorun(
     opts: IAutorunOptions = EMPTY_OBJECT
 ): IReactionDisposer {
     if (__DEV__) {
-        if (!isFunction(view)) die("Autorun expects a function as first argument")
-        if (isAction(view)) die("Autorun does not accept actions since actions are untrackable")
+        if (!isFunction(view)) {
+            die("Autorun expects a function as first argument")
+        }
+        if (isAction(view)) {
+            die("Autorun does not accept actions since actions are untrackable")
+        }
     }
 
     const name: string =
@@ -69,7 +73,9 @@ export function autorun(
                     isScheduled = true
                     scheduler(() => {
                         isScheduled = false
-                        if (!reaction.isDisposed_) reaction.track(reactionRunner)
+                        if (!reaction.isDisposed_) {
+                            reaction.track(reactionRunner)
+                        }
                     })
                 }
             },
@@ -111,9 +117,12 @@ export function reaction<T, FireImmediately extends boolean = false>(
     opts: IReactionOptions<T, FireImmediately> = EMPTY_OBJECT
 ): IReactionDisposer {
     if (__DEV__) {
-        if (!isFunction(expression) || !isFunction(effect))
+        if (!isFunction(expression) || !isFunction(effect)) {
             die("First and second argument to reaction should be functions")
-        if (!isPlainObject(opts)) die("Third argument of reactions should be an object")
+        }
+        if (!isPlainObject(opts)) {
+            die("Third argument of reactions should be an object")
+        }
     }
     const name = opts.name ?? (__DEV__ ? "Reaction@" + getNextId() : "Reaction")
     const effectAction = action(
@@ -148,7 +157,9 @@ export function reaction<T, FireImmediately extends boolean = false>(
 
     function reactionRunner() {
         isScheduled = false
-        if (r.isDisposed_) return
+        if (r.isDisposed_) {
+            return
+        }
         let changed: boolean = false
         r.track(() => {
             const nextValue = allowStateChanges(false, () => expression(r))
@@ -159,8 +170,11 @@ export function reaction<T, FireImmediately extends boolean = false>(
 
         // This casting is nesessary as TS cannot infer proper type in current funciton implementation
         type OldValue = FireImmediately extends true ? T | undefined : T
-        if (firstTime && opts.fireImmediately!) effectAction(value, oldValue as OldValue, r)
-        else if (!firstTime && changed) effectAction(value, oldValue as OldValue, r)
+        if (firstTime && opts.fireImmediately!) {
+            effectAction(value, oldValue as OldValue, r)
+        } else if (!firstTime && changed) {
+            effectAction(value, oldValue as OldValue, r)
+        }
         firstTime = false
     }
 

package/src/api/computed.ts

@@ -46,11 +46,14 @@ export const computed: IComputedFactory = function computed(arg1, arg2) {
 
     // computed(expr, options?)
     if (__DEV__) {
-        if (!isFunction(arg1)) die("First argument to `computed` should be an expression.")
-        if (isFunction(arg2))
+        if (!isFunction(arg1)) {
+            die("First argument to `computed` should be an expression.")
+        }
+        if (isFunction(arg2)) {
             die(
                 "A setter as second argument is no longer supported, use `{ set: fn }` option instead"
             )
+        }
     }
     const opts: IComputedValueOptions<any> = isPlainObject(arg2) ? arg2 : {}
     opts.get = arg1

package/src/api/configure.ts

@@ -34,7 +34,9 @@ export function configure(options: {
                 ? false
                 : typeof Proxy !== "undefined"
     }
-    if (useProxies === "ifavailable") globalState.verifyProxies = true
+    if (useProxies === "ifavailable") {
+        globalState.verifyProxies = true
+    }
     if (enforceActions !== undefined) {
         const ea = enforceActions === ALWAYS ? ALWAYS : enforceActions === OBSERVED
         globalState.enforceActions = ea
@@ -47,7 +49,9 @@ export function configure(options: {
         "disableErrorBoundaries",
         "safeDescriptors"
     ].forEach(key => {
-        if (key in options) globalState[key] = !!options[key]
+        if (key in options) {
+            globalState[key] = !!options[key]
+        }
     })
     globalState.allowStateReads = !globalState.observableRequiresReaction
     if (__DEV__ && globalState.disableErrorBoundaries === true) {

package/src/api/extendobservable.ts

@@ -21,15 +21,21 @@ export function extendObservable<A extends Object, B extends Object>(
     options?: CreateObservableOptions
 ): A & B {
     if (__DEV__) {
-        if (arguments.length > 4) die("'extendObservable' expected 2-4 arguments")
-        if (typeof target !== "object")
+        if (arguments.length > 4) {
+            die("'extendObservable' expected 2-4 arguments")
+        }
+        if (typeof target !== "object") {
             die("'extendObservable' expects an object as first argument")
-        if (isObservableMap(target))
+        }
+        if (isObservableMap(target)) {
             die("'extendObservable' should not be used on maps, use map.merge instead")
-        if (!isPlainObject(properties))
+        }
+        if (!isPlainObject(properties)) {
             die(`'extendObservable' only accepts plain objects as second argument`)
-        if (isObservable(properties) || isObservable(annotations))
+        }
+        if (isObservable(properties) || isObservable(annotations)) {
             die(`Extending an object with another observable (object) is not supported`)
+        }
     }
     // Pull descriptors first, so we don't have to deal with props added by administration ($mobx)
     const descriptors = getOwnPropertyDescriptors(properties)

package/src/api/extras.ts

@@ -18,8 +18,9 @@ function nodeToDependencyTree(node: IDepTreeNode): IDependencyTree {
     const result: IDependencyTree = {
         name: node.name_
     }
-    if (node.observing_ && node.observing_.length > 0)
+    if (node.observing_ && node.observing_.length > 0) {
         result.dependencies = unique(node.observing_).map(nodeToDependencyTree)
+    }
     return result
 }
 
@@ -31,8 +32,9 @@ function nodeToObserverTree(node: IDepTreeNode): IObserverTree {
     const result: IObserverTree = {
         name: node.name_
     }
-    if (hasObservers(node as any))
+    if (hasObservers(node as any)) {
         result.observers = Array.from(<any>getObservers(node as any)).map(<any>nodeToObserverTree)
+    }
     return result
 }
 

package/src/api/flow.ts

@@ -42,8 +42,9 @@ export const flow: Flow = Object.assign(
             return storeAnnotation(arg1, arg2, flowAnnotation)
         }
         // flow(fn)
-        if (__DEV__ && arguments.length !== 1)
+        if (__DEV__ && arguments.length !== 1) {
             die(`Flow expects single argument with generator function`)
+        }
         const generator = arg1
         const name = generator.name || "<unnamed flow>"
 
@@ -95,7 +96,9 @@ export const flow: Flow = Object.assign(
                         ret.then(next, reject)
                         return
                     }
-                    if (ret.done) return resolve(ret.value)
+                    if (ret.done) {
+                        return resolve(ret.value)
+                    }
                     pendingPromise = Promise.resolve(ret.value) as any
                     return pendingPromise!.then(onFulfilled, onRejected)
                 }
@@ -105,7 +108,9 @@ export const flow: Flow = Object.assign(
 
             promise.cancel = action(`${name} - runid: ${runId} - cancel`, function () {
                 try {
-                    if (pendingPromise) cancelPromise(pendingPromise)
+                    if (pendingPromise) {
+                        cancelPromise(pendingPromise)
+                    }
                     // Finally block can return (or yield) stuff..
                     const res = gen.return!(undefined as any)
                     // eat anything that promise would do, it's cancelled!
@@ -129,7 +134,9 @@ export const flow: Flow = Object.assign(
 flow.bound = createDecoratorAnnotation(flowBoundAnnotation)
 
 function cancelPromise(promise) {
-    if (isFunction(promise.cancel)) promise.cancel()
+    if (isFunction(promise.cancel)) {
+        promise.cancel()
+    }
 }
 
 export function flowResult<T>(

package/src/api/intercept-read.ts

@@ -39,16 +39,18 @@ export function interceptReads(thing, propOrHandler?, handler?): Lambda {
     if (isObservableMap(thing) || isObservableArray(thing) || isObservableValue(thing)) {
         target = getAdministration(thing)
     } else if (isObservableObject(thing)) {
-        if (__DEV__ && !isStringish(propOrHandler))
+        if (__DEV__ && !isStringish(propOrHandler)) {
             return die(
                 `InterceptReads can only be used with a specific property, not with an object in general`
             )
+        }
         target = getAdministration(thing, propOrHandler)
     } else if (__DEV__) {
         return die(`Expected observable map, object or array as first array`)
     }
-    if (__DEV__ && target.dehancer !== undefined)
+    if (__DEV__ && target.dehancer !== undefined) {
         return die(`An intercept reader was already established`)
+    }
     target.dehancer = typeof propOrHandler === "function" ? propOrHandler : handler
     return () => {
         target.dehancer = undefined

package/src/api/intercept.ts

@@ -43,8 +43,11 @@ export function intercept<T extends object, K extends keyof T>(
     handler: IInterceptor<IValueWillChange<T[K]>>
 ): Lambda
 export function intercept(thing, propOrHandler?, handler?): Lambda {
-    if (isFunction(handler)) return interceptProperty(thing, propOrHandler, handler)
-    else return interceptInterceptable(thing, propOrHandler)
+    if (isFunction(handler)) {
+        return interceptProperty(thing, propOrHandler, handler)
+    } else {
+        return interceptInterceptable(thing, propOrHandler)
+    }
 }
 
 function interceptInterceptable(thing, handler) {

package/src/api/iscomputed.ts

@@ -4,22 +4,28 @@ export function _isComputed(value, property?: PropertyKey): boolean {
     if (property === undefined) {
         return isComputedValue(value)
     }
-    if (isObservableObject(value) === false) return false
-    if (!value[$mobx].values_.has(property)) return false
+    if (isObservableObject(value) === false) {
+        return false
+    }
+    if (!value[$mobx].values_.has(property)) {
+        return false
+    }
     const atom = getAtom(value, property)
     return isComputedValue(atom)
 }
 
 export function isComputed(value: any): boolean {
-    if (__DEV__ && arguments.length > 1)
+    if (__DEV__ && arguments.length > 1) {
         return die(
             `isComputed expects only 1 argument. Use isComputedProp to inspect the observability of a property`
         )
+    }
     return _isComputed(value)
 }
 
 export function isComputedProp(value: any, propName: PropertyKey): boolean {
-    if (__DEV__ && !isStringish(propName))
+    if (__DEV__ && !isStringish(propName)) {
         return die(`isComputed expected a property name as second argument`)
+    }
     return _isComputed(value, propName)
 }

package/src/api/isobservable.ts

@@ -11,12 +11,15 @@ import {
 } from "../internal"
 
 function _isObservable(value, property?: PropertyKey): boolean {
-    if (!value) return false
+    if (!value) {
+        return false
+    }
     if (property !== undefined) {
-        if (__DEV__ && (isObservableMap(value) || isObservableArray(value)))
+        if (__DEV__ && (isObservableMap(value) || isObservableArray(value))) {
             return die(
                 "isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead."
             )
+        }
         if (isObservableObject(value)) {
             return value[$mobx].values_.has(property)
         }
@@ -33,14 +36,17 @@ function _isObservable(value, property?: PropertyKey): boolean {
 }
 
 export function isObservable(value: any): boolean {
-    if (__DEV__ && arguments.length !== 1)
+    if (__DEV__ && arguments.length !== 1) {
         die(
             `isObservable expects only 1 argument. Use isObservableProp to inspect the observability of a property`
         )
+    }
     return _isObservable(value)
 }
 
 export function isObservableProp(value: any, propName: PropertyKey): boolean {
-    if (__DEV__ && !isStringish(propName)) return die(`expected a property name as second argument`)
+    if (__DEV__ && !isStringish(propName)) {
+        return die(`expected a property name as second argument`)
+    }
     return _isObservable(value, propName)
 }

package/src/api/makeObservable.ts

@@ -56,10 +56,12 @@ export function makeAutoObservable<T extends object, AdditionalKeys extends Prop
     options?: CreateObservableOptions
 ): T {
     if (__DEV__) {
-        if (!isPlainObject(target) && !isPlainObject(Object.getPrototypeOf(target)))
+        if (!isPlainObject(target) && !isPlainObject(Object.getPrototypeOf(target))) {
             die(`'makeAutoObservable' can only be used for classes that don't have a superclass`)
-        if (isObservableObject(target))
+        }
+        if (isObservableObject(target)) {
             die(`makeAutoObservable can only be used on objects not already made observable`)
+        }
     }
 
     // Optimization: avoid visiting protos

package/src/api/object-api.ts

@@ -20,9 +20,9 @@ export function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>
 export function keys<T extends Object>(obj: T): ReadonlyArray<PropertyKey>
 export function keys(obj: any): any {
     if (isObservableObject(obj)) {
-        return (((obj as any) as IIsObservableObject)[
-            $mobx
-        ] as ObservableObjectAdministration).keys_()
+        return (
+            (obj as any as IIsObservableObject)[$mobx] as ObservableObjectAdministration
+        ).keys_()
     }
     if (isObservableMap(obj) || isObservableSet(obj)) {
         return Array.from(obj.keys())
@@ -86,26 +86,36 @@ export function set(obj: any, key: any, value?: any): void {
         startBatch()
         const values = key
         try {
-            for (let key in values) set(obj, key, values[key])
+            for (let key in values) {
+                set(obj, key, values[key])
+            }
         } finally {
             endBatch()
         }
         return
     }
     if (isObservableObject(obj)) {
-        ;((obj as any) as IIsObservableObject)[$mobx].set_(key, value)
+        ;(obj as any as IIsObservableObject)[$mobx].set_(key, value)
     } else if (isObservableMap(obj)) {
         obj.set(key, value)
     } else if (isObservableSet(obj)) {
         obj.add(key)
     } else if (isObservableArray(obj)) {
-        if (typeof key !== "number") key = parseInt(key, 10)
-        if (key < 0) die(`Invalid index: '${key}'`)
+        if (typeof key !== "number") {
+            key = parseInt(key, 10)
+        }
+        if (key < 0) {
+            die(`Invalid index: '${key}'`)
+        }
         startBatch()
-        if (key >= obj.length) obj.length = key + 1
+        if (key >= obj.length) {
+            obj.length = key + 1
+        }
         obj[key] = value
         endBatch()
-    } else die(8)
+    } else {
+        die(8)
+    }
 }
 
 export function remove<K, V>(obj: ObservableMap<K, V>, key: K)
@@ -114,13 +124,15 @@ export function remove<T>(obj: IObservableArray<T>, index: number)
 export function remove<T extends Object>(obj: T, key: string)
 export function remove(obj: any, key: any): void {
     if (isObservableObject(obj)) {
-        ;((obj as any) as IIsObservableObject)[$mobx].delete_(key)
+        ;(obj as any as IIsObservableObject)[$mobx].delete_(key)
     } else if (isObservableMap(obj)) {
         obj.delete(key)
     } else if (isObservableSet(obj)) {
         obj.delete(key)
     } else if (isObservableArray(obj)) {
-        if (typeof key !== "number") key = parseInt(key, 10)
+        if (typeof key !== "number") {
+            key = parseInt(key, 10)
+        }
         obj.splice(key, 1)
     } else {
         die(9)
@@ -133,7 +145,7 @@ export function has<T>(obj: IObservableArray<T>, index: number): boolean
 export function has<T extends Object>(obj: T, key: string): boolean
 export function has(obj: any, key: any): boolean {
     if (isObservableObject(obj)) {
-        return ((obj as any) as IIsObservableObject)[$mobx].has_(key)
+        return (obj as any as IIsObservableObject)[$mobx].has_(key)
     } else if (isObservableMap(obj)) {
         return obj.has(key)
     } else if (isObservableSet(obj)) {
@@ -148,9 +160,11 @@ export function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined
 export function get<T>(obj: IObservableArray<T>, index: number): T | undefined
 export function get<T extends Object>(obj: T, key: string): any
 export function get(obj: any, key: any): any {
-    if (!has(obj, key)) return undefined
+    if (!has(obj, key)) {
+        return undefined
+    }
     if (isObservableObject(obj)) {
-        return ((obj as any) as IIsObservableObject)[$mobx].get_(key)
+        return (obj as any as IIsObservableObject)[$mobx].get_(key)
     } else if (isObservableMap(obj)) {
         return obj.get(key)
     } else if (isObservableArray(obj)) {
@@ -161,14 +175,14 @@ export function get(obj: any, key: any): any {
 
 export function apiDefineProperty(obj: Object, key: PropertyKey, descriptor: PropertyDescriptor) {
     if (isObservableObject(obj)) {
-        return ((obj as any) as IIsObservableObject)[$mobx].defineProperty_(key, descriptor)
+        return (obj as any as IIsObservableObject)[$mobx].defineProperty_(key, descriptor)
     }
     die(39)
 }
 
 export function apiOwnKeys(obj: Object) {
     if (isObservableObject(obj)) {
-        return ((obj as any) as IIsObservableObject)[$mobx].ownKeys_()
+        return (obj as any as IIsObservableObject)[$mobx].ownKeys_()
     }
     die(38)
 }

package/src/api/observable.ts

@@ -102,22 +102,34 @@ function createObservable(v: any, arg2?: any, arg3?: any) {
     }
 
     // already observable - ignore
-    if (isObservable(v)) return v
+    if (isObservable(v)) {
+        return v
+    }
 
     // plain object
-    if (isPlainObject(v)) return observable.object(v, arg2, arg3)
+    if (isPlainObject(v)) {
+        return observable.object(v, arg2, arg3)
+    }
 
     // Array
-    if (Array.isArray(v)) return observable.array(v, arg2)
+    if (Array.isArray(v)) {
+        return observable.array(v, arg2)
+    }
 
     // Map
-    if (isES6Map(v)) return observable.map(v, arg2)
+    if (isES6Map(v)) {
+        return observable.map(v, arg2)
+    }
 
     // Set
-    if (isES6Set(v)) return observable.set(v, arg2)
+    if (isES6Set(v)) {
+        return observable.set(v, arg2)
+    }
 
     // other object - ignore
-    if (typeof v === "object" && v !== null) return v
+    if (typeof v === "object" && v !== null) {
+        return v
+    }
 
     // anything else
     return observable.box(v, arg2)
@@ -169,9 +181,11 @@ const observableFactories: IObservableFactory = {
     },
     array<T = any>(initialValues?: T[], options?: CreateObservableOptions): IObservableArray<T> {
         const o = asCreateObservableOptions(options)
-        return (globalState.useProxies === false || o.proxy === false
-            ? createLegacyArray
-            : createObservableArray)(initialValues, getEnhancerFromOptions(o), o.name)
+        return (
+            globalState.useProxies === false || o.proxy === false
+                ? createLegacyArray
+                : createObservableArray
+        )(initialValues, getEnhancerFromOptions(o), o.name)
     },
     map<K = any, V = any>(
         initialValues?: IObservableMapInitialValues<K, V>,

package/src/api/observe.ts

@@ -53,9 +53,11 @@ export function observe<T, K extends keyof T>(
     fireImmediately?: boolean
 ): Lambda
 export function observe(thing, propOrCb?, cbOrFire?, fireImmediately?): Lambda {
-    if (isFunction(cbOrFire))
+    if (isFunction(cbOrFire)) {
         return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately)
-    else return observeObservable(thing, propOrCb, cbOrFire)
+    } else {
+        return observeObservable(thing, propOrCb, cbOrFire)
+    }
 }
 
 function observeObservable(thing, listener, fireImmediately: boolean) {

package/src/api/tojs.ts

@@ -21,11 +21,13 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
         typeof source !== "object" ||
         source instanceof Date ||
         !isObservable(source)
-    )
+    ) {
         return source
+    }
 
-    if (isObservableValue(source) || isComputedValue(source))
+    if (isObservableValue(source) || isComputedValue(source)) {
         return toJSHelper(source.get(), __alreadySeen)
+    }
     if (__alreadySeen.has(source)) {
         return __alreadySeen.get(source)
     }
@@ -68,6 +70,8 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
  * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.
  */
 export function toJS<T>(source: T, options?: any): T {
-    if (__DEV__ && options) die("toJS no longer supports options")
+    if (__DEV__ && options) {
+        die("toJS no longer supports options")
+    }
     return toJSHelper(source, new Map())
 }

package/src/api/trace.ts

@@ -4,9 +4,13 @@ export function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): vo
 export function trace(thing?: any, enterBreakPoint?: boolean): void
 export function trace(enterBreakPoint?: boolean): void
 export function trace(...args: any[]): void {
-    if (!__DEV__) die(`trace() is not available in production builds`)
+    if (!__DEV__) {
+        die(`trace() is not available in production builds`)
+    }
     let enterBreakPoint = false
-    if (typeof args[args.length - 1] === "boolean") enterBreakPoint = args.pop()
+    if (typeof args[args.length - 1] === "boolean") {
+        enterBreakPoint = args.pop()
+    }
     const derivation = getAtomFromArgs(args)
     if (!derivation) {
         return die(