@woosh/meep-engine 2.154.0 → 2.156.0

package/src/core/clipboard/safeClipboardReadText.js

@@ -0,0 +1,55 @@
+import { obtainClipBoard } from "./obtainClipBoard.js";
+
+/**
+ * Reads text from the clipboard, falling back to a file picker prompt when no clipboard is available.
+ * @returns {Promise<string>}
+ */
+export async function safeClipboardReadText() {
+
+    return obtainClipBoard().then(() => {
+
+        const navigator = globalThis.navigator;
+        return navigator.clipboard.readText();
+    }, () => {
+        // clipboard not available
+        console.log(`No clipboard available, using a prompt instead`);
+
+        function clickElem(elem) {
+            // Thx user1601638 on Stack Overflow (6/6/2018 - https://stackoverflow.com/questions/13405129/javascript-create-and-save-file )
+            var eventMouse = document.createEvent("MouseEvents")
+            eventMouse.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null)
+            elem.dispatchEvent(eventMouse)
+        }
+
+        function openFile(func) {
+            const fileInput = document.createElement("input");
+
+            const readFile = function (e) {
+                var file = e.target.files[0];
+                if (!file) {
+                    return;
+                }
+                var reader = new FileReader();
+                reader.onload = function (e) {
+                    var contents = e.target.result;
+                    fileInput.func(contents)
+                    document.body.removeChild(fileInput)
+                }
+                reader.readAsText(file)
+            }
+            fileInput.type = 'file'
+            fileInput.style.display = 'none'
+            fileInput.onchange = readFile
+            fileInput.func = func
+            document.body.appendChild(fileInput)
+            clickElem(fileInput)
+        }
+
+        return new Promise((resolve, reject) => {
+            openFile(resolve);
+        });
+
+
+    });
+
+}

package/src/core/clipboard/safeClipboardWriteText.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Writes text to the clipboard, falling back to a file download when no clipboard is available.
+ * @param {string} text
+ * @param {string} [data_name]
+ * @returns {Promise<void>}
+ */
+export function safeClipboardWriteText(text: string, data_name?: string): Promise<void>;
+//# sourceMappingURL=safeClipboardWriteText.d.ts.map

package/src/core/clipboard/safeClipboardWriteText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeClipboardWriteText.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/safeClipboardWriteText.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6CAJW,MAAM,cACN,MAAM,GACJ,QAAQ,IAAI,CAAC,CAezB"}

package/src/core/clipboard/safeClipboardWriteText.js

@@ -0,0 +1,23 @@
+import { obtainClipBoard } from "./obtainClipBoard.js";
+import { downloadAsFile } from "../binary/downloadAsFile.js";
+
+/**
+ * Writes text to the clipboard, falling back to a file download when no clipboard is available.
+ * @param {string} text
+ * @param {string} [data_name]
+ * @returns {Promise<void>}
+ */
+export async function safeClipboardWriteText(text, data_name = "data") {
+
+    return obtainClipBoard().then(
+        () => {
+            const navigator = globalThis.navigator;
+            return navigator.clipboard.writeText(text);
+        },
+        () => {
+            // no clipboard available
+            console.log(`No clipboard available, downloading instead`);
+            downloadAsFile(text, `${data_name}.json`);
+        }
+    );
+}

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

@@ -19,7 +19,7 @@ export function array_quick_sort_by_lookup_map(
         return;
     }
 
-    const stack_frame = start.pointer;
+    const stack_frame = stack.pointer;
     let stackPointer = stack_frame;
 
     let i, j;

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

@@ -1 +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"}
+{"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;;;;EAyDC"}

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

