@woosh/meep-engine 2.121.8 → 2.121.11

package/src/core/geom/Vector4.d.ts

@@ -1,40 +1,230 @@
-import Signal from "../events/signal/Signal";
-import {Matrix4} from "three";
-
-interface Vector4Like {
-    x: number
-    y: number
-    z: number
-    w: number
-}
-
-export default class Vector4 {
-
-    x: number
-    y: number
-    z: number
-    w: number
-
-    0: number
-    1: number
-    2: number
-    3: number
-
-    public readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
-
-    constructor()
-
-    constructor(x: number, y: number, z: number, w: number)
-
-    set(x: number, y: number, z: number, w: number): void
-
-    copy(other: Vector4Like): void
-
-    readFromArray(array:ArrayLike<number>, offset?:number):void
-
-    writeToArray(array:ArrayLike<number>, offset?:number):void
-
-    asArray(): number[]
-
-    threeApplyMatrix4(matrix: Matrix4): void
-}
+export class Vector4 {
+    /**
+     *
+     * @param {Vector4} v0
+     * @param {Vector4} v1
+     * @param {Number} f interpolation fraction
+     * @param {Vector4} result
+     */
+    static lerp(v0: Vector4, v1: Vector4, f: number, result: Vector4): void;
+    /**
+     *
+     * @param {number} [x=0]
+     * @param {number} [y=0]
+     * @param {number} [z=0]
+     * @param {number} [w=0]
+     * @constructor
+     * @class
+     */
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /**
+     *
+     * @type {number}
+     */
+    x: number;
+    /**
+     *
+     * @type {number}
+     */
+    y: number;
+    /**
+     *
+     * @type {number}
+     */
+    z: number;
+    /**
+     *
+     * @type {number}
+     */
+    w: number;
+    /**
+     * Dispatched when the value changes
+     * @readonly
+     * @type {Signal<number,number,number,number,number,number,number,number>}
+     */
+    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
+    /**
+     *
+     * @param {number} v
+     */
+    set 0(v: number);
+    /**
+     *
+     * @returns {number}
+     */
+    get 0(): number;
+    /**
+     *
+     * @param {number} v
+     */
+    set 1(v: number);
+    /**
+     *
+     * @returns {number}
+     */
+    get 1(): number;
+    /**
+     *
+     * @param {number} v
+     */
+    set 2(v: number);
+    /**
+     *
+     * @returns {number}
+     */
+    get 2(): number;
+    /**
+     *
+     * @param {number} v
+     */
+    set 3(v: number);
+    /**
+     *
+     * @returns {number}
+     */
+    get 3(): number;
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    readFromArray(array: number[], offset?: number): void;
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    writeToArray(array: number[], offset?: number): void;
+    /**
+     *
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} z
+     * @param {Number} w
+     * @returns {Vector4}
+     */
+    set(x: number, y: number, z: number, w: number): Vector4;
+    /**
+     *
+     * @param {Vector3} v3
+     */
+    multiplyVector3(v3: Vector3): void;
+    /**
+     *
+     * @param {Number} value
+     * @returns {Vector4}
+     */
+    multiplyScalar(value: number): Vector4;
+    /**
+     *
+     * @param {number} a0
+     * @param {number} a1
+     * @param {number} a2
+     * @param {number} a3
+     * @param {number} b0
+     * @param {number} b1
+     * @param {number} b2
+     * @param {number} b3
+     * @param {number} c0
+     * @param {number} c1
+     * @param {number} c2
+     * @param {number} c3
+     * @param {number} d0
+     * @param {number} d1
+     * @param {number} d2
+     * @param {number} d3
+     * @returns {Vector4} this
+     */
+    _applyMatrix4(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, c0: number, c1: number, c2: number, c3: number, d0: number, d1: number, d2: number, d3: number): Vector4;
+    /**
+     *
+     * @param {Vector4} other
+     * @returns {number}
+     */
+    dot(other: Vector4): number;
+    /**
+     * Add XYZ components from another vector
+     * @param {Vector3|Vector4} v3
+     * @returns {Vector4}
+     */
+    add3(v3: Vector3 | Vector4): Vector4;
+    /**
+     *
+     * @param {Matrix4} m
+     * @returns {Vector4} this
+     */
+    threeApplyMatrix4(m: Matrix4): Vector4;
+    /**
+     *
+     * @param {Vector4} vec4
+     * @returns {Vector4}
+     */
+    copy(vec4: Vector4): Vector4;
+    /**
+     *
+     * @returns {Vector4}
+     */
+    clone(): Vector4;
+    /**
+     *
+     * @param {Quaternion} q
+     */
+    applyQuaternion(q: Quaternion): void;
+    /**
+     *
+     * @param {Vector4} vec4
+     * @returns {boolean}
+     */
+    equals(vec4: Vector4): boolean;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
+    /**
+     * @param {Vector4} v0
+     * @param {Vector4} v1
+     * @param {Number} f interpolation fraction
+     */
+    lerpVectors(v0: Vector4, v1: Vector4, f: number): void;
+    toArray: (result: number[]) => void;
+    /**
+     * @returns {number[]}
+     */
+    asArray(): number[];
+    /**
+     *
+     * @param {number[]} data
+     * @param {number} offset
+     */
+    setFromArray(data: number[], offset: number): void;
+    toJSON(): {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    fromJSON(json: any): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isVector4: boolean;
+    fromArray: (array: number[], offset?: number) => void;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+export namespace Vector4 {
+    let typeName: string;
+}
+export default Vector4;
+//# sourceMappingURL=Vector4.d.ts.map

package/src/core/geom/Vector4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":";AAMA;IAiaI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IA9aD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAiBhB;IANG,UAAU;IACV,UAAU;IACV,UAAU;IACV,UAAU;IAEV,eAA6B;IAWjC;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAkBD;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAkBD;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAkBD;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;OAIG;IACH,qBAHW,OAAO,GACL,OAAO,CAUnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAOlB;IAED;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAED,sDAOC;CAiBJ"}
+{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAMA;IAsbI;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IAncD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAsChB;IA3BG;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,oBAFU,MAAM,CAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,CAAC,CAE5C;IAWjC;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAkBD;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAkBD;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAkBD;;;OAGG;IACH,SAFW,MAAM,EAIhB;IAdD;;;OAGG;IACH,SAFa,MAAM,CAIlB;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;OAIG;IACH,qBAHW,OAAO,GACL,OAAO,CAUnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAuGL,kBAnGe,MAAM,EAAE,UAmGE;IA1FrB;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IA4BL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBA7Ve,MAAM,EAAE,WACR,MAAM,UA4VM;IAhCvB,sDAOC;CAiBJ;;kBAaS,MAAM"}

package/src/core/geom/Vector4.js

@@ -4,7 +4,7 @@ import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
-class Vector4 {
+export class Vector4 {
     /**
      *
      * @param {number} [x=0]
@@ -21,11 +21,32 @@ class Vector4 {
         w = 0
     ) {
 
+        /**
+         *
+         * @type {number}
+         */
         this.x = x;
+        /**
+         *
+         * @type {number}
+         */
         this.y = y;
+        /**
+         *
+         * @type {number}
+         */
         this.z = z;
+        /**
+         *
+         * @type {number}
+         */
         this.w = w;
 
+        /**
+         * Dispatched when the value changes
+         * @readonly
+         * @type {Signal<number,number,number,number,number,number,number,number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -438,5 +459,19 @@ class Vector4 {
     }
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Vector4.prototype.isVector4 = true;
+
+Vector4.prototype.fromArray = Vector4.prototype.readFromArray;
+Vector4.prototype.toArray = Vector4.prototype.writeToArray;
+
+/**
+ * @readonly
+ * @type {string}
+ */
+Vector4.typeName = "Vector4";
 
 export default Vector4;

package/src/core/geom/packing/max-rect/cutArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cutArea.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/cutArea.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iCAHW,KAAK,SACL,YAAY,QA4EtB"}
+{"version":3,"file":"cutArea.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/cutArea.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,iCAHW,KAAK,SACL,YAAY,QA0EtB"}

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

@@ -1,6 +1,7 @@
 import { assert } from "../../../assert.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
+import { qt_collect_by_box } from "../../2d/quad-tree/qt_collect_by_box.js";
 import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
 import { removeRedundantBoxesArray } from "./removeRedundantBoxesArray.js";
 
@@ -29,13 +30,10 @@ export function cutArea(
      */
     const removals = [];
 
-    /**
-     *
-     * @param {QuadTreeDatum} box
-     */
-    function visitOverlap(box) {
-        removals.push(box);
+    const overlap_box_count = qt_collect_by_box(removals,0,boxes,scissor.x0, scissor.y0, scissor.x1, scissor.y1);
 
+    for (let j = 0; j < overlap_box_count; j++) {
+        const box = removals[j];
 
         //compute overlap region
         const x0 = max2(scissor.x0, box.x0);
@@ -50,14 +48,17 @@ export function cutArea(
             //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));
@@ -65,8 +66,6 @@ export function cutArea(
 
     }
 
-    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++) {

package/src/core/geom/packing/miniball/Miniball.d.ts

@@ -1,11 +1,188 @@
-import {PointSet} from "./PointSet";
-
-export declare class Miniball {
-    constructor(points: PointSet)
-
-    size(): number
-
-    radius(): number
-
-    center(): ArrayLike<number>
-}
+/**
+ * Computes the miniball of the given point set.
+ * @class
+ */
+export class Miniball {
+    /**
+     * Notice that the point set `points` 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}.
+     *
+     * @param {PointSet} points the point set
+     */
+    constructor(points: PointSet);
+    /**
+     *
+     * @type {number}
+     */
+    iteration: number;
+    /**
+     *
+     * @type {number}
+     */
+    distToAff: number;
+    /**
+     *
+     * @type {number}
+     */
+    distToAffSquare: number;
+    /**
+     *
+     * The squared radius of the miniball.
+     *
+     * This is equivalent to `radius() * radius()`.
+     *
+     * Precondition: `!isEmpty()`
+     *
+     * @type {number}
+     * @private
+     */
+    private __squaredRadius;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __radius;
+    /**
+     *
+     * @type {number}
+     */
+    stopper: number;
+    /**
+     * @type {PointSet}
+     */
+    S: PointSet;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __size;
+    /**
+     * Number of dimensions (2 for 2d, 3 for 3d etc.)
+     * @type {number}
+     */
+    dim: number;
+    /**
+     *
+     * @type {number[]|Float64Array}
+     * @private
+     */
+    private __center;
+    /**
+     *
+     * @type {number[]|Float64Array}
+     */
+    centerToAff: number[] | Float64Array;
+    /**
+     *
+     * @type {number[]|Float64Array}
+     */
+    centerToPoint: number[] | Float64Array;
+    /**
+     *
+     * @type {number[]|Float64Array}
+     */
+    lambdas: number[] | Float64Array;
+    /**
+     *
+     * @type {Subspan}
+     * @private
+     */
+    private __support;
+    /**
+     * Whether 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>.
+     *
+     * @return {boolean} true iff
+     */
+    isEmpty(): boolean;
+    /**
+     * The radius of the miniball.
+     *
+     * Precondition: `!isEmpty()`
+     *
+     * @return {number} the radius of the miniball, a number ≥ 0
+     */
+    radius(): number;
+    /**
+     * The Euclidean coordinates of the center of the miniball.
+     *
+     * Precondition: `!isEmpty()`
+     *
+     * @return {number[]} an array holding the coordinates of the center of the miniball
+     */
+    center(): number[];
+    /**
+     *
+     * @returns {Subspan}
+     */
+    get support(): Subspan;
+    /**
+     * The number of input points.
+     *
+     * @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(): number;
+    /**
+     * Sets up the search ball with an arbitrary point of <i>S</i> as center and with exactly one of
+     * 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.
+     *
+     * Precondition: `size > 0`
+     * @return {Subspan}
+     * @private
+     */
+    private initBall;
+    /**
+     * @private
+     */
+    private computeDistToAff;
+    /**
+     * @private
+     */
+    private updateRadius;
+    /**
+     * The main function containing the main loop.
+     *
+     * Iteratively, we compute the point in support that is closest to the current center and then
+     * walk towards this target as far as we can, i.e., we move until some new point touches the
+     * boundary of the ball and must thus be inserted into support. In each of these two alternating
+     * phases, we always have to check whether some point must be dropped from support, which is the
+     * case when the center lies in <i>aff(support)</i>. If such an attempt to drop fails, we are
+     * done; because then the center lies even <i>conv(support)</i>.
+     * @private
+     */
+    private compute;
+    /**
+     * If center doesn't already lie in <i>conv(support)</i> and is thus not optimal yet,
+     * {@link #successfulDrop()} elects a suitable point <i>k</i> to be removed from the support and
+     * returns true. If the center lies in the convex hull, however, false is returned (and the
+     * support remains unaltered).
+     *
+     * Precondition: center lies in <i>aff(support)</i>.
+     * @return {boolean}
+     */
+    successfulDrop(): boolean;
+    /**
+     * 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 `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
+     */
+    private findStopFraction;
+    /**
+     * Outputs information about the miniball
+     * @return {string}
+     */
+    toString(): string;
+}
+import { Subspan } from "./Subspan.js";
+//# sourceMappingURL=Miniball.d.ts.map

package/src/core/geom/packing/miniball/PointSet.d.ts

@@ -1,3 +1,46 @@
-export declare class PointSet {
-    constructor(size: number, dimensions: number, data: ArrayLike<number>)
-}
+export class PointSet {
+    /**
+     *
+     * @param {number} size number of points
+     * @param {number} dimensions number of dimensions per point
+     * @param {Array|Float32Array|Float64Array} data
+     * @constructor
+     */
+    constructor(size: number, dimensions: number, data: any[] | Float32Array | Float64Array);
+    /**
+     *
+     * @type {Array|Float32Array|Float64Array}
+     * @private
+     */
+    private __data;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __size;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __dimensions;
+    /**
+     * Number of points in the set
+     * @returns {number}
+     */
+    size(): number;
+    /**
+     * Number of dimensions for each point
+     * @returns {number}
+     */
+    dimension(): number;
+    /**
+     * get coordinate for a point
+     * @param {number} i point index
+     * @param {number} j dimension
+     * @returns {number}
+     */
+    coord(i: number, j: number): number;
+}
+//# sourceMappingURL=PointSet.d.ts.map

package/src/core/geom/vec3/v3_slerp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_slerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_slerp.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,iCATW,OAAO,GAAC;IAAC,GAAG,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,OAAC;CAAC,OACzC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,YACN,MAAM,QAsChB"}
+{"version":3,"file":"v3_slerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_slerp.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,iCATW,OAAO,GAAC;IAAC,GAAG,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,OAAC;CAAC,OACzC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,YACN,MAAM,QAwChB"}

package/src/core/geom/vec3/v3_slerp.js

@@ -22,6 +22,8 @@ export function v3_slerp(
     fraction
 ) {
     assert.isNumber(fraction, 'fraction');
+    assert.notNaN(fraction, "fraction");
+    assert.greaterThanOrEqual(fraction, 0, "fraction");
 
     const dot = v3_dot(
         a_x, a_y, a_z,

package/src/core/math/EPSILON.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EPSILON.d.ts","sourceRoot":"","sources":["../../../../src/core/math/EPSILON.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sBAFU,MAAM,CAEgB"}
+{"version":3,"file":"EPSILON.d.ts","sourceRoot":"","sources":["../../../../src/core/math/EPSILON.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sBAFU,MAAM,CAEY"}

package/src/core/math/EPSILON.js

@@ -2,4 +2,4 @@
  * Very small value, used for comparison when compensation for rounding error is required
  * @type {number}
  */
-export const EPSILON = 0.000001;
+export const EPSILON = 1e-7;