@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/geom/packing/max-rect/packOneBox.js

@@ -1,54 +1,7 @@
-import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
-import { costByRemainingArea } from "./cost/costByRemainingArea.js";
-import { cutArea } from "./cutArea.js";
-import { findBestContainer } from "./findBestContainer.js";
-
-/**
- *
- * @param {AABB2} box
- * @param {QuadTreeNode} free
- * @returns {boolean}
- */
-export function packOneBox(box, free) {
-    const w = box.width;
-    const h = box.height;
-
-    const container = findBestContainer(w, h, free, costByRemainingArea);
-
-    if (container === null) {
-        //couldn't find a place for box
-        return false;
-    }
-
-    //remove container from free set
-    container.disconnect();
-
-    //place box at bottom left of the container
-    const y0 = container.y0;
-    const x0 = container.x0;
-
-    box.set(x0, y0, x0 + w, y0 + h);
-
-    //update remaining set by removing this box area from free set
-    cutArea(box, free);
-
-    //split remaining space
-    if (box.y1 !== container.y1) {
-
-        const splitA = new QuadTreeDatum(container.x0, box.y1, container.x1, container.y1);
-
-        free.insertDatum(splitA);
-
-    }
-
-    if (box.x1 !== container.x1) {
-
-        const splitB = new QuadTreeDatum(box.x1, container.y0, container.x1, container.y1);
-
-        free.insertDatum(splitB);
-
-    }
-
-
-    return true;
-}
+import { pack_one_box } from "./pack_one_box.js";
+
+/**
+ * @deprecated Renamed to {@link pack_one_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const packOneBox = pack_one_box;

package/src/core/geom/packing/max-rect/pack_max_rectangles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Packs {@link AABB2} boxes into defined bounds
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {AABB2[]} boxes
+ * @returns {boolean} true if packing was successful, false otherwise
+ */
+export function pack_max_rectangles(width: number, height: number, boxes: AABB2[]): boolean;
+//# sourceMappingURL=pack_max_rectangles.d.ts.map

package/src/core/geom/packing/max-rect/pack_max_rectangles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack_max_rectangles.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/pack_max_rectangles.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,2CALW,MAAM,UACN,MAAM,SACN,OAAO,GACL,OAAO,CAOnB"}

package/src/core/geom/packing/max-rect/pack_max_rectangles.js

@@ -0,0 +1,16 @@
+import { MaxRectanglesPacker } from "./MaxRectanglesPacker.js";
+
+/**
+ * Packs {@link AABB2} boxes into defined bounds
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {AABB2[]} boxes
+ * @returns {boolean} true if packing was successful, false otherwise
+ */
+export function pack_max_rectangles(width, height, boxes) {
+
+    const packer = new MaxRectanglesPacker(width, height);
+
+    return packer.addMany(boxes);
+}

package/src/core/geom/packing/max-rect/pack_one_box.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {AABB2} box
+ * @param {QuadTreeNode} free
+ * @returns {boolean}
+ */
+export function pack_one_box(box: AABB2, free: QuadTreeNode): boolean;
+//# sourceMappingURL=pack_one_box.d.ts.map

package/src/core/geom/packing/max-rect/pack_one_box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack_one_box.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/pack_one_box.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,8DAFa,OAAO,CA4CnB"}

package/src/core/geom/packing/max-rect/pack_one_box.js

@@ -0,0 +1,54 @@
+import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
+import { cost_by_remaining_area } from "./cost/cost_by_remaining_area.js";
+import { cut_area } from "./cut_area.js";
+import { find_best_container } from "./find_best_container.js";
+
+/**
+ *
+ * @param {AABB2} box
+ * @param {QuadTreeNode} free
+ * @returns {boolean}
+ */
+export function pack_one_box(box, free) {
+    const w = box.width;
+    const h = box.height;
+
+    const container = find_best_container(w, h, free, cost_by_remaining_area);
+
+    if (container === null) {
+        //couldn't find a place for box
+        return false;
+    }
+
+    //remove container from free set
+    container.disconnect();
+
+    //place box at bottom left of the container
+    const y0 = container.y0;
+    const x0 = container.x0;
+
+    box.set(x0, y0, x0 + w, y0 + h);
+
+    //update remaining set by removing this box area from free set
+    cut_area(box, free);
+
+    //split remaining space
+    if (box.y1 !== container.y1) {
+
+        const splitA = new QuadTreeDatum(container.x0, box.y1, container.x1, container.y1);
+
+        free.insertDatum(splitA);
+
+    }
+
+    if (box.x1 !== container.x1) {
+
+        const splitB = new QuadTreeDatum(box.x1, container.y0, container.x1, container.y1);
+
+        free.insertDatum(splitB);
+
+    }
+
+
+    return true;
+}