@@ -44,11 +44,14 @@ export function array_set_diff_sorting(a, b, compare) {
                 uniqueB.splice(j, 1);
 
                 i--;
-                j--;
 
                 length_a--;
                 length_b--;
 
+                // exactly one A and one B element are consumed per match; stop matching this A element so a
+                // single A cannot pair with multiple equal B elements (which corrupted the diff on duplicates)
+                break;
+
             } else if (diff > 0) {
                 cursor_j++;
             } else {

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

@@ -1 +1 @@
-{"version":3,"file":"array_shuffle.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_shuffle.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,+CAJsB,MAAM,uBAEjB,MAAM,QAYhB"}
+{"version":3,"file":"array_shuffle.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_shuffle.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,+CAJsB,MAAM,uBAEjB,MAAM,QAehB"}

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

@@ -1,27 +1,30 @@
-import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
-import { array_swap_one } from "./array_swap_one.js";
-
-/**
- * Randomly re-orders items in-place using Fisher–Yates.
- *
- * Pass `length` when shuffling a prefix of a larger buffer (e.g. a scratch
- * typed array sized for a worst-case but containing only a smaller active
- * range). Elements beyond `length` are untouched. Default is `array.length`,
- * which gives the natural "shuffle the whole thing" behaviour.
- *
- * @template T
- * @param {function():number} random random number generator; can use Math.random. Must return a value between 0 and 1
- * @param {T[]|TypedArray} array what to shuffle (mutated in place)
- * @param {number} [length] how many leading entries of `array` to shuffle; defaults to `array.length`
- */
-export function array_shuffle(random, array, length = array.length) {
-    for (let source_index = 0; source_index < length; ++source_index) {
-        const target_index = randomIntegerBetween(random, 0, length - (source_index + 1));
-
-        if (target_index === source_index) {
-            continue;
-        }
-
-        array_swap_one(array, source_index, target_index);
-    }
-}
+import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
+import { array_swap_one } from "./array_swap_one.js";
+
+/**
+ * Randomly re-orders items in-place using Fisher–Yates.
+ *
+ * Pass `length` when shuffling a prefix of a larger buffer (e.g. a scratch
+ * typed array sized for a worst-case but containing only a smaller active
+ * range). Elements beyond `length` are untouched. Default is `array.length`,
+ * which gives the natural "shuffle the whole thing" behaviour.
+ *
+ * @template T
+ * @param {function():number} random random number generator; can use Math.random. Must return a value between 0 and 1
+ * @param {T[]|TypedArray} array what to shuffle (mutated in place)
+ * @param {number} [length] how many leading entries of `array` to shuffle; defaults to `array.length`
+ */
+export function array_shuffle(random, array, length = array.length) {
+    for (let source_index = 0; source_index < length; ++source_index) {
+        // Fisher-Yates: swap each position with a uniformly-chosen index in the remaining suffix
+        // [source_index, length - 1]. The previous range [0, length - source_index - 1] sampled the wrong
+        // window and collapsed toward 0 as the loop advanced, producing a heavily biased ordering.
+        const target_index = randomIntegerBetween(random, source_index, length - 1);
+
+        if (target_index === source_index) {
+            continue;
+        }
+
+        array_swap_one(array, source_index, target_index);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"binarySearchLowIndex.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/binarySearchLowIndex.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qGALyB,MAAM,aACpB,MAAM,aACN,MAAM,GACL,MAAM,CA0BjB"}
+{"version":3,"file":"binarySearchLowIndex.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/binarySearchLowIndex.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qGALyB,MAAM,aACpB,MAAM,aACN,MAAM,GACL,MAAM,CA2BjB"}

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

@@ -9,7 +9,8 @@
  */
 export function binarySearchLowIndex(array, el, compareFunction, minIndex = 0, maxIndex = array.length - 1) {
 
-    let result = 0;
+    // index of the largest element <= el (the "low"/floor index), or -1 if el is below every element
+    let result = -1;
 
     while (minIndex <= maxIndex) {
 
@@ -18,12 +19,12 @@ export function binarySearchLowIndex(array, el, compareFunction, minIndex = 0, m
         const cmp = compareFunction(el, array[pivotIndex]);
 
         if (cmp > 0) {
+            // pivot is <= el so far; record it and keep searching to the right for a closer one
+            result = pivotIndex;
             minIndex = pivotIndex + 1;
         } else if (cmp < 0) {
             maxIndex = pivotIndex - 1;
-            result = maxIndex;
         } else {
-            //set low boundary for next step based on assumption that upper bound is higher than lower bound
             result = pivotIndex;
             break;
         }

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

@@ -20,7 +20,7 @@ export function array_buffer_hash(buffer, offset, length) {
             0,
             length >>> 2
         );
-    } else if ((alignment_mask & 2) === 0) {
+    } else if ((alignment_mask & 1) === 0) {
         // 2-byte alignment
         return uint16_array_hash(
             new Uint16Array(buffer, offset, length >>> 1),

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

@@ -1 +1 @@
-{"version":3,"file":"is_typed_array_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/is_typed_array_equals.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,yCAJW,UAAU,GAAC,WAAW,KACtB,UAAU,GAAC,WAAW,GACpB,OAAO,CAmFnB"}
+{"version":3,"file":"is_typed_array_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/is_typed_array_equals.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,yCAJW,UAAU,GAAC,WAAW,KACtB,UAAU,GAAC,WAAW,GACpB,OAAO,CA6FnB"}

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

@@ -69,8 +69,17 @@ export function is_typed_array_equals(a, b) {
 
     const alignment = largest_common_alignment_uint32(a_offset, b_offset, byte_length);
 
+    // Float arrays must NOT be widened to integers for comparison: reinterpreting float bits as integers
+    // changes equality semantics (e.g. distinct NaN bit patterns, +0 vs -0) and makes the result depend on the
+    // element width. Only Float16Array (2 bytes) can reach the widening branches below; guard all float types.
+    const is_float =
+        (typeof Float16Array !== "undefined" && a_constructor === Float16Array)
+        || a_constructor === Float32Array
+        || a_constructor === Float64Array;
+
     if (
-        bytes_per_element < 4
+        !is_float
+        && bytes_per_element < 4
         && alignment === 4
     ) {
 
@@ -79,7 +88,8 @@ export function is_typed_array_equals(a, b) {
         b_proxy = new Uint32Array(b_buffer, b_offset, byte_length >>> 2);
 
     } else if (
-        bytes_per_element < 2
+        !is_float
+        && bytes_per_element < 2
         && alignment === 2
     ) {
 

package/src/core/collection/heap/BinaryHeap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,qCAUC;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}
+{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,qCAUC;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAehB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAanB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/core/collection/heap/BinaryHeap.js

@@ -213,10 +213,18 @@ class BinaryHeap {
      * @param {number} i
      */
     deleteByIndex(i) {
+        // Move the last element into the hole and re-establish the heap invariant, rather than splicing
+        // (splice shifts every following element and destroys the heap ordering).
+        this.length--;
 
-        this.data.splice(i, 1);
+        const last = this.data.pop();
 
-        this.length--;
+        if (i < this.length) {
+            this.data[i] = last;
+            // the moved element may need to sink or rise; at most one of these does any work
+            this.bubbleDown(i);
+            this.bubbleUp(i);
+        }
     }
 
     /**
@@ -265,6 +273,8 @@ class BinaryHeap {
             return false;
         }
 
+        // the score may have increased or decreased; re-heapify in both directions (only one does work)
+        this.bubbleUp(index);
         this.bubbleDown(index);
         return true;
     }

package/src/core/collection/queue/Deque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH;IAgCI;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IA4FD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAiBhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAalB;IA6BD;;;;;;;OAOG;IACH,UAHW,CAAC,GACC,OAAO,CAqBnB;IA4BD;;;;OAIG;IACH,OAHW,CAAC,GACC,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAOhB;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAmBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL;;OAEG;IACH,gBAAoB;IACpB;;OAEG;IACH,uBAAoB;IACpB;;OAEG;IACH,eAAmB;IAEnB;;OAEG;IACH,iBA1GiB,IAAI,CA0GF;IAlCf;;;OAGG;IACH,qBAFa,UAAU,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}
+{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH;IAgCI;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IA4FD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAiBhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAalB;IA+BD;;;;;;;OAOG;IACH,UAHW,CAAC,GACC,OAAO,CAqBnB;IA4BD;;;;OAIG;IACH,OAHW,CAAC,GACC,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAOhB;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAmBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL;;OAEG;IACH,gBAAoB;IACpB;;OAEG;IACH,uBAAoB;IACpB;;OAEG;IACH,eAAmB;IAEnB;;OAEG;IACH,iBA1GiB,IAAI,CA0GF;IAlCf;;;OAGG;IACH,qBAFa,UAAU,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}

package/src/core/collection/queue/Deque.js

@@ -216,23 +216,25 @@ export class Deque {
      * @private
      */
     #remove_internal_shift_backward(current) {
-        let cursor = current;
-
         // shift towards head, this has a better data access pattern than shifting the other way as we're going through the data in forward sequence
 
-        const tail = this.#tail;
+        // Bound the shift by the true last occupied index, NOT by #tail. When the deque is full, #head === #tail,
+        // so #tail is the head slot rather than a free past-the-end marker; using it would walk the cursor all the
+        // way around the ring and corrupt the head element.
+        const last = this.#circular_previous_position(this.#tail);
+
+        let cursor = current;
 
-        while (cursor !== tail) {
+        while (cursor !== last) {
             const next = this.#circular_next_position(cursor);
             this.#data[cursor] = this.#data[next];
             cursor = next;
         }
 
-        this.#tail = this.#circular_previous_position(tail);
-
-
         // fill in slot of last moved element
-        this.#data[cursor] = undefined;
+        this.#data[last] = undefined;
+
+        this.#tail = last;
 
         this.#reset_status(false);
     }

package/src/core/collection/table/RowFirstTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAsDjB;IAzCG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAKL;;;;;;OAMG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgDhB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,gBACN,MAAM,SACN,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,kBAHW,MAAM,aACN,MAAM,QAyBhB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,kBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,eAHW,MAAO,MAAM,CAAC,GACZ,MAAM,CAYlB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAGD;;;;;OAKG;IACH,eAJW,MAAM,WACN,MAAM,EAAE,GACN,MAAM,EAAE,CAUpB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,EAAE,QAUlB;IAED;;;;;;OAMG;IACH,gBAFW,MAAM,QAgBhB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;;OAIG;IACH,cAFa,MAAM,EAAE,EAAE,CAetB;IAED;;;OAGG;IACH,uBAIC;IAED;;;;OAIG;IACH,YAFW,aAAa,QAmBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAwCnB;CACJ;mBApmBkB,+BAA+B"}
+{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAsDjB;IAzCG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAKL;;;;;;OAMG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgDhB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,gBACN,MAAM,SACN,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,kBAHW,MAAM,aACN,MAAM,QAyBhB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,kBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,eAHW,MAAO,MAAM,CAAC,GACZ,MAAM,CAYlB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAGD;;;;;OAKG;IACH,eAJW,MAAM,WACN,MAAM,EAAE,GACN,MAAM,EAAE,CAUpB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,EAAE,QAUlB;IAED;;;;;;OAMG;IACH,gBAFW,MAAM,QAgBhB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;;OAIG;IACH,cAFa,MAAM,EAAE,EAAE,CAetB;IAED;;;OAGG;IACH,uBAIC;IAED;;;;OAIG;IACH,YAFW,aAAa,QAqBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAwCnB;CACJ;mBAtmBkB,+BAA+B"}

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

@@ -559,9 +559,11 @@ export class RowFirstTable {
 
         const record_count = other.length;
 
-        this.resize(record_count);
+        // Set length BEFORE resizing: resize() copies `this.length` records from the old buffer, so leaving the
+        // old (larger) length in place while shrinking would read past the new, smaller buffer and throw.
+        this.length = record_count;
 
-        this.length = other.length;
+        this.resize(record_count);
 
         // copy data
         const data_byte_count = other.spec.bytesPerRecord * record_count;

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

@@ -255,7 +255,7 @@ export class RowFirstTableSpec {
      * @param {EndianType} [endianType]
      * @returns {RowFirstTableSpec}
      */
-    static get(types, endianType = EndianType.BigEndian) {
+    static get(types, endianType = EndianType.LittleEndian) {
         assert.isArray(types, 'types');
         assert.enum(endianType, EndianType, 'endianType');
 
@@ -268,7 +268,7 @@ export class RowFirstTableSpec {
             return cachedValue;
         }
 
-        const newValue = Object.freeze(new RowFirstTableSpec(types));
+        const newValue = Object.freeze(new RowFirstTableSpec(types, endianType));
         SPEC_CACHE.put(hash, newValue);
 
         return newValue;

package/src/core/color/operations/color_lerp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"color_lerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/operations/color_lerp.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,oCALW,KAAK,WACL,KAAK,KACL,MAAM,GACJ,KAAK,CAsBjB;sBApCqB,aAAa"}
+{"version":3,"file":"color_lerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/operations/color_lerp.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,oCALW,KAAK,WACL,KAAK,KACL,MAAM,GACJ,KAAK,CA6BjB;sBA3CqB,aAAa"}

package/src/core/color/operations/color_lerp.js

@@ -29,9 +29,16 @@ export function color_lerp(color_0, color_1, t) {
 
     const _t = clamp01(t);
 
-    for (let i = 0; i < 3; i++) {
-        hsv_2[i] = lerp(hsv_0[i], hsv_1[i], _t);
-    }
+    // Hue is circular (wraps at 1.0), so it must be interpolated along the shortest arc rather than linearly,
+    // otherwise the blend takes the long way around and passes through the wrong hues. Saturation and value
+    // are linear. JS `%` can return negative values, so the wrap math is guarded explicitly.
+    const h0 = hsv_0[0];
+    const h1 = hsv_1[0];
+    const hue_delta = ((h1 - h0) % 1 + 1.5) % 1 - 0.5; // signed shortest-arc delta in (-0.5, 0.5]
+
+    hsv_2[0] = ((h0 + hue_delta * _t) % 1 + 1) % 1;
+    hsv_2[1] = lerp(hsv_0[1], hsv_1[1], _t);
+    hsv_2[2] = lerp(hsv_0[2], hsv_1[2], _t);
 
     okhsv_to_linear_srgb(r, ...hsv_2);
     r.a = lerp(color_0.a, color_1.a, _t);

package/src/core/color/rgb2uint32.js

@@ -10,7 +10,7 @@ import { rgb2uint24 } from "./rgb2uint24.js";
  * @returns {number}
  */
 export function rgb2uint32(r, g, b, a) {
-    const partial = rgb2uint24(r, b, g);
+    const partial = rgb2uint24(r, g, b);
 
     const _a = float_to_uint8(a);
 

package/src/core/color/rgbe9995_to_rgb.js

@@ -11,7 +11,7 @@ export function rgbe9995_to_rgb(out, out_offset, rgbe) {
     const r = rgbe & 0x1ff;
     const g = (rgbe >> 9) & 0x1ff;
     const b = (rgbe >> 18) & 0x1ff;
-    const e = (rgbe >> 27);
+    const e = (rgbe >>> 27);
 
     const scale = Math.pow(2.0, e - 15.0 - 9.0);
 

package/src/core/function/objectsEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectsEqual.d.ts","sourceRoot":"","sources":["../../../../src/core/function/objectsEqual.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,8CAFa,OAAO,CASnB"}
+{"version":3,"file":"objectsEqual.d.ts","sourceRoot":"","sources":["../../../../src/core/function/objectsEqual.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,8CAFa,OAAO,CAUnB"}

package/src/core/function/objectsEqual.js

@@ -7,7 +7,8 @@
 export function objectsEqual(a, b) {
     return a === b
         || (
-            typeof a === "object" //guard against null and undefined values
+            typeof a === "object" // guard against undefined values
+            && a !== null // typeof null === "object", so null must be excluded explicitly
             && typeof a.equals === "function" // check for equals method
             && a.equals(b)
         );

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

@@ -1 +1 @@
-{"version":3,"file":"AABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/AABB2.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"AABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/AABB2.js"],"names":[],"mappings":"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"}

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

@@ -191,17 +191,18 @@ class AABB2 {
         const y1 = this.y1;
 
 
-        const _xa = m0 * x0 + m3 * y0 + m6;
-        const _ya = m1 * x0 + m4 * y0 + m7;
-
-        const _xb = m0 * x1 + m3 * y1 + m6;
-        const _yb = m1 * x1 + m4 * y1 + m7;
-
-        let _x0 = min2(_xa, _xb);
-        let _x1 = max2(_xa, _xb);
-
-        let _y0 = min2(_ya, _yb);
-        let _y1 = max2(_ya, _yb);
+        // Transform all 4 corners and take the min/max. Under rotation or shear the transformed extents are
+        // NOT determined by just the (x0,y0) and (x1,y1) corners — the other two diagonal corners can extend
+        // further, so transforming only two of them produces a wrong (too-small) AABB.
+        const ax = m0 * x0 + m3 * y0 + m6, ay = m1 * x0 + m4 * y0 + m7;
+        const bx = m0 * x1 + m3 * y0 + m6, by = m1 * x1 + m4 * y0 + m7;
+        const cx = m0 * x0 + m3 * y1 + m6, cy = m1 * x0 + m4 * y1 + m7;
+        const dx = m0 * x1 + m3 * y1 + m6, dy = m1 * x1 + m4 * y1 + m7;
+
+        const _x0 = min2(min2(ax, bx), min2(cx, dx));
+        const _x1 = max2(max2(ax, bx), max2(cx, dx));
+        const _y0 = min2(min2(ay, by), min2(cy, dy));
+        const _y1 = max2(max2(ay, by), max2(cy, dy));
 
         this.set(_x0, _y0, _x1, _y1);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"convex_hull_jarvis_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_jarvis_2d.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,6CAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,GACJ,MAAM,EAAE,CAqDpB"}
+{"version":3,"file":"convex_hull_jarvis_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_jarvis_2d.js"],"names":[],"mappings":"AAoBA;;;;;;;;GAQG;AACH,6CAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,GACJ,MAAM,EAAE,CA8DpB"}

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

@@ -1,6 +1,23 @@
 import { assert } from "../../../assert.js";
 import { orientation3_array } from "./orientation3_array.js";
 
+/**
+ * Squared distance between points a and b in a flat [x0,y0,x1,y1,...] array.
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function dist2_array(input, a, b) {
+    const a2 = a * 2;
+    const b2 = b * 2;
+
+    const dx = input[a2] - input[b2];
+    const dy = input[a2 + 1] - input[b2 + 1];
+
+    return dx * dx + dy * dy;
+}
+
 /**
  * Simple algorithm for computing convex hull, not the fastest, but it does the job and has very small implementation
  * Please note that the result does not repeat the first vertex, meaning that the last point is not the same as the first point
@@ -35,7 +52,9 @@ export function convex_hull_jarvis_2d(input, point_count = input.length * 0.5) {
         const x_i = input[i2];
         const x_l = input[l2];
 
-        if (x_i < x_l) {
+        // tie-break on y so a shared-minimum-x column resolves to a true hull corner rather than an
+        // interior point on the left edge (which would make the march never return and loop forever).
+        if (x_i < x_l || (x_i === x_l && input[i2 + 1] < input[l2 + 1])) {
             l = i;
         }
     }
@@ -48,7 +67,12 @@ export function convex_hull_jarvis_2d(input, point_count = input.length * 0.5) {
         q = (p + 1) % point_count;
 
         for (let i = 0; i < point_count; i++) {
-            if (orientation3_array(input, p, q, i) > 0) {
+            const o = orientation3_array(input, p, q, i);
+
+            // o > 0: i is strictly more counter-clockwise than q -> better candidate.
+            // o === 0: i is collinear with the p->q edge; pick the farther one so the march advances to the
+            //          extreme collinear point instead of getting stuck oscillating between collinear points.
+            if (o > 0 || (o === 0 && i !== p && dist2_array(input, p, i) > dist2_array(input, p, q))) {
                 q = i;
             }
         }
@@ -56,8 +80,10 @@ export function convex_hull_jarvis_2d(input, point_count = input.length * 0.5) {
         p = q;
 
     } while (
-        input[p * 2] !== input[l * 2]
-        || input[p * 2 + 1] !== input[l * 2 + 1]
+        (input[p * 2] !== input[l * 2] || input[p * 2 + 1] !== input[l * 2 + 1])
+        // safety net: a valid hull has at most point_count vertices, so if we ever exceed that we are in a
+        // degenerate cycle (e.g. duplicate coordinates) and must stop rather than grow unbounded.
+        && jarvis_vertices.length <= point_count
         );
 
     return jarvis_vertices;

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

@@ -1 +1 @@
-{"version":3,"file":"fixed_convex_hull_relaxation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js"],"names":[],"mappings":"AAmLA;;;;;;;;;;;;;;GAcG;AACH,qDAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA2FlB"}
+{"version":3,"file":"fixed_convex_hull_relaxation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js"],"names":[],"mappings":"AAmLA;;;;;;;;;;;;;;GAcG;AACH,qDAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA+FlB"}

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

@@ -239,15 +239,19 @@ export function fixed_convex_hull_relaxation(
         const edge = edges[victim];
 
         if (!collapse_edge(edge, point_buffer, point_buffer_cursor)) {
-            // couldn't collapse, re-insert with very high score
+            // couldn't collapse, re-insert with very high score so other edges are tried first
             edge_heap.insert(victim, Infinity);
 
+            retry++;
+
             if (retry >= RETRY_MAX_COUNT) {
                 console.warn('Failed to collapse an edge after maximum number of retries has been reached');
                 break;
             }
 
-            retry++;
+            // skip the post-collapse bookkeeping: the edge was NOT collapsed, so it must not be consumed
+            // (deleted / cursor-advanced / neighbour-updated) as if it had been.
+            continue;
         }
 
         retry = 0;

package/src/core/geom/2d/hash-grid/SpatialHashGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AA2BvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA6BhB;;CACJ;kCA/XiC,sDAAsD"}
+{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AA2BvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA+BhB;;CACJ;kCAjYiC,sDAAsD"}