@woosh/meep-engine 2.56.1 → 2.58.0

package/src/core/bvh2/traversal/__process_point_if_within_planes.js

@@ -1,4 +1,4 @@
-import { v3_distance_above_plane } from "../../geom/v3_distance_above_plane.js";
+import { v3_distance_above_plane } from "../../geom/vec3/v3_distance_above_plane.js";
 import { EPSILON } from "../../math/EPSILON.js";
 
 /**

package/src/core/cache/LoadingCache.js

@@ -24,7 +24,7 @@ class Record {
  * @readonly
  * @type {number}
  */
-const DEFAULT_TIME_TO_LIVE = 300; // 5 Minutes
+const DEFAULT_TIME_TO_LIVE = Infinity;
 
 /**
  * Asynchronous cache capable of resolving its own values by keys
@@ -56,6 +56,7 @@ export class LoadingCache {
 
     /**
      * @see {@link Cache} for more details on what each parameter means
+     * @template K,V
      * @param [maxWeight]
      * @param [keyWeigher]
      * @param [valueWeigher]
@@ -63,7 +64,7 @@ export class LoadingCache {
      * @param [keyEqualityFunction]
      * @param [capacity]
      * @param {number} [timeToLive] in seconds, default is 10 seconds
-     * @param load
+     * @param {function(key:K):Promise<V>} load
      * @param {boolean} [retryFailed]
      */
     constructor({

package/src/core/collection/array/arraySetSortingDiff.spec.js

@@ -1,8 +1,8 @@
 import { arraySetSortingDiff } from "./arraySetSortingDiff.js";
-import { compareNumbers } from "../../primitives/numbers/compareNumbers.js";
+import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 test('two empty inputs', () => {
-    expect(arraySetSortingDiff([], [], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([], [], number_compare_ascending)).toEqual({
         uniqueA: [],
         uniqueB: [],
         common: []
@@ -10,7 +10,7 @@ test('two empty inputs', () => {
 });
 
 test('[] and [1] inputs', () => {
-    expect(arraySetSortingDiff([], [1], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([], [1], number_compare_ascending)).toEqual({
         uniqueA: [],
         uniqueB: [1],
         common: []
@@ -18,7 +18,7 @@ test('[] and [1] inputs', () => {
 });
 
 test('[1] and [] inputs', () => {
-    expect(arraySetSortingDiff([1], [], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([1], [], number_compare_ascending)).toEqual({
         uniqueA: [1],
         uniqueB: [],
         common: []
@@ -26,7 +26,7 @@ test('[1] and [] inputs', () => {
 });
 
 test('[1] and [1] inputs', () => {
-    expect(arraySetSortingDiff([1], [1], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([1], [1], number_compare_ascending)).toEqual({
         uniqueA: [],
         uniqueB: [],
         common: [1]
@@ -34,7 +34,7 @@ test('[1] and [1] inputs', () => {
 });
 
 test('[1] and [1,2] inputs', () => {
-    expect(arraySetSortingDiff([1], [1, 2], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([1], [1, 2], number_compare_ascending)).toEqual({
         uniqueA: [],
         uniqueB: [2],
         common: [1]
@@ -42,7 +42,7 @@ test('[1] and [1,2] inputs', () => {
 });
 
 test('[1,2] and [1] inputs', () => {
-    expect(arraySetSortingDiff([1, 2], [1], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([1, 2], [1], number_compare_ascending)).toEqual({
         uniqueA: [2],
         uniqueB: [],
         common: [1]
@@ -50,7 +50,7 @@ test('[1,2] and [1] inputs', () => {
 });
 
 test('[5,4,3,2,1] and [1,2,3,4,5] inputs', () => {
-    expect(arraySetSortingDiff([5, 4, 3, 2, 1], [1, 2, 3, 4, 5], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([5, 4, 3, 2, 1], [1, 2, 3, 4, 5], number_compare_ascending)).toEqual({
         uniqueA: [],
         uniqueB: [],
         common: [1, 2, 3, 4, 5]
@@ -58,16 +58,16 @@ test('[5,4,3,2,1] and [1,2,3,4,5] inputs', () => {
 });
 
 test('[5,1] and [1,2,3,4,5] inputs', () => {
-    expect(arraySetSortingDiff([5, 1], [1, 2, 3, 4, 5], compareNumbers)).toEqual({
+    expect(arraySetSortingDiff([5, 1], [1, 2, 3, 4, 5], number_compare_ascending)).toEqual({
         uniqueA: [],
-        uniqueB: [2,3,4],
+        uniqueB: [2, 3, 4],
         common: [1, 5]
     });
 });
 
 test('[1,2,3,4,5] and [5,1] inputs', () => {
-    expect(arraySetSortingDiff([1, 2, 3, 4, 5], [5, 1], compareNumbers)).toEqual({
-        uniqueA: [2,3,4],
+    expect(arraySetSortingDiff([1, 2, 3, 4, 5], [5, 1], number_compare_ascending)).toEqual({
+        uniqueA: [2, 3, 4],
         uniqueB: [],
         common: [1, 5]
     });

package/src/core/collection/array/weightedRandomFromArray.js

@@ -1,6 +1,6 @@
 import { assert } from "../../assert.js";
-import { compareNumbers } from "../../primitives/numbers/compareNumbers.js";
 import { binarySearchHighIndex } from "./binarySearchHighIndex.js";
+import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 
 /**
@@ -45,7 +45,7 @@ export function weightedRandomFromArray(array, random, weight, weightContext, le
 
     const target_weight = random() * weight_total;
 
-    const index = binarySearchHighIndex(scratch_weights, target_weight, compareNumbers, 0, length - 1);
+    const index = binarySearchHighIndex(scratch_weights, target_weight, number_compare_ascending, 0, length - 1);
 
     return array[index];
 }

package/src/core/color/Color.js

@@ -1,15 +1,15 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { parseColor } from "./parseColor.js";
+import { parse_color } from "./parse_color.js";
 import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
-import { rgb2hsv } from "./rgb2hsv.js";
+import { rgb2hsv } from "./hsv/rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";
-import { rgb2hex } from "./rgb2hex.js";
-import { linear_to_sRGB } from "./linear_to_sRGB.js";
-import { sRGB_to_linear } from "./sRGB_to_linear.js";
+import { rgb2hex } from "./hex/rgb2hex.js";
+import { linear_to_sRGB } from "./sRGB/linear_to_sRGB.js";
+import { sRGB_to_linear } from "./sRGB/sRGB_to_linear.js";
 import { lerp } from "../math/lerp.js";
 import { float2uint8 } from "../binary/float2uint8.js";
 
@@ -534,7 +534,7 @@ export class Color {
      * @returns {void}
      */
     parse(str) {
-        const c = parseColor(str);
+        const c = parse_color(str);
 
         if (typeof c[3] === "number") {
             this.a = c[3];

package/src/core/color/Color.spec.js

@@ -1,4 +1,4 @@
-import { Color } from "./Color.js";
+import {Color} from "./Color.js";
 
 test('toUint', () => {
     const c = new Color();
@@ -146,3 +146,29 @@ test("iterator", () => {
     expect(last.done).toBe(true)
     expect(last.value).toBeUndefined()
 });
+
+test("array-style getters", () => {
+
+    const color = new Color(0.1, 0.3, 0.7, 0.11);
+
+    expect(color[0]).toBe(0.1);
+    expect(color[1]).toBe(0.3);
+    expect(color[2]).toBe(0.7);
+    expect(color[3]).toBe(0.11);
+
+});
+test("array-style setters", () => {
+
+    const color = new Color(0.001, 0.001, 0.001, 0.001);
+
+    color[0] = 0.1;
+    color[1] = 0.3;
+    color[2] = 0.7;
+    color[3] = 0.11;
+
+    expect(color.r).toBe(0.1);
+    expect(color.g).toBe(0.3);
+    expect(color.b).toBe(0.7);
+    expect(color.a).toBe(0.11);
+
+});

package/src/core/color/YCbCr/YCbCr.spec.js

@@ -0,0 +1,16 @@
+import { rgb_to_YCbCr_uint24 } from "./rgb_to_YCbCr_uint24.js";
+import { YCbCr_to_rgb_uint24 } from "./YCbCr_to_rgb_uint24.js";
+
+test("to/from consistency", () => {
+
+    const encoded = rgb_to_YCbCr_uint24(31, 73, 201);
+    const decoded = YCbCr_to_rgb_uint24((encoded >> 16) & 0xFF, (encoded >> 8) & 0xFF, encoded & 0xFF)
+
+    const r = ((decoded >> 16) & 0xFF);
+    const g = ((decoded >> 8) & 0xFF);
+    const b = ((decoded) & 0xFF);
+
+    expect(Math.abs(r - 31)).toBeLessThan(30);
+    expect(Math.abs(g - 73)).toBeLessThan(30);
+    expect(Math.abs(b - 201)).toBeLessThan(30);
+});

package/src/core/color/{YCbCr_to_rgb_uint24.js → YCbCr/YCbCr_to_rgb_uint24.js}

@@ -1,10 +1,8 @@
-import { rgb2uint24 } from "./rgb2uint24.js";
-
 /**
  * @see https://en.wikipedia.org/wiki/YUV
- * @param {number} Y
- * @param {number} Cb
- * @param {number} Cr
+ * @param {number} Y in range 0...255
+ * @param {number} Cb in range 0...255
+ * @param {number} Cr in range 0...255
  * @returns {number}
  */
 export function YCbCr_to_rgb_uint24(Y, Cb, Cr) {
@@ -15,5 +13,7 @@ export function YCbCr_to_rgb_uint24(Y, Cb, Cr) {
     const g = Y - ((_Cb >> 2) + (_Cb >> 4) + (_Cb >> 5)) - ((_Cr >> 1) + (_Cr >> 3) + (_Cr >> 4) + (_Cr >> 5));
     const b = Y + _Cb + (_Cb >> 1) + (_Cb >> 2) + (_Cb >> 6);
 
-    return rgb2uint24(r, g, b);
+    return ((r << 16) & 0xFF0000)
+        | ((g << 8) & 0xFF00)
+        | (b & 0xFF);
 }

package/src/core/color/YCbCr/rgb_to_YCbCr_uint24.js

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param r in range 0...255
+ * @param g in range 0...255
+ * @param b in range 0...255
+ * @return {number}
+ */
+export function rgb_to_YCbCr_uint24(r, g, b) {
+    const Y = 0.299 * r + 0.587 * g + 0.114 * b;
+    const Cb = -0.169 * r - 0.331 * g + 0.499 * b + 128;
+    const Cr = 0.499 * g - 0.418 * g - 0.0813 * b + 128;
+
+    return ((Y << 16) & 0xFF0000)
+        | ((Cb << 8) & 0xFF00)
+        | (Cr & 0xFF);
+}

package/src/core/color/{hex2rgb.js → hex/hex2rgb.js}

@@ -1,4 +1,4 @@
-import { hex2dec } from "../binary/hex2dec.js";
+import { hex2dec } from "../../binary/hex2dec.js";
 
 /**
  *

package/src/core/color/{rgb2hex.js → hex/rgb2hex.js}

@@ -1,4 +1,4 @@
-import { dec2hex } from "../binary/dec2hex.js";
+import { dec2hex } from "../../binary/dec2hex.js";
 
 /**
  * Takes values in 0..255 range

package/src/core/color/{hsv2rgb.js → hsv/hsv2rgb.js}

@@ -1,12 +1,12 @@
-import { clamp01 } from "../math/clamp01.js";
-import { float2uint8 } from "../binary/float2uint8.js";
+import { clamp01 } from "../../math/clamp01.js";
+import { float2uint8 } from "../../binary/float2uint8.js";
 
 /**
  *
  * @param {number} h from 0 to 1
  * @param {number} s from 0 to 1
  * @param {number} v from 0 to 1
- * @returns {{r: number, g: number, b: number}}
+ * @returns {{r: number, g: number, b: number}} output in range 0..255
  */
 export function hsv2rgb(h, s, v) {
 

package/src/core/color/hsv/rgb2hsv.js

@@ -0,0 +1,49 @@
+import { uint82float } from "../../binary/uint82float.js";
+
+/**
+ *
+ * @param {number} r 0 to 255
+ * @param {number} g 0 to 255
+ * @param {number} b 0 to 255
+ * @returns {{h: number, s: number, v: number}}
+ */
+export function rgb2hsv(r, g, b) {
+
+    const _r = uint82float(r);
+    const _g = uint82float(g);
+    const _b = uint82float(b);
+
+
+    const max = Math.max(_r, _g, _b);
+    const min = Math.min(_r, _g, _b);
+
+    let h, s, v = max;
+
+    const d = max - min;
+
+    s = max === 0 ? 0 : d / max;
+
+    if (max === min) {
+        h = 0; // achromatic
+    } else {
+        switch (max) {
+            case _r:
+                h = (_g - _b) / d + (_g < _b ? 6 : 0);
+                break;
+            case _g:
+                h = (_b - _r) / d + 2;
+                break;
+            case _b:
+                h = (_r - _g) / d + 4;
+                break;
+        }
+
+        h /= 6;
+    }
+
+    return {
+        h,
+        s,
+        v
+    };
+}

package/src/core/color/{kelvin_to_rgb.js → kelvin/kelvin_to_rgb.js}

@@ -1,4 +1,4 @@
-import { clamp01 } from "../math/clamp01.js";
+import { clamp01 } from "../../math/clamp01.js";
 
 /**
  * @see https://www.zombieprototypes.com/?p=210

package/src/core/color/{kelvin_to_rgb.spec.js → kelvin/kelvin_to_rgb.spec.js}

@@ -1,6 +1,6 @@
 import { kelvin_to_rgb } from "./kelvin_to_rgb.js";
-import { v3_distance } from "../geom/v3_distance.js";
-import { Color } from "./Color.js";
+import { v3_distance } from "../../geom/vec3/v3_distance.js";
+import { Color } from "../Color.js";
 
 function rgb([r255, g255, b255]) {
     return [r255 * 255, g255 * 255, b255 * 255];

package/src/core/color/{prototype_kelvin_to_rgb.js → kelvin/prototype_kelvin_to_rgb.js}

@@ -1,9 +1,9 @@
-import { CanvasView } from "../../view/elements/CanvasView.js";
+import { CanvasView } from "../../../view/elements/CanvasView.js";
 import { kelvin_to_rgb } from "./kelvin_to_rgb.js";
-import { lerp } from "../math/lerp.js";
-import { Sampler2D } from "../../engine/graphics/texture/sampler/Sampler2D.js";
-import sampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
-import { sRGB_to_linear } from "./sRGB_to_linear.js";
+import { lerp } from "../../math/lerp.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import sampler2D2Canvas from "../../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { sRGB_to_linear } from "../sRGB/sRGB_to_linear.js";
 
 const view = new CanvasView();
 

package/src/core/color/{rgb_to_kelvin.spec.js → kelvin/rgb_to_kelvin.spec.js}

@@ -1,5 +1,5 @@
 import { rgb_to_kelvin } from "./rgb_to_kelvin.js";
-import { Color } from "./Color.js";
+import { Color } from "../Color.js";
 
 
 test("1000 K", () => {

package/src/core/color/{parseColor.js → parse_color.js}

@@ -2,8 +2,8 @@
  * Created by Alex on 02/05/2016.
  */
 
-import { hsv2rgb } from "./hsv2rgb.js";
-import { hex2rgb } from "./hex2rgb.js";
+import { hsv2rgb } from "./hsv/hsv2rgb.js";
+import { hex2rgb } from "./hex/hex2rgb.js";
 
 
 const rgbRegEx = /rgb\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+)\s*\)/;
@@ -11,11 +11,11 @@ const rgbaRegEx = /rgba\(\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([
 const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\)/;
 
 /**
- *
+ * Parses most CSS-format colors
  * @param {string|number} c
- * @returns {number[]} Numeric array, values are in Uint8 range (0...255)
+ * @returns {number[]} Numeric array, values are in Uint8 range (0...255) for RGB and 0..1 for Alpha
  */
-export function parseColor(c) {
+export function parse_color(c) {
 
     const result = [];
 

package/src/core/color/parse_color.spec.js

@@ -0,0 +1,18 @@
+import { parse_color } from "./parse_color.js";
+
+test("number", () => {
+    expect(parse_color(0xCAFEBE)).toEqual([0xCA, 0xFE, 0xBE, 1]);
+
+});
+
+test("hash", () => {
+    expect(parse_color("#CAFEBE")).toEqual([0xCA, 0xFE, 0xBE, 1]);
+});
+
+test("rgba(r,g,b,a)", () => {
+    expect(parse_color("rgba(7,13,11,0.6)")).toEqual([7, 13, 11, 0.6]);
+});
+
+test("rgba(r,g,b)", () => {
+    expect(parse_color("rgb(7,13,11)")).toEqual([7, 13, 11, 1]);
+});

package/src/core/color/rgb2uint24.js

@@ -2,9 +2,9 @@ import { float2uint8 } from "../binary/float2uint8.js";
 
 /**
  *
- * @param {number} r
- * @param {number} g
- * @param {number} b
+ * @param {number} r in 0..1 range
+ * @param {number} g in 0..1 range
+ * @param {number} b in 0..1 range
  * @returns {number}
  */
 export function rgb2uint24(r, g, b) {

package/src/core/color/sRGB/sRGB.spec.js

@@ -0,0 +1,16 @@
+import { linear_to_sRGB } from "./linear_to_sRGB.js";
+import { sRGB_to_linear } from "./sRGB_to_linear.js";
+
+test("to/from consistency", () => {
+
+    const source = [0.7, 0.11, 0.31];
+    const srgb = [];
+    const decoded = [];
+
+    linear_to_sRGB(srgb, 0, source, 0);
+    sRGB_to_linear(decoded, 0, srgb, 0);
+
+    expect(decoded[0]).toBeCloseTo(source[0]);
+    expect(decoded[1]).toBeCloseTo(source[1]);
+    expect(decoded[2]).toBeCloseTo(source[2]);
+});

package/src/core/color/xyz/XYZ.spec.js

@@ -0,0 +1,16 @@
+import { rgb_to_xyz } from "./rgb_to_xyz.js";
+import { xyz_to_rgb } from "./xyz_to_rgb.js";
+
+test("to/from consistency", () => {
+
+    const source = [0.7, 0.11, 0.31];
+    const srgb = [];
+    const decoded = [];
+
+    rgb_to_xyz(srgb, source);
+    xyz_to_rgb(decoded, srgb);
+
+    expect(decoded[0]).toBeCloseTo(source[0]);
+    expect(decoded[1]).toBeCloseTo(source[1]);
+    expect(decoded[2]).toBeCloseTo(source[2]);
+});

package/src/core/color/xyz/rgb_to_xyz.js

@@ -0,0 +1,15 @@
+/**
+ * Assumes linear RGB space
+ * @param {vec3} out
+ * @param {vec3} input
+ */
+export function rgb_to_xyz(out, input) {
+
+    const x = input[0];
+    const y = input[1];
+    const z = input[2];
+
+    out[0] = 0.4124564 * x + 0.3575761 * y + 0.1804375 * z;
+    out[1] = 0.2126729 * x + 0.7151522 * y + 0.0721750 * z;
+    out[2] = 0.0193339 * x + 0.1191920 * y + 0.9503041 * z;
+}

package/src/core/color/xyz/xyz_to_rgb.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {vec3} out
+ * @param {vec3} input
+ */
+export function xyz_to_rgb(out, input) {
+    const x = input[0];
+    const y = input[1];
+    const z = input[2];
+
+    out[0] = 3.2404542 * x - 1.5371385 * y - 0.4985314 * z;
+    out[1] = (-0.9692660) * x + 1.8760108 * y + 0.0415560 * z;
+    out[2] = 0.0556434 * x - 0.2040259 * y + 1.0572252 * z;
+}

package/src/core/events/signal/Signal.js

@@ -16,6 +16,11 @@ import { SignalFlags } from "./SignalFlags.js";
 const dispatch_stack = [];
 let dispatch_stack_top = 0;
 
+/**
+ * Signal is a type of event bus. You can subscribe to events using {@link add) method and dispatch using sendN method where N is the number of arguments you wish to pass
+ * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference. Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
+ * @example `const mouseDown = new Signal<MouseEvent>(); mouseDown.send1(myMouseEvent);`
+ */
 export class Signal {
     /**
      * Event dispatcher dedicated to single event type

package/src/core/events/signal/{signalAggregateByTimeWindow.js → signal_aggregate_by_time_window.js}

@@ -8,7 +8,7 @@ import Signal from "./Signal.js";
  * @param {*} [thisArg]
  * @returns {{handler: handler, signal: Signal}}
  */
-export function signalAggregateByTimeWindow(delay, transform = passThrough, thisArg) {
+export function signal_aggregate_by_time_window(delay, transform = passThrough, thisArg) {
     let bucket = [];
     let timeout = null;
 

package/src/core/events/signal/{SignalUtils.js → signal_filter.js}

@@ -1,10 +1,9 @@
 import Signal from "./Signal.js";
 
 /**
- *
  * @param {function(*):boolean} predicate
  */
-export function signalFilter(predicate) {
+export function signal_filter(predicate) {
     const signal = new Signal();
 
     function handler(...args) {

package/src/core/fsm/simple/SimpleStateMachine.spec.js

@@ -1,5 +1,5 @@
-import { SimpleStateMachine } from "./SimpleStateMachine.js";
-import { SimpleStateMachineDescription } from "./SimpleStateMachineDescription.js";
+import {SimpleStateMachine} from "./SimpleStateMachine.js";
+import {SimpleStateMachineDescription} from "./SimpleStateMachineDescription.js";
 
 test("constructor does not throw", () => {
     const description = new SimpleStateMachineDescription();
@@ -31,6 +31,22 @@ test("state entry event handler is fired as expected", () => {
     expect(entry_callback).toHaveBeenCalledWith(b, a);
 });
 
+test("remove entry event handler", () => {
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const fsm = new SimpleStateMachine(description);
+
+    const handler = () => {
+    };
+
+    fsm.addEventHandlerStateEntry(a, handler);
+
+    expect(fsm.removeEventHandlerStateEntry(a, handler)).toBe(true);
+    expect(fsm.removeEventHandlerStateEntry(a, handler)).toBe(false);
+
+});
+
 test("state exit event handler is fired as expected", () => {
 
     const description = new SimpleStateMachineDescription();
@@ -54,6 +70,22 @@ test("state exit event handler is fired as expected", () => {
     expect(entry_callback).toHaveBeenCalledWith(a, b);
 });
 
+test("remove exit event handler", () => {
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const fsm = new SimpleStateMachine(description);
+
+    const handler = () => {
+    };
+
+    fsm.addEventHandlerStateExit(a, handler);
+
+    expect(fsm.removeEventHandlerStateExit(a, handler)).toBe(true);
+    expect(fsm.removeEventHandlerStateExit(a, handler)).toBe(false);
+
+});
+
 test("'advance' moves us to the next state in the chain", () => {
 
 

package/src/core/geom/2d/spline_bezier2_2d.js

@@ -0,0 +1,26 @@
+import { spline_bezier2 } from "../../math/spline/spline_bezier2.js";
+
+/**
+ *
+ * @param {Vector2} result
+ * @param {number} p0x
+ * @param {number} p0y
+ * @param {number} p1x
+ * @param {number} p1y
+ * @param {number} p2x
+ * @param {number} p2y
+ * @param {number} t
+ */
+export function spline_bezier2_2d(
+    result,
+    p0x, p0y,
+    p1x, p1y,
+    p2x, p2y,
+    t
+) {
+
+    const x0 = spline_bezier2(t, p0x, p1x, p2x);
+    const y0 = spline_bezier2(t, p0y, p1y, p2y);
+
+    result.set(x0, y0);
+}

package/src/core/geom/2d/spline_bezier2_2d.spec.js

@@ -0,0 +1,16 @@
+import { spline_bezier2_2d } from "./spline_bezier2_2d.js";
+import Vector2 from "../Vector2.js";
+
+test("spline_bezier2_2d hits knots",()=>{
+    const v2 = new Vector2();
+
+    spline_bezier2_2d(v2,1,3,5,7,11,13,0);
+
+    expect(v2.x).toBeCloseTo(1);
+    expect(v2.y).toBeCloseTo(3);
+
+    spline_bezier2_2d(v2,1,3,5,7,11,13,1);
+
+    expect(v2.x).toBeCloseTo(11);
+    expect(v2.y).toBeCloseTo(13);
+});

package/src/core/geom/3d/SurfacePoint3.js

@@ -1,5 +1,5 @@
 import Vector3 from "../Vector3.js";
-import { v3_length } from "../v3_length.js";
+import { v3_length } from "../vec3/v3_length.js";
 import { assert } from "../../assert.js";
 
 /**

package/src/core/geom/3d/aabb/aabb3_compute_plane_side.js

@@ -1,4 +1,4 @@
-import { v3_dot } from "../../v3_dot.js";
+import { v3_dot } from "../../vec3/v3_dot.js";
 
 /**
  * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane