@woosh/meep-engine 2.48.23 → 2.49.1

package/src/core/geom/packing/max-rect/cutArea.js

@@ -0,0 +1,79 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
+import { removeRedundantBoxesArray } from "./removeRedundantBoxesArray.js";
+
+/**
+ * Cut out a region from given set of boxes
+ * @param {AABB2} scissor area to be cut out
+ * @param {QuadTreeNode} boxes
+ */
+export function cutArea(scissor, boxes) {
+
+    /**
+     *
+     * @type {QuadTreeDatum[]}
+     */
+    const additions = [];
+
+    /**
+     *
+     * @type {QuadTreeDatum[]}
+     */
+    const removals = [];
+
+    /**
+     *
+     * @param {QuadTreeDatum} box
+     */
+    function visitOverlap(box) {
+        removals.push(box);
+
+
+        //compute overlap region
+        const x0 = max2(scissor.x0, box.x0);
+        const x1 = min2(scissor.x1, box.x1);
+
+        const y0 = max2(scissor.y0, box.y0);
+        const y1 = min2(scissor.y1, box.y1);
+
+
+        //create 4 boxes around overlap
+        if (x0 > box.x0) {
+            //add left box
+            additions.push(new QuadTreeDatum(box.x0, box.y0, x0, box.y1));
+        }
+        if (x1 < box.x1) {
+            //add right box
+            additions.push(new QuadTreeDatum(x1, box.y0, box.x1, box.y1));
+        }
+        if (y0 > box.y0) {
+            //add top box
+            additions.push(new QuadTreeDatum(box.x0, box.y0, box.x1, y0));
+        }
+        if (y1 < box.y1) {
+            //add bottom box
+            additions.push(new QuadTreeDatum(box.x0, y1, box.x1, box.y1));
+        }
+
+    }
+
+    boxes.traverseRectangleIntersections(scissor.x0, scissor.y0, scissor.x1, scissor.y1, visitOverlap);
+
+    let i, l;
+    //perform removals
+    for (i = 0, l = removals.length; i < l; i++) {
+        const removal = removals[i];
+        removal.disconnect();
+    }
+
+    //drop potential overlaps between additions
+    removeRedundantBoxesArray(additions);
+
+    //perform additions
+    for (i = 0, l = additions.length; i < l; i++) {
+        const addition = additions[i];
+
+        boxes.insertDatum(addition);
+    }
+}

package/src/core/geom/packing/max-rect/findBestContainer.js

@@ -0,0 +1,58 @@
+/**
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {QuadTreeNode} boxes
+ * @param {function(containerWidth:number, containerHeight:number, childWidth:number, childHeight:number):number} costFunction
+ * @returns {QuadTreeDatum} suitable container box
+ */
+export function findBestContainer(width, height, boxes, costFunction) {
+    let best = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+
+    const visitor = (node) => {
+
+        if (node.getWidth() < width) {
+            //too small, don't traverse deeper
+            return false;
+        }
+
+        if (node.getHeight() < height) {
+            //too small, don't traverse deeper
+            return false;
+        }
+
+        const data = node.data;
+        const numBoxes = data.length;
+
+        for (let i = 0; i < numBoxes; i++) {
+            const box = data[i];
+
+            const bW = box.getWidth();
+
+            if (bW < width) {
+                //too small
+                continue;
+            }
+
+            const bH = box.getHeight();
+
+            if (bH < height) {
+                //too small
+                continue;
+            }
+
+            const cost = costFunction(bW, bH, width, height);
+            if (cost < bestScore) {
+                bestScore = cost;
+                best = box;
+            }
+        }
+
+        return true;
+    };
+
+    boxes.traversePreOrder(visitor);
+
+    return best;
+}

package/src/core/geom/packing/max-rect/packOneBox.js