package/src/core/geom/packing/max-rect/removeRedundantBoxes.d.ts

@@ -1,6 +1,7 @@
 /**
- * Remove all rectangles that are fully contained within others
- * @param {QuadTreeNode} boxes
+ * @deprecated Renamed to {@link remove_redundant_boxes}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function removeRedundantBoxes(boxes: QuadTreeNode): void;
+export const removeRedundantBoxes: typeof remove_redundant_boxes;
+import { remove_redundant_boxes } from "./remove_redundant_boxes.js";
 //# sourceMappingURL=removeRedundantBoxes.d.ts.map

package/src/core/geom/packing/max-rect/removeRedundantBoxes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeRedundantBoxes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/removeRedundantBoxes.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,gEA+EC"}
+{"version":3,"file":"removeRedundantBoxes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/removeRedundantBoxes.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iEAA2D;uCANpB,6BAA6B"}

package/src/core/geom/packing/max-rect/removeRedundantBoxes.js

@@ -1,84 +1,7 @@
-/**
- * Remove all rectangles that are fully contained within others
- * @param {QuadTreeNode} boxes
- */
-export function removeRedundantBoxes(boxes) {
-    const removals = [];
-    const removalSet = new Set();
-
-    function scheduleRemoval(box) {
-        if (!removalSet.has(box)) {
-            removalSet.add(box);
-            removals.push(box);
-        }
-    }
-
-    let datum;
-
-    /**
-     *
-     * @param {QuadTreeDatum} intersection
-     */
-    function visitDatumIntersection(intersection) {
-        if (datum === intersection) {
-            //skip self
-            return;
-        }
-
-        // A box already scheduled for removal must not, in turn, cause other boxes to be removed. This is what
-        // makes two IDENTICAL boxes resolve to exactly one survivor: whichever is seen first schedules the
-        // other for removal, and when the removed one is later visited as `datum` we bail here instead of
-        // scheduling its (equal) container too — otherwise both equal boxes would be removed.
-        if (removalSet.has(datum)) {
-            return;
-        }
-
-        const ax0 = intersection.x0;
-        const ay0 = intersection.y0;
-        const ax1 = intersection.x1;
-        const ay1 = intersection.y1;
-
-        const bx0 = datum.x0;
-        const by0 = datum.y0;
-        const bx1 = datum.x1;
-        const by1 = datum.y1;
-
-        //question is now whether it is containment
-        if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
-            //b (datum) contains a (intersection)
-            scheduleRemoval(intersection);
-        } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
-            //a (intersection) contains b (datum)
-            scheduleRemoval(datum);
-
-            //scheduled removal of the datum, prevent further traversal
-            return false;
-        }
-    }
-
-    /**
-     *
-     * @param {QuadTreeNode} node
-     */
-    function visitTreeNode(node) {
-        const data = node.data;
-        const dataCount = data.length;
-
-        for (let i = 0; i < dataCount; i++) {
-            /**
-             *
-             * @type {QuadTreeDatum}
-             */
-            datum = data[i];
-
-            node.traverseRectangleIntersections(datum.x0, datum.y0, datum.x1, datum.y1, visitDatumIntersection);
-        }
-    }
-
-    boxes.traversePreOrder(visitTreeNode);
-
-    for (let i = 0; i < removals.length; i++) {
-        const removal = removals[i];
-        removal.disconnect();
-    }
-}
+import { remove_redundant_boxes } from "./remove_redundant_boxes.js";
+
+/**
+ * @deprecated Renamed to {@link remove_redundant_boxes}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const removeRedundantBoxes = remove_redundant_boxes;

package/src/core/geom/packing/max-rect/removeRedundantBoxesArray.d.ts

@@ -1,6 +1,7 @@
 /**
- * Remove all rectangles that are fully contained within others
- * @param {AABB2[]} boxes
+ * @deprecated Renamed to {@link remove_redundant_boxes_from_array}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function removeRedundantBoxesArray(boxes: AABB2[]): void;
+export const removeRedundantBoxesArray: typeof remove_redundant_boxes_from_array;
+import { remove_redundant_boxes_from_array } from "./remove_redundant_boxes_from_array.js";
 //# sourceMappingURL=removeRedundantBoxesArray.d.ts.map

package/src/core/geom/packing/max-rect/removeRedundantBoxesArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeRedundantBoxesArray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/removeRedundantBoxesArray.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,iDAFW,OAAO,QA2CjB"}
+{"version":3,"file":"removeRedundantBoxesArray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/removeRedundantBoxesArray.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iFAA2E;kDANzB,wCAAwC"}

package/src/core/geom/packing/max-rect/removeRedundantBoxesArray.js

@@ -1,46 +1,7 @@
-/**
- * Remove all rectangles that are fully contained within others
- * @param {AABB2[]} boxes
- */
-export function removeRedundantBoxesArray(boxes) {
-    let i, j;
-    let box_count = boxes.length;
-
-    loop_a: for (i = 0; i < box_count; i++) {
-        const a = boxes[i];
-
-        const ax0 = a.x0;
-        const ay0 = a.y0;
-        const ax1 = a.x1;
-        const ay1 = a.y1;
-
-        for (j = i + 1; j < box_count; j++) {
-            const b = boxes[j];
-
-            const bx0 = b.x0;
-            const by0 = b.y0;
-            const bx1 = b.x1;
-            const by1 = b.y1;
-
-            //question is now whether it is containment
-            if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
-
-                // B contains A
-
-                boxes.splice(i, 1);
-                i--;
-                box_count--;
-                continue loop_a;
-
-            } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
-
-                // A contains B
-
-                boxes.splice(j, 1);
-                j--;
-                box_count--;
-
-            }
-        }
-    }
-}
+import { remove_redundant_boxes_from_array } from "./remove_redundant_boxes_from_array.js";
+
+/**
+ * @deprecated Renamed to {@link remove_redundant_boxes_from_array}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const removeRedundantBoxesArray = remove_redundant_boxes_from_array;

package/src/core/geom/packing/max-rect/remove_redundant_boxes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {QuadTreeNode} boxes
+ */
+export function remove_redundant_boxes(boxes: QuadTreeNode): void;
+//# sourceMappingURL=remove_redundant_boxes.d.ts.map

