@woosh/meep-engine 2.113.13 → 2.113.14

package/src/core/collection/table/RowFirstTable.js

@@ -3,6 +3,7 @@ import { makeArrayBuffer } from "../../binary/makeArrayBuffer.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/array_copy.js";
+import { array_buffer_copy } from "../array/typed/array_buffer_copy.js";
 
 /**
  * How much space to reserve in a newly created table, counted in ROWs
@@ -128,25 +129,25 @@ export class RowFirstTable {
         let result = byteLength;
 
 
-            const uint32_length = byteLength >> 2;
+        const uint32_length = byteLength >> 2;
 
-            // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
-            const tap_count = 31;
+        // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
+        const tap_count = 31;
 
-            const step_size = max2(
-                Math.floor(uint32_length / tap_count ),
-                1
-            );
+        const step_size = max2(
+            Math.floor(uint32_length / tap_count),
+            1
+        );
 
-            const step_count = Math.floor(uint32_length / step_size);
+        const step_count = Math.floor(uint32_length / step_size);
 
-            for (let i = 0; i < step_count; i++) {
-                const address = (i * step_size) << 2;
+        for (let i = 0; i < step_count; i++) {
+            const address = (i * step_size) << 2;
 
-                const uint32 = dataView.getUint32(address);
+            const uint32 = dataView.getUint32(address);
 
-                result = ((result << 5) - result) + uint32;
-            }
+            result = ((result << 5) - result) + uint32;
+        }
 
         return result;
     }
@@ -182,6 +183,8 @@ export class RowFirstTable {
             throw new Error("Generated array was truncated unexpectedly from " + byteSize + " to " + this.data.byteLength);
         }
 
+        // TODO consider using {@link array_buffer_copy} instead for speed
+
         const newArray = new Uint8Array(this.data);
         const oldArray = new Uint8Array(oldData);
 
@@ -378,14 +381,22 @@ export class RowFirstTable {
 
         const onAdded = this.on.added;
 
+        /**
+         *
+         * @param {number} index
+         */
         function addOneSignaling(index) {
             addOneSilent(index);
             onAdded.send2(index, row);
         }
 