@@ -0,0 +1,49 @@
+import { findBestContainer } from "./findBestContainer.js";
+import { costByRemainingArea } from "./cost/costByRemainingArea.js";
+import { cutArea } from "./cutArea.js";
+import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
+
+/**
+ *
+ * @param {AABB2} box
+ * @param {QuadTreeNode} free
+ * @returns {boolean}
+ */
+export function packOneBox(box, free) {
+    const w = box.getWidth();
+    const h = box.getHeight();
+
+    const container = findBestContainer(w, h, free, costByRemainingArea);
+
+    if (container === null) {
+        //couldn't find a place for box
+        return false;
+    }
+
+    //remove container from free set
+    container.disconnect();
+
+    //place box at bottom left of the container
+    const y0 = container.y0;
+    const x0 = container.x0;
+
+    box.set(x0, y0, x0 + w, y0 + h);
+
+    //update remaining set by removing this box area from free set
+    cutArea(box, free);
+
+    //split remaining space
+    if (box.y1 !== container.y1) {
+        const splitA = new QuadTreeDatum(container.x0, box.y1, container.x1, container.y1);
+
+        free.insertDatum(splitA);
+    }
+
+    if (box.x1 !== container.x1) {
+        const splitB = new QuadTreeDatum(box.x1, container.y0, container.x1, container.y1);
+        free.insertDatum(splitB);
+    }
+
+
+    return true;
+}

package/src/core/geom/packing/miniball/Miniball.js

@@ -33,7 +33,7 @@ const MAX_ITERATIONS = 10000;
 /**
  * Computes the miniball of the given point set.
  *
- * Notice that the point set {@code pts} is assumed to be immutable during the computation. That
+ * Notice that the point set `pts` is assumed to be immutable during the computation. That
  * is, if you add, remove, or change points in the point set, you have to create a new instance of
  * {@link Miniball}.
  *
@@ -102,7 +102,7 @@ class Miniball {
     }
 
     /**
-     * Whether or not the miniball is the empty set, equivalently, whether {@code points.size() == 0}
+     * Whether or not the miniball is the empty set, equivalently, whether `points.size() == 0`
      * was true when this miniball instance was constructed.
      *
      * Notice that the miniball of a point set <i>S</i> is empty if and only if <i>S={}</i>.
@@ -116,7 +116,7 @@ class Miniball {
     /**
      * The radius of the miniball.
      * <p>
-     * Precondition: {@code !isEmpty()}
+     * Precondition: `!isEmpty()`
      *
      * @return {number} the radius of the miniball, a number ≥ 0
      */