package/src/core/geom/packing/max-rect/remove_redundant_boxes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove_redundant_boxes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/remove_redundant_boxes.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,kEA+EC"}

package/src/core/geom/packing/max-rect/remove_redundant_boxes.js

@@ -0,0 +1,84 @@
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {QuadTreeNode} boxes
+ */
+export function remove_redundant_boxes(boxes) {
+    const removals = [];
+    const removalSet = new Set();
+
+    function scheduleRemoval(box) {
+        if (!removalSet.has(box)) {
+            removalSet.add(box);
+            removals.push(box);
+        }
+    }
+
+    let datum;
+
+    /**
+     *
+     * @param {QuadTreeDatum} intersection
+     */
+    function visitDatumIntersection(intersection) {
+        if (datum === intersection) {
+            //skip self
+            return;
+        }
+
+        // A box already scheduled for removal must not, in turn, cause other boxes to be removed. This is what
+        // makes two IDENTICAL boxes resolve to exactly one survivor: whichever is seen first schedules the
+        // other for removal, and when the removed one is later visited as `datum` we bail here instead of
+        // scheduling its (equal) container too — otherwise both equal boxes would be removed.
+        if (removalSet.has(datum)) {
+            return;
+        }
+
+        const ax0 = intersection.x0;
+        const ay0 = intersection.y0;
+        const ax1 = intersection.x1;
+        const ay1 = intersection.y1;
+
+        const bx0 = datum.x0;
+        const by0 = datum.y0;
+        const bx1 = datum.x1;
+        const by1 = datum.y1;
+
+        //question is now whether it is containment
+        if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
+            //b (datum) contains a (intersection)
+            scheduleRemoval(intersection);
+        } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
+            //a (intersection) contains b (datum)
+            scheduleRemoval(datum);
+
+            //scheduled removal of the datum, prevent further traversal
+            return false;
+        }
+    }
+
+    /**
+     *
+     * @param {QuadTreeNode} node
+     */
+    function visitTreeNode(node) {
+        const data = node.data;
+        const dataCount = data.length;
+
+        for (let i = 0; i < dataCount; i++) {
+            /**
+             *
+             * @type {QuadTreeDatum}
+             */
+            datum = data[i];
+
+            node.traverseRectangleIntersections(datum.x0, datum.y0, datum.x1, datum.y1, visitDatumIntersection);
+        }
+    }
+
+    boxes.traversePreOrder(visitTreeNode);
+
+    for (let i = 0; i < removals.length; i++) {
+        const removal = removals[i];
+        removal.disconnect();
+    }
+}

package/src/core/geom/packing/max-rect/remove_redundant_boxes_from_array.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {AABB2[]} boxes
+ */
+export function remove_redundant_boxes_from_array(boxes: AABB2[]): void;
+//# sourceMappingURL=remove_redundant_boxes_from_array.d.ts.map

package/src/core/geom/packing/max-rect/remove_redundant_boxes_from_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove_redundant_boxes_from_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/remove_redundant_boxes_from_array.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,yDAFW,OAAO,QA2CjB"}

package/src/core/geom/packing/max-rect/remove_redundant_boxes_from_array.js

@@ -0,0 +1,46 @@
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {AABB2[]} boxes
+ */
+export function remove_redundant_boxes_from_array(boxes) {
+    let i, j;
+    let box_count = boxes.length;
+
+    loop_a: for (i = 0; i < box_count; i++) {
+        const a = boxes[i];
+
+        const ax0 = a.x0;
+        const ay0 = a.y0;
+        const ax1 = a.x1;
+        const ay1 = a.y1;
+
+        for (j = i + 1; j < box_count; j++) {
+            const b = boxes[j];
+
+            const bx0 = b.x0;
+            const by0 = b.y0;
+            const bx1 = b.x1;
+            const by1 = b.y1;
+
+            //question is now whether it is containment
+            if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
+
+                // B contains A
+
+                boxes.splice(i, 1);
+                i--;
+                box_count--;
+                continue loop_a;
+
+            } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
+
+                // A contains B
+
+                boxes.splice(j, 1);
+                j--;
+                box_count--;
+
+            }
+        }
+    }
+}

package/src/core/geom/packing/sphere_compute_bounding_of_spheres.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Computes bounding sphere of a number of spheres
+ * NOTE: implementation does not produce a very tight sphere, here is a good resource for a better implementation:
+ *          https://github.com/CGAL/cgal/blob/master/Bounding_volumes/include/CGAL/Min_sphere_of_spheres_d/Min_sphere_of_spheres_d_support_set.h
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number[]|Float32Array|Float64Array} data
+ * @param {number} offset
+ * @param {number} count
+ * @param {number} dimensions
+ */
+export function sphere_compute_bounding_of_spheres(result: number[] | Float32Array | Float64Array, data: number[] | Float32Array | Float64Array, offset: number, count: number, dimensions: number): void;
+//# sourceMappingURL=sphere_compute_bounding_of_spheres.d.ts.map

package/src/core/geom/packing/sphere_compute_bounding_of_spheres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere_compute_bounding_of_spheres.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/packing/sphere_compute_bounding_of_spheres.js"],"names":[],"mappings":"AAyBA;;;;;;;;;GASG;AACH,2DANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,SACN,MAAM,cACN,MAAM,QAoEhB"}

package/src/core/geom/packing/sphere_compute_bounding_of_spheres.js

