@woosh/meep-engine 2.165.6 → 2.166.0

package/src/core/math/spline/spline3_hermite_bounds_t.js

@@ -1,109 +1,115 @@
-import { assert } from "../../assert.js";
-import { spline3_hermite } from "./spline3_hermite.js";
-
-/**
- * Compute the parameter values `t` at which a cubic Hermite spline reaches its
- * minimum and maximum on `[0, 1]`. `t_at_min` is written to
- * `result[result_offset]`, `t_at_max` to `result[result_offset + result_stride]`.
- * Both values lie in `[0, 1]`.
- *
- * Companion to {@link spline3_hermite_bounds}, which writes the values; this
- * one writes the parameters at which those values are reached. Either function
- * does its own critical-point search — call whichever you actually need.
- *
- * @param {number[]|Float32Array|Float64Array} result
- * @param {number} result_offset
- * @param {number} result_stride
- * @param {number} p0
- * @param {number} p1
- * @param {number} m0
- * @param {number} m1
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function spline3_hermite_bounds_t(
-    result,
-    result_offset,
-    result_stride,
-    p0, p1, m0, m1
-) {
-    assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
-    assert.isInteger(result_stride, 'result_stride');
-
-    // Derivative of the Hermite polynomial:
-    //   3 t² (m0 + m1 + 2 p0 - 2 p1) - 2 t (2 m0 + m1 + 3 p0 - 3 p1) + m0
-    const a = 3 * (m0 + m1 + 2 * p0 - 2 * p1);
-    const b = -2 * (2 * m0 + m1 + 3 * p0 - 3 * p1);
-    const c = m0;
-
-    let min, max, t_at_min, t_at_max;
-    if (p0 <= p1) {
-        min = p0; t_at_min = 0;
-        max = p1; t_at_max = 1;
-    } else {
-        min = p1; t_at_min = 1;
-        max = p0; t_at_max = 0;
-    }
-
-    if (Math.abs(a) < 1e-12) {
-
-        if (Math.abs(b) >= 1e-12) {
-            const t = -c / b;
-
-            if (0 < t && t < 1) {
-                const value = spline3_hermite(t, p0, p1, m0, m1);
-
-                if (value < min) {
-                    min = value;
-                    t_at_min = t;
-                }
-                if (value > max) {
-                    max = value;
-                    t_at_max = t;
-                }
-            }
-        }
-
-    } else {
-
-        const b2ac = b * b - 4 * c * a;
-
-        if (b2ac >= 0) {
-            const sqrtb2ac = Math.sqrt(b2ac);
-
-            const t1 = (-b + sqrtb2ac) / (2 * a);
-
-            if (0 < t1 && t1 < 1) {
-                const value = spline3_hermite(t1, p0, p1, m0, m1);
-
-                if (value < min) {
-                    min = value;
-                    t_at_min = t1;
-                }
-                if (value > max) {
-                    max = value;
-                    t_at_max = t1;
-                }
-            }
-
-            const t2 = (-b - sqrtb2ac) / (2 * a);
-
-            if (0 < t2 && t2 < 1) {
-                const value = spline3_hermite(t2, p0, p1, m0, m1);
-
-                if (value < min) {
-                    min = value;
-                    t_at_min = t2;
-                }
-                if (value > max) {
-                    max = value;
-                    t_at_max = t2;
-                }
-            }
-        }
-    }
-
-    result[result_offset] = t_at_min;
-    result[result_offset + result_stride] = t_at_max;
-}
+import { assert } from "../../assert.js";
+import { max3 } from "../max3.js";
+import { spline3_hermite } from "./spline3_hermite.js";
+
+/**
+ * Compute the parameter values `t` at which a cubic Hermite spline reaches its
+ * minimum and maximum on `[0, 1]`. `t_at_min` is written to
+ * `result[result_offset]`, `t_at_max` to `result[result_offset + result_stride]`.
+ * Both values lie in `[0, 1]`.
+ *
+ * Companion to {@link spline3_hermite_bounds}, which writes the values; this
+ * one writes the parameters at which those values are reached. Either function
+ * does its own critical-point search — call whichever you actually need.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number} result_stride
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0
+ * @param {number} m1
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function spline3_hermite_bounds_t(
+    result,
+    result_offset,
+    result_stride,
+    p0, p1, m0, m1
+) {
+    assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
+    assert.isInteger(result_stride, 'result_stride');
+
+    // Derivative of the Hermite polynomial:
+    //   3 t² (m0 + m1 + 2 p0 - 2 p1) - 2 t (2 m0 + m1 + 3 p0 - 3 p1) + m0
+    const a = 3 * (m0 + m1 + 2 * p0 - 2 * p1);
+    const b = -2 * (2 * m0 + m1 + 3 * p0 - 3 * p1);
+    const c = m0;
+
+    let min, max, t_at_min, t_at_max;
+    if (p0 <= p1) {
+        min = p0; t_at_min = 0;
+        max = p1; t_at_max = 1;
+    } else {
+        min = p1; t_at_min = 1;
+        max = p0; t_at_max = 0;
+    }
+
+    // `a`, `b` and `c` all scale linearly with the curve's coordinates, so the degeneracy test has to
+    // be relative to them. An absolute threshold silently treats an entire small-coordinate curve as
+    // degenerate and reports the endpoints as the extrema, missing interior ones.
+    const epsilon = max3(Math.abs(a), Math.abs(b), Math.abs(c)) * 1e-12;
+
+    if (Math.abs(a) <= epsilon) {
+
+        if (Math.abs(b) > epsilon) {
+            const t = -c / b;
+
+            if (0 < t && t < 1) {
+                const value = spline3_hermite(t, p0, p1, m0, m1);
+
+                if (value < min) {
+                    min = value;
+                    t_at_min = t;
+                }
+                if (value > max) {
+                    max = value;
+                    t_at_max = t;
+                }
+            }
+        }
+
+    } else {
+
+        const b2ac = b * b - 4 * c * a;
+
+        if (b2ac >= 0) {
+            const sqrtb2ac = Math.sqrt(b2ac);
+
+            const t1 = (-b + sqrtb2ac) / (2 * a);
+
+            if (0 < t1 && t1 < 1) {
+                const value = spline3_hermite(t1, p0, p1, m0, m1);
+
+                if (value < min) {
+                    min = value;
+                    t_at_min = t1;
+                }
+                if (value > max) {
+                    max = value;
+                    t_at_max = t1;
+                }
+            }
+
+            const t2 = (-b - sqrtb2ac) / (2 * a);
+
+            if (0 < t2 && t2 < 1) {
+                const value = spline3_hermite(t2, p0, p1, m0, m1);
+
+                if (value < min) {
+                    min = value;
+                    t_at_min = t2;
+                }
+                if (value > max) {
+                    max = value;
+                    t_at_max = t2;
+                }
+            }
+        }
+    }
+
+    result[result_offset] = t_at_min;
+    result[result_offset + result_stride] = t_at_max;
+}

package/src/core/math/spline/spline3_hermite_to_bezier.d.ts

@@ -1,5 +1,7 @@
 /**
  * One-dimensional cubic curve conversion from Hermite to bezier
+ * The result is the 4 bezier control points in order. {@link spline3_bezier_to_hermite} inverts this,
+ * and writes its Hermite as `[p0, p1, m0, m1]`, so its output can be fed straight back in here.
  * @param {Float32Array|number[]} result where to put results
  * @param {number} result_offset offset to start writing at in result array
  * @param {number} result_stride how far to step between each written value. Necessary for N-dimensional curves where we want to interleave multiple curves together, such as for color or quaternions

package/src/core/math/spline/spline3_hermite_to_bezier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_to_bezier.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_to_bezier.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kDATW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsBhB"}
+{"version":3,"file":"spline3_hermite_to_bezier.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_to_bezier.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,kDATW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsBhB"}

package/src/core/math/spline/spline3_hermite_to_bezier.js

@@ -1,5 +1,7 @@
 /**
  * One-dimensional cubic curve conversion from Hermite to bezier
+ * The result is the 4 bezier control points in order. {@link spline3_bezier_to_hermite} inverts this,
+ * and writes its Hermite as `[p0, p1, m0, m1]`, so its output can be fed straight back in here.
  * @param {Float32Array|number[]} result where to put results
  * @param {number} result_offset offset to start writing at in result array
  * @param {number} result_stride how far to step between each written value. Necessary for N-dimensional curves where we want to interleave multiple curves together, such as for color or quaternions

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

@@ -14,7 +14,7 @@ export function computeStatisticalMean(values, start = 0, end = values.length) {
 
     const sample_count = end - start;
 
-    for (let i = 0; i < end; i++) {
+    for (let i = start; i < end; i++) {
         const value = values[i];
 
         total += value;

package/src/core/math/statistics/gaussian_amplitude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gaussian_amplitude.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/gaussian_amplitude.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,6CAJW,MAAM,sBACN,MAAM,GACJ,MAAM,CAMlB"}
+{"version":3,"file":"gaussian_amplitude.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/gaussian_amplitude.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,6CAJW,MAAM,sBACN,MAAM,GACJ,MAAM,CAQlB"}

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

@@ -9,5 +9,7 @@ import { gaussian } from "../gaussian.js";
 export function gaussian_amplitude(variance, distance_from_mean) {
     // Adapted from https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx#L339
 
-    return 1.0 / Math.sqrt(2.0 * Math.PI * variance) * gaussian(variance, distance_from_mean);
+    // gaussian() takes a standard deviation and squares it internally, so pass sqrt(variance) to get
+    // the exponent -distance^2 / (2 * variance) that the 1/sqrt(2*PI*variance) normalization expects.
+    return 1.0 / Math.sqrt(2.0 * Math.PI * variance) * gaussian(Math.sqrt(variance), distance_from_mean);
 }

package/src/core/model/BooleanVector3.d.ts

@@ -1,28 +1,77 @@
-import Signal from "../events/signal/Signal";
-
-export class BooleanVector3 {
-    constructor(x?: boolean, y?: boolean, z?: boolean)
-
-    readonly x: boolean
-    readonly y: boolean
-    readonly z: boolean
-
-    readonly onChanged: Signal<boolean, boolean, boolean, boolean, boolean, boolean>
-
-    static true: BooleanVector3
-    static false: BooleanVector3
-
-    public set(x: boolean, y: boolean, z: boolean): void
-
-    public setX(v: boolean): void
-
-    public setY(v: boolean): void
-
-    public setZ(v: boolean): void
-
-    public copy(other: BooleanVector3): void
-
-    public toJSON(): any
-
-    public fromJSON(json: any): void
-}
+export class BooleanVector3 {
+    /**
+     *
+     * @param {boolean} x
+     * @param {boolean} y
+     * @param {boolean} z
+     * @constructor
+     */
+    constructor(x?: boolean, y?: boolean, z?: boolean);
+    /**
+     *
+     * @type {boolean}
+     */
+    x: boolean;
+    /**
+     *
+     * @type {boolean}
+     */
+    y: boolean;
+    /**
+     *
+     * @type {boolean}
+     */
+    z: boolean;
+    onChanged: Signal;
+    /**
+     *
+     * @param {boolean} x
+     * @param {boolean} y
+     * @param {boolean} z
+     */
+    set(x: boolean, y: boolean, z: boolean): void;
+    /**
+     *
+     * @param {boolean} v
+     */
+    setX(v: boolean): void;
+    /**
+     *
+     * @param {boolean} v
+     */
+    setY(v: boolean): void;
+    /**
+     *
+     * @param {boolean} v
+     */
+    setZ(v: boolean): void;
+    /**
+     *
+     * @param {BooleanVector3} other
+     */
+    copy(other: BooleanVector3): void;
+    toJSON(): {
+        x: boolean;
+        y: boolean;
+        z: boolean;
+    };
+    fromJSON(json: any): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer: BinaryBuffer): void;
+}
+export namespace BooleanVector3 {
+    let _true: BooleanVector3;
+    export { _true as true };
+    let _false: BooleanVector3;
+    export { _false as false };
+}
+import Signal from "../events/signal/Signal.js";
+//# sourceMappingURL=BooleanVector3.d.ts.map

