@woosh/meep-engine 2.121.0 → 2.121.2

package/README.md

@@ -15,7 +15,7 @@ To help get you started, various samples are provided under `/samples` folder. F
 
 Meep is covered by 2,508 unit tests
 
-The aim is not to have 100% coverage, [but to ensure quality](https://about.codecov.io/blog/the-case-against-100-code-coverage/). As a result, the tests are written to cover complex code first and to exhaustively validate critical algorithms.
+The aim is to [ensure quality](https://about.codecov.io/blog/the-case-against-100-code-coverage/). As a result, the tests are written to cover complex code first and to exhaustively validate critical algorithms.
 Most of the test code is significantly larger than the code that is being tested.
 
 ## Features

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.121.0",
+  "version": "2.121.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/map/HashMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AAgGD;;;;;;;GAOG;AACH,qBAHa,CAAC,EAAC,CAAC;IAkEZ;;;;;;OAMG;IACH,6EALW,CAAS,IAAC,EAAD,GAAC,KAAE,MAAM,EAsC5B;IAtGD;;;;OAIG;IACH,QAFU,WAAW,CAED;IAEpB;;;OAGG;IACH,WAFU,KAAK,CAAC,YAAY,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAET;IAEzB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,oBAAgB;IAEhB;;;OAGG;IACH,2BAFU,MAAM,CAEc;IAE9B,iCAA6B;IAE7B,qCAAiC;IAEjC;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,WAFU,MAAM,CAEF;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAuGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,WACD,CAAS,IAAC,EAAD,CAAC,KAAE,CAAC,oBACb,GAAC,GACA,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAaZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,sCAHW,GAAC,GACC,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBA0DC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,WAFa,QAAQ,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAM3B;IAED;;;OAGG;IACH,UAFa,QAAQ,CAAC,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,QAAQ,CAAC,CAAC,CAAC,CAMvB;IA1DD,yDA2BC;;CAgCJ;AA/1BD;;GAEG;AACH,2BAFa,CAAC,EAAC,CAAC;IAGZ;;;;;OAKG;IACH,iBAJW,CAAC,SACD,CAAC,QACD,MAAM,EAsBhB;IAlBG;;;OAGG;IACH,KAFU,CAAC,CAEG;IAEd;;;OAGG;IACH,OAFU,CAAC,CAEO;IAElB;;;OAGG;IACH,MAFU,MAAM,CAEA;IAKxB,wBAAqC;CAFpC"}
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AAgGD;;;;;;;GAOG;AACH,qBAHa,CAAC,EAAC,CAAC;IAyFZ;;;;;;OAMG;IACH,6EALW,CAAS,IAAC,EAAD,GAAC,KAAE,MAAM,EAsC5B;IA7HD;;;;;OAKG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAyB;IAEzB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,oBAAgB;IAEhB;;;;OAIG;IACH,kCAA8B;IAE9B;;;;OAIG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,qCAAiC;IAEjC;;;;OAIG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,kBAAc;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD;;;OAGG;IACH,YAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAuGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA0EX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,WACD,CAAS,IAAC,EAAD,CAAC,KAAE,CAAC,oBACb,GAAC,GACA,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAaZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,sCAHW,GAAC,GACC,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBA0DC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,WAFa,QAAQ,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAM3B;IAED;;;OAGG;IACH,UAFa,QAAQ,CAAC,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,QAAQ,CAAC,CAAC,CAAC,CAMvB;IA1DD,yDA2BC;;CAgCJ"}

package/src/core/collection/map/HashMap.js

@@ -140,48 +140,70 @@ export class HashMap {
      * Index pointers to entries array,
      * number of bins is always power or two
      * @type {Uint32Array}
+     * @private
      */
     __bins = EMPTY_BINS;
 
     /**
      * Note that dead entries are marked as such with a special reserved hash values, so records can be reused for new entries
      * @type {Array<HashMapEntry<K,V>>}
+     * @private
      */
     __entries = new Array(0);
 
     /**
      * Pointer to the end of allocated entries segment
      * @type {number}
+     * @private
      */
     __entries_bound = 0;
 
     /**
      *
      * @type {number}
+     * @private
      */
     __entries_start = 0;
 
     /**
      * number of records in the map
      * @type {number}
+     * @private
      */
     __size = 0;
 
+    /**
+     *
+     * @type {number}
+     * @private
+     */
     __bin_count = 0;
 
     /**
      * Always exactly half of the number of bins
      * @type {number}
+     * @private
      */
     __entries_allocated_count = 0;
 
+    /**
+     *
+     * @type {number}
+     * @private
+     */
     __bin_count_power_of_two = 0;
 
+    /**
+     *
+     * @type {number}
+     * @private
+     */
     __entries_count_power_of_two = 0;
 
     /**
      * Mask used to map from hash to a bin index
      * @type {number}
+     * @private
      */
     __bin_count_mask = 0;
 
@@ -194,14 +216,15 @@ export class HashMap {
 
     /**
      * Used to track modifications to prevent concurrent changes during iteration
+     * @private
      * @type {number}
      */
     __version = 0;
 
     /**
      * @template K, V
-     * @param {function(K):number} [keyHashFunction]
-     * @param {function(K,K):boolean} [keyEqualityFunction]
+     * @param {function(K):number} [keyHashFunction] function to compute hash of a given key
+     * @param {function(K,K):boolean} [keyEqualityFunction] function to compute equality between two keys
      * @param {number} [capacity] initial number of buckets in the hash table
      * @param {number} [loadFactor] a measure of how full the hash table is allowed to get before its capacity is automatically increased
      */
@@ -240,6 +263,10 @@ export class HashMap {
         this.#setBinCount(ceilPowerOfTwo(capacity));
     }
 
+    /**
+     *
+     * @return {number}
+     */
     get size() {
         return this.__size;
     }

package/src/core/geom/2d/aabb/aabb2_intersects_point.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ * @return {boolean}
+ */
+export function aabb2_intersects_point(x0: number, y0: number, x1: number, y1: number, px: number, py: number): boolean;
+//# sourceMappingURL=aabb2_intersects_point.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_intersects_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_intersects_point.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,2CARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,OAAO,CAQlB"}

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

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ * @return {boolean}
+ */
+export function aabb2_intersects_point(
+    x0, y0,
+    x1, y1,
+    px, py
+) {
+    return x0 <= px && x1 >= px && y0 <= py && y1 >= py;
+}

package/src/core/geom/2d/quad-tree/QuadTreeNode.d.ts

@@ -3,7 +3,8 @@
  * @extends AABB2
  */
 export class QuadTreeNode<D> extends AABB2 {
-    constructor(x0?: number, y0?: number, x1?: number, y1?: number);
+    constructor(x0: number, y0: number, x1: number, y1: number);
+    constructor();
     /**
      *
      * @type {QuadTreeNode|null}
@@ -29,6 +30,10 @@ export class QuadTreeNode<D> extends AABB2 {
      * @type {QuadTreeNode|null}
      */
     parentNode: QuadTreeNode<any> | null;
+    /**
+     *
+     * @type {number}
+     */
     treeDataCount: number;
     /**
      *
@@ -98,12 +103,12 @@ export class QuadTreeNode<D> extends AABB2 {
     traverseData(visitor: (arg0: QuadTreeDatum<D>) => any, thisArg?: any): void;
     /**
      *
-     * @param {function(QuadTreeNode):boolean} visitor
+     * @param {function(QuadTreeNode<D>):boolean} visitor
      * @param {*} [thisArg]
      */
-    traversePreOrder(visitor: (arg0: QuadTreeNode<any>) => boolean, thisArg?: any): void;
+    traversePreOrder(visitor: (arg0: QuadTreeNode<D>) => boolean, thisArg?: any): void;
     /**
-     *
+     * @deprecated use {@link qt_collect_by_point}
      * @param {number} x
      * @param {number} y
      * @param {function(QuadTreeDatum<D>, x:number,y:number):boolean?} visitor
@@ -111,7 +116,7 @@ export class QuadTreeNode<D> extends AABB2 {
      */
     traversePointIntersections(x: number, y: number, visitor: any, thisArg?: any): void;
     /**
-     *
+     * @deprecated use {@link qt_collect_by_point} directly
      * @param {Array<QuadTreeDatum<D>>} result
      * @param {number} x
      * @param {number} y
@@ -119,7 +124,7 @@ export class QuadTreeNode<D> extends AABB2 {
      */
     requestDatumIntersectionsPoint(result: Array<QuadTreeDatum<D>>, x: number, y: number): number;
     /**
-     *
+     * @deprecated use {@link qt_collect_by_box} instead
      * @param {Array<QuadTreeDatum<D>>} result
      * @param {number} x0
      * @param {number} y0
@@ -130,6 +135,7 @@ export class QuadTreeNode<D> extends AABB2 {
     requestDatumIntersectionsRectangle(result: Array<QuadTreeDatum<D>>, x0: number, y0: number, x1: number, y1: number): number;
     /**
      * NOTE: touching is not counted as intersection
+     * @deprecated use {@link qt_collect_by_box} instead
      * @param {number} x0
      * @param {number} y0
      * @param {number} x1
@@ -138,6 +144,11 @@ export class QuadTreeNode<D> extends AABB2 {
      * @param {*} [thisArg]
      */
     traverseRectangleIntersections(x0: number, y0: number, x1: number, y1: number, visitor: (arg0: QuadTreeDatum<D>) => any, thisArg?: any): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isQuadTreeNode: boolean;
 }
 import AABB2 from "../../2d/aabb/AABB2.js";
 import { QuadTreeDatum } from "./QuadTreeDatum.js";

package/src/core/geom/2d/quad-tree/QuadTreeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QuadTreeNode.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/QuadTreeNode.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,0BAHa,CAAC;IAIV,gEAsCC;IAnCG;;;OAGG;IACH,SAFU,oBAAa,IAAI,CAER;IACnB;;;OAGG;IACH,UAFU,oBAAa,IAAI,CAEP;IACpB;;;OAGG;IACH,YAFU,oBAAa,IAAI,CAEL;IACtB;;;OAGG;IACH,aAFU,oBAAa,IAAI,CAEJ;IAEvB;;;OAGG;IACH,YAFU,oBAAa,IAAI,CAEL;IAEtB,sBAAsB;IAGtB;;;OAGG;IACH,MAFU,aAAa,CAAC,CAAC,CAAC,EAAE,CAEd;IAGlB,qBAeC;IAED,wBAYC;IAED;;;;;;OAMG;IACH,WALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;IAED;;;;;;;;OAQG;IACH,IARa,CAAC,QACH,CAAC,MACD,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,sBAWhB;IAED;;;OAGG;IACH,6CAuEC;IAED;;;OAGG;IACH,iBAaC;IAED;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cA8BC;IAED;;OAEG;IACH,mBAKC;IAED;;;OAGG;IACH,8CAiBC;IAED;;OAEG;IACH,qBA2DC;IAED,cASC;IAED,cAQC;IAED;;OAEG;IACH,mBAFW,CAAC,EAAE,QAUb;IAED;;;;OAIG;IACH,sBAHW,CAAS,IAAgB,EAAhB,aAAa,CAAC,CAAC,CAAC,QAAC,YAC1B,GAAC,QAeX;IAED;;;;OAIG;IACH,0BAHW,CAAS,IAAY,wBAAE,OAAO,YAC9B,GAAC,QAgBX;IAED;;;;;;OAMG;IACH,8BALW,MAAM,KACN,MAAM,0BAEN,GAAC,QA0CX;IAED;;;;;;OAMG;IACH,uCALW,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KACvB,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,2CAPW,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,MACvB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;;OAQG;IACH,mCAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,CAAS,IAAgB,EAAhB,aAAa,CAAC,CAAC,CAAC,QAAC,YAC1B,GAAC,QA0CX;CAEJ;kBA9jBiB,wBAAwB;8BACZ,oBAAoB"}
+{"version":3,"file":"QuadTreeNode.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/QuadTreeNode.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,0BAHa,CAAC;;;IAIV;;;OAGG;IACH,SAFU,oBAAa,IAAI,CAEZ;IACf;;;OAGG;IACH,UAFU,oBAAa,IAAI,CAEX;IAChB;;;OAGG;IACH,YAFU,oBAAa,IAAI,CAET;IAClB;;;OAGG;IACH,aAFU,oBAAa,IAAI,CAER;IAEnB;;;OAGG;IACH,YAFU,oBAAa,IAAI,CAET;IAElB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAGlB;;;OAGG;IACH,MAFU,aAAa,CAAC,CAAC,CAAC,EAAE,CAElB;IAEV,qBAeC;IAED,wBAYC;IAED;;;;;;OAMG;IACH,WALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;IAED;;;;;;;;OAQG;IACH,IARa,CAAC,QACH,CAAC,MACD,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,sBAWhB;IAED;;;OAGG;IACH,6CAuEC;IAED;;;OAGG;IACH,iBAaC;IAED;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cA8BC;IAED;;OAEG;IACH,mBAKC;IAED;;;OAGG;IACH,8CAiBC;IAED;;OAEG;IACH,qBA2DC;IAED,cASC;IAED,cAQC;IAED;;OAEG;IACH,mBAFW,CAAC,EAAE,QAUb;IAED;;;;OAIG;IACH,sBAHW,CAAS,IAAgB,EAAhB,aAAa,CAAC,CAAC,CAAC,QAAC,YAC1B,GAAC,QAeX;IAED;;;;OAIG;IACH,0BAHW,CAAS,IAAe,EAAf,YAAY,CAAC,CAAC,CAAC,KAAE,OAAO,YACjC,GAAC,QAgBX;IAED;;;;;;OAMG;IACH,8BALW,MAAM,KACN,MAAM,0BAEN,GAAC,QASX;IAED;;;;;;OAMG;IACH,uCALW,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KACvB,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,2CAPW,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,MACvB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;OASG;IACH,mCAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,CAAS,IAAgB,EAAhB,aAAa,CAAC,CAAC,CAAC,QAAC,YAC1B,GAAC,QA0CX;IAIL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC;kBAjhBiB,wBAAwB;8BAGZ,oBAAoB"}

package/src/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -2,6 +2,8 @@ import { assert } from "../../../assert.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
 import AABB2 from "../../2d/aabb/AABB2.js";
+import { qt_collect_by_box } from "./qt_collect_by_box.js";
+import { qt_collect_by_point } from "./qt_collect_by_point.js";
 import { QuadTreeDatum } from "./QuadTreeDatum.js";
 
 
@@ -13,45 +15,45 @@ const THRESHOLD_MERGE = 8;
  * @extends AABB2
  */
 export class QuadTreeNode extends AABB2 {
-    constructor(x0 = 0, y0 = 0, x1 = 0, y1 = 0) {
-        super(x0, y0, x1, y1);
-
-        /**
-         *
-         * @type {QuadTreeNode|null}
-         */
-        this.topLeft = null;
-        /**
-         *
-         * @type {QuadTreeNode|null}
-         */
-        this.topRight = null;
-        /**
-         *
-         * @type {QuadTreeNode|null}
-         */
-        this.bottomLeft = null;
-        /**
-         *
-         * @type {QuadTreeNode|null}
-         */
-        this.bottomRight = null;
+    /**
+     *
+     * @type {QuadTreeNode|null}
+     */
+    topLeft = null;
+    /**
+     *
+     * @type {QuadTreeNode|null}
+     */
+    topRight = null;
+    /**
+     *
+     * @type {QuadTreeNode|null}
+     */
+    bottomLeft = null;
+    /**
+     *
+     * @type {QuadTreeNode|null}
+     */
+    bottomRight = null;
 
-        /**
-         *
-         * @type {QuadTreeNode|null}
-         */
-        this.parentNode = null;
+    /**
+     *
+     * @type {QuadTreeNode|null}
+     */
+    parentNode = null;
 
-        this.treeDataCount = 0;
+    /**
+     *
+     * @type {number}
+     */
+    treeDataCount = 0;
 
 
-        /**
-         *
-         * @type {QuadTreeDatum<D>[]}
-         */
-        this.data = [];
-    }
+    /**
+     *
+     * @type {QuadTreeDatum<D>[]}
+     */
+    data = [];
 
     balance() {
         const dataLength = this.data.length;
@@ -174,8 +176,8 @@ export class QuadTreeNode extends AABB2 {
                 }
             }
 
-            const xm = (x0 + x1) *0.5;
-            const ym = (y0 + y1) *0.5;
+            const xm = (x0 + x1) * 0.5;
+            const ym = (y0 + y1) * 0.5;
 
             if (datum.y1 < ym) {
                 //top
@@ -417,7 +419,7 @@ export class QuadTreeNode extends AABB2 {
 
     /**
      *
-     * @param {function(QuadTreeNode):boolean} visitor
+     * @param {function(QuadTreeNode<D>):boolean} visitor
      * @param {*} [thisArg]
      */
     traversePreOrder(visitor, thisArg) {
@@ -437,75 +439,34 @@ export class QuadTreeNode extends AABB2 {
     }
 
     /**
-     *
+     * @deprecated use {@link qt_collect_by_point}
      * @param {number} x
      * @param {number} y
      * @param {function(QuadTreeDatum<D>, x:number,y:number):boolean?} visitor
      * @param {*} [thisArg]
      */
-    traversePointIntersections(x, y, visitor, thisArg) {
-        const data = this.data;
-        const dataCount = data.length;
-
-        for (let i = 0; i < dataCount; i++) {
-            const datum = data[i];
-
-            if (datum.x0 <= x && datum.x1 >= x && datum.y0 <= y && datum.y1 >= y) {
-                const continueTraversal = visitor.call(thisArg, datum, x, y);
-
-                if (continueTraversal === false) {
-                    return;
-                }
-            }
-        }
-
-        if (this.isSplit()) {
-
-            const hx = (this.x0 + this.x1) / 2;
-            const hy = (this.y0 + this.y1) / 2;
-
-            if (hx >= x) {
-                if (hy >= y) {
-                    this.topLeft.traversePointIntersections(x, y, visitor, thisArg);
-                }
-                if (hy <= y) {
-                    this.bottomLeft.traversePointIntersections(x, y, visitor, thisArg);
-                }
-            }
-
-            if (hx <= x) {
-                if (hy >= y) {
-                    this.topRight.traversePointIntersections(x, y, visitor, thisArg);
-                }
-                if (hy <= y) {
-                    this.bottomRight.traversePointIntersections(x, y, visitor, thisArg);
-                }
-            }
-
-        }
+    traversePointIntersections(
+        x,
+        y,
+        visitor,
+        thisArg
+    ) {
+        throw new Error('Deprecated, use `qt_collect_by_point` instead')
     }
 
     /**
-     *
+     * @deprecated use {@link qt_collect_by_point} directly
      * @param {Array<QuadTreeDatum<D>>} result
      * @param {number} x
      * @param {number} y
      * @returns {number} number of intersecting objects added to the result
      */
     requestDatumIntersectionsPoint(result, x, y) {
-        //TODO optimize closures out to avoid GC
-
-        let count = 0;
-
-        this.traversePointIntersections(x, y, (d) => {
-            result[count++] = d;
-        });
-
-        return count;
+        return qt_collect_by_point(result, 0, this, x, y);
     }
 
     /**
-     *
+     * @deprecated use {@link qt_collect_by_box} instead
      * @param {Array<QuadTreeDatum<D>>} result
      * @param {number} x0
      * @param {number} y0
@@ -514,18 +475,12 @@ export class QuadTreeNode extends AABB2 {
      * @returns {number} number of intersecting objects added to the result
      */
     requestDatumIntersectionsRectangle(result, x0, y0, x1, y1) {
-        let count = 0;
-
-        //TODO optimize closures out, to avoid GC
-        this.traverseRectangleIntersections(x0, y0, x1, y1, (d) => {
-            result[count++] = d;
-        });
-
-        return count;
+        return qt_collect_by_box(result, 0, this, x0, y0, x1, y1);
     }
 
     /**
      * NOTE: touching is not counted as intersection
+     * @deprecated use {@link qt_collect_by_box} instead
      * @param {number} x0
      * @param {number} y0
      * @param {number} x1
@@ -576,3 +531,9 @@ export class QuadTreeNode extends AABB2 {
     }
 
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+QuadTreeNode.prototype.isQuadTreeNode = true;

package/src/core/geom/2d/quad-tree/qt_collect_by_box.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @returns {number}
+ */
+export function qt_collect_by_box<T>(result: Array<QuadTreeDatum<T>>, result_offset: number, tree: QuadTreeNode<T>, x0: number, y0: number, x1: number, y1: number): number;
+//# sourceMappingURL=qt_collect_by_box.d.ts.map

package/src/core/geom/2d/quad-tree/qt_collect_by_box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qt_collect_by_box.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_collect_by_box.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,kCAVa,CAAC,UACH,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,iBACvB,MAAM,QACN,YAAY,CAAC,CAAC,CAAC,MACf,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAsElB"}

package/src/core/geom/2d/quad-tree/qt_collect_by_box.js

@@ -0,0 +1,90 @@
+import { assert } from "../../../assert.js";
+import { aabb2_overlap_exists } from "../aabb/aabb2_overlap_exists.js";
+
+/**
+ *
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ *
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @returns {number}
+ */
+export function qt_collect_by_box(
+    result, result_offset,
+    tree,
+    x0, y0,x1, y1
+){
+    assert.isArray(result, 'result');
+    assert.isNonNegativeInteger(result_offset, 'result_offset');
+    assert.defined(tree, 'tree');
+    assert.notNull(tree, 'tree');
+    assert.equal(tree.isQuadTreeNode, true, 'tree.isQuadTreeNode !== true');
+    assert.isNumber(x0, 'x0');
+    assert.isNumber(y0, 'y0');
+    assert.isNumber(x1, 'x1');
+    assert.isNumber(y1, 'y1');
+
+    let result_cursor = result_offset;
+
+    let stack_pointer = 1;
+
+    node_stack[0] = tree;
+
+    while (stack_pointer-- > 0) {
+
+        const node = node_stack[stack_pointer];
+
+        if (!aabb2_overlap_exists(node.x0, node.y0, node.x1, node.y1, x0, y0, x1,y1)) {
+            // not a match
+            continue;
+        }
+
+        const data = node.data;
+        const data_count = data.length;
+
+        for (let i = 0; i < data_count; i++) {
+            const datum = data[i];
+
+            if (aabb2_overlap_exists(datum.x0, datum.y0, datum.x1, datum.y1, x0, y0, x1,y1)) {
+                result[result_cursor++] = datum;
+            }
+        }
+
+        if (node.isSplit()) {
+            const hx = (node.x0 + node.x1) * 0.5;
+            const hy = (node.y0 + node.y1) * 0.5;
+
+            if (hx >= x0) {
+                if (hy >= y0) {
+                    node_stack[stack_pointer++] = node.topLeft;
+                }
+                if (hy <= y1) {
+                    node_stack[stack_pointer++] = node.bottomLeft;
+                }
+            }
+
+            if (hx <= x1) {
+                if (hy >= y0) {
+                    node_stack[stack_pointer++] = node.topRight;
+                }
+                if (hy <= y1) {
+                    node_stack[stack_pointer++] = node.bottomRight;
+                }
+            }
+
+
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/src/core/geom/2d/quad-tree/qt_collect_by_point.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ */
+export function qt_collect_by_point<T>(result: Array<QuadTreeDatum<T>>, result_offset: number, tree: QuadTreeNode<T>, x: number, y: number): number;
+//# sourceMappingURL=qt_collect_by_point.d.ts.map

package/src/core/geom/2d/quad-tree/qt_collect_by_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qt_collect_by_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_collect_by_point.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,oCARa,CAAC,UACH,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,iBACvB,MAAM,QACN,YAAY,CAAC,CAAC,CAAC,KACf,MAAM,KACN,MAAM,GACJ,MAAM,CAoElB"}