-        function addOneSilent(i) {
-            valueSupplier(i, row);
-            writeRowMethod(dataView, bytesPerRecord * i, row);
+        /**
+         *
+         * @param {number} index
+         */
+        function addOneSilent(index) {
+            valueSupplier(index, row);
+            writeRowMethod(dataView, bytesPerRecord * index, row);
         }
 
         //depending on whether signal is being listened, pick signaling or silent generator
@@ -444,12 +455,10 @@ export class RowFirstTable {
 
         this.length = other.length;
 
-        const target = new Uint8Array(this.data);
-        const source = new Uint8Array(other.data);
-
         // copy data
         const data_byte_count = other.spec.bytesPerRecord * record_count;
-        target.set(source.slice(0, data_byte_count));
+
+        array_buffer_copy(other.data, 0, this.data, 0, data_byte_count);
     }
 
     /**
@@ -492,7 +501,7 @@ export class RowFirstTable {
     }
 
     /**
-     *
+     * Read a single row of values from the table
      * @param {number} index
      * @param {number[]} [result] where row values are to be stored
      * @returns {number[]} result
@@ -508,7 +517,7 @@ export class RowFirstTable {
     }
 
     /**
-     *
+     * Write a single row of values
      * @param {number} index
      * @param {number[]} record
      */
@@ -517,6 +526,8 @@ export class RowFirstTable {
 
         const spec = this.spec;
 
+        assert.greaterThanOrEqual(record.length, spec.getColumnCount(), 'input record length is too small');
+
         spec.writeRowMethod(this.dataView, spec.bytesPerRecord * index, record);
     }
 
@@ -539,8 +550,8 @@ export class RowFirstTable {
 
         const last_row_index = length - 1;
 
-
         const traversal_limit = last_row_index >>> 1;
+
         for (let i = 0; i <= traversal_limit; i++) {
             const address = i * bpr;
             array_copy(wrapper, address, copy_buffer, 0, bpr);

package/src/core/math/random/randomIntegerBetween.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomIntegerBetween.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomIntegerBetween.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAWlB"}
+{"version":3,"file":"randomIntegerBetween.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomIntegerBetween.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/random/randomIntegerBetween.js

@@ -15,5 +15,8 @@ export function randomIntegerBetween(random, min, max) {
 
     const roll = random();
 
+    assert.greaterThanOrEqual(roll, 0, 'random should return value between 0 and 1');
+    assert.lessThanOrEqual(roll, 1, 'random should return value between 0 and 1');
+
     return Math.round(roll * span) + min;
 }

package/src/core/model/reactive/model/ReactiveExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEQ,0DAA6B;IAGjC,uBAEC;IAED,cAEC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,UAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,YAFa,CAAC,GAAC,OAAO,GAAC,MAAM,CAI5B;IAED;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,mBAFY,MAAM,CAQjB;IAED;;;OAGG;IACH,iCAIC;IAED;;;;OAIG;IACH,sBAFa,OAAO,GAAC,MAAM,GAAC,MAAM,CAIjC;IAGL,cAAqC;IAErC;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CARhD;mBA/FkB,kCAAkC"}
+{"version":3,"file":"ReactiveExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEQ,0DAA6B;IAGjC,uBAEC;IAED,cAEC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,UAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,YAFa,CAAC,GAAC,OAAO,GAAC,MAAM,GAAC,MAAM,CAInC;IAED;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,mBAFY,MAAM,CAQjB;IAED;;;OAGG;IACH,iCAIC;IAED;;;;OAIG;IACH,sBAFa,OAAO,GAAC,MAAM,GAAC,MAAM,CAIjC;IAGL,cAAqC;IAErC;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CARhD;mBA/FkB,kCAAkC"}

package/src/core/model/reactive/model/ReactiveExpression.js

@@ -48,7 +48,7 @@ export class ReactiveExpression {
     }
 
     /**
-     * @returns {T|boolean|number}
+     * @returns {T|boolean|number|string}
      */
     getValue() {
         throw new Error('ReactiveExpression.getValue not overridden');

package/src/core/model/reactive/model/ReactiveUnaryExpression.d.ts

@@ -30,7 +30,11 @@ export class ReactiveUnaryExpression<T, R> extends ReactiveExpression<any> {
      */
     hash(): number;
     getValue(): void;
-    isUnaryExpression: boolean;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isUnaryExpression: boolean;
 }
 import { ReactiveExpression } from "./ReactiveExpression.js";
 //# sourceMappingURL=ReactiveUnaryExpression.d.ts.map

package/src/core/model/reactive/model/ReactiveUnaryExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveUnaryExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveUnaryExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI,cASC;IANG;;;OAGG;IACH,QAFU,mBAAmB,CAAC,CAAC,CAEb;IAItB,uBAMC;IAED,qBAIC;IAED,2CAIC;IAED,2BAMC;IAED,mBAIC;IAED;;OAEG;IACH,kCAEC;IAED,0BAIC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED,iBAEC;IAGL,2BAAmD;CAFlD;mCAvFkC,yBAAyB"}
+{"version":3,"file":"ReactiveUnaryExpression.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/model/ReactiveUnaryExpression.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI,cASC;IANG;;;OAGG;IACH,QAFU,mBAAmB,CAAC,CAAC,CAEb;IAItB,uBAMC;IAED,qBAIC;IAED,2CAIC;IAED,2BAMC;IAED,mBAIC;IAED;;OAEG;IACH,kCAEC;IAED,0BAIC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED,iBAEC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAEkC;CANlD;mCAvFkC,yBAAyB"}

package/src/core/model/reactive/model/ReactiveUnaryExpression.js

@@ -89,4 +89,8 @@ export class ReactiveUnaryExpression extends ReactiveExpression {
     }
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
 ReactiveUnaryExpression.prototype.isUnaryExpression = true;

package/src/core/model/reactive/model/arithmetic/ReactiveAdd.d.ts

@@ -1,4 +1,11 @@
 export class ReactiveAdd extends ReactiveBinaryExpression {
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveAdd}
+     */
+    static from(left: ReactiveExpression, right: ReactiveExpression): ReactiveAdd;
     /**
      *
      * @param {number} left
@@ -27,16 +34,6 @@ export class ReactiveAdd extends ReactiveBinaryExpression {
      * @type {boolean}
      */
     readonly isReactiveAdd: boolean;
-    isCommutative: boolean;
-}
-export namespace ReactiveAdd {
-    /**
-     *
-     * @param {ReactiveExpression} left
-     * @param {ReactiveExpression} right
-     * @returns {ReactiveAdd}
-     */
-    function from(left: ReactiveExpression, right: ReactiveExpression): ReactiveAdd;
 }
 import { ReactiveBinaryExpression } from "../ReactiveBinaryExpression.js";
 //# sourceMappingURL=ReactiveAdd.d.ts.map

package/src/core/model/reactive/model/arithmetic/ReactiveAdd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveAdd.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveAdd.js"],"names":[],"mappings":"AAGA;IACI;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,WAAW,CAQtB;IAMD,iBAEC;IAGL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEK;IAE9B;;;OAGG;IACH,iCAFU,OAAO,CAE2B;IAE5C;;;OAGG;IACH,wBAFU,OAAO,CAEkB;IAEnC,uBAAmC;CApBlC;;IAsBD;;;;;OAKG;IACH,gFAMC;;yCAlEwC,gCAAgC"}
+{"version":3,"file":"ReactiveAdd.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveAdd.js"],"names":[],"mappings":"AAGA;IAgCI;;;;;OAKG;IACH,kEAFa,WAAW,CAQvB;IA3CD;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,WAAW,CAQtB;IAMD,iBAEC;IAmBL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEK;IAE9B;;;OAGG;IACH,iCAFU,OAAO,CAE2B;IAE5C;;;OAGG;IACH,wBAFU,OAAO,CAEkB;CAlBlC;yCAhDwC,gCAAgC"}

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

@@ -31,6 +31,22 @@ export class ReactiveAdd extends ReactiveBinaryExpression {
     toCode() {
         return `( ${this.left.toCode()} + ${this.right.toCode()} )`
     }
+
+
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveAdd}
+     */
+    static from(left, right) {
+        const r = new ReactiveAdd();
+
+        r.connect(left, right);
+
+        return r;
+    }
+
 }
 
 /**
@@ -51,18 +67,8 @@ ReactiveAdd.prototype.isArithmeticExpression = true;
  */
 ReactiveAdd.prototype.isReactiveAdd = true;
 
-ReactiveAdd.prototype.isCommutative = true;
-
 /**
- *
- * @param {ReactiveExpression} left
- * @param {ReactiveExpression} right
- * @returns {ReactiveAdd}
+ * @readonly
+ * @type {boolean}
  */
-ReactiveAdd.from = function (left, right) {
-    const r = new ReactiveAdd();
-
-    r.connect(left, right);
-
-    return r;
-};
+ReactiveAdd.prototype.isCommutative = true;

package/src/core/model/reactive/model/arithmetic/ReactiveDivide.d.ts

@@ -1,4 +1,11 @@
 export class ReactiveDivide extends ReactiveBinaryExpression {
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveDivide}
+     */
+    static from(left: ReactiveExpression, right: ReactiveExpression): ReactiveDivide;
     /**
      *
      * @param {number} left
@@ -28,14 +35,5 @@ export class ReactiveDivide extends ReactiveBinaryExpression {
      */
     readonly isReactiveDivide: boolean;
 }
-export namespace ReactiveDivide {
-    /**
-     *
-     * @param {ReactiveExpression} left
-     * @param {ReactiveExpression} right
-     * @returns {ReactiveDivide}
-     */
-    function from(left: ReactiveExpression, right: ReactiveExpression): ReactiveDivide;
-}
 import { ReactiveBinaryExpression } from "../ReactiveBinaryExpression.js";
 //# sourceMappingURL=ReactiveDivide.d.ts.map

package/src/core/model/reactive/model/arithmetic/ReactiveDivide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveDivide.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveDivide.js"],"names":[],"mappings":"AAGA;IACI;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAMD,iBAEC;IAGL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEQ;IAEjC;;;OAGG;IACH,iCAFU,OAAO,CAE8B;IAE/C;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CAlBxC;;IAoBD;;;;;OAKG;IACH,mFAMC;;yCAhEwC,gCAAgC"}
+{"version":3,"file":"ReactiveDivide.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveDivide.js"],"names":[],"mappings":"AAGA;IA+BI;;;;;OAKG;IACH,kEAFa,cAAc,CAQ1B;IA1CD;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAMD,iBAEC;IAiBL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEQ;IAEjC;;;OAGG;IACH,iCAFU,OAAO,CAE8B;IAE/C;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CAlBxC;yCA9CwC,gCAAgC"}

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

@@ -31,6 +31,20 @@ export class ReactiveDivide extends ReactiveBinaryExpression {
     toCode() {
         return `( ${this.left.toCode()} / ${this.right.toCode()} )`
     }
+
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveDivide}
+     */
+    static from(left, right) {
+        const r = new ReactiveDivide();
+
+        r.connect(left, right);
+
+        return r;
+    }
 }
 
 /**
@@ -51,16 +65,3 @@ ReactiveDivide.prototype.isArithmeticExpression = true;
  */
 ReactiveDivide.prototype.isReactiveDivide = true;
 
-/**
- *
- * @param {ReactiveExpression} left
- * @param {ReactiveExpression} right
- * @returns {ReactiveDivide}
- */
-ReactiveDivide.from = function (left, right) {
-    const r = new ReactiveDivide();
-
-    r.connect(left, right);
-
-    return r;
-};

package/src/core/model/reactive/model/arithmetic/ReactiveMultiply.d.ts

@@ -1,4 +1,11 @@
 export class ReactiveMultiply extends ReactiveBinaryExpression {
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveMultiply}
+     */
+    static from(left: ReactiveExpression, right: ReactiveExpression): ReactiveMultiply;
     /**
      *
      * @param {number} left
@@ -27,16 +34,6 @@ export class ReactiveMultiply extends ReactiveBinaryExpression {
      * @type {boolean}
      */
     readonly isReactiveMultiply: boolean;