@@ -0,0 +1,102 @@
+import { assert } from "../../assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} d number of dimensions
+ * @returns {number}
+ */
+function compute_point_distance(a, b, d) {
+    let result = 0;
+    for (let i = 0; i < d; i++) {
+        const x = a[i] - b[i];
+
+        result += x * x;
+    }
+
+    return Math.sqrt(result);
+}
+
+const SCRATCH_DIMENSIONS = 4;
+
+const _scratch_center = new Float64Array(SCRATCH_DIMENSIONS);
+const _scratch_sphere = new Float64Array(SCRATCH_DIMENSIONS + 1);
+
+/**
+ * Computes bounding sphere of a number of spheres
+ * NOTE: implementation does not produce a very tight sphere, here is a good resource for a better implementation:
+ *          https://github.com/CGAL/cgal/blob/master/Bounding_volumes/include/CGAL/Min_sphere_of_spheres_d/Min_sphere_of_spheres_d_support_set.h
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number[]|Float32Array|Float64Array} data
+ * @param {number} offset
+ * @param {number} count
+ * @param {number} dimensions
+ */
+export function sphere_compute_bounding_of_spheres(result, data, offset, count, dimensions) {
+    assert.isArrayLike(result, 'result');
+
+    const sphere_component_count = dimensions + 1;
+
+    let center;
+    let sphere;
+
+    if (dimensions <= SCRATCH_DIMENSIONS) {
+        // avoid allocation
+        center = _scratch_center;
+        sphere = _scratch_sphere;
+
+        center.fill(0);
+    } else {
+        center = new Float64Array(dimensions);
+        sphere = new Float64Array(sphere_component_count);
+    }
+
+    for (let i = 0; i < count; i++) {
+        const sphere_offset = offset + i * sphere_component_count;
+
+        //read sphere
+        for (let j = 0; j < sphere_component_count; j++) {
+            sphere[j] = data[sphere_offset + j];
+        }
+
+        // add position of the sphere to center accumulator
+        for (let j = 0; j < dimensions; j++) {
+            center[j] += sphere[j];
+        }
+    }
+
+    // compute average
+    for (let i = 0; i < dimensions; i++) {
+        center[i] /= count;
+    }
+
+    let max_radius = 0;
+
+    for (let i = 0; i < count; i++) {
+        // compute squared distance from center to each sphere
+        const sphere_offset = offset + i*sphere_component_count;
+
+        //read sphere
+        for (let j = 0; j < sphere_component_count; j++) {
+            sphere[j] = data[sphere_offset + j];
+        }
+
+        const sqr_distance_to_center = compute_point_distance(center, sphere, dimensions);
+
+        const sphere_radius = sphere[dimensions];
+        const distance = sqr_distance_to_center + sphere_radius;
+
+        if (distance > max_radius) {
+            max_radius = distance;
+        }
+    }
+
+    for (let i = 0; i < dimensions; i++) {
+        // write center
+        result[i] = center[i];
+    }
+
+    // write radius
+    result[dimensions] = max_radius;
+}

package/src/core/geom/random/randomPointInBox.d.ts

@@ -1,8 +1,7 @@
 /**
- *
- * @param {function} random
- * @param {number[]} result
- * @param {number} result_offset
+ * @deprecated Renamed to {@link random_point_in_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function randomPointInBox(random: Function, result: number[], result_offset: number): void;
+export const randomPointInBox: typeof random_point_in_box;
+import { random_point_in_box } from "./random_point_in_box.js";
 //# sourceMappingURL=randomPointInBox.d.ts.map

package/src/core/geom/random/randomPointInBox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomPointInBox.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/random/randomPointInBox.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,2DAHW,MAAM,EAAE,iBACR,MAAM,QAWhB"}
+{"version":3,"file":"randomPointInBox.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/random/randomPointInBox.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,0DAAoD;oCANhB,0BAA0B"}

package/src/core/geom/random/randomPointInBox.js

@@ -1,16 +1,7 @@
-/**
- *
- * @param {function} random
- * @param {number[]} result
- * @param {number} result_offset
- */
-export function randomPointInBox(random, result, result_offset) {
-    const x = random() - 0.5;
-    const y = random() - 0.5;
-    const z = random() - 0.5;
-
-    //write the result
-    result[result_offset] = x;
-    result[result_offset + 1] = y;
-    result[result_offset + 2] = z;
-}
+import { random_point_in_box } from "./random_point_in_box.js";
+
+/**
+ * @deprecated Renamed to {@link random_point_in_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const randomPointInBox = random_point_in_box;