@woosh/meep-engine 2.114.0 → 2.116.0

package/src/core/binary/clz32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clz32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/clz32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yBAHW,MAAM,GACJ,MAAM,CAiClB"}

package/src/core/binary/clz32.js

@@ -0,0 +1,37 @@
+/**
+ * Count leading zeroes in a 32bit integer
+ * @param {number} x
+ * @returns {number}
+ */
+export function clz32(x) {
+    if (x === 0) {
+        return 32;
+    }
+
+    let v = x >>> 0;
+    let result = 0;
+
+    // Binary search.
+    if ((v & 0xFFFF0000) === 0) {
+        v <<= 16;
+        result += 16;
+    }
+    if ((v & 0xFF000000) === 0) {
+        v <<= 8;
+        result += 8;
+    }
+    if ((v & 0xF0000000) === 0) {
+        v <<= 4;
+        result += 4;
+    }
+    if ((v & 0xC0000000) === 0) {
+        v <<= 2;
+        result += 2;
+    }
+
+    if ((v & 0x80000000) === 0) {
+        result += 1;
+    }
+
+    return result;
+}

package/src/core/binary/is_data_url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is_data_url.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/is_data_url.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,iCAHW,MAAM,GACL,OAAO,CAQlB"}
+{"version":3,"file":"is_data_url.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/is_data_url.js"],"names":[],"mappings":"AACA;;;;GAIG;AACH,iCAHW,MAAM,GACL,OAAO,CAQlB"}

package/src/core/binary/is_data_url.js

@@ -1,3 +1,4 @@
+
 /**
  * Returns true if string is a data URL
  * @param {string} url

package/src/core/binary/makeArrayBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/makeArrayBuffer.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2CAJW,MAAM,WACN,OAAO,GACN,WAAW,GAAC,iBAAiB,CAcxC"}
+{"version":3,"file":"makeArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/makeArrayBuffer.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2CAJW,MAAM,WACN,OAAO,GACN,WAAW,GAAC,iBAAiB,CAexC"}

package/src/core/binary/makeArrayBuffer.js

@@ -8,6 +8,7 @@ import { assert } from "../assert.js";
  */
 export function makeArrayBuffer(byte_size, shared = false) {
     assert.isNonNegativeInteger(byte_size, 'size');
+    assert.isBoolean(shared, 'shared');
 
     if (shared) {
         if (crossOriginIsolated) {

package/src/core/binary/msb_32.d.ts

@@ -1,2 +1,8 @@
-export {};
+/**
+ * get most significant set bit
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} x 32 bit integer
+ * @returns {number} integer position of most significant bit
+ */
+export function msb_32(x: number): number;
 //# sourceMappingURL=msb_32.d.ts.map

package/src/core/binary/msb_32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":""}
+{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,0BAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/binary/msb_32.js

@@ -1,4 +1,4 @@
-import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
+import { clz32 } from "./clz32.js";
 
 /**
  * get most significant set bit
@@ -6,15 +6,6 @@ import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
  * @param {number} x 32 bit integer
  * @returns {number} integer position of most significant bit
  */
-function msb_32(x) {
-    let v = x;
-
-    v |= v >>> 1;
-    v |= v >>> 2;
-    v |= v >>> 4;
-    v |= v >>> 8;
-    v |= v >>> 16;
-    v = (v >>> 1) + 1;
-
-    return msb_lut_de_bruijn[(v * 0x077CB531) >>> 27];
+export function msb_32(x) {
+    return 31 - clz32(x);
 }

package/src/core/collection/RingBuffer.d.ts

@@ -63,7 +63,7 @@ export class RingBuffer {
      */
     removeElementByIndex(index: number): void;
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}

package/src/core/collection/RingBuffer.js

@@ -167,7 +167,7 @@ export class RingBuffer {
     }
 
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}

package/src/core/{primitives/array/compareArrays.d.ts → collection/array/array_compare.d.ts}

@@ -5,5 +5,5 @@
  * @param {function(T,T):number} comparator
  * @return {number}
  */
-export function compareArrays<T>(as: T[], bs: T[], comparator: (arg0: T, arg1: T) => number): number;
-//# sourceMappingURL=compareArrays.d.ts.map
+export function array_compare<T>(as: T[], bs: T[], comparator: (arg0: T, arg1: T) => number): number;
+//# sourceMappingURL=array_compare.d.ts.map

package/src/core/collection/array/array_compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_compare.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_compare.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,qFAHyB,MAAM,GACnB,MAAM,CA0BjB"}

package/src/core/{primitives/array/compareArrays.js → collection/array/array_compare.js}

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * @template T
  * @param {T[]} as
@@ -5,7 +7,9 @@
  * @param {function(T,T):number} comparator
  * @return {number}
  */
-export function compareArrays(as, bs, comparator) {
+export function array_compare(as, bs, comparator) {
+    assert.isFunction(comparator,'comparator');
+
     const n = as.length;
     const m = bs.length;
 

package/src/core/collection/array/{arrayIndexByEquality.d.ts → array_index_by_equality.d.ts}

@@ -6,5 +6,5 @@
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function arrayIndexByEquality<T>(array: T[], element: T, equals: any): number;
-//# sourceMappingURL=arrayIndexByEquality.d.ts.map
+export function array_index_by_equality<T>(array: T[], element: T, equals: any): number;
+//# sourceMappingURL=array_index_by_equality.d.ts.map

package/src/core/collection/array/array_index_by_equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_index_by_equality.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_index_by_equality.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,iFAFa,MAAM,CAclB"}

package/src/core/collection/array/{arrayIndexByEquality.js → array_index_by_equality.js}

@@ -6,7 +6,7 @@
  * @param {function(a:T,b:T):boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function arrayIndexByEquality(array, element, equals) {
+export function array_index_by_equality(array, element, equals) {
     const n = array.length;
 
     for (let i = 0; i < n; i++) {

package/src/core/collection/array/array_pick_best_element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_pick_best_element.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_element.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8EAkCC"}

package/src/core/collection/array/{arrayPickBestElement.js → array_pick_best_element.js}

@@ -8,9 +8,9 @@ import { assert } from "../../assert.js";
  * @param {function(el:T, index:number):number} scoreFunction
  * @returns {T|undefined}
  */
-export function arrayPickBestElement(array, scoreFunction) {
+export function array_pick_best_element(array, scoreFunction) {
     assert.notEqual(array, undefined, 'array is undefined');
-    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
+    assert.isFunction(scoreFunction, 'scoreFunction');
 
     let bestElement;
     let bestScore;

package/src/core/collection/array/array_pick_best_elements.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(el:T, index:number):number} scoreFunction
+ * @returns {T[]}
+ */
+export function array_pick_best_elements<T>(array: T[], scoreFunction: any): T[];
+//# sourceMappingURL=array_pick_best_elements.d.ts.map

package/src/core/collection/array/array_pick_best_elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_pick_best_elements.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_elements.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iFA0CC"}

package/src/core/collection/array/{arrayPickBestElements.js → array_pick_best_elements.js}

@@ -6,7 +6,7 @@ import { assert } from "../../assert.js";
  * @param {function(el:T, index:number):number} scoreFunction
  * @returns {T[]}
  */
-export function arrayPickBestElements(array, scoreFunction) {
+export function array_pick_best_elements(array, scoreFunction) {
     assert.notEqual(array, undefined, 'array is undefined');
     assert.isArray(array, 'array');
 

package/src/core/collection/array/{arraySetDiff.d.ts → array_set_diff.d.ts}

@@ -1,16 +1,16 @@
 /**
  * Compute a diff between two arrays, result is a 3 way split between common items, unique items in `a` array and unique items in `b` array
- * @see prefer to use {@link arraySetSortingDiff}, as it's much faster, especially for large sets
+ * @see prefer to use {@link array_set_diff_sorting}, as it's much faster, especially for large sets
  * @template T
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(a:T,b:T):boolean} [equals] method to determine equality between two elements
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetDiff<T>(a: T[], b: T[], equals?: typeof strictEquals): {
+export function array_set_diff<T>(a: T[], b: T[], equals?: typeof strictEquals): {
     uniqueA: T[];
     uniqueB: T[];
     common: T[];
 };
 import { strictEquals } from "../../function/strictEquals.js";
-//# sourceMappingURL=arraySetDiff.d.ts.map
+//# sourceMappingURL=array_set_diff.d.ts.map

package/src/core/collection/array/array_set_diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_set_diff.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_set_diff.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH;;;;EAoCC;6BAhD4B,gCAAgC"}

package/src/core/collection/array/{arraySetDiff.js → array_set_diff.js}

@@ -1,18 +1,18 @@
 import { assert } from "../../assert.js";
 
 import { strictEquals } from "../../function/strictEquals.js";
-import { arrayIndexByEquality } from "./arrayIndexByEquality.js";
+import { array_index_by_equality } from "./array_index_by_equality.js";
 
 /**
  * Compute a diff between two arrays, result is a 3 way split between common items, unique items in `a` array and unique items in `b` array
- * @see prefer to use {@link arraySetSortingDiff}, as it's much faster, especially for large sets
+ * @see prefer to use {@link array_set_diff_sorting}, as it's much faster, especially for large sets
  * @template T
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(a:T,b:T):boolean} [equals] method to determine equality between two elements
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetDiff(a, b, equals = strictEquals) {
+export function array_set_diff(a, b, equals = strictEquals) {
     assert.isArray(a, 'a');
     assert.isArray(b, 'b');
     assert.isFunction(equals, 'equals');
@@ -27,7 +27,7 @@ export function arraySetDiff(a, b, equals = strictEquals) {
     for (let i = 0; i < a_length; i++) {
         const elA = uniqueA[i];
 
-        const j = arrayIndexByEquality(uniqueB, elA, equals);
+        const j = array_index_by_equality(uniqueB, elA, equals);
 
         if (j !== -1) {
             // common element found

package/src/core/collection/array/{arraySetSortingDiff.d.ts → array_set_diff_sorting.d.ts}

@@ -6,9 +6,9 @@
  * @param {function(a:T,b:T):number} [compare]
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetSortingDiff<T>(a: T[], b: T[], compare: any): {
+export function array_set_diff_sorting<T>(a: T[], b: T[], compare: any): {
     uniqueA: T[];
     uniqueB: T[];
     common: T[];
 };
-//# sourceMappingURL=arraySetSortingDiff.d.ts.map
+//# sourceMappingURL=array_set_diff_sorting.d.ts.map

package/src/core/collection/array/array_set_diff_sorting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_set_diff_sorting.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_set_diff_sorting.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;;;;EAsDC"}

package/src/core/collection/array/{arraySetSortingDiff.js → array_set_diff_sorting.js}

@@ -10,7 +10,7 @@ import { assert } from "../../assert.js";
  * @param {function(a:T,b:T):number} [compare]
  * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
  */
-export function arraySetSortingDiff(a, b, compare) {
+export function array_set_diff_sorting(a, b, compare) {
     assert.isFunction(compare, 'compare');
 
     const uniqueA = a.slice();

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

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { computeIntegerArrayHash } from "../../primitives/array/computeIntegerArrayHash.js";
+import { computeIntegerArrayHash } from "./computeIntegerArrayHash.js";
 
 /**
  * Computes hash on integer values, useful for building composite hashes

package/src/core/{primitives → collection}/array/computeIntegerArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeIntegerArrayHash.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8CAJW,UAAU,GAAC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,UAAU,UAChD,MAAM,UACN,MAAM,UAIhB"}
+{"version":3,"file":"computeIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeIntegerArrayHash.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8CAJW,UAAU,GAAC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,UAAU,UAChD,MAAM,UACN,MAAM,UAIhB"}

package/src/core/{primitives → collection}/array/computeStridedArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAwBjB"}
+{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAwBjB"}

package/src/core/{primitives → collection}/array/computeStridedIntegerArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStridedIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeStridedIntegerArrayHash.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sDANW,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,UAC3C,MAAM,UACN,MAAM,UACN,MAAM,GACL,MAAM,CAoBjB"}
+{"version":3,"file":"computeStridedIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedIntegerArrayHash.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sDANW,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,UAC3C,MAAM,UACN,MAAM,UACN,MAAM,GACL,MAAM,CAoBjB"}

package/src/core/collection/array/randomMultipleFromArray.d.ts

@@ -2,11 +2,11 @@
  * Pick multiple random items from an array
  *
  * @template T
- * @param {function} random
- * @param {T[]} source
- * @param {T[]} target
- * @param {number} count how many items to pick
- * @returns {T}
+ * @param {function} random random function, must return a value between 0 and 1
+ * @param {T[]} source Where to pick elements from
+ * @param {T[]} target Where to place picked elements
+ * @param {number} count how many items to pick, if this number is greater than the length of {@link source}, it will be limited to length of {@link source} instead
+ * @returns {number} number of picked elements
  */
-export function randomMultipleFromArray<T>(random: Function, source: T[], target: T[], count: number): T;
+export function randomMultipleFromArray<T>(random: Function, source: T[], target: T[], count: number): number;
 //# sourceMappingURL=randomMultipleFromArray.d.ts.map

package/src/core/collection/array/randomMultipleFromArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomMultipleFromArray.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/randomMultipleFromArray.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,8FAHW,MAAM,KAuBhB"}
+{"version":3,"file":"randomMultipleFromArray.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/randomMultipleFromArray.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,8FAHW,MAAM,GACJ,MAAM,CAsBlB"}

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

@@ -5,11 +5,11 @@ import { array_shuffle } from "./array_shuffle.js";
  * Pick multiple random items from an array
  *
  * @template T
- * @param {function} random
- * @param {T[]} source
- * @param {T[]} target
- * @param {number} count how many items to pick
- * @returns {T}
+ * @param {function} random random function, must return a value between 0 and 1
+ * @param {T[]} source Where to pick elements from
+ * @param {T[]} target Where to place picked elements
+ * @param {number} count how many items to pick, if this number is greater than the length of {@link source}, it will be limited to length of {@link source} instead
+ * @returns {number} number of picked elements
  */
 export function randomMultipleFromArray(random, source, target, count) {
 

package/src/core/collection/array/typed/sparse_typed_array_hash.js

@@ -1,6 +1,6 @@
 import { min2 } from "../../../math/min2.js";
-import { computeStridedArrayHash } from "../../../primitives/array/computeStridedArrayHash.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
+import { computeStridedArrayHash } from "../computeStridedArrayHash.js";
 
 /**
  *

package/src/core/collection/array/typed/typedArrayConstructorByInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedArrayConstructorByInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typedArrayConstructorByInstance.js"],"names":[],"mappings":"AAAA,8SAwBC"}

package/src/core/collection/list/FilteredListProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilteredListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/FilteredListProjection.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,qCAHW,sBAAsB,EA6BhC;IAzBG;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,gBAAwB;IAExB;;;OAGG;IACH,SAFU,sBAAsB,CAEV;IAEtB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB,wBAAoD;IAGxD,eAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,0BAGC;IAED;;;OAGG;IACH,4BAGC;IAED,aAUC;IAED,eAQC;IAED,cAiFC;CACJ;iBAxLgB,WAAW"}
+{"version":3,"file":"FilteredListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/FilteredListProjection.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,qCAHW,sBAAsB,EA6BhC;IAzBG;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,gBAAwB;IAExB;;;OAGG;IACH,SAFU,sBAAsB,CAEV;IAEtB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB,wBAAoD;IAGxD,eAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,0BAGC;IAED;;;OAGG;IACH,4BAGC;IAED,aAUC;IAED,eAQC;IAED,cAiFC;CACJ;iBAvLgB,WAAW"}

package/src/core/collection/list/FilteredListProjection.js

@@ -1,7 +1,7 @@
 import { frameThrottle } from "../../../engine/graphics/FrameThrottle.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
+import { array_set_diff } from "../array/array_set_diff.js";
 import List from "./List.js";
-import { arraySetDiff } from "../array/arraySetDiff.js";
 
 export class FilteredListProjection {
     /**
@@ -136,7 +136,7 @@ export class FilteredListProjection {
             newOutput.push(v);
         }
 
-        const diff = arraySetDiff(oldOutput, newOutput, invokeObjectEquals);
+        const diff = array_set_diff(oldOutput, newOutput, invokeObjectEquals);
 
         //resolve diff
         const removals = diff.uniqueA;

package/src/core/collection/list/List.js

@@ -7,8 +7,8 @@ import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { objectsEqual } from "../../function/objectsEqual.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { arrayIndexByEquality } from "../array/arrayIndexByEquality.js";
-import { arraySetDiff } from "../array/arraySetDiff.js";
+import { array_index_by_equality } from "../array/array_index_by_equality.js";
+import { array_set_diff } from "../array/array_set_diff.js";
 
 
 /**
@@ -214,7 +214,7 @@ class List {
 
         const data = this.data;
 
-        const diff = arraySetDiff(data, new_data, objectsEqual);
+        const diff = array_set_diff(data, new_data, objectsEqual);
 
         //resolve diff
         const removals = diff.uniqueA;
@@ -744,7 +744,7 @@ class List {
         for (let i = 0; i < nThisItems; i++) {
             const a = thisItems[i];
 
-            const index = arrayIndexByEquality(otherItems, a, invokeObjectEquals);
+            const index = array_index_by_equality(otherItems, a, invokeObjectEquals);
 
             if (index !== -1) {
                 newData[index] = a;

package/src/core/geom/2d/Rectangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Rectangle.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/Rectangle.js"],"names":[],"mappings":";AAMA;IACI;;;;;;;OAOG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,EAgBhB;IAXG;;;OAGG;IACH,mBAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,eAFU,OAAO,CAEqB;IAG1C;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,OALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAKhB;IAED;;;OAGG;IACH,SAFa,SAAS,CAUrB;IAED;;;OAGG;IACH,YAFW,SAAS,QAKnB;IAED;;;;;;;OAOG;IACH,gBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,gBAHW,SAAS,GACP,OAAO,CAQnB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAyBhB;IAED;;;OAGG;IACH,mBAFW,SAAS,QASnB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAYnB;IAED;;;;OAIG;IACH,gBAHW,SAAS,GACP,OAAO,CASnB;IAED;;;OAGG;IACH,sBAFW,OAAO,QAUjB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,gBAHW,MAAO,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,iBACnD,MAAM,QAOhB;IAED;;;MAKC;IAED,0BAGC;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;oBAvRmB,eAAe"}
+{"version":3,"file":"Rectangle.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/Rectangle.js"],"names":[],"mappings":";AAOA;IACI;;;;;;;OAOG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,EAgBhB;IAXG;;;OAGG;IACH,mBAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,eAFU,OAAO,CAEqB;IAG1C;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,OALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAKhB;IAED;;;OAGG;IACH,SAFa,SAAS,CAUrB;IAED;;;OAGG;IACH,YAFW,SAAS,QAKnB;IAED;;;;;;;OAOG;IACH,gBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAenB;IAED;;;;OAIG;IACH,gBAHW,SAAS,GACP,OAAO,CASnB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAyBhB;IAED;;;OAGG;IACH,mBAFW,SAAS,QASnB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAiBnB;IAED;;;;OAIG;IACH,gBAHW,SAAS,GACP,OAAO,CAUnB;IAED;;;OAGG;IACH,sBAFW,OAAO,QAUjB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,gBAHW,MAAO,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,iBACnD,MAAM,QAOhB;IAED;;;MAKC;IAED,0BAGC;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;oBArSmB,eAAe"}

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

@@ -1,8 +1,9 @@
 import { intersects1D } from "../../math/interval/intersects1D.js";
-import { overlap1D } from "../../math/interval/overlap1D.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
 import Vector2 from "../Vector2.js";
+import { aabb2_contains } from "./aabb/aabb2_contains.js";
+import { aabb2_overlap_exists } from "./aabb/aabb2_overlap_exists.js";
 
 class Rectangle {
     /**
@@ -140,8 +141,13 @@ class Rectangle {
 
         const _x0 = p.x;
         const _y0 = p.y;
+        const _x1 = s.x + _x0;
+        const _y1 = _y0 + s.y;
 
-        return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
+        return aabb2_overlap_exists(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -154,6 +160,7 @@ class Rectangle {
         const y0 = other.position.y;
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
+
         return this._overlaps(x0, y0, x1, y1);
     }
 
@@ -213,13 +220,18 @@ class Rectangle {
     _contains(x0, y0, x1, y1) {
         const size = this.size;
 
-        const _x0 = this.position.x;
-        const _y0 = this.position.y;
+        const position = this.position;
+
+        const _x0 = position.x;
+        const _y0 = position.y;
 
         const _y1 = size.y + _y0;
         const _x1 = size.x + _x0;
 
-        return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
+        return aabb2_contains(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -230,6 +242,7 @@ class Rectangle {
     contains(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;
+
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
 

package/src/core/geom/2d/aabb/aabb2_overlap_exists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb2_overlap_exists.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_overlap_exists.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,0CAVW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAKnB"}
+{"version":3,"file":"aabb2_overlap_exists.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_overlap_exists.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,0CAVW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAQnB"}

package/src/core/geom/2d/aabb/aabb2_overlap_exists.js

@@ -12,7 +12,10 @@ import { overlap1D } from "../../../math/interval/overlap1D.js";
  * @param {number} by1
  * @returns {boolean} true if overlap exists, false if no overlap
  */
-export function aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1) {
+export function aabb2_overlap_exists(
+    ax0, ay0, ax1, ay1,
+    bx0, by0, bx1, by1
+) {
     return overlap1D(ax0, ax1, bx0, bx1)
         && overlap1D(ay0, ay1, by0, by1);
 }

package/src/core/geom/2d/convex-hull/fixed_convex_hull_humus.d.ts

@@ -6,12 +6,12 @@
  * @param {number[]|Float32Array} output result will be written here
  * @param {number} output_offset offset into output array where to write the result
  * @param {number} output_point_count number of points to comprise bounding polygon
- * @param {number[]} input_points Points to be bounded, must be an ordered loop
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop. Must form a convex hull
  * @param {number} input_point_count number of points in the input to consider
- * @returns {boolean} whether or not a valid result could be found
+ * @returns {number} number of points added to the output
  *
  * @see 2014 "Implementation of linear minimum area enclosing triangle algorithm" Ovidiu Pârvu & David Gilbert
  * @see https://github.com/MagnusTiberius/humus3/blob/9d43412d6e6be869e224817f0a966fe48a1af40f/Util/ConvexHull.cpp#L281
  */
-export function fixed_convex_hull_humus(output: number[] | Float32Array, output_offset: number, output_point_count: number, input_points: number[], input_point_count: number): boolean;
+export function fixed_convex_hull_humus(output: number[] | Float32Array, output_offset: number, output_point_count: number, input_points: number[], input_point_count: number): number;
 //# sourceMappingURL=fixed_convex_hull_humus.d.ts.map

package/src/core/geom/2d/convex-hull/fixed_convex_hull_humus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixed_convex_hull_humus.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,gDAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,OAAO,CAmInB"}
+{"version":3,"file":"fixed_convex_hull_humus.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,gDAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA0IlB"}

package/src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js

@@ -13,9 +13,9 @@ import { intersect_ray_2d } from "../intersect_ray_2d.js";
  * @param {number[]|Float32Array} output result will be written here
  * @param {number} output_offset offset into output array where to write the result
  * @param {number} output_point_count number of points to comprise bounding polygon
- * @param {number[]} input_points Points to be bounded, must be an ordered loop
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop. Must form a convex hull
  * @param {number} input_point_count number of points in the input to consider
- * @returns {boolean} whether or not a valid result could be found
+ * @returns {number} number of points added to the output
  *
  * @see 2014 "Implementation of linear minimum area enclosing triangle algorithm" Ovidiu Pârvu & David Gilbert
  * @see https://github.com/MagnusTiberius/humus3/blob/9d43412d6e6be869e224817f0a966fe48a1af40f/Util/ConvexHull.cpp#L281
@@ -24,9 +24,11 @@ export function fixed_convex_hull_humus(
     output, output_offset, output_point_count,
     input_points, input_point_count
 ) {
+
     if (output_point_count >= input_point_count) {
         // special case, input polygon is smaller or equal to in cardinality to what's desired
         array_copy(input_points, 0, output, output_offset, input_point_count * 2);
+
         return input_point_count;
     }
 
@@ -61,6 +63,7 @@ export function fixed_convex_hull_humus(
         combos++;
 
         for (let i = 0; i < k; i++) {
+            // pick point indices to represent a line
             const i0 = subset[i];
             const i1 = subset[(i + 1) % k];
 
@@ -143,7 +146,11 @@ export function fixed_convex_hull_humus(
         process_combination(s);
     }
 
-    console.log(`combinations:  ${combos}, valid: ${combos_valid} (${(combos_valid * 100 / combos).toFixed(2)}%)`);
+    // console.log(`combinations:  ${combos}, valid: ${combos_valid} (${(combos_valid * 100 / combos).toFixed(2)}%)`);
+    if(combos_valid === 0){
+        // no valid combinations
+        return 0;
+    }
 
-    return combos_valid > 0;
+    return output_point_count;
 }

package/src/core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js

@@ -1,7 +1,7 @@
 import { array_copy } from "../../../collection/array/array_copy.js";
 import { Uint32Heap } from "../../../collection/heap/Uint32Heap.js";
 import { intersect_ray_2d } from "../intersect_ray_2d.js";
-import { compute_triangle_area_2d } from "../compute_triangle_area_2d.js";
+import { triangle2d_compute_area } from "../triangle2d_compute_area.js";
 
 
 const v2_temp = new Float32Array(2);
@@ -158,7 +158,7 @@ function compute_collapse_cost(edge, vertex_buffer) {
     const v1x = vertex_buffer[edge.v1 * 2];
     const v1y = vertex_buffer[edge.v1 * 2 + 1];
 
-    const area = compute_triangle_area_2d(
+    const area = triangle2d_compute_area(
         v0x, v0y, v2_temp[0], v2_temp[1], v1x, v1y
     );