@woosh/meep-engine 3.60.6 → 3.60.8

package/src/core/binary/zstd/zstd_huffman.js

@@ -1,244 +1,246 @@
-import { ZstdReverseBitReader } from "./ZstdReverseBitReader.js";
-import { zstd_read_fse_table } from "./zstd_fse.js";
-
-/**
- * The widest Huffman code Zstandard allows for literals.
- *
- * @readonly
- * @type {number}
- */
-const MAX_CODE_BITS = 11;
-
-/**
- * The widest accuracy log an FSE table coding Huffman weights may declare.
- *
- * @readonly
- * @type {number}
- */
-const WEIGHT_MAX_ACCURACY_LOG = 6;
-
-/**
- * A Huffman decoding table for literals, as a flat lookup over the widest code.
- *
- * Every code is padded out to {@link MAX_CODE_BITS} and every padding of it points at the same
- * symbol, so decoding is one array read and a subtraction rather than a walk. A table is 2048 entries
- * and is built once per block at most.
- *
- * @typedef {object} ZstdHuffmanTable
- * @property {number} max_bits the widest code actually present
- * @property {Uint8Array} symbol indexed by the next `max_bits` bits
- * @property {Uint8Array} bits how many of them the code actually used
- */
-
-/**
- * Turn a set of per-symbol weights into a decoding table.
- *
- * A weight is a *rank*, not a code length: a symbol of weight `w` gets a code of
- * `max_weight + 1 - w` bits, so the largest weight is the shortest code. Codes are then handed out
- * shortest-last — sorted by weight, and by symbol within a weight — which is what makes the
- * assignment canonical and the encoder's and decoder's agree.
- *
- * @param {Uint8Array} weights one per symbol
- * @param {number} count how many symbols `weights` describes
- * @returns {ZstdHuffmanTable}
- * @throws {Error} for weights whose implied code space is not exactly filled
- */
-function table_from_weights(weights, count) {
-    let total = 0;
-
-    for (let i = 0; i < count; i++) {
-        if (weights[i] > 0) {
-            total += 1 << (weights[i] - 1);
-        }
-    }
-
-    if (total === 0) {
-        throw new Error("zstd: a Huffman table describes no symbols");
-    }
-
-    /*
-     The last symbol's weight is not transmitted. It is whatever fills the code space to the next
-     power of two — which is why the encoder can leave it out, and why a corrupt weight set shows up
-     here as a total that is already past that power.
-    */
-    const max_bits = 32 - Math.clz32(total);
-    const last = (1 << max_bits) - total;
-
-    if (last === 0 || (last & (last - 1)) !== 0) {
-        throw new Error(
-            "zstd: a Huffman weight set leaves a code space the final symbol cannot fill"
-        );
-    }
-
-    const all = new Uint8Array(count + 1);
-
-    all.set(weights.subarray(0, count));
-
-    all[count] = 32 - Math.clz32(last);
-
-    const symbol_count = count + 1;
-
-    const size = 1 << max_bits;
-
-    const symbol = new Uint8Array(size);
-    const bits = new Uint8Array(size);
-
-    /*
-     Codes are assigned by ascending weight — so descending code length — and by symbol within a
-     weight. Filling the table means writing every padding of a code, which is what turns the decode
-     into a single lookup.
-    */
-    let position = 0;
-
-    for (let weight = 1; weight <= max_bits; weight++) {
-        const length = max_bits + 1 - weight;
-
-        for (let s = 0; s < symbol_count; s++) {
-            if (all[s] !== weight) {
-                continue;
-            }
-
-            const span = 1 << (max_bits - length);
-
-            symbol.fill(s, position, position + span);
-            bits.fill(length, position, position + span);
-
-            position += span;
-        }
-    }
-
-    if (position !== size) {
-        throw new Error("zstd: a Huffman weight set does not fill its code space exactly");
-    }
-
-    return { max_bits, symbol, bits };
-}
-
-/**
- * Read a Huffman tree description and build its table.
- *
- * The weights are themselves either written out at four bits each or FSE-coded — and the FSE case
- * runs *two interleaved states over one distribution*, one taking the even-indexed weights and one
- * the odd, which is the only place in the format that does so.
- *
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {number} end one past the last readable byte
- * @returns {{table: ZstdHuffmanTable, byte_length: number}}
- * @throws {Error} for a description that runs past `end` or does not describe a valid tree
- *
- * @see RFC 8878, section 4.2.1
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function zstd_read_huffman_table(data, offset, end) {
-    const header = data[offset];
-
-    const weights = new Uint8Array(255);
-
-    if (header >= 128) {
-        // written out, two weights to a byte, the first in the high nibble
-        const count = header - 127;
-
-        for (let i = 0; i < count; i++) {
-            const byte = data[offset + 1 + (i >> 1)];
-
-            weights[i] = (i & 1) === 0 ? (byte >> 4) : (byte & 15);
-        }
-
-        return {
-            table: table_from_weights(weights, count),
-            byte_length: 1 + ((count + 1) >> 1),
-        };
-    }
-
-    const compressed_end = offset + 1 + header;
-
-    if (compressed_end > end) {
-        throw new Error(
-            `zstd: a Huffman tree description claims ${header} bytes and only`
-            + ` ${end - offset - 1} remain in the block`
-        );
-    }
-
-    const { table: fse, byte_length: fse_bytes } = zstd_read_fse_table(
-        data, offset + 1, compressed_end, 255, WEIGHT_MAX_ACCURACY_LOG
-    );
-
-    const reader = new ZstdReverseBitReader().init(
-        data, offset + 1 + fse_bytes, header - fse_bytes
-    );
-
-    let state1 = reader.read(fse.accuracy_log);
-    let state2 = reader.read(fse.accuracy_log);
-
-    let count = 0;
-
-    /*
-     **The number of weights is not transmitted; running out of bits is what ends the stream.** Each
-     turn takes the symbol the state currently names and *then* advances that state, which is the
-     order every FSE decode uses — and the advance is allowed to read past the start of the stream,
-     where the reader supplies zeros. Once it has, the other state's pending symbol is taken and the
-     description is complete.
-
-     Checking before the advance instead, or checking whether the *other* state could advance, both
-     produce a weight set that is right for most of its length and wrong near the end.
-    */
-    for (; ;) {
-        if (count >= 254) {
-            throw new Error("zstd: a Huffman tree description codes more than 255 weights");
-        }
-
-        weights[count++] = fse.symbol[state1];
-
-        state1 = fse.baseline[state1] + reader.read(fse.bits[state1]);
-
-        if (reader.remaining < 0) {
-            weights[count++] = fse.symbol[state2];
-
-            break;
-        }
-
-        weights[count++] = fse.symbol[state2];
-
-        state2 = fse.baseline[state2] + reader.read(fse.bits[state2]);
-
-        if (reader.remaining < 0) {
-            weights[count++] = fse.symbol[state1];
-
-            break;
-        }
-    }
-
-    return { table: table_from_weights(weights, count), byte_length: 1 + header };
-}
-
-/**
- * Decode one Huffman-coded stream into `out`.
- *
- * @param {ZstdHuffmanTable} table
- * @param {Uint8Array} data
- * @param {number} offset
- * @param {number} byte_length
- * @param {Uint8Array} out
- * @param {number} out_offset
- * @param {number} count symbols to produce
- * @throws {Error} for a stream that does not end exactly where its symbols run out
- */
-export function zstd_decode_huffman_stream(
-    table, data, offset, byte_length, out, out_offset, count
-) {
-    const reader = new ZstdReverseBitReader().init(data, offset, byte_length);
-
-    for (let i = 0; i < count; i++) {
-        /*
-         The lookup is over the widest code, so what is peeked is a code plus whatever followed it.
-         The table says how many of those bits the code actually was, and only those are consumed.
-        */
-        const index = reader.peek(table.max_bits);
-
-        out[out_offset + i] = table.symbol[index];
-
-        reader.consume(table.bits[index]);
-    }
-}
+import { ZstdReverseBitReader } from "./ZstdReverseBitReader.js";
+import { zstd_read_fse_table } from "./zstd_fse.js";
+import { msb_32 } from "../msb_32.js";
+import { isPowerOfTwo } from "../../math/isPowerOfTwo.js";
+
+/**
+ * The widest Huffman code Zstandard allows for literals.
+ *
+ * @readonly
+ * @type {number}
+ */
+const MAX_CODE_BITS = 11;
+
+/**
+ * The widest accuracy log an FSE table coding Huffman weights may declare.
+ *
+ * @readonly
+ * @type {number}
+ */
+const WEIGHT_MAX_ACCURACY_LOG = 6;
+
+/**
+ * A Huffman decoding table for literals, as a flat lookup over the widest code.
+ *
+ * Every code is padded out to {@link MAX_CODE_BITS} and every padding of it points at the same
+ * symbol, so decoding is one array read and a subtraction rather than a walk. A table is 2048 entries
+ * and is built once per block at most.
+ *
+ * @typedef {object} ZstdHuffmanTable
+ * @property {number} max_bits the widest code actually present
+ * @property {Uint8Array} symbol indexed by the next `max_bits` bits
+ * @property {Uint8Array} bits how many of them the code actually used
+ */
+
+/**
+ * Turn a set of per-symbol weights into a decoding table.
+ *
+ * A weight is a *rank*, not a code length: a symbol of weight `w` gets a code of
+ * `max_weight + 1 - w` bits, so the largest weight is the shortest code. Codes are then handed out
+ * shortest-last — sorted by weight, and by symbol within a weight — which is what makes the
+ * assignment canonical and the encoder's and decoder's agree.
+ *
+ * @param {Uint8Array} weights one per symbol
+ * @param {number} count how many symbols `weights` describes
+ * @returns {ZstdHuffmanTable}
+ * @throws {Error} for weights whose implied code space is not exactly filled
+ */
+function table_from_weights(weights, count) {
+    let total = 0;
+
+    for (let i = 0; i < count; i++) {
+        if (weights[i] > 0) {
+            total += 1 << (weights[i] - 1);
+        }
+    }
+
+    if (total === 0) {
+        throw new Error("zstd: a Huffman table describes no symbols");
+    }
+
+    /*
+     The last symbol's weight is not transmitted. It is whatever fills the code space to the next
+     power of two — which is why the encoder can leave it out, and why a corrupt weight set shows up
+     here as a total that is already past that power.
+    */
+    const max_bits = msb_32(total) + 1;
+    const last = (1 << max_bits) - total;
+
+    if (last === 0 || !isPowerOfTwo(last)) {
+        throw new Error(
+            "zstd: a Huffman weight set leaves a code space the final symbol cannot fill"
+        );
+    }
+
+    const all = new Uint8Array(count + 1);
+
+    all.set(weights.subarray(0, count));
+
+    all[count] = msb_32(last) + 1;
+
+    const symbol_count = count + 1;
+
+    const size = 1 << max_bits;
+
+    const symbol = new Uint8Array(size);
+    const bits = new Uint8Array(size);
+
+    /*
+     Codes are assigned by ascending weight — so descending code length — and by symbol within a
+     weight. Filling the table means writing every padding of a code, which is what turns the decode
+     into a single lookup.
+    */
+    let position = 0;
+
+    for (let weight = 1; weight <= max_bits; weight++) {
+        const length = max_bits + 1 - weight;
+
+        for (let s = 0; s < symbol_count; s++) {
+            if (all[s] !== weight) {
+                continue;
+            }
+
+            const span = 1 << (max_bits - length);
+
+            symbol.fill(s, position, position + span);
+            bits.fill(length, position, position + span);
+
+            position += span;
+        }
+    }
+
+    if (position !== size) {
+        throw new Error("zstd: a Huffman weight set does not fill its code space exactly");
+    }
+
+    return { max_bits, symbol, bits };
+}
+
+/**
+ * Read a Huffman tree description and build its table.
+ *
+ * The weights are themselves either written out at four bits each or FSE-coded — and the FSE case
+ * runs *two interleaved states over one distribution*, one taking the even-indexed weights and one
+ * the odd, which is the only place in the format that does so.
+ *
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {number} end one past the last readable byte
+ * @returns {{table: ZstdHuffmanTable, byte_length: number}}
+ * @throws {Error} for a description that runs past `end` or does not describe a valid tree
+ *
+ * @see RFC 8878, section 4.2.1
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function zstd_read_huffman_table(data, offset, end) {
+    const header = data[offset];
+
+    const weights = new Uint8Array(255);
+
+    if (header >= 128) {
+        // written out, two weights to a byte, the first in the high nibble
+        const count = header - 127;
+
+        for (let i = 0; i < count; i++) {
+            const byte = data[offset + 1 + (i >> 1)];
+
+            weights[i] = (i & 1) === 0 ? (byte >> 4) : (byte & 15);
+        }
+
+        return {
+            table: table_from_weights(weights, count),
+            byte_length: 1 + ((count + 1) >> 1),
+        };
+    }
+
+    const compressed_end = offset + 1 + header;
+
+    if (compressed_end > end) {
+        throw new Error(
+            `zstd: a Huffman tree description claims ${header} bytes and only`
+            + ` ${end - offset - 1} remain in the block`
+        );
+    }
+
+    const { table: fse, byte_length: fse_bytes } = zstd_read_fse_table(
+        data, offset + 1, compressed_end, 255, WEIGHT_MAX_ACCURACY_LOG
+    );
+
+    const reader = new ZstdReverseBitReader().init(
+        data, offset + 1 + fse_bytes, header - fse_bytes
+    );
+
+    let state1 = reader.read(fse.accuracy_log);
+    let state2 = reader.read(fse.accuracy_log);
+
+    let count = 0;
+
+    /*
+     **The number of weights is not transmitted; running out of bits is what ends the stream.** Each
+     turn takes the symbol the state currently names and *then* advances that state, which is the
+     order every FSE decode uses — and the advance is allowed to read past the start of the stream,
+     where the reader supplies zeros. Once it has, the other state's pending symbol is taken and the
+     description is complete.
+
+     Checking before the advance instead, or checking whether the *other* state could advance, both
+     produce a weight set that is right for most of its length and wrong near the end.
+    */
+    for (; ;) {
+        if (count >= 254) {
+            throw new Error("zstd: a Huffman tree description codes more than 255 weights");
+        }
+
+        weights[count++] = fse.symbol[state1];
+
+        state1 = fse.baseline[state1] + reader.read(fse.bits[state1]);
+
+        if (reader.remaining < 0) {
+            weights[count++] = fse.symbol[state2];
+
+            break;
+        }
+
+        weights[count++] = fse.symbol[state2];
+
+        state2 = fse.baseline[state2] + reader.read(fse.bits[state2]);
+
+        if (reader.remaining < 0) {
+            weights[count++] = fse.symbol[state1];
+
+            break;
+        }
+    }
+
+    return { table: table_from_weights(weights, count), byte_length: 1 + header };
+}
+
+/**
+ * Decode one Huffman-coded stream into `out`.
+ *
+ * @param {ZstdHuffmanTable} table
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {number} byte_length
+ * @param {Uint8Array} out
+ * @param {number} out_offset
+ * @param {number} count symbols to produce
+ * @throws {Error} for a stream that does not end exactly where its symbols run out
+ */
+export function zstd_decode_huffman_stream(
+    table, data, offset, byte_length, out, out_offset, count
+) {
+    const reader = new ZstdReverseBitReader().init(data, offset, byte_length);
+
+    for (let i = 0; i < count; i++) {
+        /*
+         The lookup is over the widest code, so what is peeked is a code plus whatever followed it.
+         The table says how many of those bits the code actually was, and only those are consumed.
+        */
+        const index = reader.peek(table.max_bits);
+
+        out[out_offset + i] = table.symbol[index];
+
+        reader.consume(table.bits[index]);
+    }
+}

