@woosh/meep-engine 2.108.4 → 2.109.1

package/build/meep.module.js

@@ -555,7 +555,7 @@ assert.isArray = function (value, name = 'value') {
 
 /**
  * @template T
- * @param {ArrayLike<T>|T[]} value
+ * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
  * @param {string} name
  */
 assert.isArrayLike = function (value, name = 'value') {
@@ -3606,7 +3606,7 @@ let Quaternion$1 = class Quaternion {
     /**
      *
      * @param {Quaternion} other
-     * @param {number} max_delta
+     * @param {number} max_delta in radians
      */
     rotateTowards(other, max_delta) {
         Quaternion.rotateTowards(this, this, other, max_delta);
@@ -4985,6 +4985,19 @@ class Transform {
         return result;
     }
 
+    /**
+     *
+     * @param {number[]|Float32Array} mat
+     * @returns {Transform}
+     */
+    static fromMatrix(mat) {
+        const result = new Transform();
+
+        result.fromMatrix4(mat);
+
+        return result;
+    }
+
     /**
      * Multiply two transforms, result it written into this one
      * @param {Transform} a
@@ -4998,17 +5011,18 @@ class Transform {
 
     /**
      *
-     * @param {mat4|number[]|Float32Array} m
+     * @param {mat4|number[]|Float32Array} matrix
      */
-    fromMatrix4(m) {
+    fromMatrix4(matrix) {
+
         // we know we are changing the matrix, so we're going to need to disable the flag that sets matrix from position/rotation/scale changes
         const ad = this.getFlag(TransformFlags.AutomaticChangeDetection);
 
         this.clearFlag(TransformFlags.AutomaticChangeDetection);
 
-        this.matrix.set(m);
+        this.matrix.set(matrix);
 
-        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+        decompose_matrix_4_array(matrix, this.position, this.rotation, this.scale);
 
         // restore value of the flag
         this.writeFlag(TransformFlags.AutomaticChangeDetection, ad);
@@ -59939,7 +59953,7 @@ const DEFAULT_INITIAL_CAPACITY_POWER = 4;
  * @readonly
  * @type {number}
  */
-const DEFAULT_INITIAL_CAPACITY = 2 ** DEFAULT_INITIAL_CAPACITY_POWER;
+const DEFAULT_INITIAL_CAPACITY$1 = 2 ** DEFAULT_INITIAL_CAPACITY_POWER;
 
 /**
  * @readonly
@@ -60068,7 +60082,7 @@ class HashMap {
     constructor({
                     keyHashFunction = invokeObjectHash,
                     keyEqualityFunction = invokeObjectEquals,
-                    capacity = DEFAULT_INITIAL_CAPACITY,
+                    capacity = DEFAULT_INITIAL_CAPACITY$1,
                     loadFactor = DEFAULT_LOAD_FACTOR
                 } = {}) {
 
@@ -69341,6 +69355,36 @@ function computeSystemName(system) {
     return system.constructor.name;
 }
 
+/**
+ *
+ * @param {Object3D} object
+ */
+function threeUpdateMatrix(object) {
+    object.updateMatrix();
+
+    const children = object.children;
+    for (let i = 0, childCount = children.length; i < childCount; i++) {
+        const child = children[i];
+
+        threeUpdateMatrix(child);
+    }
+}
+
+/**
+ *
+ * @param {Object3D} object3
+ */
+function threeUpdateTransform(object3) {
+
+    /**
+     signal that transformation matrix should be updated
+     @see https://threejs.org/docs/index.html#api/core/Object3D.matrixWorldNeedsUpdate
+     */
+    threeUpdateMatrix(object3);
+
+    object3.updateMatrixWorld(false);
+}
+
 /**
  *
  * @param {Camera} c
@@ -70087,50 +70131,43 @@ function set_camera_aspect_ratio(camera, width, height) {
 
 /**
  *
- * @param {Object3D} object
+ * @param {Camera} camera
  */
-function threeUpdateMatrix(object) {
-    object.updateMatrix();
+function update_camera_transform(camera) {
 
-    const children = object.children;
-    for (let i = 0, childCount = children.length; i < childCount; i++) {
-        const child = children[i];
+    const three_camera = camera.object;
 
-        threeUpdateMatrix(child);
+    if (three_camera === null) {
+        return;
     }
+
+    three_camera.updateProjectionMatrix();
+    threeUpdateTransform(three_camera);
 }
 
 /**
  *
- * @param {Object3D} object3
+ * @param {THREE.Camera} object
+ * @param {Quaternion} rotation
  */
-function threeUpdateTransform(object3) {
+function three_camera_set_transform_rotation(object, rotation) {
 
-    /**
-     signal that transformation matrix should be updated
-     @see https://threejs.org/docs/index.html#api/core/Object3D.matrixWorldNeedsUpdate
+    /*
+    NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
+    See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
      */
-    threeUpdateMatrix(object3);
 
-    object3.updateMatrixWorld(false);
-}
-
-/**
- *
- * @param {Camera} camera
- */
-function update_camera_transform(camera) {
+    invertQuaternionOrientation(object.quaternion, rotation);
 
-    const three_camera = camera.object;
+    object.rotation.setFromQuaternion(object.quaternion);
 
-    if (three_camera === null) {
-        return;
-    }
+    // rotation.__setThreeEuler(camera.object.rotation); // seems unnecessary, based on Object3D.lookAt implementation
+    // camera.object.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+
+    object.updateProjectionMatrix();
+    threeUpdateTransform(object);
+}
 
-    three_camera.updateProjectionMatrix();
-    threeUpdateTransform(three_camera);
-}
-
 class CameraSystem extends System {
     /**
      *
@@ -70219,19 +70256,7 @@ class CameraSystem extends System {
         function synchronizeRotation() {
             const rotation = transform.rotation;
 
-            /*
-            NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
-            See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
-             */
-
-            invertQuaternionOrientation(camera.object.quaternion, rotation);
-
-            camera.object.rotation.setFromQuaternion(camera.object.quaternion);
-
-            // rotation.__setThreeEuler(camera.object.rotation); // seems unnecessary, based on Object3D.lookAt implementation
-            // camera.object.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
-
-            update_camera_transform(camera);
+            three_camera_set_transform_rotation(camera.object, rotation);
         }
 
         function rebuild() {
@@ -70750,16 +70775,25 @@ const EntityFlags = {
     WatchDestruction: 4
 };
 
+/**
+ * Align to the nearest number divisible by 32, rounding up
+ * @param {number} n
+ * @returns {number}
+ */
+function align_32(n) {
+    return ((n + 31) >>> 5) << 5
+}
+
 /**
  * de Bruijn sequence
  * @see https://graphics.stanford.edu/~seander/bithacks.html
  * @type {Uint8Array}
  */
-const msb_lut = new Uint8Array([
+const msb_lut_de_bruijn = new Uint8Array([
     0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
     31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
-]);
-
+]);
+
 /**
  * Get index of the least significant set bit
  * Also known as ctz32 or "count trailing zeroes"
@@ -70768,9 +70802,9 @@ const msb_lut = new Uint8Array([
  * @returns {number}
  */
 function lsb_32(v) {
-    return msb_lut[((v & -v) * 0x077CB531) >>> 27];
-}
-
+    return msb_lut_de_bruijn[((v & -v) * 0x077CB531) >>> 27];
+}
+
 /**
  * Used for overallocating space when bit set needs to grow
  * @constant
@@ -70791,12 +70825,20 @@ const SHRINK_FACTOR$1 = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_INITIAL_CAPACITY = 64;
+
 class BitSet {
     /**
      * Dynamically sized bit field
      * @constructor
+     * @param {number} [initial_capacity]
      */
-    constructor() {
+    constructor(initial_capacity = DEFAULT_INITIAL_CAPACITY) {
+
         /**
          * Number of bits currently in use
          * @private
@@ -70809,7 +70851,7 @@ class BitSet {
          * @private
          * @type {number}
          */
-        this.__capacity = 64;
+        this.__capacity = align_32(initial_capacity);
 
         /**
          * Uint32-backed storage
@@ -71335,9 +71377,7 @@ class BitSet {
      * @returns {BitSet}
      */
     static fixedSize(x) {
-        const r = new BitSet();
-
-        r.setCapacity(x);
+        const r = new BitSet(x);
 
         //prevent resizing
         r.__shrinkFactor = 0;

package/package.json

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

package/src/core/assert.d.ts

@@ -79,10 +79,10 @@ export namespace assert {
     export function isArray<T>(value: T[], name?: string): void;
     /**
      * @template T
-     * @param {ArrayLike<T>|T[]} value
+     * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
      * @param {string} name
      */
-    export function isArrayLike<T>(value: ArrayLike<T> | T[], name?: string): void;
+    export function isArrayLike<T>(value: Uint32Array | Float32Array | ArrayLike<T> | T[], name?: string): void;
     /**
      *
      * @param {*} value

package/src/core/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA+BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,+EAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAfD,qDAOC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA+BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,4GAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAfD,qDAOC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}

package/src/core/assert.js

@@ -334,7 +334,7 @@ assert.isArray = function (value, name = 'value') {
 
 /**
  * @template T
- * @param {ArrayLike<T>|T[]} value
+ * @param {ArrayLike<T>|T[]|Uint32Array|Float32Array} value
  * @param {string} name
  */
 assert.isArrayLike = function (value, name = 'value') {

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

@@ -5,6 +5,12 @@ export class BitSet {
      * @returns {BitSet}
      */
     static fixedSize(x: number): BitSet;
+    /**
+     * Dynamically sized bit field
+     * @constructor
+     * @param {number} [initial_capacity]
+     */
+    constructor(initial_capacity?: number);
     /**
      * Number of bits currently in use
      * @private

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

@@ -1 +1 @@
-{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AA6DA;IAsiBI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAWlB;IA9iBG;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,mBAAoB;IAEpB;;;;OAIG;IACH,sBAA0D;IAE1D;;OAEG;IACH,gBAFU,MAAM,CAEmB;IAGvC,sBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAsBC;IAED,uBAMC;IAED;;;;OAIG;IACH,oBAyBC;IAED;;;;OAIG;IACH,oCAqCC;IAED;;;;OAIG;IACH,4BAFa,MAAM,CAuDlB;IAED;;;;OAIG;IACH,8BAFa,MAAM,CAkDlB;IAED;;;;OAIG;IACH,0BAFW,OAAO,QAmCjB;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,YACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,YACN,MAAM,QAShB;IAED;;;OAGG;IACH,SAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFa,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;CAiBJ"}
+{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AAgCA;IAyiBI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CASlB;IApjBD;;;;OAIG;IACH,+BAFW,MAAM,EA8BhB;IAzBG;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,mBAA4C;IAE5C;;;;OAIG;IACH,sBAA0D;IAE1D;;OAEG;IACH,gBAFU,MAAM,CAEmB;IAGvC,sBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAsBC;IAED,uBAMC;IAED;;;;OAIG;IACH,oBAyBC;IAED;;;;OAIG;IACH,oCAqCC;IAED;;;;OAIG;IACH,4BAFa,MAAM,CAuDlB;IAED;;;;OAIG;IACH,8BAFa,MAAM,CAkDlB;IAED;;;;OAIG;IACH,0BAFW,OAAO,QAmCjB;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,YACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,YACN,MAAM,QAShB;IAED;;;OAGG;IACH,SAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFa,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;CAeJ"}

package/src/core/binary/BitSet.js

@@ -1,43 +1,8 @@
 import { assert } from "../assert.js";
 import { max3 } from "../math/max3.js";
 import { min2 } from "../math/min2.js";
-
-/**
- * de Bruijn sequence
- * @see https://graphics.stanford.edu/~seander/bithacks.html
- * @type {Uint8Array}
- */
-const msb_lut = new Uint8Array([
-    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
-    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
-]);
-
-/**
- * get most significant set bit
- * @see https://graphics.stanford.edu/~seander/bithacks.html
- * @param {number} v 32 bit integer
- * @returns {number} integer position of most significant bit
- */
-function msb_32(v) {
-    v |= v >>> 1;
-    v |= v >>> 2;
-    v |= v >>> 4;
-    v |= v >>> 8;
-    v |= v >>> 16;
-    v = (v >>> 1) + 1;
-    return msb_lut[(v * 0x077CB531) >>> 27];
-}
-
-/**
- * Get index of the least significant set bit
- * Also known as ctz32 or "count trailing zeroes"
- * @see https://graphics.stanford.edu/~seander/bithacks.html
- * @param {number} v
- * @returns {number}
- */
-function lsb_32(v) {
-    return msb_lut[((v & -v) * 0x077CB531) >>> 27];
-}
+import { align_32 } from "./align_32.js";
+import { lsb_32 } from "./lsb_32.js";
 
 /**
  * Used for overallocating space when bit set needs to grow
@@ -59,12 +24,21 @@ const SHRINK_FACTOR = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_INITIAL_CAPACITY = 64;
+
 export class BitSet {
     /**
      * Dynamically sized bit field
      * @constructor
+     * @param {number} [initial_capacity]
      */
-    constructor() {
+    constructor(initial_capacity = DEFAULT_INITIAL_CAPACITY) {
+        assert.isNonNegativeInteger(initial_capacity, 'initial_capacity');
+
         /**
          * Number of bits currently in use
          * @private
@@ -77,7 +51,7 @@ export class BitSet {
          * @private
          * @type {number}
          */
-        this.__capacity = 64;
+        this.__capacity = align_32(initial_capacity);
 
         /**
          * Uint32-backed storage
@@ -615,9 +589,7 @@ export class BitSet {
      * @returns {BitSet}
      */
     static fixedSize(x) {
-        const r = new BitSet();
-
-        r.setCapacity(x);
+        const r = new BitSet(x);
 
         //prevent resizing
         r.__shrinkFactor = 0;

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

@@ -0,0 +1,7 @@
+/**
+ * Align to the nearest number divisible by 32, rounding up
+ * @param {number} n
+ * @returns {number}
+ */
+export function align_32(n: number): number;
+//# sourceMappingURL=align_32.d.ts.map

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

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

package/src/core/binary/align_32.js

@@ -0,0 +1,8 @@
+/**
+ * Align to the nearest number divisible by 32, rounding up
+ * @param {number} n
+ * @returns {number}
+ */
+export function align_32(n) {
+    return ((n + 31) >>> 5) << 5
+}

package/src/core/binary/align_32.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=align_32.spec.d.ts.map

package/src/core/binary/align_32.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align_32.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/align_32.spec.js"],"names":[],"mappings":""}

package/src/core/binary/align_32.spec.js

@@ -0,0 +1,11 @@
+import { align_32 } from "./align_32.js";
+
+test("basics", () => {
+    expect(align_32(0)).toBe(0);
+    expect(align_32(1)).toBe(32);
+    expect(align_32(31)).toBe(32);
+    expect(align_32(32)).toBe(32);
+    expect(align_32(33)).toBe(64);
+    expect(align_32(63)).toBe(64);
+    expect(align_32(64)).toBe(64);
+});

package/src/core/binary/align_4.js

@@ -11,4 +11,5 @@ export function align_4(n) {
     assert.greaterThanOrEqual(result, n, 'aligned result must be >= input');
 
     return result;
-}
+}
+

package/src/core/binary/align_4.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=align_4.spec.d.ts.map

package/src/core/binary/align_4.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align_4.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/align_4.spec.js"],"names":[],"mappings":""}

package/src/core/binary/align_4.spec.js

@@ -0,0 +1,20 @@
+import { align_4 } from "./align_4.js";
+
+test("basics", () => {
+
+    expect(align_4(0)).toBe(0);
+    expect(align_4(1)).toBe(4);
+    expect(align_4(3)).toBe(4);
+    expect(align_4(4)).toBe(4);
+
+    expect(align_4(5)).toBe(8);
+    expect(align_4(6)).toBe(8);
+    expect(align_4(7)).toBe(8);
+    expect(align_4(8)).toBe(8);
+
+    expect(align_4(9)).toBe(12);
+    expect(align_4(10)).toBe(12);
+    expect(align_4(11)).toBe(12);
+    expect(align_4(12)).toBe(12);
+
+});

package/src/core/binary/{de_interleave_bits_by_2.d.ts → de_interleave_2_bits.d.ts}

@@ -4,4 +4,4 @@
  * @returns {number} Odd bits end up in lower 16 bits, even bits end up in top part
  */
 export function de_interleave_2_bits(interleaved: number): number;
-//# sourceMappingURL=de_interleave_bits_by_2.d.ts.map
+//# sourceMappingURL=de_interleave_2_bits.d.ts.map

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

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

package/src/core/binary/de_interleave_2_bits.spec.js

@@ -1,4 +1,4 @@
-import { de_interleave_2_bits } from "./de_interleave_bits_by_2.js";
+import { de_interleave_2_bits } from "./de_interleave_2_bits.js";
 
 test("deinterleave 0", () => {
 

package/src/core/binary/hex2dec.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hex2dec.spec.d.ts.map

package/src/core/binary/hex2dec.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex2dec.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/hex2dec.spec.js"],"names":[],"mappings":""}

package/src/core/binary/hex2dec.spec.js

@@ -0,0 +1,22 @@
+import { hex2dec } from "./hex2dec.js";
+
+test("basics", () => {
+
+    expect(hex2dec("0")).toBe(0)
+    expect(hex2dec("1")).toBe(1)
+    expect(hex2dec("2")).toBe(2)
+    expect(hex2dec("3")).toBe(3)
+    expect(hex2dec("4")).toBe(4)
+    expect(hex2dec("5")).toBe(5)
+    expect(hex2dec("6")).toBe(6)
+    expect(hex2dec("7")).toBe(7)
+    expect(hex2dec("8")).toBe(8)
+    expect(hex2dec("9")).toBe(9)
+    expect(hex2dec("A")).toBe(0xA)
+    expect(hex2dec("B")).toBe(0xB)
+    expect(hex2dec("C")).toBe(0xC)
+    expect(hex2dec("D")).toBe(0xD)
+    expect(hex2dec("E")).toBe(0xE)
+    expect(hex2dec("F")).toBe(0xF)
+
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Get index of the least significant set bit
+ * Also known as ctz32 or "count trailing zeroes"
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} v
+ * @returns {number}
+ */
+export function lsb_32(v: number): number;
+//# sourceMappingURL=lsb_32.d.ts.map

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

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

package/src/core/binary/lsb_32.js

@@ -0,0 +1,12 @@
+import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
+
+/**
+ * Get index of the least significant set bit
+ * Also known as ctz32 or "count trailing zeroes"
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @param {number} v
+ * @returns {number}
+ */
+export function lsb_32(v) {
+    return msb_lut_de_bruijn[((v & -v) * 0x077CB531) >>> 27];
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=msb_32.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"msb_32.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_32.js"],"names":[],"mappings":""}

package/src/core/binary/msb_32.js

@@ -0,0 +1,20 @@
+import { msb_lut_de_bruijn } from "./msb_lut_de_bruijn.js";
+
+/**
+ * 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
+ */
+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];
+}

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

@@ -0,0 +1,7 @@
+/**
+ * de Bruijn sequence
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @type {Uint8Array}
+ */
+export const msb_lut_de_bruijn: Uint8Array;
+//# sourceMappingURL=msb_lut_de_bruijn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"msb_lut_de_bruijn.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/msb_lut_de_bruijn.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,gCAFU,UAAU,CAKjB"}

package/src/core/binary/msb_lut_de_bruijn.js

@@ -0,0 +1,9 @@
+/**
+ * de Bruijn sequence
+ * @see https://graphics.stanford.edu/~seander/bithacks.html
+ * @type {Uint8Array}
+ */
+export const msb_lut_de_bruijn = new Uint8Array([
+    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
+    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
+]);

package/src/core/binary/split_by_2.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=split_by_2.spec.d.ts.map

package/src/core/binary/split_by_2.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split_by_2.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/split_by_2.spec.js"],"names":[],"mappings":""}