@weasel-js/geom 1.13.0 → 1.14.1

package/dist/nd/index.js

@@ -1,3 +1,4 @@
+export { createBvh } from '../chunk-XXNK4N7Z.js';
 export { PORT_REACH, cubicAt, portControls, portCurvePoints } from '../chunk-YQADYJJ7.js';
 
 // src/snap/flat.ts
@@ -295,686 +296,37 @@ function stepLine(about, toward, basis, step) {
   return { at: about, dirs: [u.map((x, i) => x * c + v[i] * s)] };
 }
 
-// src/bvh/bvhTree.ts
-var LEAF_SIZE = 4;
-var BvhTree = class {
-  dim;
-  root = -1;
-  nodeBox;
-  left;
-  right;
-  parent;
-  leafCount;
-  leafItems;
-  count;
-  nodeCap = 0;
-  nodeTop = 0;
-  freeNodes = [];
-  itemBox;
-  /** Twice each item's box center, `[item * dim + axis]`: what a build splits on. */
-  itemCentroid2;
-  itemLeaf;
-  keys = [];
-  itemCap = 0;
-  itemTop = 0;
-  freeItems = [];
-  constructor(dim) {
-    this.dim = dim;
-    this.nodeBox = new Float64Array(0);
-    this.left = this.right = this.parent = this.leafCount = this.leafItems = this.count = new Int32Array(0);
-    this.itemBox = new Float64Array(0);
-    this.itemCentroid2 = new Float64Array(0);
-    this.itemLeaf = new Int32Array(0);
-    this.growNodes(16);
-    this.growItems(16);
-  }
-  growNodes(cap) {
-    const s = 2 * this.dim;
-    this.nodeBox = grow(this.nodeBox, cap * s);
-    this.left = grow(this.left, cap);
-    this.right = grow(this.right, cap);
-    this.parent = grow(this.parent, cap);
-    this.leafCount = grow(this.leafCount, cap);
-    this.leafItems = grow(this.leafItems, cap * LEAF_SIZE);
-    this.count = grow(this.count, cap);
-    this.nodeCap = cap;
-  }
-  growItems(cap) {
-    this.itemBox = grow(this.itemBox, cap * 2 * this.dim);
-    this.itemCentroid2 = grow(this.itemCentroid2, cap * this.dim);
-    this.itemLeaf = grow(this.itemLeaf, cap);
-    this.itemCap = cap;
-  }
-  allocNode(parent) {
-    let n = this.freeNodes.pop();
-    if (n === void 0) {
-      if (this.nodeTop === this.nodeCap) this.growNodes(this.nodeCap * 2);
-      n = this.nodeTop++;
-    }
-    this.left[n] = -1;
-    this.right[n] = -1;
-    this.parent[n] = parent;
-    this.leafCount[n] = 0;
-    return n;
-  }
-  freeNode(n) {
-    this.freeNodes.push(n);
-  }
-  allocItem(key, box) {
-    let i = this.freeItems.pop();
-    if (i === void 0) {
-      if (this.itemTop === this.itemCap) this.growItems(this.itemCap * 2);
-      i = this.itemTop++;
-    }
-    this.keys[i] = key;
-    this.writeItemBox(i, box);
-    return i;
-  }
-  freeItem(i) {
-    this.keys[i] = void 0;
-    this.itemLeaf[i] = -1;
-    this.freeItems.push(i);
-  }
-  writeItemBox(i, box) {
-    const d = this.dim;
-    const s = 2 * d;
-    for (let j = 0; j < s; j++) this.itemBox[i * s + j] = box[j];
-    for (let a = 0; a < d; a++) this.itemCentroid2[i * d + a] = box[a] + box[d + a];
-  }
-  /** Recompute `n`'s box and count from its children or items. */
-  computeBox(n) {
-    const d = this.dim;
-    const s = 2 * d;
-    const nb = this.nodeBox;
-    const o = n * s;
-    for (let j = 0; j < d; j++) {
-      nb[o + j] = Infinity;
-      nb[o + d + j] = -Infinity;
-    }
-    if (this.left[n] !== -1) {
-      unionInto(nb, o, nb, this.left[n] * s, d);
-      unionInto(nb, o, nb, this.right[n] * s, d);
-      this.count[n] = this.count[this.left[n]] + this.count[this.right[n]];
-      return;
-    }
-    this.count[n] = this.leafCount[n];
-    const base = n * LEAF_SIZE;
-    for (let k = 0; k < this.leafCount[n]; k++) unionInto(nb, o, this.itemBox, this.leafItems[base + k] * s, d);
-  }
-  refitUp(n) {
-    for (; n !== -1; n = this.parent[n]) this.computeBox(n);
-  }
-  /** Discard the topology and rebuild it top-down over every live item. */
-  build() {
-    this.freeNodes = [];
-    this.nodeTop = 0;
-    this.root = -1;
-    const live = [];
-    for (let i = 0; i < this.itemTop; i++) if (this.itemLeaf[i] !== -1) live.push(i);
-    if (live.length === 0) return;
-    if (this.nodeCap < 2 * live.length) this.growNodes(2 * live.length);
-    const idx = Int32Array.from(live);
-    this.root = this.buildRange(idx, 0, idx.length, -1);
-  }
-  /** Rebuild the subtree under `n` balanced, in its place. */
-  rebuildSubtree(n) {
-    const p = this.parent[n];
-    const wasLeft = p !== -1 && this.left[p] === n;
-    const items = new Int32Array(this.count[n]);
-    const nodes = [n];
-    let m = 0;
-    while (nodes.length > 0) {
-      const c = nodes.pop();
-      if (this.left[c] !== -1) nodes.push(this.left[c], this.right[c]);
-      else for (let k = 0; k < this.leafCount[c]; k++) items[m++] = this.leafItems[c * LEAF_SIZE + k];
-      this.freeNode(c);
-    }
-    const r = this.buildRange(items, 0, m, p);
-    if (p === -1) this.root = r;
-    else if (wasLeft) this.left[p] = r;
-    else this.right[p] = r;
-  }
-  /** `key` is scratch the length of `idx`, for `select`. */
-  buildRange(idx, lo, hi, parent, key = new Float64Array(idx.length)) {
-    const n = this.allocNode(parent);
-    if (hi - lo <= LEAF_SIZE) {
-      for (let k = lo; k < hi; k++) this.placeInLeaf(n, idx[k]);
-    } else {
-      const mid = lo + hi >> 1;
-      this.select(idx, key, lo, hi, mid, this.longestCentroidAxis(idx, lo, hi));
-      const l = this.buildRange(idx, lo, mid, n, key);
-      const r = this.buildRange(idx, mid, hi, n, key);
-      this.left[n] = l;
-      this.right[n] = r;
-    }
-    this.computeBox(n);
-    return n;
-  }
-  placeInLeaf(n, item) {
-    this.leafItems[n * LEAF_SIZE + this.leafCount[n]++] = item;
-    this.itemLeaf[item] = n;
-  }
-  /** Turn a full leaf into an internal node over two leaves, the full set
-   *  plus `extra` split at the median of their longest centroid axis. */
-  splitLeaf(n, extra) {
-    const base = n * LEAF_SIZE;
-    const idx = new Int32Array(LEAF_SIZE + 1);
-    for (let k = 0; k < LEAF_SIZE; k++) idx[k] = this.leafItems[base + k];
-    idx[LEAF_SIZE] = extra;
-    const mid = idx.length >> 1;
-    this.select(idx, new Float64Array(idx.length), 0, idx.length, mid, this.longestCentroidAxis(idx, 0, idx.length));
-    this.leafCount[n] = 0;
-    const l = this.allocNode(n);
-    const r = this.allocNode(n);
-    for (let k = 0; k < mid; k++) this.placeInLeaf(l, idx[k]);
-    for (let k = mid; k < idx.length; k++) this.placeInLeaf(r, idx[k]);
-    this.left[n] = l;
-    this.right[n] = r;
-    this.computeBox(l);
-    this.computeBox(r);
-  }
-  longestCentroidAxis(idx, lo, hi) {
-    const d = this.dim;
-    const cent = this.itemCentroid2;
-    let best = 0;
-    let bestExt = -1;
-    for (let a = 0; a < this.dim; a++) {
-      let mn = Infinity;
-      let mx = -Infinity;
-      for (let k = lo; k < hi; k++) {
-        const c = cent[idx[k] * d + a];
-        if (c < mn) mn = c;
-        if (c > mx) mx = c;
-      }
-      if (mx - mn > bestExt) {
-        bestExt = mx - mn;
-        best = a;
-      }
-    }
-    return best;
-  }
-  /** Quickselect: reorder `idx[lo, hi)` so `idx[k]` holds the item whose
-   *  centroid on `axis` ranks k, with smaller ones before it. The centroids
-   *  are copied into `key` beside `idx` and swapped with it, so the scans read
-   *  memory in order. */
-  select(idx, key, lo, hi, k, axis) {
-    const d = this.dim;
-    const cent = this.itemCentroid2;
-    for (let m = lo; m < hi; m++) key[m] = cent[idx[m] * d + axis];
-    let a = lo;
-    let b = hi - 1;
-    while (a < b) {
-      const pivot = key[a + b >> 1];
-      let i = a;
-      let j = b;
-      while (i <= j) {
-        while (key[i] < pivot) i++;
-        while (key[j] > pivot) j--;
-        if (i <= j) {
-          const t = idx[i];
-          idx[i] = idx[j];
-          idx[j] = t;
-          const u = key[i];
-          key[i] = key[j];
-          key[j] = u;
-          i++;
-          j--;
-        }
-      }
-      if (k <= j) b = j;
-      else if (k >= i) a = i;
-      else return;
-    }
-  }
-};
-function grow(arr, len) {
-  const next = new arr.constructor(len);
-  next.set(arr);
-  return next;
-}
-function unionInto(dst, o, src, so, d) {
-  for (let j = 0; j < d; j++) {
-    if (src[so + j] < dst[o + j]) dst[o + j] = src[so + j];
-    if (src[so + d + j] > dst[o + d + j]) dst[o + d + j] = src[so + d + j];
-  }
-}
-
-// src/bvh/bvhQuery.ts
-var Scratch = class _Scratch {
-  stack = new Int32Array(64);
-  heapT = new Float64Array(64);
-  heapId = new Int32Array(64);
-  busy = false;
-  take() {
-    if (this.busy) return new _Scratch();
-    this.busy = true;
-    return this;
-  }
-  release() {
-    this.busy = false;
-  }
-  stackAt(len) {
-    if (len >= this.stack.length) {
-      const next = new Int32Array(this.stack.length * 2);
-      next.set(this.stack);
-      this.stack = next;
-    }
-    return this.stack;
-  }
-  ensureHeap(len) {
-    if (len < this.heapT.length) return;
-    const t = new Float64Array(this.heapT.length * 2);
-    const id = new Int32Array(this.heapId.length * 2);
-    t.set(this.heapT);
-    id.set(this.heapId);
-    this.heapT = t;
-    this.heapId = id;
-  }
-};
-function heapPush(sc, size, t, id) {
-  sc.ensureHeap(size + 1);
-  const ht = sc.heapT;
-  const hid = sc.heapId;
-  let i = size;
-  while (i > 0) {
-    const p = i - 1 >> 1;
-    if (ht[p] <= t) break;
-    ht[i] = ht[p];
-    hid[i] = hid[p];
-    i = p;
-  }
-  ht[i] = t;
-  hid[i] = id;
-  return size + 1;
-}
-function heapPop(sc, size) {
-  const ht = sc.heapT;
-  const hid = sc.heapId;
-  const n = size - 1;
-  const lastT = ht[n];
-  const lastId = hid[n];
-  let i = 0;
-  for (; ; ) {
-    let c = 2 * i + 1;
-    if (c >= n) break;
-    if (c + 1 < n && ht[c + 1] < ht[c]) c++;
-    if (ht[c] >= lastT) break;
-    ht[i] = ht[c];
-    hid[i] = hid[c];
-    i = c;
-  }
-  ht[i] = lastT;
-  hid[i] = lastId;
-}
-function meets2(arr, o, d, q, qmin, qmax) {
-  for (let j = 0; j < d; j++) if (arr[o + j] > q[qmax + j] || q[qmin + j] > arr[o + d + j]) return false;
-  return true;
-}
-function queryOverlap(tree, pool2, q, qmin, qmax, visit) {
-  if (tree.root === -1) return;
-  const sc = pool2.take();
-  const d = tree.dim;
-  const s = 2 * d;
-  try {
-    let stack = sc.stackAt(0);
-    let sp = 0;
-    stack[sp++] = tree.root;
-    while (sp > 0) {
-      const n = stack[--sp];
-      if (!meets2(tree.nodeBox, n * s, d, q, qmin, qmax)) continue;
-      if (tree.left[n] === -1) {
-        const base = n * LEAF_SIZE;
-        for (let k = 0; k < tree.leafCount[n]; k++) {
-          const it = tree.leafItems[base + k];
-          if (meets2(tree.itemBox, it * s, d, q, qmin, qmax) && visit(tree.keys[it]) === false) return;
-        }
-        continue;
-      }
-      stack = sc.stackAt(sp + 1);
-      stack[sp++] = tree.left[n];
-      stack[sp++] = tree.right[n];
-    }
-  } finally {
-    sc.release();
-  }
-}
-function notOutside(arr, o, d, planes) {
-  for (let p = 0; p < planes.length; p++) {
-    const { normal, offset } = planes[p];
-    let v = offset;
-    for (let j = 0; j < d; j++) v += normal[j] * (normal[j] >= 0 ? arr[o + d + j] : arr[o + j]);
-    if (v < 0) return false;
-  }
+// src/bvh/settledCache.ts
+function sameKey(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
   return true;
 }
-function queryHalfSpaces(tree, pool2, planes, visit) {
-  if (tree.root === -1) return;
-  const sc = pool2.take();
-  const d = tree.dim;
-  const s = 2 * d;
-  try {
-    let stack = sc.stackAt(0);
-    let sp = 0;
-    stack[sp++] = tree.root;
-    while (sp > 0) {
-      const n = stack[--sp];
-      if (!notOutside(tree.nodeBox, n * s, d, planes)) continue;
-      if (tree.left[n] === -1) {
-        const base = n * LEAF_SIZE;
-        for (let k = 0; k < tree.leafCount[n]; k++) {
-          const it = tree.leafItems[base + k];
-          if (notOutside(tree.itemBox, it * s, d, planes) && visit(tree.keys[it]) === false) return;
-        }
-        continue;
-      }
-      stack = sc.stackAt(sp + 1);
-      stack[sp++] = tree.left[n];
-      stack[sp++] = tree.right[n];
-    }
-  } finally {
-    sc.release();
-  }
-}
-function entry(arr, o, d, org, dir, tMax) {
-  let near = 0;
-  let far = tMax;
-  for (let j = 0; j < d; j++) {
-    const lo = arr[o + j];
-    const hi = arr[o + d + j];
-    if (dir[j] === 0) {
-      if (org[j] < lo || org[j] > hi) return -1;
-      continue;
-    }
-    const t1 = (lo - org[j]) / dir[j];
-    const t2 = (hi - org[j]) / dir[j];
-    if (t1 < t2) {
-      if (t1 > near) near = t1;
-      if (t2 < far) far = t2;
-    } else {
-      if (t2 > near) near = t2;
-      if (t1 < far) far = t1;
-    }
-    if (near > far) return -1;
-  }
-  return near;
-}
-function raycast(tree, pool2, org, dir, visit, tMax) {
-  if (tree.root === -1) return;
-  const d = tree.dim;
-  const s = 2 * d;
-  const t0 = entry(tree.nodeBox, tree.root * s, d, org, dir, tMax);
-  if (t0 < 0) return;
-  const sc = pool2.take();
-  try {
-    let size = heapPush(sc, 0, t0, tree.root);
-    while (size > 0) {
-      const t = sc.heapT[0];
-      const id = sc.heapId[0];
-      heapPop(sc, size--);
-      if (id < 0) {
-        if (visit(tree.keys[-id - 1], t) === false) return;
-        continue;
-      }
-      if (tree.left[id] === -1) {
-        const base = id * LEAF_SIZE;
-        for (let k = 0; k < tree.leafCount[id]; k++) {
-          const it = tree.leafItems[base + k];
-          const ti = entry(tree.itemBox, it * s, d, org, dir, tMax);
-          if (ti >= 0) size = heapPush(sc, size, ti, -it - 1);
-        }
-        continue;
-      }
-      const l = tree.left[id];
-      const r = tree.right[id];
-      const tl = entry(tree.nodeBox, l * s, d, org, dir, tMax);
-      if (tl >= 0) size = heapPush(sc, size, tl, l);
-      const tr = entry(tree.nodeBox, r * s, d, org, dir, tMax);
-      if (tr >= 0) size = heapPush(sc, size, tr, r);
-    }
-  } finally {
-    sc.release();
-  }
-}
-
-// src/bvh/bvh.ts
-var ALPHA = 0.7;
-function depthLimit(n) {
-  return 2 * Math.ceil(Math.log2(Math.max(n, 2)));
-}
-function balancedHeight(m) {
-  let h = 0;
-  for (; m > LEAF_SIZE; m = Math.ceil(m / 2)) h++;
-  return h;
-}
-function validBox(box, dim) {
-  if (box.length < 2 * dim) return false;
-  for (let j = 0; j < dim; j++) {
-    const lo = box[j];
-    const hi = box[dim + j];
-    if (!Number.isFinite(lo) || !Number.isFinite(hi) || lo > hi) return false;
-  }
-  return true;
-}
-var BvhImpl = class {
-  dim;
-  tree;
-  items = /* @__PURE__ */ new Map();
-  scratch = new Scratch();
-  /** Largest size since the last whole rebuild; shrinking to half of it rebuilds again. */
-  peakSize = 0;
-  constructor(dim) {
-    this.dim = dim;
-    this.tree = new BvhTree(dim);
-  }
-  get size() {
-    return this.items.size;
-  }
-  /** Store without touching the topology; `rebuild` places them. */
-  load(entries) {
-    for (const [key, box] of entries) {
-      if (!validBox(box, this.dim)) continue;
-      const old = this.items.get(key);
-      if (old !== void 0) {
-        this.tree.writeItemBox(old, box);
-        continue;
-      }
-      const it = this.tree.allocItem(key, box);
-      this.tree.itemLeaf[it] = 0;
-      this.items.set(key, it);
-    }
-  }
-  insert(key, box) {
-    if (!validBox(box, this.dim)) return false;
-    if (this.items.has(key)) return this.update(key, box);
-    const it = this.tree.allocItem(key, box);
-    this.items.set(key, it);
-    if (this.items.size > this.peakSize) this.peakSize = this.items.size;
-    this.place(it);
-    return true;
-  }
-  update(key, box) {
-    const it = this.items.get(key);
-    if (it === void 0 || !validBox(box, this.dim)) return false;
-    const t = this.tree;
-    const leaf = t.itemLeaf[it];
-    if (this.leafHolds(leaf, box)) {
-      t.writeItemBox(it, box);
-      return true;
-    }
-    this.detach(it);
-    t.writeItemBox(it, box);
-    this.place(it);
-    return true;
-  }
-  remove(key) {
-    const it = this.items.get(key);
-    if (it === void 0) return false;
-    this.detach(it);
-    this.items.delete(key);
-    this.tree.freeItem(it);
-    if (this.items.size < this.peakSize >> 1) this.rebuild();
-    return true;
-  }
-  refit() {
-    const t = this.tree;
-    if (t.root === -1) return;
-    const sc = this.scratch.take();
-    try {
-      let order = sc.stackAt(0);
-      order[0] = t.root;
-      let len = 1;
-      for (let i = 0; i < len; i++) {
-        const n = order[i];
-        if (t.left[n] === -1) continue;
-        order = sc.stackAt(len + 1);
-        order[len++] = t.left[n];
-        order[len++] = t.right[n];
-      }
-      for (let i = len - 1; i >= 0; i--) t.computeBox(order[i]);
-    } finally {
-      sc.release();
-    }
-  }
-  rebuild() {
-    this.tree.build();
-    this.peakSize = this.items.size;
-  }
-  /** Deepest leaf, counting the root as depth 0. */
-  maxDepth() {
-    const t = this.tree;
-    if (t.root === -1) return 0;
-    let deepest = 0;
-    const stack = [[t.root, 0]];
-    while (stack.length > 0) {
-      const [n, d] = stack.pop();
-      if (t.left[n] === -1) deepest = Math.max(deepest, d);
-      else stack.push([t.left[n], d + 1], [t.right[n], d + 1]);
-    }
-    return deepest;
-  }
-  queryBox(box, visit) {
-    queryOverlap(this.tree, this.scratch, box, 0, this.dim, visit);
-  }
-  queryPoint(p, visit) {
-    queryOverlap(this.tree, this.scratch, p, 0, 0, visit);
-  }
-  raycast(origin, dir, visit, tMax = Infinity) {
-    raycast(this.tree, this.scratch, origin, dir, visit, tMax);
-  }
-  queryHalfSpaces(planes, visit) {
-    queryHalfSpaces(this.tree, this.scratch, planes, visit);
-  }
-  leafHolds(leaf, box) {
-    const d = this.dim;
-    const o = leaf * 2 * d;
-    const nb = this.tree.nodeBox;
-    for (let j = 0; j < d; j++) if (box[j] < nb[o + j] || box[d + j] > nb[o + d + j]) return false;
-    return true;
-  }
-  /** Descend by least enlargement and add `it` to a leaf, splitting it when full. */
-  place(it) {
-    const t = this.tree;
-    if (t.root === -1) {
-      t.root = t.allocNode(-1);
-      t.placeInLeaf(t.root, it);
-      t.computeBox(t.root);
-      return;
-    }
-    let n = t.root;
-    let depth = 0;
-    while (t.left[n] !== -1) {
-      const l = t.left[n];
-      const r = t.right[n];
-      const el = this.enlargement(l, it);
-      const er = this.enlargement(r, it);
-      n = el < er || el === er && t.count[l] <= t.count[r] ? l : r;
-      depth++;
-    }
-    if (t.leafCount[n] < LEAF_SIZE) t.placeInLeaf(n, it);
-    else {
-      t.splitLeaf(n, it);
-      depth++;
-    }
-    t.refitUp(n);
-    if (depth > depthLimit(this.items.size)) this.rebalance(t.itemLeaf[it], depth);
-  }
-  /** Least enlargement alone lets sorted or coincident inserts grow one
-   *  spine. Rebuild the lowest ancestor whose balanced rebuild brings this
-   *  leaf back within the limit, preferring a weight-unbalanced one. */
-  rebalance(leaf, depth) {
-    const t = this.tree;
-    const limit = depthLimit(this.items.size);
-    let fit = -1;
-    for (let c = leaf, a = t.parent[leaf], d = depth - 1; a !== -1; c = a, a = t.parent[a], d--) {
-      if (d + balancedHeight(t.count[a]) > limit) continue;
-      if (t.count[c] > ALPHA * t.count[a]) {
-        t.rebuildSubtree(a);
-        return;
+function createSettledCache({ reads = 2 } = {}) {
+  if (!(reads >= 1) || !Number.isInteger(reads)) throw new RangeError(`createSettledCache: reads must be a positive integer, got ${reads}`);
+  let seen;
+  let count = 0;
+  let built = null;
+  return {
+    read(key, build) {
+      if (seen === void 0 || !sameKey(seen, key)) {
+        seen = key.slice();
+        count = 0;
+        built = null;
       }
-      if (fit === -1) fit = a;
-    }
-    if (fit !== -1) t.rebuildSubtree(fit);
-    else this.rebuild();
-  }
-  /** Margin (sum of extents) a node would gain by covering item `it`. Margin
-   *  rather than volume, so zero-extent boxes still rank. */
-  enlargement(n, it) {
-    const d = this.dim;
-    const nb = this.tree.nodeBox;
-    const ib = this.tree.itemBox;
-    const o = n * 2 * d;
-    const io = it * 2 * d;
-    let grow2 = 0;
-    for (let j = 0; j < d; j++) {
-      const lo = Math.min(nb[o + j], ib[io + j]);
-      const hi = Math.max(nb[o + d + j], ib[io + d + j]);
-      grow2 += hi - lo - (nb[o + d + j] - nb[o + j]);
-    }
-    return grow2;
-  }
-  /** Take `it` out of its leaf, collapsing the leaf into its sibling when it empties. */
-  detach(it) {
-    const t = this.tree;
-    const leaf = t.itemLeaf[it];
-    const base = leaf * LEAF_SIZE;
-    const count = t.leafCount[leaf];
-    for (let k = 0; k < count; k++) {
-      if (t.leafItems[base + k] !== it) continue;
-      t.leafItems[base + k] = t.leafItems[base + count - 1];
-      break;
-    }
-    t.leafCount[leaf] = count - 1;
-    t.itemLeaf[it] = -1;
-    if (count > 1) {
-      t.refitUp(leaf);
-      return;
-    }
-    const p = t.parent[leaf];
-    t.freeNode(leaf);
-    if (p === -1) {
-      t.root = -1;
-      return;
+      if (built !== null) return built.value;
+      if (++count < reads) return null;
+      built = { value: build() };
+      return built.value;
+    },
+    clear() {
+      seen = void 0;
+      count = 0;
+      built = null;
     }
-    const sib = t.left[p] === leaf ? t.right[p] : t.left[p];
-    const g = t.parent[p];
-    t.parent[sib] = g;
-    if (g === -1) t.root = sib;
-    else if (t.left[g] === p) t.left[g] = sib;
-    else t.right[g] = sib;
-    t.freeNode(p);
-    t.refitUp(g);
-  }
-};
-function createBvh(dim, entries) {
-  if (!Number.isInteger(dim) || dim < 1) throw new RangeError(`createBvh: dim must be a positive integer, got ${dim}`);
-  const bvh = new BvhImpl(dim);
-  if (entries) {
-    bvh.load(entries);
-    bvh.rebuild();
-  }
-  return bvh;
+  };
 }
 
-export { closestBetweenFlats, closestOnFlat, createBvh, flatDim, intersectFlats, resolveSnap, stepLine };
+export { closestBetweenFlats, closestOnFlat, createSettledCache, flatDim, intersectFlats, resolveSnap, stepLine };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map