package/src/core/model/BooleanVector3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BooleanVector3.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BooleanVector3.js"],"names":[],"mappings":"AAGA;IACI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,MACP,OAAO,EAqBjB;IAjBG;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IAEV,0DAA6B;IAGjC;;;;;OAKG;IACH,OAJW,OAAO,KACP,OAAO,KACP,OAAO,QAoBjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;MAMC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAIC;IAED;;;OAGG;IACH,6CAQC;CACJ;;eAIS,cAAc;;gBAKd,cAAc;;;mBApIL,4BAA4B"}
+{"version":3,"file":"BooleanVector3.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BooleanVector3.js"],"names":[],"mappings":"AAGA;IACI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,MACP,OAAO,EAqBjB;IAjBG;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IACV;;;OAGG;IACH,GAFU,OAAO,CAEP;IAEV,kBAA6B;IAGjC;;;;;OAKG;IACH,OAJW,OAAO,KACP,OAAO,KACP,OAAO,QAoBjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,QAFW,OAAO,QAIjB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;MAMC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAIC;IAED;;;OAGG;IACH,6CAQC;CACJ;;eAIS,cAAc;;gBAKd,cAAc;;;mBApIL,4BAA4B"}

package/src/core/model/BoundedValue.d.ts

@@ -23,12 +23,12 @@ declare class BoundedValue {
      * @private
      */
     private __limitLower;
-    onChanged: Signal<any, any, any, any, any, any, any, any>;
-    onOverflow: Signal<any, any, any, any, any, any, any, any>;
-    onFilled: Signal<any, any, any, any, any, any, any, any>;
+    onChanged: Signal;
+    onOverflow: Signal;
+    onFilled: Signal;
     on: {
-        changed: Signal<any, any, any, any, any, any, any, any>;
-        overflow: Signal<any, any, any, any, any, any, any, any>;
+        changed: Signal;
+        overflow: Signal;
     };
     /**
      *

package/src/core/model/BoundedValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BoundedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BoundedValue.js"],"names":[],"mappings":";AAIA;IACI;;;;;;OAMG;IACH,2EA0BC;IAzBG;;;OAGG;IACH,gBAA4D;IAC5D;;;OAGG;IACH,qBAA6D;IAE7D;;;OAGG;IACH,qBAA6D;IAE7D,0DAA6B;IAC7B,2DAA8B;IAC9B,yDAA4B;IAE5B;;;MAGC;IAGL;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,+BAYC;IAED;;;OAGG;IACH,0BAiBC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;;OAGG;IACH,kBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,YAHW,YAAY,GACV,YAAY,CAMxB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;CACJ;mBAxNkB,4BAA4B"}
+{"version":3,"file":"BoundedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/BoundedValue.js"],"names":[],"mappings":";AAIA;IACI;;;;;;OAMG;IACH,2EA0BC;IAzBG;;;OAGG;IACH,gBAA4D;IAC5D;;;OAGG;IACH,qBAA6D;IAE7D;;;OAGG;IACH,qBAA6D;IAE7D,kBAA6B;IAC7B,mBAA8B;IAC9B,iBAA4B;IAE5B;;;MAGC;IAGL;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,+BAYC;IAED;;;OAGG;IACH,0BAiBC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;;OAGG;IACH,kBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,YAHW,YAAY,GACV,YAAY,CAMxB;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;CACJ;mBAxNkB,4BAA4B"}

package/src/core/model/ModuleRegistry.d.ts

@@ -1,3 +1,45 @@
-export class ModuleRegistry {
-
-}
+/**
+ * @template T
+ */
+export class ModuleRegistry<T> {
+    /**
+     * @readonly
+     * @type {ModuleRegistry}
+     */
+    readonly proxy: ModuleRegistry<any>;
+    /**
+     *
+     * @param {function(name:string,module:T):void} visitor
+     */
+    traverse(visitor: any): void;
+    /**
+     * @template {T} M
+     * @param {String} name
+     * @returns {M}
+     */
+    get<M extends T>(name: string): M;
+    /**
+     *
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has(name: string): boolean;
+    /**
+     * @template {T} M
+     * @param {string} name
+     * @param {M} module
+     * @returns {boolean}
+     */
+    add<M_1 extends T>(name: string, module: M_1): boolean;
+    /**
+     * Find all names associated with the given module
+     * @template M
+     * @param {M} module
+     * @returns {string[]}
+     * @throws {Error} if module is not registered
+     */
+    findNamesByModule<M_2>(module: M_2): string[];
+    initialize(): void;
+    #private;
+}
+//# sourceMappingURL=ModuleRegistry.d.ts.map

package/src/core/model/ObservedBoolean.d.ts

@@ -26,7 +26,7 @@ declare class ObservedBoolean extends Boolean {
      * @readonly
      * @type {Signal<boolean,boolean>}
      */
-    readonly onChanged: Signal<boolean, boolean>;
+    readonly onChanged: any;
     /**
      *
      * @type {boolean}
@@ -109,5 +109,4 @@ declare namespace ObservedBoolean {
     let FALSE: ObservedBoolean;
     let TRUE: ObservedBoolean;
 }
-import Signal from "../events/signal/Signal.js";
 //# sourceMappingURL=ObservedBoolean.d.ts.map

package/src/core/model/ObservedBoolean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObservedBoolean.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedBoolean.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;GAcG;AACH;IASI;;;;OAIG;IACH,oBAHW,OAAO,EAcjB;IAvBD;;;;OAIG;IACH,oBAFU,OAAO,OAAO,EAAC,OAAO,CAAC,CAER;IAYrB;;;;OAIG;IACH,gBAAoB;IAmBxB;;;;OAIG;IACH,WAHW,OAAO,GACL,eAAe,CAa3B;IAED;;;OAGG;IACH,gBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,kBAJoB,OAAO,QAAC,OAAO,0BAEtB,IAAI,CAWhB;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAEC;IAED,kBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAGC;IAeL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;IAE3C;;;OAGG;IACH,gBAFsB,MAAM,CAEM;CAxBjC;;eAIS,eAAe;cAMf,eAAe;;mBA1LN,4BAA4B"}
+{"version":3,"file":"ObservedBoolean.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedBoolean.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;GAcG;AACH;IASI;;;;OAIG;IACH,oBAHW,OAAO,EAcjB;IAvBD;;;;OAIG;IACH,wBAAyB;IAYrB;;;;OAIG;IACH,gBAAoB;IAmBxB;;;;OAIG;IACH,WAHW,OAAO,GACL,eAAe,CAa3B;IAED;;;OAGG;IACH,gBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,kBAJoB,OAAO,QAAC,OAAO,0BAEtB,IAAI,CAWhB;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,eAEC;IAED,kBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAGC;IAeL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;IAE3C;;;OAGG;IACH,gBAFsB,MAAM,CAEM;CAxBjC;;eAIS,eAAe;cAMf,eAAe"}

package/src/core/model/ObservedEnum.d.ts

@@ -1,7 +1,91 @@
-export default class ObservedEnum<T> {
-    constructor(value, validSet)
-
-    set(value: T): ObservedEnum<T>
-
-    getValue(): T
-}
+export default ObservedEnum;
+/**
+ * Enumerable value abstraction. Think `enum` keyword in TypeScript or any other programming language.
+ * Given a set of valid values, holds one of such values.
+ * This is an observable value, meaning you can subscribe to be notified of changes via {@link onChanged} signal.
+ *
+ * @example
+ *  const v = new ObservedEnum(7, {
+ *      ONE: 1,
+ *      SEVEN: 7
+ *  });
+ *
+ *  v.getValue(); // 7
+ *
+ *  v.set(1);
+ *
+ *  v.getValue(); // 1
+ *
+ *  v.set(2); // will throw error, as 2 is not a valid enum value
+ */
+declare class ObservedEnum {
+    /**
+     * @template T
+     * @param {T} value
+     * @param {Object.<string,T>} validSet
+     */
+    constructor(value: T_1, validSet: {
+        [x: string]: T_1;
+    });
+    /**
+     *
+     * @type {T}
+     * @private
+     */
+    private __value;
+    /**
+     *
+     * @type {Object<string, T>}
+     * @private
+     */
+    private __validSet;
+    /**
+     * @readonly
+     * @type {Signal<T,T>}
+     */
+    readonly onChanged: any;
+    /**
+     * Do not modify result
+     * @returns {Object<string, T>}
+     */
+    getValidValueSet(): {
+        [x: string]: T;
+    };
+    /**
+     *
+     * @param {T} value
+     * @returns {ObservedEnum}
+     */
+    set(value: T): ObservedEnum;
+    /**
+     * @template T
+     * @param {ObservedEnum<T>} other
+     * @returns {boolean}
+     */
+    equals<T>(other: any): boolean;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
+    /**
+     *
+     * @param {ObservedEnum} other
+     */
+    copy(other: ObservedEnum): void;
+    /**
+     *
+     * @returns {T}
+     */
+    getValue(): T;
+    /**
+     *
+     * @param {function(T,T)} processor
+     * @param {*} [thisArg]
+     * @returns {this}
+     */
+    process(processor: (arg0: T, arg1: T) => any, thisArg?: any): this;
+    toJSON(): T_1;
+    fromJSON(obj: any): void;
+}
+//# sourceMappingURL=ObservedEnum.d.ts.map

package/src/core/model/ObservedEnum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObservedEnum.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedEnum.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH;;OAsBC;IAlBG;;;;OAIG;IACH,gBAAoB;IACpB;;;;OAIG;IACH,mBAA0B;IAE1B;;;OAGG;IACH,+DAA6B;IAGjC;;;OAGG;IACH;YAFoB,MAAM;MAIzB;IAED;;;;OAIG;IACH,eAFa,YAAY,CAYxB;IAED;;;;OAIG;IACH,yBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAcjB;IAED;;;OAGG;IACH,YAFW,YAAY,QAItB;IAED;;;OAGG;IACH,cAEC;IAED;;;;;OAKG;IACH,8DAFa,IAAI,CAUhB;IAED,YAEC;IAED,yBAEC;CACJ;mBA9IkB,4BAA4B"}
+{"version":3,"file":"ObservedEnum.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedEnum.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;OAIG;IACH;;OAsBC;IAlBG;;;;OAIG;IACH,gBAAoB;IACpB;;;;OAIG;IACH,mBAA0B;IAE1B;;;OAGG;IACH,wBAA6B;IAGjC;;;OAGG;IACH;YAFoB,MAAM;MAIzB;IAED;;;;OAIG;IACH,eAFa,YAAY,CAYxB;IAED;;;;OAIG;IACH,uBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAcjB;IAED;;;OAGG;IACH,YAFW,YAAY,QAItB;IAED;;;OAGG;IACH,cAEC;IAED;;;;;OAKG;IACH,8DAFa,IAAI,CAUhB;IAED,cAEC;IAED,yBAEC;CACJ"}

package/src/core/model/ObservedString.d.ts

@@ -29,7 +29,7 @@ declare class ObservedString extends String {
      *
      * @type {Signal<string,string>}
      */
-    onChanged: Signal<string, string>;
+    onChanged: any;
     /**
      *
      * @param {string} value
@@ -90,5 +90,4 @@ declare class ObservedString extends String {
 declare namespace ObservedString {
     let typeName: string;
 }
-import Signal from "../events/signal/Signal.js";
 //# sourceMappingURL=ObservedString.d.ts.map

package/src/core/model/ObservedString.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObservedString.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedString.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;GAaG;AACH;IACI;;;OAGG;IACH,oBAFW,MAAM,EAmBhB;IAZG;;;;OAIG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,WAFU,OAAO,MAAM,EAAC,MAAM,CAAC,CAEF;IAmBjC;;;;OAIG;IACH,WAHW,MAAM,GACJ,cAAc,CAa1B;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;OAEG;IACH,SAFY,cAAc,CAQzB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAJoB,MAAM,QAAC,MAAM,0BAEpB,IAAI,CAUhB;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAIC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;IAUzC,cAtHiB,MAAM,CAsHQ;IAC/B,kBA/Ge,MAAM,KACJ,cAAc,CA8GE;CAlBhC;;kBAWS,MAAM;;mBAnKG,4BAA4B"}
+{"version":3,"file":"ObservedString.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedString.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;GAaG;AACH;IACI;;;OAGG;IACH,oBAFW,MAAM,EAmBhB;IAZG;;;;OAIG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,eAA6B;IAmBjC;;;;OAIG;IACH,WAHW,MAAM,GACJ,cAAc,CAa1B;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;OAEG;IACH,SAFY,cAAc,CAQzB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAJoB,MAAM,QAAC,MAAM,0BAEpB,IAAI,CAUhB;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAIC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;IAUzC,cAtHiB,MAAM,CAsHQ;IAC/B,kBA/Ge,MAAM,KACJ,cAAc,CA8GE;CAlBhC;;kBAWS,MAAM"}

package/src/core/model/ObservedValue.d.ts

@@ -7,7 +7,7 @@ declare class ObservedValue {
      * @constructor
      */
     constructor(v: T);
-    onChanged: Signal<any, any, any, any, any, any, any, any>;
+    onChanged: Signal;
     __value: T;
     /**
      *

package/src/core/model/ObservedValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObservedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedValue.js"],"names":[],"mappings":";AAEA;IACI;;;;;OAKG;IACH,kBAQC;IAPG,0DAA6B;IAC7B,WAAgB;IAChB;;;OAGG;IACH,kBAA2C;IAG/C;;;OAGG;IACH,oBAMC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;OAGG;IACH,SAEC;IAED;;;OAGG;IACH,YAFW,aAAa,QAIvB;IAED;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAInB;IAED;;;OAGG;IACH,aAEC;IAED;;;;;OAKG;IACH,iDAQC;IAED,mBAIC;IAED,YAEC;IAED,2BAEC;CACJ;mBAtGkB,4BAA4B"}
+{"version":3,"file":"ObservedValue.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedValue.js"],"names":[],"mappings":";AAEA;IACI;;;;;OAKG;IACH,kBAQC;IAPG,kBAA6B;IAC7B,WAAgB;IAChB;;;OAGG;IACH,kBAA2C;IAG/C;;;OAGG;IACH,oBAMC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;OAGG;IACH,SAEC;IAED;;;OAGG;IACH,YAFW,aAAa,QAIvB;IAED;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAInB;IAED;;;OAGG;IACH,aAEC;IAED;;;;;OAKG;IACH,iDAQC;IAED,mBAIC;IAED,YAEC;IAED,2BAEC;CACJ;mBAtGkB,4BAA4B"}