@@ -127,9 +127,9 @@ class Miniball {
     /**
      * The squared radius of the miniball.
      * <p>
-     * This is equivalent to {@code radius() * radius()}.
+     * This is equivalent to `radius() * radius()`.
      * <p>
-     * Precondition: {@code !isEmpty()}
+     * Precondition: `!isEmpty()`
      *
      * @return {number} the squared radius of the miniball
      */
@@ -140,7 +140,7 @@ class Miniball {
     /**
      * The Euclidean coordinates of the center of the miniball.
      * <p>
-     * Precondition: {@code !isEmpty()}
+     * Precondition: `!isEmpty()`
      *
      * @return {number[]} an array holding the coordinates of the center of the miniball
      */
@@ -151,8 +151,8 @@ class Miniball {
     /**
      * The number of input points.
      *
-     * @return {number} the number of points in the original point set, i.e., {@code pts.size()} where
-     * {@code pts} was the {@link PointSet} instance passed to the constructor of this
+     * @return {number} the number of points in the original point set, i.e., `pts.size()` where
+     * `pts` was the {@link PointSet} instance passed to the constructor of this
      * instance
      */
     size() {
@@ -179,7 +179,7 @@ class Miniball {
      * the points farthest from center in the support. So the current ball contains all points of
      * <i>S</i> and has radius at most twice as large as the minball.
      * <p>
-     * Precondition: {@code size > 0}
+     * Precondition: `size > 0`
      * @return {Subspan}
      * @private
      */
@@ -334,10 +334,10 @@ class Miniball {
     }
 
     /**
-     * Given the center of the current enclosing ball and the walking direction {@code centerToAff},
+     * Given the center of the current enclosing ball and the walking direction `centerToAff`,
      * determine how much we can walk into this direction without losing a point from <i>S</i>. The
-     * (positive) factor by which we can walk along {@code centerToAff} is returned. Further,
-     * {@code stopper} is set to the index of the most restricting point and to -1 if no such point
+     * (positive) factor by which we can walk along `centerToAff` is returned. Further,
+     * `stopper` is set to the index of the most restricting point and to -1 if no such point
      * was found.
      * @return {number}
      * @private

package/src/core/geom/packing/miniball/Quality.js

@@ -57,7 +57,7 @@ class Quality {
      * the miniball ("over-length"). The returned number is the maximal such over-length, divided by
      * the radius of the computed miniball.
      * <p>
-     * Notice that {@code getMaxOverlength() == 0} if and only if all points are contained in the
+     * Notice that `getMaxOverlength() == 0` if and only if all points are contained in the
      * miniball.
      *
      * @return {number} the maximal over-length, a number ≥ 0
@@ -74,7 +74,7 @@ class Quality {
      * this point towards the boundary of the miniball ("under-length"). The returned number is the
      * maximal such under-length, divided by the radius of the computed miniball.
      * <p>
-     * Notice that in theory {@code getMaxUnderlength()} should be zero, otherwise the computed
+     * Notice that in theory `getMaxUnderlength()` should be zero, otherwise the computed
      * miniball is enclosing but not minimal.
      *
      * @return {number} the maximal under-length, a number ≥ 0

package/src/core/geom/packing/miniball/Subspan.js

@@ -117,7 +117,7 @@ export class Subspan {
     }
 
     /**
-     * The size of the instance's set <i>M</i>, a number between 0 and {@code dim+1}.
+     * The size of the instance's set <i>M</i>, a number between 0 and `dim+1`.
      * <p>
      * Complexity: O(1).
      *
@@ -143,9 +143,9 @@ export class Subspan {
     /**
      * The global index (into <i>S</i>) of an arbitrary element of <i>M</i>.
      * <p>
-     * Precondition: {@code size()>0}
+     * Precondition: `size()>0`
      * <p>
-     * Postcondition: {@code isMember(anyMember())}
+     * Postcondition: `isMember(anyMember())`
      * @returns {number}
      */
     anyMember() {
@@ -160,7 +160,7 @@ export class Subspan {
      * Complexity: O(1)
      *
      * @param {number} i
-     * the "local" index, 0 ≤ i < {@code size()}
+     * the "local" index, 0 ≤ i < `size()`
      * @return {number} <i>j</i> such that <i>S[j]</i> equals the <i>i</i>th point of M
      */
     globalIndex(i) {
@@ -184,7 +184,7 @@ export class Subspan {
     }
 
     /**
-     * The point {@code members[r]} is called the <i>origin</i>.
+     * The point `members[r]` is called the <i>origin</i>.
      *
      * @return {number} index into <i>S</i> of the origin.
      * @private
@@ -207,7 +207,7 @@ export class Subspan {
      * <p>
      * Note that the code of this class sometimes does not call this method but only mentions it in a
      * comment. The reason for this is performance; Java does not allow an efficient way of returning
-     * a pair of doubles, so we sometimes manually "inline" {@code givens()} for the sake of
+     * a pair of doubles, so we sometimes manually "inline" `givens()` for the sake of
      * performance.
      * @param {number} a
      * @param {number} b
@@ -234,7 +234,7 @@ export class Subspan {
      * the index of the column used now for insertion; <i>r</i> is not altered by this routine and
      * should be changed by the caller afterwards.
      * <p>
-     * Precondition: {@code r<dim}
+     * Precondition: `r<dim`
      * @private
      */
     appendColumn() {
@@ -269,7 +269,7 @@ export class Subspan {
     /**
      * Adds the point <i>S[index]</i> to the instance's set <i>M</i>.
      * <p>
-     * Precondition: {@code !isMember(index)}
+     * Precondition: `!isMember(index)`
      * <p>
      * Complexity: O(dim^2).
      *
@@ -302,7 +302,7 @@ export class Subspan {
      * Computes the vector <i>w</i> directed from point <i>p</i> to <i>v</i>, where <i>v</i> is the
      * point in <i>aff(M)</i> that lies nearest to <i>p</i>.
      * <p>
-     * Precondition: {@code size()}>0
+     * Precondition: `size()>0`
      * <p>
      * Complexity: O(dim^2)
      *
@@ -389,11 +389,11 @@ export class Subspan {
     }
 
     /**
-     * Calculates the {@code size()}-many coefficients in the representation of <i>p</i> as an affine
+     * Calculates the `size()`-many coefficients in the representation of <i>p</i> as an affine
      * combination of the points <i>M</i>.
      * <p>
-     * The <i>i</i>th computed coefficient {@code lambdas[i]} corresponds to the <i>i</i>th point in
-     * <i>M</i>, or, in other words, to the point in <i>S</i> with index {@code globalIndex(i)}.
+     * The <i>i</i>th computed coefficient `lambdas[i] `corresponds to the <i>i</i>th point in
+     * <i>M</i>, or, in other words, to the point in <i>S</i> with index `globalIndex(i)`.
      * <p>
      * Complexity: O(dim^2)
      * <p>
@@ -441,7 +441,7 @@ export class Subspan {
     }
 
     /**
-     * Given <i>R</i> in lower Hessenberg form with subdiagonal entries 0 to {@code pos-1} already all
+     * Given <i>R</i> in lower Hessenberg form with subdiagonal entries 0 to `pos-1` already all
      * zero, clears the remaining subdiagonal entries via Givens rotations.
      * @param {number} pos
      * @private

package/src/core/geom/v3_dot.js

@@ -1,5 +1,5 @@
 /**
- *
+ * Compute vector dot product in 3d
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0

package/src/core/graph/layout/CircleLayout.js

@@ -10,10 +10,10 @@ import { line2SegmentsIntersect } from "../../geom/2d/LineSegment2.js";
 import Vector2, { v2_distance } from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
-import { applyCentralGravityAABB2 } from "./BoxLayouter.js";
 import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js";
 import { Connection } from "./Connection.js";
 import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
+import { applyCentralGravityAABB2 } from "./box/applyCentralGravityAABB2.js";
 
 
 /**

package/src/core/graph/layout/{BoxLayouter.js → box/BoxLayouter.js}

@@ -4,11 +4,12 @@
  */
 
 
-import AABB2 from "../../geom/2d/aabb/AABB2.js";
-import Vector2 from "../../geom/Vector2.js";
-import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js";
-import { Connection } from "./Connection.js";
-import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
+import AABB2 from "../../../geom/2d/aabb/AABB2.js";
+import Vector2 from "../../../geom/Vector2.js";
+import { computeDisconnectedSubGraphs } from "../computeDisconnectedSubGraphs.js";
+import { Connection } from "../Connection.js";
+import { resolveAABB2Overlap } from "./resolveAABB2Overlap.js";
+import { applyCentralGravityAABB2 } from "./applyCentralGravityAABB2.js";
 
 
 /**
@@ -181,51 +182,6 @@ function applyPull(edges, strength) {
     }
 }
 
-/**
- *
- * @param {Array.<AABB2>} boxes
- * @returns {Vector2}
- */
-function computeCenter(boxes) {
-    const numBoxes = boxes.length;
-
-    const center = new Vector2();
-    for (let i = 0; i < numBoxes; i++) {
-        const box = boxes[i];
-        center._add(box.midX(), box.midY());
-    }
-    center.multiplyScalar(1 / numBoxes);
-
-    return center;
-}
-
-/**
- *
- * @param {Array.<AABB2>} boxes
- * @param {number} strength
- */
-export function applyCentralGravityAABB2(boxes, strength) {
-    const numBoxes = boxes.length;
-
-    const center = computeCenter(boxes);
-
-    const delta = new Vector2();
-    for (let i = 0; i < numBoxes; i++) {
-        const box = boxes[i];
-
-        if (box.locked === true) {
-            continue;
-        }
-
-        delta.copy(center);
-        delta._sub(box.midX(), box.midY());
-
-        delta.multiplyScalar(strength);
-
-        box.move(delta.x, delta.y);
-    }
-}
-
 
 function resolveBoxConnectionOverlaps(boxes, connections, maxSteps) {
     for (let i = 0; i < maxSteps; i++) {

package/src/core/graph/layout/box/applyCentralGravityAABB2.js

@@ -0,0 +1,29 @@
+import { aabb2_compute_center_from_multiple } from "../../../geom/2d/aabb/aabb2_compute_center_from_multiple.js";
+import Vector2 from "../../../geom/Vector2.js";
+
+/**
+ *
+ * @param {(AABB2|{locked:boolean})[]} boxes
+ * @param {number} strength
+ */
+export function applyCentralGravityAABB2(boxes, strength) {
+    const numBoxes = boxes.length;
+
+    const center = aabb2_compute_center_from_multiple(boxes);
+
+    const delta = new Vector2();
+    for (let i = 0; i < numBoxes; i++) {
+        const box = boxes[i];
+
+        if (box.locked === true) {
+            continue;
+        }
+
+        delta.copy(center);
+        delta._sub(box.midX(), box.midY());
+
+        delta.multiplyScalar(strength);
+
+        box.move(delta.x, delta.y);
+    }
+}

package/src/core/json/resolvePath.spec.js

@@ -0,0 +1,14 @@
+import { resolvePath } from "./resolvePath.js";
+
+test("resolve global path", () => {
+    const root = {};
+    expect(resolvePath(root, '')).toBe(root);
+});
+
+test("resolve nested path", () => {
+    const nested_child = {};
+
+    const root = { a: { b: nested_child } };
+
+    expect(resolvePath(root, '/a/b')).toBe(nested_child);
+});

package/src/core/land/reactive/{compiler/ReactiveCompiler.spec.js → compileReactiveExpression.spec.js}

@@ -1,20 +1,20 @@
-import { ReactiveAdd } from "../../../model/reactive/model/arithmetic/ReactiveAdd.js";
-import { ReactiveDivide } from "../../../model/reactive/model/arithmetic/ReactiveDivide.js";
-import { ReactiveMultiply } from "../../../model/reactive/model/arithmetic/ReactiveMultiply.js";
-import { ReactiveNegate } from "../../../model/reactive/model/arithmetic/ReactiveNegate.js";
-import { ReactiveSubtract } from "../../../model/reactive/model/arithmetic/ReactiveSubtract.js";
-import { ReactiveEquals } from "../../../model/reactive/model/comparative/ReactiveEquals.js";
-import { ReactiveGreaterThan } from "../../../model/reactive/model/comparative/ReactiveGreaterThan.js";
-import { ReactiveGreaterThanOrEqual } from "../../../model/reactive/model/comparative/ReactiveGreaterThanOrEqual.js";
-import { ReactiveLessThan } from "../../../model/reactive/model/comparative/ReactiveLessThan.js";
-import { ReactiveLessThanOrEqual } from "../../../model/reactive/model/comparative/ReactiveLessThanOrEqual.js";
-import { ReactiveNotEquals } from "../../../model/reactive/model/comparative/ReactiveNotEquals.js";
-import { ReactiveAnd } from "../../../model/reactive/model/logic/ReactiveAnd.js";
-import { ReactiveNot } from "../../../model/reactive/model/logic/ReactiveNot.js";
-import { ReactiveOr } from "../../../model/reactive/model/logic/ReactiveOr.js";
-import { ReactiveLiteralNumber } from "../../../model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveReference } from "../../../model/reactive/model/terminal/ReactiveReference.js";
-import { compileReactiveExpression } from "../compileReactiveExpression.js";
+import { ReactiveAdd } from "../../model/reactive/model/arithmetic/ReactiveAdd.js";
+import { ReactiveDivide } from "../../model/reactive/model/arithmetic/ReactiveDivide.js";
+import { ReactiveMultiply } from "../../model/reactive/model/arithmetic/ReactiveMultiply.js";
+import { ReactiveNegate } from "../../model/reactive/model/arithmetic/ReactiveNegate.js";
+import { ReactiveSubtract } from "../../model/reactive/model/arithmetic/ReactiveSubtract.js";
+import { ReactiveEquals } from "../../model/reactive/model/comparative/ReactiveEquals.js";
+import { ReactiveGreaterThan } from "../../model/reactive/model/comparative/ReactiveGreaterThan.js";
+import { ReactiveGreaterThanOrEqual } from "../../model/reactive/model/comparative/ReactiveGreaterThanOrEqual.js";
+import { ReactiveLessThan } from "../../model/reactive/model/comparative/ReactiveLessThan.js";
+import { ReactiveLessThanOrEqual } from "../../model/reactive/model/comparative/ReactiveLessThanOrEqual.js";
+import { ReactiveNotEquals } from "../../model/reactive/model/comparative/ReactiveNotEquals.js";
+import { ReactiveAnd } from "../../model/reactive/model/logic/ReactiveAnd.d.ts";
+import { ReactiveNot } from "../../model/reactive/model/logic/ReactiveNot.js";
+import { ReactiveOr } from "../../model/reactive/model/logic/ReactiveOr.js";
+import { ReactiveLiteralNumber } from "../../model/reactive/model/terminal/ReactiveLiteralNumber.js";
+import { ReactiveReference } from "../../model/reactive/model/terminal/ReactiveReference.d.ts";
+import { compileReactiveExpression } from "./compileReactiveExpression.js";
 
 test('compile: REFERENCE', () => {
     const expression = compileReactiveExpression('a');

package/src/core/math/random/MersenneTwister.spec.js

@@ -0,0 +1,19 @@
+import { MersenneTwister } from "./MersenneTwister.js";
+
+test("constructor does not throw", () => {
+    expect(() => new MersenneTwister(0)).not.toThrow();
+});
+
+test("from seed of 0, first 3 values are within 0..1 range", () => {
+    const rng = new MersenneTwister(0);
+
+    for (let i = 0; i < 3; i++) {
+
+        const value = rng.random();
+
+        expect(value).toBeLessThanOrEqual(1)
+        expect(value).toBeGreaterThanOrEqual(0)
+
+    }
+
+});

package/src/core/math/random/randomGaussian.spec.js

@@ -0,0 +1,9 @@
+import { makeSequenceLoop } from "../makeSequenceLoop.js";
+import { randomGaussian } from "./randomGaussian.js";
+
+test("sample is average of rolls", () => {
+
+    const random = makeSequenceLoop([0, 1, 2, 11]);
+
+    expect(randomGaussian(random, 4)).toBe(3.5);
+});

package/src/core/math/statistics/computeStatisticalMean.js

@@ -12,7 +12,7 @@ export function computeStatisticalMean(values, start = 0, end = values.length) {
 
     let total = 0;
 
-    const sampleSize = end - start;
+    const sample_count = end - start;
 
     for (let i = 0; i < end; i++) {
         const value = values[i];
@@ -20,5 +20,5 @@ export function computeStatisticalMean(values, start = 0, end = values.length) {
         total += value;
     }
 
-    return total / sampleSize;
+    return total / sample_count;
 }

package/src/core/model/reactive/model/arithmetic/ReactiveAdd.js

@@ -25,7 +25,7 @@ export class ReactiveAdd extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveAdd && super.equals(other);
+        return (other.isReactiveAdd === true) && super.equals(other);
     }
 
     toCode() {

package/src/core/model/reactive/model/arithmetic/ReactiveDivide.js

@@ -23,9 +23,11 @@ export class ReactiveDivide extends ReactiveBinaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveDivide && super.equals(other);
+        return (other.isReactiveDivide === true) && super.equals(other);
     }
+
     toCode() {
         return `( ${this.left.toCode()} / ${this.right.toCode()} )`
     }

package/src/core/model/reactive/model/arithmetic/ReactiveMultiply.js

@@ -25,7 +25,7 @@ export class ReactiveMultiply extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveMultiply && super.equals(other);
+        return (other.isReactiveMultiply === true) && super.equals(other);
     }
 
     toCode() {

package/src/core/model/reactive/model/arithmetic/ReactiveNegate.js

@@ -22,9 +22,11 @@ export class ReactiveNegate extends ReactiveUnaryExpression {
 
         return r;
     }
+
     equals(other) {
-        return other.isReactiveNegate && super.equals(other);
+        return (other.isReactiveNegate === true) && super.equals(other);
     }
+
     toCode() {
         return `-${this.source.toCode()}`
     }

package/src/core/model/reactive/model/arithmetic/ReactiveSubtract.js

@@ -25,7 +25,7 @@ export class ReactiveSubtract extends ReactiveBinaryExpression {
     }
 
     equals(other) {
-        return other.isReactiveSubtract && super.equals(other);
+        return (other.isReactiveSubtract === true) && super.equals(other);
     }
 
     toCode() {