package/src/core/bvh2/binary/2/BinaryUint32BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;;;;;;;GAOG;AACH;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,8BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,MAAM,CASjB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAqElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}
+{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;;;;;;;GAOG;AACH;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,8BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,MAAM,CASjB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAqElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cA2EC;CACJ"}

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -7,6 +7,7 @@ import { aabb3_array_combine } from "../../../geom/3d/aabb/aabb3_array_combine.j
 import { aabb3_array_set } from "../../../geom/3d/aabb/aabb3_array_set.js";
 import { aabb3_half_surface_area_extents } from "../../../geom/3d/aabb/aabb3_half_surface_area_extents.js";
 import { v3_morton_encode_bounded } from "../../../geom/3d/morton/v3_morton_encode_bounded.js";
+import { msb_32 } from "../../../binary/msb_32.js";
 
 /**
  * @readonly
@@ -428,12 +429,17 @@ export class BinaryUint32BVH {
 
         const leaf_node_block_address = binary_node_count * BVH_BINARY_NODE_SIZE;
 
-        let level = Math.floor(Math.log(binary_node_count) / Math.log(2));
+        if (binary_node_count === 0) {
+            // no leaves, nothing to build
+            return;
+        }
+
+        let level = msb_32(binary_node_count);
 
         let i, offset, level_node_count;
         //NOTE: building the first level separately allows us to avoid some switching logic needed to determine what is the type of lower level node
         //build one level above leaf nodes
-        level_node_count = Math.pow(2, level);
+        level_node_count = 1 << level;
         offset = (level_node_count - 1) * BVH_BINARY_NODE_SIZE;
 
         let parentIndex;

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QAiKhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAiRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QAiKhB"}

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.js

@@ -2,6 +2,8 @@ import { assert } from "../../assert.js";
 import { ctz32 } from "../../binary/ctz32.js";
 import { bitCount } from "../../binary/operations/bitCount.js";
 import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
+import { ceil_log2 } from "../../binary/operations/ceil_log2.js";
+import { isPowerOfTwo } from "../../math/isPowerOfTwo.js";
 
 // Common continuous memory region for better cache performance
 const scratch_memory = new ArrayBuffer((256 * 3 + 16) * 4 + 256 * 6 * 4);
@@ -84,8 +86,7 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
         let min_x, min_y, min_z, max_x, max_y, max_z;
 
         // Check if 's' is a power of 2 (i.e., a single leaf)
-        // (s & (s-1)) === 0 is the standard trick for this
-        const is_a_leaf = (s & (s - 1)) === 0;
+        const is_a_leaf = isPowerOfTwo(s);
 
         if (is_a_leaf) {
             // --- CASE A: LEAF ---
@@ -312,7 +313,7 @@ export function ebvh_optimize_treelet(
         return;
     }
 
-    const min_height = Math.ceil(Math.log2(treelet_size));
+    const min_height = ceil_log2(treelet_size);
 
     // do a stackless traversal
     while (true) {
@@ -357,10 +358,10 @@ export function ebvh_optimize_treelet(
             came_from_node = node;
 
             node = parent;
-        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
-            if (node === root) {
-                // traversed all the way back up
-                break;
+        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+            if (node === root) {
+                // traversed all the way back up
+                break;
             }
             // finishing traversal of this branch
             came_from_node = node;

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

@@ -1 +1 @@
-{"version":3,"file":"PairUint32Map.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/PairUint32Map.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AA2BzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAII;;;OAGG;IACH,+BAFW,MAAM,EAahB;IAjBD,eAAW;IAYP,mBAAqB;IACrB,eAAqB;IACrB,gBAAkC;IAClC,yBAA2E;IAC3E,oBAAgD;IAGpD;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;OAKG;IACH,sBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,WAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAiClB;IAED;;;;;OAKG;IACH,WAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,WAJW,MAAM,SACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,yBAiDC;IAED;;;;;OAKG;IACH,cAJW,MAAM,SACN,MAAM,GACJ,OAAO,CA+DnB;IAED,cAGC;IAED;;;OAGG;IACH,iBAkBC;CACJ;;iBAGS,MAAM"}
+{"version":3,"file":"PairUint32Map.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/PairUint32Map.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AA2BzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAII;;;OAGG;IACH,+BAFW,MAAM,EAYhB;IAhBD,eAAW;IAWP,mBAAqB;IACrB,eAAqB;IACrB,gBAAkC;IAClC,yBAA2E;IAC3E,oBAAgD;IAGpD;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;OAKG;IACH,sBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,WAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAiClB;IAED;;;;;OAKG;IACH,WAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,WAJW,MAAM,SACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,yBAiDC;IAED;;;;;OAKG;IACH,cAJW,MAAM,SACN,MAAM,GACJ,OAAO,CA+DnB;IAED,cAGC;IAED;;;OAGG;IACH,iBAkBC;CACJ;;iBAGS,MAAM"}

package/src/core/collection/PairUint32Map.js

@@ -1,4 +1,5 @@
 import { assert } from "../assert.js";
+import { ceilPowerOfTwo } from "../binary/operations/ceilPowerOfTwo.js";
 
 /**
  * Returned by {@link PairUint32Map#get} when the key pair is absent.
@@ -64,8 +65,7 @@ export class PairUint32Map {
     constructor(initial_capacity = DEFAULT_CAPACITY) {
         assert.isNonNegativeInteger(initial_capacity, 'initial_capacity');
 
-        let cap = MIN_CAPACITY;
-        while (cap < initial_capacity) cap <<= 1;
+        const cap = Math.max(MIN_CAPACITY, ceilPowerOfTwo(initial_capacity));
 
         this.__capacity = cap;
         this.__mask = cap - 1;

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

@@ -1 +1 @@
-{"version":3,"file":"Uint32Map.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/Uint32Map.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AA6BpC;;;;;;;;;;;;;;;;;GAiBG;AACH;IAQI;;;OAGG;IACH,+BAFW,MAAM,EAqChB;IA7CD;;;OAGG;IACH,eAAW;IAcP;;;OAGG;IACH,mBAAqB;IACrB;;;OAGG;IACH,eAAqB;IACrB;;;;OAIG;IACH,gBAAkC;IAClC;;;OAGG;IACH,yBAA2E;IAC3E;;;;OAIG;IACH,eAAuC;IAG3C;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,QAHW,MAAM,GACJ,MAAM,CAkClB;IAED;;;;OAIG;IACH,QAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,QAHW,MAAM,SACN,MAAM,QAehB;IAED;;;;;;;;OAQG;IACH,yBA4CC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CA+DnB;IAED;;OAEG;IACH,cAGC;IAED;;;;;OAKG;IACH,iBAkBC;CACJ"}
+{"version":3,"file":"Uint32Map.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/Uint32Map.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AA6BpC;;;;;;;;;;;;;;;;;GAiBG;AACH;IAQI;;;OAGG;IACH,+BAFW,MAAM,EAkChB;IA1CD;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,mBAAqB;IACrB;;;OAGG;IACH,eAAqB;IACrB;;;;OAIG;IACH,gBAAkC;IAClC;;;OAGG;IACH,yBAA2E;IAC3E;;;;OAIG;IACH,eAAuC;IAG3C;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,QAHW,MAAM,GACJ,MAAM,CAkClB;IAED;;;;OAIG;IACH,QAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,QAHW,MAAM,SACN,MAAM,QAehB;IAED;;;;;;;;OAQG;IACH,yBA4CC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CA+DnB;IAED;;OAEG;IACH,cAGC;IAED;;;;;OAKG;IACH,iBAkBC;CACJ"}

package/src/core/collection/Uint32Map.js

@@ -1,4 +1,5 @@
 import { assert } from "../assert.js";
+import { ceilPowerOfTwo } from "../binary/operations/ceilPowerOfTwo.js";
 
 const UINT32_MAX = 4294967295;
 
@@ -69,10 +70,7 @@ export class Uint32Map {
     constructor(initial_capacity = DEFAULT_CAPACITY) {
         assert.isNonNegativeInteger(initial_capacity, 'initial_capacity');
 
-        let cap = MIN_CAPACITY;
-        while (cap < initial_capacity) {
-            cap <<= 1;
-        }
+        const cap = Math.max(MIN_CAPACITY, ceilPowerOfTwo(initial_capacity));
 
         /**
          * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"FibonacciHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/FibonacciHeap.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IASI;;;OAGG;IACH,+BAFW,MAAM,EAiChB;IA1CD;;;;OAIG;IACH,eAAW;IASP;;;OAGG;IACH,eAAuE;IAEvE;;;;OAIG;IACH,cAAwB;IAExB;;;;;;;;;;;;;OAaG;IACH,kBAA0B;IAG9B;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,qBAKC;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,cAFa,MAAM,CAOlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAyBC;IAED;;;;;;OAMG;IACH,+BASC;IAED;;;;OAIG;IACH,WAHW,MAAM,SACN,MAAM,QA4BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAwDlB;IAED;;;;;OAKG;IACH,sBAwDC;IAED;;;;;;OAMG;IACH,eA4BC;IAED;;;;;;OAMG;IACH,uBAkBC;IAED;;;;;;OAMG;IACH,cA2BC;IAED;;;;;OAKG;IACH,wBAaC;IAED;;;;;OAKG;IACH,wBAGC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,SACN,MAAM,QAQhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;OAEG;IACH,cAKC;CACJ"}
+{"version":3,"file":"FibonacciHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/FibonacciHeap.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IASI;;;OAGG;IACH,+BAFW,MAAM,EAiChB;IA1CD;;;;OAIG;IACH,eAAW;IASP;;;OAGG;IACH,eAAuE;IAEvE;;;;OAIG;IACH,cAAwB;IAExB;;;;;;;;;;;;;OAaG;IACH,kBAA0B;IAG9B;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,qBAKC;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED;;;OAGG;IACH,cAFa,MAAM,CAOlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAyBC;IAED;;;;;;OAMG;IACH,+BASC;IAED;;;;OAIG;IACH,WAHW,MAAM,SACN,MAAM,QA4BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAwDlB;IAED;;;;;OAKG;IACH,sBAwDC;IAED;;;;;;OAMG;IACH,eA4BC;IAED;;;;;;OAMG;IACH,uBAkBC;IAED;;;;;;OAMG;IACH,cA2BC;IAED;;;;;OAKG;IACH,wBAaC;IAED;;;;;OAKG;IACH,wBAGC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,SACN,MAAM,QAQhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;OAEG;IACH,cAKC;CACJ"}