-    isCommutative: boolean;
-}
-export namespace ReactiveMultiply {
-    /**
-     *
-     * @param {ReactiveExpression} left
-     * @param {ReactiveExpression} right
-     * @returns {ReactiveMultiply}
-     */
-    function from(left: ReactiveExpression, right: ReactiveExpression): ReactiveMultiply;
 }
 import { ReactiveBinaryExpression } from "../ReactiveBinaryExpression.js";
 //# sourceMappingURL=ReactiveMultiply.d.ts.map

package/src/core/model/reactive/model/arithmetic/ReactiveMultiply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveMultiply.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveMultiply.js"],"names":[],"mappings":"AAGA;IACI;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,gBAAgB,CAQ3B;IAMD,iBAEC;IAGL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEU;IAEnC;;;OAGG;IACH,iCAFU,OAAO,CAEgC;IAEjD;;;OAGG;IACH,6BAFU,OAAO,CAE4B;IAE7C,uBAAwC;CApBvC;;IAsBD;;;;;OAKG;IACH,qFAMC;;yCAlEwC,gCAAgC"}
+{"version":3,"file":"ReactiveMultiply.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveMultiply.js"],"names":[],"mappings":"AAGA;IAgCI;;;;;OAKG;IACH,kEAFa,gBAAgB,CAQ5B;IA3CD;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,gBAAgB,CAQ3B;IAMD,iBAEC;IAmBL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEU;IAEnC;;;OAGG;IACH,iCAFU,OAAO,CAEgC;IAEjD;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAlB5C;yCAhDwC,gCAAgC"}

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

@@ -31,6 +31,22 @@ export class ReactiveMultiply extends ReactiveBinaryExpression {
     toCode() {
         return `( ${this.left.toCode()} * ${this.right.toCode()} )`
     }
+
+
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveMultiply}
+     */
+    static from(left, right) {
+        const r = new ReactiveMultiply();
+
+        r.connect(left, right);
+
+        return r;
+    }
+
 }
 
 /**
@@ -51,18 +67,8 @@ ReactiveMultiply.prototype.isArithmeticExpression = true;
  */
 ReactiveMultiply.prototype.isReactiveMultiply = true;
 
-ReactiveMultiply.prototype.isCommutative = true;
-
 /**
- *
- * @param {ReactiveExpression} left
- * @param {ReactiveExpression} right
- * @returns {ReactiveMultiply}
+ * @readonly
+ * @type {boolean}
  */
-ReactiveMultiply.from = function (left, right) {
-    const r = new ReactiveMultiply();
-
-    r.connect(left, right);
-
-    return r;
-};
+ReactiveMultiply.prototype.isCommutative = true;

package/src/core/model/reactive/model/arithmetic/ReactiveNegate.d.ts

@@ -1,4 +1,10 @@
 export class ReactiveNegate extends ReactiveUnaryExpression<any, any> {
+    /**
+     *
+     * @param {ReactiveExpression} source
+     * @returns {ReactiveNegate}
+     */
+    static from(source: ReactiveExpression): ReactiveNegate;
     constructor();
     /**
      *
@@ -29,13 +35,5 @@ export class ReactiveNegate extends ReactiveUnaryExpression<any, any> {
      */
     readonly isReactiveNegate: boolean;
 }
-export namespace ReactiveNegate {
-    /**
-     *
-     * @param {ReactiveExpression} source
-     * @returns {ReactiveNegate}
-     */
-    function from(source: ReactiveExpression): ReactiveNegate;
-}
 import { ReactiveUnaryExpression } from "../ReactiveUnaryExpression.js";
 //# sourceMappingURL=ReactiveNegate.d.ts.map

package/src/core/model/reactive/model/arithmetic/ReactiveNegate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveNegate.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveNegate.js"],"names":[],"mappings":"AAGA;IAMW,cAWP;IAhBA;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED,4BAEC;IAED,iBAEC;IAGL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEQ;IAEjC;;;OAGG;IACH,iCAFU,OAAO,CAE8B;IAE/C;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CAlBxC;;IAqBD;;;;OAIG;IACH,0DAMC;;wCA/DuC,+BAA+B"}
+{"version":3,"file":"ReactiveNegate.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveNegate.js"],"names":[],"mappings":"AAGA;IA+BI;;;;OAIG;IACH,yCAFa,cAAc,CAQ1B;IApCM,cAWP;IAhBA;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED,4BAEC;IAED,iBAEC;IAiBL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEQ;IAEjC;;;OAGG;IACH,iCAFU,OAAO,CAE8B;IAE/C;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CAlBxC;wCA7CuC,+BAA+B"}

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

@@ -30,6 +30,20 @@ export class ReactiveNegate extends ReactiveUnaryExpression {
     toCode() {
         return `-${this.source.toCode()}`
     }
+
+
+    /**
+     *
+     * @param {ReactiveExpression} source
+     * @returns {ReactiveNegate}
+     */
+    static from(source) {
+        const r = new ReactiveNegate();
+
+        r.connect(source);
+
+        return r;
+    }
 }
 
 /**
@@ -51,15 +65,3 @@ ReactiveNegate.prototype.isArithmeticExpression = true;
 ReactiveNegate.prototype.isReactiveNegate = true;
 
 
-/**
- *
- * @param {ReactiveExpression} source
- * @returns {ReactiveNegate}
- */
-ReactiveNegate.from = function (source) {
-    const r = new ReactiveNegate();
-
-    r.connect(source);
-
-    return r;
-};

package/src/core/model/reactive/model/arithmetic/ReactiveSubtract.d.ts

@@ -1,4 +1,11 @@
 export class ReactiveSubtract extends ReactiveBinaryExpression {
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveSubtract}
+     */
+    static from(left: ReactiveExpression, right: ReactiveExpression): ReactiveSubtract;
     /**
      *
      * @param {number} left
@@ -28,14 +35,5 @@ export class ReactiveSubtract extends ReactiveBinaryExpression {
      */
     readonly isReactiveSubtract: boolean;
 }
-export namespace ReactiveSubtract {
-    /**
-     *
-     * @param {ReactiveExpression} left
-     * @param {ReactiveExpression} right
-     * @returns {ReactiveSubtract}
-     */
-    function from(left: ReactiveExpression, right: ReactiveExpression): ReactiveSubtract;
-}
 import { ReactiveBinaryExpression } from "../ReactiveBinaryExpression.js";
 //# sourceMappingURL=ReactiveSubtract.d.ts.map

package/src/core/model/reactive/model/arithmetic/ReactiveSubtract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveSubtract.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveSubtract.js"],"names":[],"mappings":"AAGA;IACI;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,gBAAgB,CAQ3B;IAMD,iBAEC;IAGL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEU;IAEnC;;;OAGG;IACH,iCAFU,OAAO,CAEgC;IAEjD;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAlB5C;;IAqBD;;;;;OAKG;IACH,qFAMC;;yCAjEwC,gCAAgC"}
+{"version":3,"file":"ReactiveSubtract.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/arithmetic/ReactiveSubtract.js"],"names":[],"mappings":"AAGA;IAgCI;;;;;OAKG;IACH,kEAFa,gBAAgB,CAQ5B;IA3CD;;;;;OAKG;IACH,gBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,SAFY,gBAAgB,CAQ3B;IAMD,iBAEC;IAmBL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEU;IAEnC;;;OAGG;IACH,iCAFU,OAAO,CAEgC;IAEjD;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAlB5C;yCAhDwC,gCAAgC"}

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

@@ -31,6 +31,22 @@ export class ReactiveSubtract extends ReactiveBinaryExpression {
     toCode() {
         return `( ${this.left.toCode()} - ${this.right.toCode()} )`
     }
+
+
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveSubtract}
+     */
+    static from(left, right) {
+        const r = new ReactiveSubtract();
+
+        r.connect(left, right);
+
+        return r;
+    }
+
 }
 
 /**
@@ -51,17 +67,3 @@ ReactiveSubtract.prototype.isArithmeticExpression = true;
  */
 ReactiveSubtract.prototype.isReactiveSubtract = true;
 
-
-/**
- *
- * @param {ReactiveExpression} left
- * @param {ReactiveExpression} right
- * @returns {ReactiveSubtract}
- */
-ReactiveSubtract.from = function (left, right) {
-    const r = new ReactiveSubtract();
-
-    r.connect(left, right);
-
-    return r;
-};

package/src/core/model/reactive/model/comparative/ReactiveEquals.d.ts

@@ -1,4 +1,11 @@
 export class ReactiveEquals extends ReactiveBinaryExpression {
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveEquals}
+     */
+    static from(left: ReactiveExpression, right: ReactiveExpression): ReactiveEquals;
     /**
      *
      * @param {number|boolean} left
@@ -27,16 +34,6 @@ export class ReactiveEquals extends ReactiveBinaryExpression {
      * @type {boolean}
      */
     readonly isReactiveEquals: boolean;
-    isCommutative: boolean;
-}
-export namespace ReactiveEquals {
-    /**
-     *
-     * @param {ReactiveExpression} left
-     * @param {ReactiveExpression} right
-     * @returns {ReactiveEquals}
-     */
-    function from(left: ReactiveExpression, right: ReactiveExpression): ReactiveEquals;
 }
 import { ReactiveBinaryExpression } from "../ReactiveBinaryExpression.js";
 //# sourceMappingURL=ReactiveEquals.d.ts.map

package/src/core/model/reactive/model/comparative/ReactiveEquals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveEquals.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/comparative/ReactiveEquals.js"],"names":[],"mappings":"AAGA;IACI;;;;;OAKG;IACH,gBAJW,MAAM,GAAC,OAAO,SACd,MAAM,GAAC,OAAO,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAMD,iBAEC;IAGL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEQ;IAEjC;;;OAGG;IACH,kCAFU,OAAO,CAE+B;IAEhD;;;OAGG;IACH,2BAFU,OAAO,CAEwB;IAEzC,uBAAsC;CApBrC;;IAsBD;;;;;OAKG;IACH,mFAMC;;yCAlEwC,gCAAgC"}
+{"version":3,"file":"ReactiveEquals.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/comparative/ReactiveEquals.js"],"names":[],"mappings":"AAGA;IAgCI;;;;;OAKG;IACH,kEAFa,cAAc,CAQ1B;IA3CD;;;;;OAKG;IACH,gBAJW,MAAM,GAAC,OAAO,SACd,MAAM,GAAC,OAAO,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAMD,iBAEC;IAkBL;;;OAGG;IACH,mBAFU,WAAS,MAAM,CAEQ;IAEjC;;;OAGG;IACH,kCAFU,OAAO,CAE+B;IAEhD;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CAlBxC;yCA/CwC,gCAAgC"}

package/src/core/model/reactive/model/comparative/ReactiveEquals.js

@@ -31,6 +31,21 @@ export class ReactiveEquals extends ReactiveBinaryExpression {
     toCode() {
         return `( ${this.left.toCode()} == ${this.right.toCode()} )`
     }
+
+
+    /**
+     *
+     * @param {ReactiveExpression} left
+     * @param {ReactiveExpression} right
+     * @returns {ReactiveEquals}
+     */
+    static from(left, right) {
+        const r = new ReactiveEquals();
+
+        r.connect(left, right);
+
+        return r;
+    }
 }
 
 /**
@@ -51,18 +66,9 @@ ReactiveEquals.prototype.isComparativeExpression = true;
  */
 ReactiveEquals.prototype.isReactiveEquals = true;
 
-ReactiveEquals.prototype.isCommutative = true;
-
 /**
- *
- * @param {ReactiveExpression} left
- * @param {ReactiveExpression} right
- * @returns {ReactiveEquals}
+ * @readonly
+ * @type {boolean}
  */
-ReactiveEquals.from = function (left, right) {
-    const r = new ReactiveEquals();
-
-    r.connect(left, right);
+ReactiveEquals.prototype.isCommutative = true;
 
-    return r;
-};