build-dxf 0.0.19 → 0.0.20-1

package/src/index2.js

@@ -1,3541 +1,10 @@
 import { C as Component, P as Point, V as Variable, D as DxfSystem, M as ModelDataPlugin, a as DetailsPoint, W as WhiteModel } from "./build.js";
 import * as THREE from "three";
-import { BufferAttribute, Vector3, Plane, Line3, Vector2, Triangle, Sphere, Matrix4, Box3, BackSide, DoubleSide, REVISION, FrontSide, Mesh, BatchedMesh, Ray, Group } from "three";
+import { Group } from "three";
 import "clipper-lib";
 import "dxf-writer";
-import { CSS3DObject, CSS3DSprite, CSS3DRenderer } from "three/addons/renderers/CSS3DRenderer.js";
-import { CSS2DObject, CSS2DRenderer } from "three/addons/renderers/CSS2DRenderer.js";
-import { OrbitControls } from "three/addons/controls/OrbitControls.js";
-import * as TWEEN from "@tweenjs/tween.js";
+import { E as ElButton, R as Renderer, L as Lines, D as DomEventRegister, a as DomContainer, b as ElCheckbox, S as SelectLocalFile } from "./selectLocalFile.js";
 import { defineComponent, createElementBlock, openBlock, createElementVNode, toDisplayString, createVNode, unref, withCtx, createTextVNode, createApp, ref, watch, onMounted, onUnmounted, createCommentVNode, createStaticVNode } from "vue";
-import { E as ElButton, L as Lines, a as ElCheckbox, S as SelectLocalFile } from "./selectLocalFile.js";
-const CENTER = 0;
-const AVERAGE = 1;
-const SAH = 2;
-const CONTAINED = 2;
-const TRIANGLE_INTERSECT_COST = 1.25;
-const TRAVERSAL_COST = 1;
-const BYTES_PER_NODE = 6 * 4 + 4 + 4;
-const IS_LEAFNODE_FLAG = 65535;
-const FLOAT32_EPSILON = Math.pow(2, -24);
-const SKIP_GENERATION = Symbol("SKIP_GENERATION");
-function getVertexCount(geo) {
-  return geo.index ? geo.index.count : geo.attributes.position.count;
-}
-function getTriCount(geo) {
-  return getVertexCount(geo) / 3;
-}
-function getIndexArray(vertexCount, BufferConstructor = ArrayBuffer) {
-  if (vertexCount > 65535) {
-    return new Uint32Array(new BufferConstructor(4 * vertexCount));
-  } else {
-    return new Uint16Array(new BufferConstructor(2 * vertexCount));
-  }
-}
-function ensureIndex(geo, options) {
-  if (!geo.index) {
-    const vertexCount = geo.attributes.position.count;
-    const BufferConstructor = options.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer;
-    const index2 = getIndexArray(vertexCount, BufferConstructor);
-    geo.setIndex(new BufferAttribute(index2, 1));
-    for (let i = 0; i < vertexCount; i++) {
-      index2[i] = i;
-    }
-  }
-}
-function getFullGeometryRange(geo, range) {
-  const triCount = getTriCount(geo);
-  const drawRange = range ? range : geo.drawRange;
-  const start = drawRange.start / 3;
-  const end = (drawRange.start + drawRange.count) / 3;
-  const offset = Math.max(0, start);
-  const count = Math.min(triCount, end) - offset;
-  return [{
-    offset: Math.floor(offset),
-    count: Math.floor(count)
-  }];
-}
-function getRootIndexRanges(geo, range) {
-  if (!geo.groups || !geo.groups.length) {
-    return getFullGeometryRange(geo, range);
-  }
-  const ranges = [];
-  const rangeBoundaries = /* @__PURE__ */ new Set();
-  const drawRange = range ? range : geo.drawRange;
-  const drawRangeStart = drawRange.start / 3;
-  const drawRangeEnd = (drawRange.start + drawRange.count) / 3;
-  for (const group of geo.groups) {
-    const groupStart = group.start / 3;
-    const groupEnd = (group.start + group.count) / 3;
-    rangeBoundaries.add(Math.max(drawRangeStart, groupStart));
-    rangeBoundaries.add(Math.min(drawRangeEnd, groupEnd));
-  }
-  const sortedBoundaries = Array.from(rangeBoundaries.values()).sort((a, b) => a - b);
-  for (let i = 0; i < sortedBoundaries.length - 1; i++) {
-    const start = sortedBoundaries[i];
-    const end = sortedBoundaries[i + 1];
-    ranges.push({
-      offset: Math.floor(start),
-      count: Math.floor(end - start)
-    });
-  }
-  return ranges;
-}
-function hasGroupGaps(geometry, range) {
-  const vertexCount = getTriCount(geometry);
-  const groups = getRootIndexRanges(geometry, range).sort((a, b) => a.offset - b.offset);
-  const finalGroup = groups[groups.length - 1];
-  finalGroup.count = Math.min(vertexCount - finalGroup.offset, finalGroup.count);
-  let total = 0;
-  groups.forEach(({ count }) => total += count);
-  return vertexCount !== total;
-}
-function getBounds(triangleBounds, offset, count, target, centroidTarget) {
-  let minx = Infinity;
-  let miny = Infinity;
-  let minz = Infinity;
-  let maxx = -Infinity;
-  let maxy = -Infinity;
-  let maxz = -Infinity;
-  let cminx = Infinity;
-  let cminy = Infinity;
-  let cminz = Infinity;
-  let cmaxx = -Infinity;
-  let cmaxy = -Infinity;
-  let cmaxz = -Infinity;
-  for (let i = offset * 6, end = (offset + count) * 6; i < end; i += 6) {
-    const cx = triangleBounds[i + 0];
-    const hx = triangleBounds[i + 1];
-    const lx = cx - hx;
-    const rx = cx + hx;
-    if (lx < minx) minx = lx;
-    if (rx > maxx) maxx = rx;
-    if (cx < cminx) cminx = cx;
-    if (cx > cmaxx) cmaxx = cx;
-    const cy = triangleBounds[i + 2];
-    const hy = triangleBounds[i + 3];
-    const ly = cy - hy;
-    const ry = cy + hy;
-    if (ly < miny) miny = ly;
-    if (ry > maxy) maxy = ry;
-    if (cy < cminy) cminy = cy;
-    if (cy > cmaxy) cmaxy = cy;
-    const cz = triangleBounds[i + 4];
-    const hz = triangleBounds[i + 5];
-    const lz = cz - hz;
-    const rz = cz + hz;
-    if (lz < minz) minz = lz;
-    if (rz > maxz) maxz = rz;
-    if (cz < cminz) cminz = cz;
-    if (cz > cmaxz) cmaxz = cz;
-  }
-  target[0] = minx;
-  target[1] = miny;
-  target[2] = minz;
-  target[3] = maxx;
-  target[4] = maxy;
-  target[5] = maxz;
-  centroidTarget[0] = cminx;
-  centroidTarget[1] = cminy;
-  centroidTarget[2] = cminz;
-  centroidTarget[3] = cmaxx;
-  centroidTarget[4] = cmaxy;
-  centroidTarget[5] = cmaxz;
-}
-function computeTriangleBounds(geo, target = null, offset = null, count = null) {
-  const posAttr = geo.attributes.position;
-  const index2 = geo.index ? geo.index.array : null;
-  const triCount = getTriCount(geo);
-  const normalized = posAttr.normalized;
-  let triangleBounds;
-  if (target === null) {
-    triangleBounds = new Float32Array(triCount * 6);
-    offset = 0;
-    count = triCount;
-  } else {
-    triangleBounds = target;
-    offset = offset || 0;
-    count = count || triCount;
-  }
-  const posArr = posAttr.array;
-  const bufferOffset = posAttr.offset || 0;
-  let stride = 3;
-  if (posAttr.isInterleavedBufferAttribute) {
-    stride = posAttr.data.stride;
-  }
-  const getters = ["getX", "getY", "getZ"];
-  for (let tri = offset; tri < offset + count; tri++) {
-    const tri3 = tri * 3;
-    const tri6 = tri * 6;
-    let ai = tri3 + 0;
-    let bi = tri3 + 1;
-    let ci = tri3 + 2;
-    if (index2) {
-      ai = index2[ai];
-      bi = index2[bi];
-      ci = index2[ci];
-    }
-    if (!normalized) {
-      ai = ai * stride + bufferOffset;
-      bi = bi * stride + bufferOffset;
-      ci = ci * stride + bufferOffset;
-    }
-    for (let el = 0; el < 3; el++) {
-      let a, b, c;
-      if (normalized) {
-        a = posAttr[getters[el]](ai);
-        b = posAttr[getters[el]](bi);
-        c = posAttr[getters[el]](ci);
-      } else {
-        a = posArr[ai + el];
-        b = posArr[bi + el];
-        c = posArr[ci + el];
-      }
-      let min = a;
-      if (b < min) min = b;
-      if (c < min) min = c;
-      let max = a;
-      if (b > max) max = b;
-      if (c > max) max = c;
-      const halfExtents = (max - min) / 2;
-      const el2 = el * 2;
-      triangleBounds[tri6 + el2 + 0] = min + halfExtents;
-      triangleBounds[tri6 + el2 + 1] = halfExtents + (Math.abs(min) + halfExtents) * FLOAT32_EPSILON;
-    }
-  }
-  return triangleBounds;
-}
-function arrayToBox(nodeIndex32, array, target) {
-  target.min.x = array[nodeIndex32];
-  target.min.y = array[nodeIndex32 + 1];
-  target.min.z = array[nodeIndex32 + 2];
-  target.max.x = array[nodeIndex32 + 3];
-  target.max.y = array[nodeIndex32 + 4];
-  target.max.z = array[nodeIndex32 + 5];
-  return target;
-}
-function getLongestEdgeIndex(bounds) {
-  let splitDimIdx = -1;
-  let splitDist = -Infinity;
-  for (let i = 0; i < 3; i++) {
-    const dist = bounds[i + 3] - bounds[i];
-    if (dist > splitDist) {
-      splitDist = dist;
-      splitDimIdx = i;
-    }
-  }
-  return splitDimIdx;
-}
-function copyBounds(source, target) {
-  target.set(source);
-}
-function unionBounds(a, b, target) {
-  let aVal, bVal;
-  for (let d = 0; d < 3; d++) {
-    const d3 = d + 3;
-    aVal = a[d];
-    bVal = b[d];
-    target[d] = aVal < bVal ? aVal : bVal;
-    aVal = a[d3];
-    bVal = b[d3];
-    target[d3] = aVal > bVal ? aVal : bVal;
-  }
-}
-function expandByTriangleBounds(startIndex, triangleBounds, bounds) {
-  for (let d = 0; d < 3; d++) {
-    const tCenter = triangleBounds[startIndex + 2 * d];
-    const tHalf = triangleBounds[startIndex + 2 * d + 1];
-    const tMin = tCenter - tHalf;
-    const tMax = tCenter + tHalf;
-    if (tMin < bounds[d]) {
-      bounds[d] = tMin;
-    }
-    if (tMax > bounds[d + 3]) {
-      bounds[d + 3] = tMax;
-    }
-  }
-}
-function computeSurfaceArea(bounds) {
-  const d0 = bounds[3] - bounds[0];
-  const d1 = bounds[4] - bounds[1];
-  const d2 = bounds[5] - bounds[2];
-  return 2 * (d0 * d1 + d1 * d2 + d2 * d0);
-}
-const BIN_COUNT = 32;
-const binsSort = (a, b) => a.candidate - b.candidate;
-const sahBins = new Array(BIN_COUNT).fill().map(() => {
-  return {
-    count: 0,
-    bounds: new Float32Array(6),
-    rightCacheBounds: new Float32Array(6),
-    leftCacheBounds: new Float32Array(6),
-    candidate: 0
-  };
-});
-const leftBounds = new Float32Array(6);
-function getOptimalSplit(nodeBoundingData, centroidBoundingData, triangleBounds, offset, count, strategy) {
-  let axis = -1;
-  let pos = 0;
-  if (strategy === CENTER) {
-    axis = getLongestEdgeIndex(centroidBoundingData);
-    if (axis !== -1) {
-      pos = (centroidBoundingData[axis] + centroidBoundingData[axis + 3]) / 2;
-    }
-  } else if (strategy === AVERAGE) {
-    axis = getLongestEdgeIndex(nodeBoundingData);
-    if (axis !== -1) {
-      pos = getAverage(triangleBounds, offset, count, axis);
-    }
-  } else if (strategy === SAH) {
-    const rootSurfaceArea = computeSurfaceArea(nodeBoundingData);
-    let bestCost = TRIANGLE_INTERSECT_COST * count;
-    const cStart = offset * 6;
-    const cEnd = (offset + count) * 6;
-    for (let a = 0; a < 3; a++) {
-      const axisLeft = centroidBoundingData[a];
-      const axisRight = centroidBoundingData[a + 3];
-      const axisLength = axisRight - axisLeft;
-      const binWidth = axisLength / BIN_COUNT;
-      if (count < BIN_COUNT / 4) {
-        const truncatedBins = [...sahBins];
-        truncatedBins.length = count;
-        let b = 0;
-        for (let c = cStart; c < cEnd; c += 6, b++) {
-          const bin = truncatedBins[b];
-          bin.candidate = triangleBounds[c + 2 * a];
-          bin.count = 0;
-          const {
-            bounds,
-            leftCacheBounds,
-            rightCacheBounds
-          } = bin;
-          for (let d = 0; d < 3; d++) {
-            rightCacheBounds[d] = Infinity;
-            rightCacheBounds[d + 3] = -Infinity;
-            leftCacheBounds[d] = Infinity;
-            leftCacheBounds[d + 3] = -Infinity;
-            bounds[d] = Infinity;
-            bounds[d + 3] = -Infinity;
-          }
-          expandByTriangleBounds(c, triangleBounds, bounds);
-        }
-        truncatedBins.sort(binsSort);
-        let splitCount = count;
-        for (let bi = 0; bi < splitCount; bi++) {
-          const bin = truncatedBins[bi];
-          while (bi + 1 < splitCount && truncatedBins[bi + 1].candidate === bin.candidate) {
-            truncatedBins.splice(bi + 1, 1);
-            splitCount--;
-          }
-        }
-        for (let c = cStart; c < cEnd; c += 6) {
-          const center = triangleBounds[c + 2 * a];
-          for (let bi = 0; bi < splitCount; bi++) {
-            const bin = truncatedBins[bi];
-            if (center >= bin.candidate) {
-              expandByTriangleBounds(c, triangleBounds, bin.rightCacheBounds);
-            } else {
-              expandByTriangleBounds(c, triangleBounds, bin.leftCacheBounds);
-              bin.count++;
-            }
-          }
-        }
-        for (let bi = 0; bi < splitCount; bi++) {
-          const bin = truncatedBins[bi];
-          const leftCount = bin.count;
-          const rightCount = count - bin.count;
-          const leftBounds2 = bin.leftCacheBounds;
-          const rightBounds = bin.rightCacheBounds;
-          let leftProb = 0;
-          if (leftCount !== 0) {
-            leftProb = computeSurfaceArea(leftBounds2) / rootSurfaceArea;
-          }
-          let rightProb = 0;
-          if (rightCount !== 0) {
-            rightProb = computeSurfaceArea(rightBounds) / rootSurfaceArea;
-          }
-          const cost = TRAVERSAL_COST + TRIANGLE_INTERSECT_COST * (leftProb * leftCount + rightProb * rightCount);
-          if (cost < bestCost) {
-            axis = a;
-            bestCost = cost;
-            pos = bin.candidate;
-          }
-        }
-      } else {
-        for (let i = 0; i < BIN_COUNT; i++) {
-          const bin = sahBins[i];
-          bin.count = 0;
-          bin.candidate = axisLeft + binWidth + i * binWidth;
-          const bounds = bin.bounds;
-          for (let d = 0; d < 3; d++) {
-            bounds[d] = Infinity;
-            bounds[d + 3] = -Infinity;
-          }
-        }
-        for (let c = cStart; c < cEnd; c += 6) {
-          const triCenter = triangleBounds[c + 2 * a];
-          const relativeCenter = triCenter - axisLeft;
-          let binIndex = ~~(relativeCenter / binWidth);
-          if (binIndex >= BIN_COUNT) binIndex = BIN_COUNT - 1;
-          const bin = sahBins[binIndex];
-          bin.count++;
-          expandByTriangleBounds(c, triangleBounds, bin.bounds);
-        }
-        const lastBin = sahBins[BIN_COUNT - 1];
-        copyBounds(lastBin.bounds, lastBin.rightCacheBounds);
-        for (let i = BIN_COUNT - 2; i >= 0; i--) {
-          const bin = sahBins[i];
-          const nextBin = sahBins[i + 1];
-          unionBounds(bin.bounds, nextBin.rightCacheBounds, bin.rightCacheBounds);
-        }
-        let leftCount = 0;
-        for (let i = 0; i < BIN_COUNT - 1; i++) {
-          const bin = sahBins[i];
-          const binCount = bin.count;
-          const bounds = bin.bounds;
-          const nextBin = sahBins[i + 1];
-          const rightBounds = nextBin.rightCacheBounds;
-          if (binCount !== 0) {
-            if (leftCount === 0) {
-              copyBounds(bounds, leftBounds);
-            } else {
-              unionBounds(bounds, leftBounds, leftBounds);
-            }
-          }
-          leftCount += binCount;
-          let leftProb = 0;
-          let rightProb = 0;
-          if (leftCount !== 0) {
-            leftProb = computeSurfaceArea(leftBounds) / rootSurfaceArea;
-          }
-          const rightCount = count - leftCount;
-          if (rightCount !== 0) {
-            rightProb = computeSurfaceArea(rightBounds) / rootSurfaceArea;
-          }
-          const cost = TRAVERSAL_COST + TRIANGLE_INTERSECT_COST * (leftProb * leftCount + rightProb * rightCount);
-          if (cost < bestCost) {
-            axis = a;
-            bestCost = cost;
-            pos = bin.candidate;
-          }
-        }
-      }
-    }
-  } else {
-    console.warn(`MeshBVH: Invalid build strategy value ${strategy} used.`);
-  }
-  return { axis, pos };
-}
-function getAverage(triangleBounds, offset, count, axis) {
-  let avg = 0;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    avg += triangleBounds[i * 6 + axis * 2];
-  }
-  return avg / count;
-}
-class MeshBVHNode {
-  constructor() {
-    this.boundingData = new Float32Array(6);
-  }
-}
-function partition(indirectBuffer, index2, triangleBounds, offset, count, split) {
-  let left = offset;
-  let right = offset + count - 1;
-  const pos = split.pos;
-  const axisOffset = split.axis * 2;
-  while (true) {
-    while (left <= right && triangleBounds[left * 6 + axisOffset] < pos) {
-      left++;
-    }
-    while (left <= right && triangleBounds[right * 6 + axisOffset] >= pos) {
-      right--;
-    }
-    if (left < right) {
-      for (let i = 0; i < 3; i++) {
-        let t0 = index2[left * 3 + i];
-        index2[left * 3 + i] = index2[right * 3 + i];
-        index2[right * 3 + i] = t0;
-      }
-      for (let i = 0; i < 6; i++) {
-        let tb = triangleBounds[left * 6 + i];
-        triangleBounds[left * 6 + i] = triangleBounds[right * 6 + i];
-        triangleBounds[right * 6 + i] = tb;
-      }
-      left++;
-      right--;
-    } else {
-      return left;
-    }
-  }
-}
-function partition_indirect(indirectBuffer, index2, triangleBounds, offset, count, split) {
-  let left = offset;
-  let right = offset + count - 1;
-  const pos = split.pos;
-  const axisOffset = split.axis * 2;
-  while (true) {
-    while (left <= right && triangleBounds[left * 6 + axisOffset] < pos) {
-      left++;
-    }
-    while (left <= right && triangleBounds[right * 6 + axisOffset] >= pos) {
-      right--;
-    }
-    if (left < right) {
-      let t = indirectBuffer[left];
-      indirectBuffer[left] = indirectBuffer[right];
-      indirectBuffer[right] = t;
-      for (let i = 0; i < 6; i++) {
-        let tb = triangleBounds[left * 6 + i];
-        triangleBounds[left * 6 + i] = triangleBounds[right * 6 + i];
-        triangleBounds[right * 6 + i] = tb;
-      }
-      left++;
-      right--;
-    } else {
-      return left;
-    }
-  }
-}
-function IS_LEAF(n16, uint16Array2) {
-  return uint16Array2[n16 + 15] === 65535;
-}
-function OFFSET(n32, uint32Array2) {
-  return uint32Array2[n32 + 6];
-}
-function COUNT(n16, uint16Array2) {
-  return uint16Array2[n16 + 14];
-}
-function LEFT_NODE(n32) {
-  return n32 + 8;
-}
-function RIGHT_NODE(n32, uint32Array2) {
-  return uint32Array2[n32 + 6];
-}
-function SPLIT_AXIS(n32, uint32Array2) {
-  return uint32Array2[n32 + 7];
-}
-function BOUNDING_DATA_INDEX(n32) {
-  return n32;
-}
-let float32Array, uint32Array, uint16Array, uint8Array;
-const MAX_POINTER = Math.pow(2, 32);
-function countNodes(node) {
-  if ("count" in node) {
-    return 1;
-  } else {
-    return 1 + countNodes(node.left) + countNodes(node.right);
-  }
-}
-function populateBuffer(byteOffset, node, buffer) {
-  float32Array = new Float32Array(buffer);
-  uint32Array = new Uint32Array(buffer);
-  uint16Array = new Uint16Array(buffer);
-  uint8Array = new Uint8Array(buffer);
-  return _populateBuffer(byteOffset, node);
-}
-function _populateBuffer(byteOffset, node) {
-  const stride4Offset = byteOffset / 4;
-  const stride2Offset = byteOffset / 2;
-  const isLeaf = "count" in node;
-  const boundingData = node.boundingData;
-  for (let i = 0; i < 6; i++) {
-    float32Array[stride4Offset + i] = boundingData[i];
-  }
-  if (isLeaf) {
-    if (node.buffer) {
-      const buffer = node.buffer;
-      uint8Array.set(new Uint8Array(buffer), byteOffset);
-      for (let offset = byteOffset, l = byteOffset + buffer.byteLength; offset < l; offset += BYTES_PER_NODE) {
-        const offset2 = offset / 2;
-        if (!IS_LEAF(offset2, uint16Array)) {
-          uint32Array[offset / 4 + 6] += stride4Offset;
-        }
-      }
-      return byteOffset + buffer.byteLength;
-    } else {
-      const offset = node.offset;
-      const count = node.count;
-      uint32Array[stride4Offset + 6] = offset;
-      uint16Array[stride2Offset + 14] = count;
-      uint16Array[stride2Offset + 15] = IS_LEAFNODE_FLAG;
-      return byteOffset + BYTES_PER_NODE;
-    }
-  } else {
-    const left = node.left;
-    const right = node.right;
-    const splitAxis = node.splitAxis;
-    let nextUnusedPointer;
-    nextUnusedPointer = _populateBuffer(byteOffset + BYTES_PER_NODE, left);
-    if (nextUnusedPointer / 4 > MAX_POINTER) {
-      throw new Error("MeshBVH: Cannot store child pointer greater than 32 bits.");
-    }
-    uint32Array[stride4Offset + 6] = nextUnusedPointer / 4;
-    nextUnusedPointer = _populateBuffer(nextUnusedPointer, right);
-    uint32Array[stride4Offset + 7] = splitAxis;
-    return nextUnusedPointer;
-  }
-}
-function generateIndirectBuffer(geometry, useSharedArrayBuffer) {
-  const triCount = (geometry.index ? geometry.index.count : geometry.attributes.position.count) / 3;
-  const useUint32 = triCount > 2 ** 16;
-  const byteCount = useUint32 ? 4 : 2;
-  const buffer = useSharedArrayBuffer ? new SharedArrayBuffer(triCount * byteCount) : new ArrayBuffer(triCount * byteCount);
-  const indirectBuffer = useUint32 ? new Uint32Array(buffer) : new Uint16Array(buffer);
-  for (let i = 0, l = indirectBuffer.length; i < l; i++) {
-    indirectBuffer[i] = i;
-  }
-  return indirectBuffer;
-}
-function buildTree(bvh, triangleBounds, offset, count, options) {
-  const {
-    maxDepth,
-    verbose,
-    maxLeafTris,
-    strategy,
-    onProgress,
-    indirect
-  } = options;
-  const indirectBuffer = bvh._indirectBuffer;
-  const geometry = bvh.geometry;
-  const indexArray = geometry.index ? geometry.index.array : null;
-  const partionFunc = indirect ? partition_indirect : partition;
-  const totalTriangles = getTriCount(geometry);
-  const cacheCentroidBoundingData = new Float32Array(6);
-  let reachedMaxDepth = false;
-  const root = new MeshBVHNode();
-  getBounds(triangleBounds, offset, count, root.boundingData, cacheCentroidBoundingData);
-  splitNode(root, offset, count, cacheCentroidBoundingData);
-  return root;
-  function triggerProgress(trianglesProcessed) {
-    if (onProgress) {
-      onProgress(trianglesProcessed / totalTriangles);
-    }
-  }
-  function splitNode(node, offset2, count2, centroidBoundingData = null, depth = 0) {
-    if (!reachedMaxDepth && depth >= maxDepth) {
-      reachedMaxDepth = true;
-      if (verbose) {
-        console.warn(`MeshBVH: Max depth of ${maxDepth} reached when generating BVH. Consider increasing maxDepth.`);
-        console.warn(geometry);
-      }
-    }
-    if (count2 <= maxLeafTris || depth >= maxDepth) {
-      triggerProgress(offset2 + count2);
-      node.offset = offset2;
-      node.count = count2;
-      return node;
-    }
-    const split = getOptimalSplit(node.boundingData, centroidBoundingData, triangleBounds, offset2, count2, strategy);
-    if (split.axis === -1) {
-      triggerProgress(offset2 + count2);
-      node.offset = offset2;
-      node.count = count2;
-      return node;
-    }
-    const splitOffset = partionFunc(indirectBuffer, indexArray, triangleBounds, offset2, count2, split);
-    if (splitOffset === offset2 || splitOffset === offset2 + count2) {
-      triggerProgress(offset2 + count2);
-      node.offset = offset2;
-      node.count = count2;
-    } else {
-      node.splitAxis = split.axis;
-      const left = new MeshBVHNode();
-      const lstart = offset2;
-      const lcount = splitOffset - offset2;
-      node.left = left;
-      getBounds(triangleBounds, lstart, lcount, left.boundingData, cacheCentroidBoundingData);
-      splitNode(left, lstart, lcount, cacheCentroidBoundingData, depth + 1);
-      const right = new MeshBVHNode();
-      const rstart = splitOffset;
-      const rcount = count2 - lcount;
-      node.right = right;
-      getBounds(triangleBounds, rstart, rcount, right.boundingData, cacheCentroidBoundingData);
-      splitNode(right, rstart, rcount, cacheCentroidBoundingData, depth + 1);
-    }
-    return node;
-  }
-}
-function buildPackedTree(bvh, options) {
-  const geometry = bvh.geometry;
-  if (options.indirect) {
-    bvh._indirectBuffer = generateIndirectBuffer(geometry, options.useSharedArrayBuffer);
-    if (hasGroupGaps(geometry, options.range) && !options.verbose) {
-      console.warn(
-        'MeshBVH: Provided geometry contains groups or a range that do not fully span the vertex contents while using the "indirect" option. BVH may incorrectly report intersections on unrendered portions of the geometry.'
-      );
-    }
-  }
-  if (!bvh._indirectBuffer) {
-    ensureIndex(geometry, options);
-  }
-  const BufferConstructor = options.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer;
-  const triangleBounds = computeTriangleBounds(geometry);
-  const geometryRanges = options.indirect ? getFullGeometryRange(geometry, options.range) : getRootIndexRanges(geometry, options.range);
-  bvh._roots = geometryRanges.map((range) => {
-    const root = buildTree(bvh, triangleBounds, range.offset, range.count, options);
-    const nodeCount = countNodes(root);
-    const buffer = new BufferConstructor(BYTES_PER_NODE * nodeCount);
-    populateBuffer(0, root, buffer);
-    return buffer;
-  });
-}
-class SeparatingAxisBounds {
-  constructor() {
-    this.min = Infinity;
-    this.max = -Infinity;
-  }
-  setFromPointsField(points, field) {
-    let min = Infinity;
-    let max = -Infinity;
-    for (let i = 0, l = points.length; i < l; i++) {
-      const p = points[i];
-      const val = p[field];
-      min = val < min ? val : min;
-      max = val > max ? val : max;
-    }
-    this.min = min;
-    this.max = max;
-  }
-  setFromPoints(axis, points) {
-    let min = Infinity;
-    let max = -Infinity;
-    for (let i = 0, l = points.length; i < l; i++) {
-      const p = points[i];
-      const val = axis.dot(p);
-      min = val < min ? val : min;
-      max = val > max ? val : max;
-    }
-    this.min = min;
-    this.max = max;
-  }
-  isSeparated(other) {
-    return this.min > other.max || other.min > this.max;
-  }
-}
-SeparatingAxisBounds.prototype.setFromBox = (function() {
-  const p = new Vector3();
-  return function setFromBox(axis, box) {
-    const boxMin = box.min;
-    const boxMax = box.max;
-    let min = Infinity;
-    let max = -Infinity;
-    for (let x = 0; x <= 1; x++) {
-      for (let y = 0; y <= 1; y++) {
-        for (let z = 0; z <= 1; z++) {
-          p.x = boxMin.x * x + boxMax.x * (1 - x);
-          p.y = boxMin.y * y + boxMax.y * (1 - y);
-          p.z = boxMin.z * z + boxMax.z * (1 - z);
-          const val = axis.dot(p);
-          min = Math.min(val, min);
-          max = Math.max(val, max);
-        }
-      }
-    }
-    this.min = min;
-    this.max = max;
-  };
-})();
-const closestPointLineToLine = (function() {
-  const dir1 = new Vector3();
-  const dir2 = new Vector3();
-  const v02 = new Vector3();
-  return function closestPointLineToLine2(l1, l2, result) {
-    const v0 = l1.start;
-    const v10 = dir1;
-    const v2 = l2.start;
-    const v32 = dir2;
-    v02.subVectors(v0, v2);
-    dir1.subVectors(l1.end, l1.start);
-    dir2.subVectors(l2.end, l2.start);
-    const d0232 = v02.dot(v32);
-    const d3210 = v32.dot(v10);
-    const d3232 = v32.dot(v32);
-    const d0210 = v02.dot(v10);
-    const d1010 = v10.dot(v10);
-    const denom = d1010 * d3232 - d3210 * d3210;
-    let d, d2;
-    if (denom !== 0) {
-      d = (d0232 * d3210 - d0210 * d3232) / denom;
-    } else {
-      d = 0;
-    }
-    d2 = (d0232 + d * d3210) / d3232;
-    result.x = d;
-    result.y = d2;
-  };
-})();
-const closestPointsSegmentToSegment = (function() {
-  const paramResult = new Vector2();
-  const temp12 = new Vector3();
-  const temp22 = new Vector3();
-  return function closestPointsSegmentToSegment2(l1, l2, target1, target2) {
-    closestPointLineToLine(l1, l2, paramResult);
-    let d = paramResult.x;
-    let d2 = paramResult.y;
-    if (d >= 0 && d <= 1 && d2 >= 0 && d2 <= 1) {
-      l1.at(d, target1);
-      l2.at(d2, target2);
-      return;
-    } else if (d >= 0 && d <= 1) {
-      if (d2 < 0) {
-        l2.at(0, target2);
-      } else {
-        l2.at(1, target2);
-      }
-      l1.closestPointToPoint(target2, true, target1);
-      return;
-    } else if (d2 >= 0 && d2 <= 1) {
-      if (d < 0) {
-        l1.at(0, target1);
-      } else {
-        l1.at(1, target1);
-      }
-      l2.closestPointToPoint(target1, true, target2);
-      return;
-    } else {
-      let p;
-      if (d < 0) {
-        p = l1.start;
-      } else {
-        p = l1.end;
-      }
-      let p2;
-      if (d2 < 0) {
-        p2 = l2.start;
-      } else {
-        p2 = l2.end;
-      }
-      const closestPoint = temp12;
-      const closestPoint2 = temp22;
-      l1.closestPointToPoint(p2, true, temp12);
-      l2.closestPointToPoint(p, true, temp22);
-      if (closestPoint.distanceToSquared(p2) <= closestPoint2.distanceToSquared(p)) {
-        target1.copy(closestPoint);
-        target2.copy(p2);
-        return;
-      } else {
-        target1.copy(p);
-        target2.copy(closestPoint2);
-        return;
-      }
-    }
-  };
-})();
-const sphereIntersectTriangle = (function() {
-  const closestPointTemp = new Vector3();
-  const projectedPointTemp = new Vector3();
-  const planeTemp = new Plane();
-  const lineTemp = new Line3();
-  return function sphereIntersectTriangle2(sphere, triangle3) {
-    const { radius, center } = sphere;
-    const { a, b, c } = triangle3;
-    lineTemp.start = a;
-    lineTemp.end = b;
-    const closestPoint1 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint1.distanceTo(center) <= radius) return true;
-    lineTemp.start = a;
-    lineTemp.end = c;
-    const closestPoint2 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint2.distanceTo(center) <= radius) return true;
-    lineTemp.start = b;
-    lineTemp.end = c;
-    const closestPoint3 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint3.distanceTo(center) <= radius) return true;
-    const plane = triangle3.getPlane(planeTemp);
-    const dp = Math.abs(plane.distanceToPoint(center));
-    if (dp <= radius) {
-      const pp = plane.projectPoint(center, projectedPointTemp);
-      const cp = triangle3.containsPoint(pp);
-      if (cp) return true;
-    }
-    return false;
-  };
-})();
-const ZERO_EPSILON = 1e-15;
-function isNearZero(value) {
-  return Math.abs(value) < ZERO_EPSILON;
-}
-class ExtendedTriangle extends Triangle {
-  constructor(...args) {
-    super(...args);
-    this.isExtendedTriangle = true;
-    this.satAxes = new Array(4).fill().map(() => new Vector3());
-    this.satBounds = new Array(4).fill().map(() => new SeparatingAxisBounds());
-    this.points = [this.a, this.b, this.c];
-    this.sphere = new Sphere();
-    this.plane = new Plane();
-    this.needsUpdate = true;
-  }
-  intersectsSphere(sphere) {
-    return sphereIntersectTriangle(sphere, this);
-  }
-  update() {
-    const a = this.a;
-    const b = this.b;
-    const c = this.c;
-    const points = this.points;
-    const satAxes = this.satAxes;
-    const satBounds = this.satBounds;
-    const axis0 = satAxes[0];
-    const sab0 = satBounds[0];
-    this.getNormal(axis0);
-    sab0.setFromPoints(axis0, points);
-    const axis1 = satAxes[1];
-    const sab1 = satBounds[1];
-    axis1.subVectors(a, b);
-    sab1.setFromPoints(axis1, points);
-    const axis2 = satAxes[2];
-    const sab2 = satBounds[2];
-    axis2.subVectors(b, c);
-    sab2.setFromPoints(axis2, points);
-    const axis3 = satAxes[3];
-    const sab3 = satBounds[3];
-    axis3.subVectors(c, a);
-    sab3.setFromPoints(axis3, points);
-    this.sphere.setFromPoints(this.points);
-    this.plane.setFromNormalAndCoplanarPoint(axis0, a);
-    this.needsUpdate = false;
-  }
-}
-ExtendedTriangle.prototype.closestPointToSegment = (function() {
-  const point1 = new Vector3();
-  const point2 = new Vector3();
-  const edge = new Line3();
-  return function distanceToSegment(segment, target1 = null, target2 = null) {
-    const { start, end } = segment;
-    const points = this.points;
-    let distSq;
-    let closestDistanceSq = Infinity;
-    for (let i = 0; i < 3; i++) {
-      const nexti = (i + 1) % 3;
-      edge.start.copy(points[i]);
-      edge.end.copy(points[nexti]);
-      closestPointsSegmentToSegment(edge, segment, point1, point2);
-      distSq = point1.distanceToSquared(point2);
-      if (distSq < closestDistanceSq) {
-        closestDistanceSq = distSq;
-        if (target1) target1.copy(point1);
-        if (target2) target2.copy(point2);
-      }
-    }
-    this.closestPointToPoint(start, point1);
-    distSq = start.distanceToSquared(point1);
-    if (distSq < closestDistanceSq) {
-      closestDistanceSq = distSq;
-      if (target1) target1.copy(point1);
-      if (target2) target2.copy(start);
-    }
-    this.closestPointToPoint(end, point1);
-    distSq = end.distanceToSquared(point1);
-    if (distSq < closestDistanceSq) {
-      closestDistanceSq = distSq;
-      if (target1) target1.copy(point1);
-      if (target2) target2.copy(end);
-    }
-    return Math.sqrt(closestDistanceSq);
-  };
-})();
-ExtendedTriangle.prototype.intersectsTriangle = (function() {
-  const saTri2 = new ExtendedTriangle();
-  const arr1 = new Array(3);
-  const arr2 = new Array(3);
-  const cachedSatBounds = new SeparatingAxisBounds();
-  const cachedSatBounds2 = new SeparatingAxisBounds();
-  const cachedAxis = new Vector3();
-  const dir = new Vector3();
-  const dir1 = new Vector3();
-  const dir2 = new Vector3();
-  const tempDir = new Vector3();
-  const edge = new Line3();
-  const edge1 = new Line3();
-  const edge2 = new Line3();
-  const tempPoint = new Vector3();
-  function triIntersectPlane(tri, plane, targetEdge) {
-    const points = tri.points;
-    let count = 0;
-    let startPointIntersection = -1;
-    for (let i = 0; i < 3; i++) {
-      const { start, end } = edge;
-      start.copy(points[i]);
-      end.copy(points[(i + 1) % 3]);
-      edge.delta(dir);
-      const startIntersects = isNearZero(plane.distanceToPoint(start));
-      if (isNearZero(plane.normal.dot(dir)) && startIntersects) {
-        targetEdge.copy(edge);
-        count = 2;
-        break;
-      }
-      const doesIntersect = plane.intersectLine(edge, tempPoint);
-      if (!doesIntersect && startIntersects) {
-        tempPoint.copy(start);
-      }
-      if ((doesIntersect || startIntersects) && !isNearZero(tempPoint.distanceTo(end))) {
-        if (count <= 1) {
-          const point = count === 1 ? targetEdge.start : targetEdge.end;
-          point.copy(tempPoint);
-          if (startIntersects) {
-            startPointIntersection = count;
-          }
-        } else if (count >= 2) {
-          const point = startPointIntersection === 1 ? targetEdge.start : targetEdge.end;
-          point.copy(tempPoint);
-          count = 2;
-          break;
-        }
-        count++;
-        if (count === 2 && startPointIntersection === -1) {
-          break;
-        }
-      }
-    }
-    return count;
-  }
-  return function intersectsTriangle(other, target = null, suppressLog = false) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    if (!other.isExtendedTriangle) {
-      saTri2.copy(other);
-      saTri2.update();
-      other = saTri2;
-    } else if (other.needsUpdate) {
-      other.update();
-    }
-    const plane1 = this.plane;
-    const plane2 = other.plane;
-    if (Math.abs(plane1.normal.dot(plane2.normal)) > 1 - 1e-10) {
-      const satBounds1 = this.satBounds;
-      const satAxes1 = this.satAxes;
-      arr2[0] = other.a;
-      arr2[1] = other.b;
-      arr2[2] = other.c;
-      for (let i = 0; i < 4; i++) {
-        const sb = satBounds1[i];
-        const sa = satAxes1[i];
-        cachedSatBounds.setFromPoints(sa, arr2);
-        if (sb.isSeparated(cachedSatBounds)) return false;
-      }
-      const satBounds2 = other.satBounds;
-      const satAxes2 = other.satAxes;
-      arr1[0] = this.a;
-      arr1[1] = this.b;
-      arr1[2] = this.c;
-      for (let i = 0; i < 4; i++) {
-        const sb = satBounds2[i];
-        const sa = satAxes2[i];
-        cachedSatBounds.setFromPoints(sa, arr1);
-        if (sb.isSeparated(cachedSatBounds)) return false;
-      }
-      for (let i = 0; i < 4; i++) {
-        const sa1 = satAxes1[i];
-        for (let i2 = 0; i2 < 4; i2++) {
-          const sa2 = satAxes2[i2];
-          cachedAxis.crossVectors(sa1, sa2);
-          cachedSatBounds.setFromPoints(cachedAxis, arr1);
-          cachedSatBounds2.setFromPoints(cachedAxis, arr2);
-          if (cachedSatBounds.isSeparated(cachedSatBounds2)) return false;
-        }
-      }
-      if (target) {
-        if (!suppressLog) {
-          console.warn("ExtendedTriangle.intersectsTriangle: Triangles are coplanar which does not support an output edge. Setting edge to 0, 0, 0.");
-        }
-        target.start.set(0, 0, 0);
-        target.end.set(0, 0, 0);
-      }
-      return true;
-    } else {
-      const count1 = triIntersectPlane(this, plane2, edge1);
-      if (count1 === 1 && other.containsPoint(edge1.end)) {
-        if (target) {
-          target.start.copy(edge1.end);
-          target.end.copy(edge1.end);
-        }
-        return true;
-      } else if (count1 !== 2) {
-        return false;
-      }
-      const count2 = triIntersectPlane(other, plane1, edge2);
-      if (count2 === 1 && this.containsPoint(edge2.end)) {
-        if (target) {
-          target.start.copy(edge2.end);
-          target.end.copy(edge2.end);
-        }
-        return true;
-      } else if (count2 !== 2) {
-        return false;
-      }
-      edge1.delta(dir1);
-      edge2.delta(dir2);
-      if (dir1.dot(dir2) < 0) {
-        let tmp = edge2.start;
-        edge2.start = edge2.end;
-        edge2.end = tmp;
-      }
-      const s1 = edge1.start.dot(dir1);
-      const e1 = edge1.end.dot(dir1);
-      const s2 = edge2.start.dot(dir1);
-      const e2 = edge2.end.dot(dir1);
-      const separated1 = e1 < s2;
-      const separated2 = s1 < e2;
-      if (s1 !== e2 && s2 !== e1 && separated1 === separated2) {
-        return false;
-      }
-      if (target) {
-        tempDir.subVectors(edge1.start, edge2.start);
-        if (tempDir.dot(dir1) > 0) {
-          target.start.copy(edge1.start);
-        } else {
-          target.start.copy(edge2.start);
-        }
-        tempDir.subVectors(edge1.end, edge2.end);
-        if (tempDir.dot(dir1) < 0) {
-          target.end.copy(edge1.end);
-        } else {
-          target.end.copy(edge2.end);
-        }
-      }
-      return true;
-    }
-  };
-})();
-ExtendedTriangle.prototype.distanceToPoint = (function() {
-  const target = new Vector3();
-  return function distanceToPoint(point) {
-    this.closestPointToPoint(point, target);
-    return point.distanceTo(target);
-  };
-})();
-ExtendedTriangle.prototype.distanceToTriangle = (function() {
-  const point = new Vector3();
-  const point2 = new Vector3();
-  const cornerFields = ["a", "b", "c"];
-  const line1 = new Line3();
-  const line2 = new Line3();
-  return function distanceToTriangle(other, target1 = null, target2 = null) {
-    const lineTarget = target1 || target2 ? line1 : null;
-    if (this.intersectsTriangle(other, lineTarget)) {
-      if (target1 || target2) {
-        if (target1) lineTarget.getCenter(target1);
-        if (target2) lineTarget.getCenter(target2);
-      }
-      return 0;
-    }
-    let closestDistanceSq = Infinity;
-    for (let i = 0; i < 3; i++) {
-      let dist;
-      const field = cornerFields[i];
-      const otherVec = other[field];
-      this.closestPointToPoint(otherVec, point);
-      dist = otherVec.distanceToSquared(point);
-      if (dist < closestDistanceSq) {
-        closestDistanceSq = dist;
-        if (target1) target1.copy(point);
-        if (target2) target2.copy(otherVec);
-      }
-      const thisVec = this[field];
-      other.closestPointToPoint(thisVec, point);
-      dist = thisVec.distanceToSquared(point);
-      if (dist < closestDistanceSq) {
-        closestDistanceSq = dist;
-        if (target1) target1.copy(thisVec);
-        if (target2) target2.copy(point);
-      }
-    }
-    for (let i = 0; i < 3; i++) {
-      const f11 = cornerFields[i];
-      const f12 = cornerFields[(i + 1) % 3];
-      line1.set(this[f11], this[f12]);
-      for (let i2 = 0; i2 < 3; i2++) {
-        const f21 = cornerFields[i2];
-        const f22 = cornerFields[(i2 + 1) % 3];
-        line2.set(other[f21], other[f22]);
-        closestPointsSegmentToSegment(line1, line2, point, point2);
-        const dist = point.distanceToSquared(point2);
-        if (dist < closestDistanceSq) {
-          closestDistanceSq = dist;
-          if (target1) target1.copy(point);
-          if (target2) target2.copy(point2);
-        }
-      }
-    }
-    return Math.sqrt(closestDistanceSq);
-  };
-})();
-class OrientedBox {
-  constructor(min, max, matrix) {
-    this.isOrientedBox = true;
-    this.min = new Vector3();
-    this.max = new Vector3();
-    this.matrix = new Matrix4();
-    this.invMatrix = new Matrix4();
-    this.points = new Array(8).fill().map(() => new Vector3());
-    this.satAxes = new Array(3).fill().map(() => new Vector3());
-    this.satBounds = new Array(3).fill().map(() => new SeparatingAxisBounds());
-    this.alignedSatBounds = new Array(3).fill().map(() => new SeparatingAxisBounds());
-    this.needsUpdate = false;
-    if (min) this.min.copy(min);
-    if (max) this.max.copy(max);
-    if (matrix) this.matrix.copy(matrix);
-  }
-  set(min, max, matrix) {
-    this.min.copy(min);
-    this.max.copy(max);
-    this.matrix.copy(matrix);
-    this.needsUpdate = true;
-  }
-  copy(other) {
-    this.min.copy(other.min);
-    this.max.copy(other.max);
-    this.matrix.copy(other.matrix);
-    this.needsUpdate = true;
-  }
-}
-OrientedBox.prototype.update = /* @__PURE__ */ (function() {
-  return function update() {
-    const matrix = this.matrix;
-    const min = this.min;
-    const max = this.max;
-    const points = this.points;
-    for (let x = 0; x <= 1; x++) {
-      for (let y = 0; y <= 1; y++) {
-        for (let z = 0; z <= 1; z++) {
-          const i = (1 << 0) * x | (1 << 1) * y | (1 << 2) * z;
-          const v = points[i];
-          v.x = x ? max.x : min.x;
-          v.y = y ? max.y : min.y;
-          v.z = z ? max.z : min.z;
-          v.applyMatrix4(matrix);
-        }
-      }
-    }
-    const satBounds = this.satBounds;
-    const satAxes = this.satAxes;
-    const minVec = points[0];
-    for (let i = 0; i < 3; i++) {
-      const axis = satAxes[i];
-      const sb = satBounds[i];
-      const index2 = 1 << i;
-      const pi = points[index2];
-      axis.subVectors(minVec, pi);
-      sb.setFromPoints(axis, points);
-    }
-    const alignedSatBounds = this.alignedSatBounds;
-    alignedSatBounds[0].setFromPointsField(points, "x");
-    alignedSatBounds[1].setFromPointsField(points, "y");
-    alignedSatBounds[2].setFromPointsField(points, "z");
-    this.invMatrix.copy(this.matrix).invert();
-    this.needsUpdate = false;
-  };
-})();
-OrientedBox.prototype.intersectsBox = (function() {
-  const aabbBounds = new SeparatingAxisBounds();
-  return function intersectsBox(box) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    const min = box.min;
-    const max = box.max;
-    const satBounds = this.satBounds;
-    const satAxes = this.satAxes;
-    const alignedSatBounds = this.alignedSatBounds;
-    aabbBounds.min = min.x;
-    aabbBounds.max = max.x;
-    if (alignedSatBounds[0].isSeparated(aabbBounds)) return false;
-    aabbBounds.min = min.y;
-    aabbBounds.max = max.y;
-    if (alignedSatBounds[1].isSeparated(aabbBounds)) return false;
-    aabbBounds.min = min.z;
-    aabbBounds.max = max.z;
-    if (alignedSatBounds[2].isSeparated(aabbBounds)) return false;
-    for (let i = 0; i < 3; i++) {
-      const axis = satAxes[i];
-      const sb = satBounds[i];
-      aabbBounds.setFromBox(axis, box);
-      if (sb.isSeparated(aabbBounds)) return false;
-    }
-    return true;
-  };
-})();
-OrientedBox.prototype.intersectsTriangle = (function() {
-  const saTri = new ExtendedTriangle();
-  const pointsArr = new Array(3);
-  const cachedSatBounds = new SeparatingAxisBounds();
-  const cachedSatBounds2 = new SeparatingAxisBounds();
-  const cachedAxis = new Vector3();
-  return function intersectsTriangle(triangle3) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    if (!triangle3.isExtendedTriangle) {
-      saTri.copy(triangle3);
-      saTri.update();
-      triangle3 = saTri;
-    } else if (triangle3.needsUpdate) {
-      triangle3.update();
-    }
-    const satBounds = this.satBounds;
-    const satAxes = this.satAxes;
-    pointsArr[0] = triangle3.a;
-    pointsArr[1] = triangle3.b;
-    pointsArr[2] = triangle3.c;
-    for (let i = 0; i < 3; i++) {
-      const sb = satBounds[i];
-      const sa = satAxes[i];
-      cachedSatBounds.setFromPoints(sa, pointsArr);
-      if (sb.isSeparated(cachedSatBounds)) return false;
-    }
-    const triSatBounds = triangle3.satBounds;
-    const triSatAxes = triangle3.satAxes;
-    const points = this.points;
-    for (let i = 0; i < 3; i++) {
-      const sb = triSatBounds[i];
-      const sa = triSatAxes[i];
-      cachedSatBounds.setFromPoints(sa, points);
-      if (sb.isSeparated(cachedSatBounds)) return false;
-    }
-    for (let i = 0; i < 3; i++) {
-      const sa1 = satAxes[i];
-      for (let i2 = 0; i2 < 4; i2++) {
-        const sa2 = triSatAxes[i2];
-        cachedAxis.crossVectors(sa1, sa2);
-        cachedSatBounds.setFromPoints(cachedAxis, pointsArr);
-        cachedSatBounds2.setFromPoints(cachedAxis, points);
-        if (cachedSatBounds.isSeparated(cachedSatBounds2)) return false;
-      }
-    }
-    return true;
-  };
-})();
-OrientedBox.prototype.closestPointToPoint = /* @__PURE__ */ (function() {
-  return function closestPointToPoint2(point, target1) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    target1.copy(point).applyMatrix4(this.invMatrix).clamp(this.min, this.max).applyMatrix4(this.matrix);
-    return target1;
-  };
-})();
-OrientedBox.prototype.distanceToPoint = (function() {
-  const target = new Vector3();
-  return function distanceToPoint(point) {
-    this.closestPointToPoint(point, target);
-    return point.distanceTo(target);
-  };
-})();
-OrientedBox.prototype.distanceToBox = (function() {
-  const xyzFields = ["x", "y", "z"];
-  const segments1 = new Array(12).fill().map(() => new Line3());
-  const segments2 = new Array(12).fill().map(() => new Line3());
-  const point1 = new Vector3();
-  const point2 = new Vector3();
-  return function distanceToBox(box, threshold = 0, target1 = null, target2 = null) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    if (this.intersectsBox(box)) {
-      if (target1 || target2) {
-        box.getCenter(point2);
-        this.closestPointToPoint(point2, point1);
-        box.closestPointToPoint(point1, point2);
-        if (target1) target1.copy(point1);
-        if (target2) target2.copy(point2);
-      }
-      return 0;
-    }
-    const threshold2 = threshold * threshold;
-    const min = box.min;
-    const max = box.max;
-    const points = this.points;
-    let closestDistanceSq = Infinity;
-    for (let i = 0; i < 8; i++) {
-      const p = points[i];
-      point2.copy(p).clamp(min, max);
-      const dist = p.distanceToSquared(point2);
-      if (dist < closestDistanceSq) {
-        closestDistanceSq = dist;
-        if (target1) target1.copy(p);
-        if (target2) target2.copy(point2);
-        if (dist < threshold2) return Math.sqrt(dist);
-      }
-    }
-    let count = 0;
-    for (let i = 0; i < 3; i++) {
-      for (let i1 = 0; i1 <= 1; i1++) {
-        for (let i2 = 0; i2 <= 1; i2++) {
-          const nextIndex = (i + 1) % 3;
-          const nextIndex2 = (i + 2) % 3;
-          const index2 = i1 << nextIndex | i2 << nextIndex2;
-          const index22 = 1 << i | i1 << nextIndex | i2 << nextIndex2;
-          const p1 = points[index2];
-          const p2 = points[index22];
-          const line1 = segments1[count];
-          line1.set(p1, p2);
-          const f1 = xyzFields[i];
-          const f2 = xyzFields[nextIndex];
-          const f3 = xyzFields[nextIndex2];
-          const line2 = segments2[count];
-          const start = line2.start;
-          const end = line2.end;
-          start[f1] = min[f1];
-          start[f2] = i1 ? min[f2] : max[f2];
-          start[f3] = i2 ? min[f3] : max[f2];
-          end[f1] = max[f1];
-          end[f2] = i1 ? min[f2] : max[f2];
-          end[f3] = i2 ? min[f3] : max[f2];
-          count++;
-        }
-      }
-    }
-    for (let x = 0; x <= 1; x++) {
-      for (let y = 0; y <= 1; y++) {
-        for (let z = 0; z <= 1; z++) {
-          point2.x = x ? max.x : min.x;
-          point2.y = y ? max.y : min.y;
-          point2.z = z ? max.z : min.z;
-          this.closestPointToPoint(point2, point1);
-          const dist = point2.distanceToSquared(point1);
-          if (dist < closestDistanceSq) {
-            closestDistanceSq = dist;
-            if (target1) target1.copy(point1);
-            if (target2) target2.copy(point2);
-            if (dist < threshold2) return Math.sqrt(dist);
-          }
-        }
-      }
-    }
-    for (let i = 0; i < 12; i++) {
-      const l1 = segments1[i];
-      for (let i2 = 0; i2 < 12; i2++) {
-        const l2 = segments2[i2];
-        closestPointsSegmentToSegment(l1, l2, point1, point2);
-        const dist = point1.distanceToSquared(point2);
-        if (dist < closestDistanceSq) {
-          closestDistanceSq = dist;
-          if (target1) target1.copy(point1);
-          if (target2) target2.copy(point2);
-          if (dist < threshold2) return Math.sqrt(dist);
-        }
-      }
-    }
-    return Math.sqrt(closestDistanceSq);
-  };
-})();
-class PrimitivePool {
-  constructor(getNewPrimitive) {
-    this._getNewPrimitive = getNewPrimitive;
-    this._primitives = [];
-  }
-  getPrimitive() {
-    const primitives = this._primitives;
-    if (primitives.length === 0) {
-      return this._getNewPrimitive();
-    } else {
-      return primitives.pop();
-    }
-  }
-  releasePrimitive(primitive) {
-    this._primitives.push(primitive);
-  }
-}
-class ExtendedTrianglePoolBase extends PrimitivePool {
-  constructor() {
-    super(() => new ExtendedTriangle());
-  }
-}
-const ExtendedTrianglePool = /* @__PURE__ */ new ExtendedTrianglePoolBase();
-class _BufferStack {
-  constructor() {
-    this.float32Array = null;
-    this.uint16Array = null;
-    this.uint32Array = null;
-    const stack = [];
-    let prevBuffer = null;
-    this.setBuffer = (buffer) => {
-      if (prevBuffer) {
-        stack.push(prevBuffer);
-      }
-      prevBuffer = buffer;
-      this.float32Array = new Float32Array(buffer);
-      this.uint16Array = new Uint16Array(buffer);
-      this.uint32Array = new Uint32Array(buffer);
-    };
-    this.clearBuffer = () => {
-      prevBuffer = null;
-      this.float32Array = null;
-      this.uint16Array = null;
-      this.uint32Array = null;
-      if (stack.length !== 0) {
-        this.setBuffer(stack.pop());
-      }
-    };
-  }
-}
-const BufferStack = new _BufferStack();
-let _box1, _box2;
-const boxStack = [];
-const boxPool = /* @__PURE__ */ new PrimitivePool(() => new Box3());
-function shapecast(bvh, root, intersectsBounds, intersectsRange, boundsTraverseOrder, byteOffset) {
-  _box1 = boxPool.getPrimitive();
-  _box2 = boxPool.getPrimitive();
-  boxStack.push(_box1, _box2);
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = shapecastTraverse(0, bvh.geometry, intersectsBounds, intersectsRange, boundsTraverseOrder, byteOffset);
-  BufferStack.clearBuffer();
-  boxPool.releasePrimitive(_box1);
-  boxPool.releasePrimitive(_box2);
-  boxStack.pop();
-  boxStack.pop();
-  const length = boxStack.length;
-  if (length > 0) {
-    _box2 = boxStack[length - 1];
-    _box1 = boxStack[length - 2];
-  }
-  return result;
-}
-function shapecastTraverse(nodeIndex32, geometry, intersectsBoundsFunc, intersectsRangeFunc, nodeScoreFunc = null, nodeIndexByteOffset = 0, depth = 0) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    arrayToBox(BOUNDING_DATA_INDEX(nodeIndex32), float32Array2, _box1);
-    return intersectsRangeFunc(offset, count, false, depth, nodeIndexByteOffset + nodeIndex32, _box1);
-  } else {
-    let getLeftOffset = function(nodeIndex322) {
-      const { uint16Array: uint16Array3, uint32Array: uint32Array3 } = BufferStack;
-      let nodeIndex162 = nodeIndex322 * 2;
-      while (!IS_LEAF(nodeIndex162, uint16Array3)) {
-        nodeIndex322 = LEFT_NODE(nodeIndex322);
-        nodeIndex162 = nodeIndex322 * 2;
-      }
-      return OFFSET(nodeIndex322, uint32Array3);
-    }, getRightEndOffset = function(nodeIndex322) {
-      const { uint16Array: uint16Array3, uint32Array: uint32Array3 } = BufferStack;
-      let nodeIndex162 = nodeIndex322 * 2;
-      while (!IS_LEAF(nodeIndex162, uint16Array3)) {
-        nodeIndex322 = RIGHT_NODE(nodeIndex322, uint32Array3);
-        nodeIndex162 = nodeIndex322 * 2;
-      }
-      return OFFSET(nodeIndex322, uint32Array3) + COUNT(nodeIndex162, uint16Array3);
-    };
-    const left = LEFT_NODE(nodeIndex32);
-    const right = RIGHT_NODE(nodeIndex32, uint32Array2);
-    let c1 = left;
-    let c2 = right;
-    let score1, score2;
-    let box1, box2;
-    if (nodeScoreFunc) {
-      box1 = _box1;
-      box2 = _box2;
-      arrayToBox(BOUNDING_DATA_INDEX(c1), float32Array2, box1);
-      arrayToBox(BOUNDING_DATA_INDEX(c2), float32Array2, box2);
-      score1 = nodeScoreFunc(box1);
-      score2 = nodeScoreFunc(box2);
-      if (score2 < score1) {
-        c1 = right;
-        c2 = left;
-        const temp5 = score1;
-        score1 = score2;
-        score2 = temp5;
-        box1 = box2;
-      }
-    }
-    if (!box1) {
-      box1 = _box1;
-      arrayToBox(BOUNDING_DATA_INDEX(c1), float32Array2, box1);
-    }
-    const isC1Leaf = IS_LEAF(c1 * 2, uint16Array2);
-    const c1Intersection = intersectsBoundsFunc(box1, isC1Leaf, score1, depth + 1, nodeIndexByteOffset + c1);
-    let c1StopTraversal;
-    if (c1Intersection === CONTAINED) {
-      const offset = getLeftOffset(c1);
-      const end = getRightEndOffset(c1);
-      const count = end - offset;
-      c1StopTraversal = intersectsRangeFunc(offset, count, true, depth + 1, nodeIndexByteOffset + c1, box1);
-    } else {
-      c1StopTraversal = c1Intersection && shapecastTraverse(
-        c1,
-        geometry,
-        intersectsBoundsFunc,
-        intersectsRangeFunc,
-        nodeScoreFunc,
-        nodeIndexByteOffset,
-        depth + 1
-      );
-    }
-    if (c1StopTraversal) return true;
-    box2 = _box2;
-    arrayToBox(BOUNDING_DATA_INDEX(c2), float32Array2, box2);
-    const isC2Leaf = IS_LEAF(c2 * 2, uint16Array2);
-    const c2Intersection = intersectsBoundsFunc(box2, isC2Leaf, score2, depth + 1, nodeIndexByteOffset + c2);
-    let c2StopTraversal;
-    if (c2Intersection === CONTAINED) {
-      const offset = getLeftOffset(c2);
-      const end = getRightEndOffset(c2);
-      const count = end - offset;
-      c2StopTraversal = intersectsRangeFunc(offset, count, true, depth + 1, nodeIndexByteOffset + c2, box2);
-    } else {
-      c2StopTraversal = c2Intersection && shapecastTraverse(
-        c2,
-        geometry,
-        intersectsBoundsFunc,
-        intersectsRangeFunc,
-        nodeScoreFunc,
-        nodeIndexByteOffset,
-        depth + 1
-      );
-    }
-    if (c2StopTraversal) return true;
-    return false;
-  }
-}
-const temp = /* @__PURE__ */ new Vector3();
-const temp1$2 = /* @__PURE__ */ new Vector3();
-function closestPointToPoint(bvh, point, target = {}, minThreshold = 0, maxThreshold = Infinity) {
-  const minThresholdSq = minThreshold * minThreshold;
-  const maxThresholdSq = maxThreshold * maxThreshold;
-  let closestDistanceSq = Infinity;
-  let closestDistanceTriIndex = null;
-  bvh.shapecast(
-    {
-      boundsTraverseOrder: (box) => {
-        temp.copy(point).clamp(box.min, box.max);
-        return temp.distanceToSquared(point);
-      },
-      intersectsBounds: (box, isLeaf, score) => {
-        return score < closestDistanceSq && score < maxThresholdSq;
-      },
-      intersectsTriangle: (tri, triIndex) => {
-        tri.closestPointToPoint(point, temp);
-        const distSq = point.distanceToSquared(temp);
-        if (distSq < closestDistanceSq) {
-          temp1$2.copy(temp);
-          closestDistanceSq = distSq;
-          closestDistanceTriIndex = triIndex;
-        }
-        if (distSq < minThresholdSq) {
-          return true;
-        } else {
-          return false;
-        }
-      }
-    }
-  );
-  if (closestDistanceSq === Infinity) return null;
-  const closestDistance = Math.sqrt(closestDistanceSq);
-  if (!target.point) target.point = temp1$2.clone();
-  else target.point.copy(temp1$2);
-  target.distance = closestDistance, target.faceIndex = closestDistanceTriIndex;
-  return target;
-}
-const IS_GT_REVISION_169 = parseInt(REVISION) >= 169;
-const _vA = /* @__PURE__ */ new Vector3();
-const _vB = /* @__PURE__ */ new Vector3();
-const _vC = /* @__PURE__ */ new Vector3();
-const _uvA = /* @__PURE__ */ new Vector2();
-const _uvB = /* @__PURE__ */ new Vector2();
-const _uvC = /* @__PURE__ */ new Vector2();
-const _normalA = /* @__PURE__ */ new Vector3();
-const _normalB = /* @__PURE__ */ new Vector3();
-const _normalC = /* @__PURE__ */ new Vector3();
-const _intersectionPoint = /* @__PURE__ */ new Vector3();
-function checkIntersection(ray2, pA, pB, pC, point, side, near, far) {
-  let intersect;
-  if (side === BackSide) {
-    intersect = ray2.intersectTriangle(pC, pB, pA, true, point);
-  } else {
-    intersect = ray2.intersectTriangle(pA, pB, pC, side !== DoubleSide, point);
-  }
-  if (intersect === null) return null;
-  const distance = ray2.origin.distanceTo(point);
-  if (distance < near || distance > far) return null;
-  return {
-    distance,
-    point: point.clone()
-  };
-}
-function checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a, b, c, side, near, far) {
-  _vA.fromBufferAttribute(position, a);
-  _vB.fromBufferAttribute(position, b);
-  _vC.fromBufferAttribute(position, c);
-  const intersection = checkIntersection(ray2, _vA, _vB, _vC, _intersectionPoint, side, near, far);
-  if (intersection) {
-    const barycoord = new Vector3();
-    Triangle.getBarycoord(_intersectionPoint, _vA, _vB, _vC, barycoord);
-    if (uv) {
-      _uvA.fromBufferAttribute(uv, a);
-      _uvB.fromBufferAttribute(uv, b);
-      _uvC.fromBufferAttribute(uv, c);
-      intersection.uv = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2());
-    }
-    if (uv1) {
-      _uvA.fromBufferAttribute(uv1, a);
-      _uvB.fromBufferAttribute(uv1, b);
-      _uvC.fromBufferAttribute(uv1, c);
-      intersection.uv1 = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2());
-    }
-    if (normal) {
-      _normalA.fromBufferAttribute(normal, a);
-      _normalB.fromBufferAttribute(normal, b);
-      _normalC.fromBufferAttribute(normal, c);
-      intersection.normal = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _normalA, _normalB, _normalC, new Vector3());
-      if (intersection.normal.dot(ray2.direction) > 0) {
-        intersection.normal.multiplyScalar(-1);
-      }
-    }
-    const face = {
-      a,
-      b,
-      c,
-      normal: new Vector3(),
-      materialIndex: 0
-    };
-    Triangle.getNormal(_vA, _vB, _vC, face.normal);
-    intersection.face = face;
-    intersection.faceIndex = a;
-    if (IS_GT_REVISION_169) {
-      intersection.barycoord = barycoord;
-    }
-  }
-  return intersection;
-}
-function intersectTri(geo, side, ray2, tri, intersections, near, far) {
-  const triOffset = tri * 3;
-  let a = triOffset + 0;
-  let b = triOffset + 1;
-  let c = triOffset + 2;
-  const index2 = geo.index;
-  if (geo.index) {
-    a = index2.getX(a);
-    b = index2.getX(b);
-    c = index2.getX(c);
-  }
-  const { position, normal, uv, uv1 } = geo.attributes;
-  const intersection = checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a, b, c, side, near, far);
-  if (intersection) {
-    intersection.faceIndex = tri;
-    if (intersections) intersections.push(intersection);
-    return intersection;
-  }
-  return null;
-}
-function setTriangle(tri, i, index2, pos) {
-  const ta = tri.a;
-  const tb = tri.b;
-  const tc = tri.c;
-  let i0 = i;
-  let i1 = i + 1;
-  let i2 = i + 2;
-  if (index2) {
-    i0 = index2.getX(i0);
-    i1 = index2.getX(i1);
-    i2 = index2.getX(i2);
-  }
-  ta.x = pos.getX(i0);
-  ta.y = pos.getY(i0);
-  ta.z = pos.getZ(i0);
-  tb.x = pos.getX(i1);
-  tb.y = pos.getY(i1);
-  tb.z = pos.getZ(i1);
-  tc.x = pos.getX(i2);
-  tc.y = pos.getY(i2);
-  tc.z = pos.getZ(i2);
-}
-function intersectTris(bvh, side, ray2, offset, count, intersections, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    intersectTri(geometry, side, ray2, i, intersections, near, far);
-  }
-}
-function intersectClosestTri(bvh, side, ray2, offset, count, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  let dist = Infinity;
-  let res = null;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    let intersection;
-    intersection = intersectTri(geometry, side, ray2, i, null, near, far);
-    if (intersection && intersection.distance < dist) {
-      res = intersection;
-      dist = intersection.distance;
-    }
-  }
-  return res;
-}
-function iterateOverTriangles(offset, count, bvh, intersectsTriangleFunc, contained, depth, triangle3) {
-  const { geometry } = bvh;
-  const { index: index2 } = geometry;
-  const pos = geometry.attributes.position;
-  for (let i = offset, l = count + offset; i < l; i++) {
-    let tri;
-    tri = i;
-    setTriangle(triangle3, tri * 3, index2, pos);
-    triangle3.needsUpdate = true;
-    if (intersectsTriangleFunc(triangle3, tri, contained, depth)) {
-      return true;
-    }
-  }
-  return false;
-}
-function refit(bvh, nodeIndices = null) {
-  if (nodeIndices && Array.isArray(nodeIndices)) {
-    nodeIndices = new Set(nodeIndices);
-  }
-  const geometry = bvh.geometry;
-  const indexArr = geometry.index ? geometry.index.array : null;
-  const posAttr = geometry.attributes.position;
-  let buffer, uint32Array2, uint16Array2, float32Array2;
-  let byteOffset = 0;
-  const roots = bvh._roots;
-  for (let i = 0, l = roots.length; i < l; i++) {
-    buffer = roots[i];
-    uint32Array2 = new Uint32Array(buffer);
-    uint16Array2 = new Uint16Array(buffer);
-    float32Array2 = new Float32Array(buffer);
-    _traverse2(0, byteOffset);
-    byteOffset += buffer.byteLength;
-  }
-  function _traverse2(node32Index, byteOffset2, force = false) {
-    const node16Index = node32Index * 2;
-    const isLeaf = uint16Array2[node16Index + 15] === IS_LEAFNODE_FLAG;
-    if (isLeaf) {
-      const offset = uint32Array2[node32Index + 6];
-      const count = uint16Array2[node16Index + 14];
-      let minx = Infinity;
-      let miny = Infinity;
-      let minz = Infinity;
-      let maxx = -Infinity;
-      let maxy = -Infinity;
-      let maxz = -Infinity;
-      for (let i = 3 * offset, l = 3 * (offset + count); i < l; i++) {
-        let index2 = indexArr[i];
-        const x = posAttr.getX(index2);
-        const y = posAttr.getY(index2);
-        const z = posAttr.getZ(index2);
-        if (x < minx) minx = x;
-        if (x > maxx) maxx = x;
-        if (y < miny) miny = y;
-        if (y > maxy) maxy = y;
-        if (z < minz) minz = z;
-        if (z > maxz) maxz = z;
-      }
-      if (float32Array2[node32Index + 0] !== minx || float32Array2[node32Index + 1] !== miny || float32Array2[node32Index + 2] !== minz || float32Array2[node32Index + 3] !== maxx || float32Array2[node32Index + 4] !== maxy || float32Array2[node32Index + 5] !== maxz) {
-        float32Array2[node32Index + 0] = minx;
-        float32Array2[node32Index + 1] = miny;
-        float32Array2[node32Index + 2] = minz;
-        float32Array2[node32Index + 3] = maxx;
-        float32Array2[node32Index + 4] = maxy;
-        float32Array2[node32Index + 5] = maxz;
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      const left = node32Index + 8;
-      const right = uint32Array2[node32Index + 6];
-      const offsetLeft = left + byteOffset2;
-      const offsetRight = right + byteOffset2;
-      let forceChildren = force;
-      let includesLeft = false;
-      let includesRight = false;
-      if (nodeIndices) {
-        if (!forceChildren) {
-          includesLeft = nodeIndices.has(offsetLeft);
-          includesRight = nodeIndices.has(offsetRight);
-          forceChildren = !includesLeft && !includesRight;
-        }
-      } else {
-        includesLeft = true;
-        includesRight = true;
-      }
-      const traverseLeft = forceChildren || includesLeft;
-      const traverseRight = forceChildren || includesRight;
-      let leftChange = false;
-      if (traverseLeft) {
-        leftChange = _traverse2(left, byteOffset2, forceChildren);
-      }
-      let rightChange = false;
-      if (traverseRight) {
-        rightChange = _traverse2(right, byteOffset2, forceChildren);
-      }
-      const didChange = leftChange || rightChange;
-      if (didChange) {
-        for (let i = 0; i < 3; i++) {
-          const lefti = left + i;
-          const righti = right + i;
-          const minLeftValue = float32Array2[lefti];
-          const maxLeftValue = float32Array2[lefti + 3];
-          const minRightValue = float32Array2[righti];
-          const maxRightValue = float32Array2[righti + 3];
-          float32Array2[node32Index + i] = minLeftValue < minRightValue ? minLeftValue : minRightValue;
-          float32Array2[node32Index + i + 3] = maxLeftValue > maxRightValue ? maxLeftValue : maxRightValue;
-        }
-      }
-      return didChange;
-    }
-  }
-}
-function intersectRay(nodeIndex32, array, ray2, near, far) {
-  let tmin, tmax, tymin, tymax, tzmin, tzmax;
-  const invdirx = 1 / ray2.direction.x, invdiry = 1 / ray2.direction.y, invdirz = 1 / ray2.direction.z;
-  const ox = ray2.origin.x;
-  const oy = ray2.origin.y;
-  const oz = ray2.origin.z;
-  let minx = array[nodeIndex32];
-  let maxx = array[nodeIndex32 + 3];
-  let miny = array[nodeIndex32 + 1];
-  let maxy = array[nodeIndex32 + 3 + 1];
-  let minz = array[nodeIndex32 + 2];
-  let maxz = array[nodeIndex32 + 3 + 2];
-  if (invdirx >= 0) {
-    tmin = (minx - ox) * invdirx;
-    tmax = (maxx - ox) * invdirx;
-  } else {
-    tmin = (maxx - ox) * invdirx;
-    tmax = (minx - ox) * invdirx;
-  }
-  if (invdiry >= 0) {
-    tymin = (miny - oy) * invdiry;
-    tymax = (maxy - oy) * invdiry;
-  } else {
-    tymin = (maxy - oy) * invdiry;
-    tymax = (miny - oy) * invdiry;
-  }
-  if (tmin > tymax || tymin > tmax) return false;
-  if (tymin > tmin || isNaN(tmin)) tmin = tymin;
-  if (tymax < tmax || isNaN(tmax)) tmax = tymax;
-  if (invdirz >= 0) {
-    tzmin = (minz - oz) * invdirz;
-    tzmax = (maxz - oz) * invdirz;
-  } else {
-    tzmin = (maxz - oz) * invdirz;
-    tzmax = (minz - oz) * invdirz;
-  }
-  if (tmin > tzmax || tzmin > tmax) return false;
-  if (tzmin > tmin || tmin !== tmin) tmin = tzmin;
-  if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
-  return tmin <= far && tmax >= near;
-}
-function intersectTris_indirect(bvh, side, ray2, offset, count, intersections, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    let vi = _indirectBuffer ? _indirectBuffer[i] : i;
-    intersectTri(geometry, side, ray2, vi, intersections, near, far);
-  }
-}
-function intersectClosestTri_indirect(bvh, side, ray2, offset, count, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  let dist = Infinity;
-  let res = null;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    let intersection;
-    intersection = intersectTri(geometry, side, ray2, _indirectBuffer ? _indirectBuffer[i] : i, null, near, far);
-    if (intersection && intersection.distance < dist) {
-      res = intersection;
-      dist = intersection.distance;
-    }
-  }
-  return res;
-}
-function iterateOverTriangles_indirect(offset, count, bvh, intersectsTriangleFunc, contained, depth, triangle3) {
-  const { geometry } = bvh;
-  const { index: index2 } = geometry;
-  const pos = geometry.attributes.position;
-  for (let i = offset, l = count + offset; i < l; i++) {
-    let tri;
-    tri = bvh.resolveTriangleIndex(i);
-    setTriangle(triangle3, tri * 3, index2, pos);
-    triangle3.needsUpdate = true;
-    if (intersectsTriangleFunc(triangle3, tri, contained, depth)) {
-      return true;
-    }
-  }
-  return false;
-}
-function raycast(bvh, root, side, ray2, intersects, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  _raycast$1(0, bvh, side, ray2, intersects, near, far);
-  BufferStack.clearBuffer();
-}
-function _raycast$1(nodeIndex32, bvh, side, ray2, intersects, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  const nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    intersectTris(bvh, side, ray2, offset, count, intersects, near, far);
-  } else {
-    const leftIndex = LEFT_NODE(nodeIndex32);
-    if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
-      _raycast$1(leftIndex, bvh, side, ray2, intersects, near, far);
-    }
-    const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
-    if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
-      _raycast$1(rightIndex, bvh, side, ray2, intersects, near, far);
-    }
-  }
-}
-const _xyzFields$1 = ["x", "y", "z"];
-function raycastFirst(bvh, root, side, ray2, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _raycastFirst$1(0, bvh, side, ray2, near, far);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _raycastFirst$1(nodeIndex32, bvh, side, ray2, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    return intersectClosestTri(bvh, side, ray2, offset, count, near, far);
-  } else {
-    const splitAxis = SPLIT_AXIS(nodeIndex32, uint32Array2);
-    const xyzAxis = _xyzFields$1[splitAxis];
-    const rayDir = ray2.direction[xyzAxis];
-    const leftToRight = rayDir >= 0;
-    let c1, c2;
-    if (leftToRight) {
-      c1 = LEFT_NODE(nodeIndex32);
-      c2 = RIGHT_NODE(nodeIndex32, uint32Array2);
-    } else {
-      c1 = RIGHT_NODE(nodeIndex32, uint32Array2);
-      c2 = LEFT_NODE(nodeIndex32);
-    }
-    const c1Intersection = intersectRay(c1, float32Array2, ray2, near, far);
-    const c1Result = c1Intersection ? _raycastFirst$1(c1, bvh, side, ray2, near, far) : null;
-    if (c1Result) {
-      const point = c1Result.point[xyzAxis];
-      const isOutside = leftToRight ? point <= float32Array2[c2 + splitAxis] : (
-        // min bounding data
-        point >= float32Array2[c2 + splitAxis + 3]
-      );
-      if (isOutside) {
-        return c1Result;
-      }
-    }
-    const c2Intersection = intersectRay(c2, float32Array2, ray2, near, far);
-    const c2Result = c2Intersection ? _raycastFirst$1(c2, bvh, side, ray2, near, far) : null;
-    if (c1Result && c2Result) {
-      return c1Result.distance <= c2Result.distance ? c1Result : c2Result;
-    } else {
-      return c1Result || c2Result || null;
-    }
-  }
-}
-const boundingBox$1 = /* @__PURE__ */ new Box3();
-const triangle$1 = /* @__PURE__ */ new ExtendedTriangle();
-const triangle2$1 = /* @__PURE__ */ new ExtendedTriangle();
-const invertedMat$1 = /* @__PURE__ */ new Matrix4();
-const obb$4 = /* @__PURE__ */ new OrientedBox();
-const obb2$3 = /* @__PURE__ */ new OrientedBox();
-function intersectsGeometry(bvh, root, otherGeometry, geometryToBvh) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _intersectsGeometry$1(0, bvh, otherGeometry, geometryToBvh);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _intersectsGeometry$1(nodeIndex32, bvh, otherGeometry, geometryToBvh, cachedObb = null) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  if (cachedObb === null) {
-    if (!otherGeometry.boundingBox) {
-      otherGeometry.computeBoundingBox();
-    }
-    obb$4.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-    cachedObb = obb$4;
-  }
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const thisGeometry = bvh.geometry;
-    const thisIndex = thisGeometry.index;
-    const thisPos = thisGeometry.attributes.position;
-    const index2 = otherGeometry.index;
-    const pos = otherGeometry.attributes.position;
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    invertedMat$1.copy(geometryToBvh).invert();
-    if (otherGeometry.boundsTree) {
-      arrayToBox(BOUNDING_DATA_INDEX(nodeIndex32), float32Array2, obb2$3);
-      obb2$3.matrix.copy(invertedMat$1);
-      obb2$3.needsUpdate = true;
-      const res = otherGeometry.boundsTree.shapecast({
-        intersectsBounds: (box) => obb2$3.intersectsBox(box),
-        intersectsTriangle: (tri) => {
-          tri.a.applyMatrix4(geometryToBvh);
-          tri.b.applyMatrix4(geometryToBvh);
-          tri.c.applyMatrix4(geometryToBvh);
-          tri.needsUpdate = true;
-          for (let i = offset * 3, l = (count + offset) * 3; i < l; i += 3) {
-            setTriangle(triangle2$1, i, thisIndex, thisPos);
-            triangle2$1.needsUpdate = true;
-            if (tri.intersectsTriangle(triangle2$1)) {
-              return true;
-            }
-          }
-          return false;
-        }
-      });
-      return res;
-    } else {
-      for (let i = offset * 3, l = (count + offset) * 3; i < l; i += 3) {
-        setTriangle(triangle$1, i, thisIndex, thisPos);
-        triangle$1.a.applyMatrix4(invertedMat$1);
-        triangle$1.b.applyMatrix4(invertedMat$1);
-        triangle$1.c.applyMatrix4(invertedMat$1);
-        triangle$1.needsUpdate = true;
-        for (let i2 = 0, l2 = index2.count; i2 < l2; i2 += 3) {
-          setTriangle(triangle2$1, i2, index2, pos);
-          triangle2$1.needsUpdate = true;
-          if (triangle$1.intersectsTriangle(triangle2$1)) {
-            return true;
-          }
-        }
-      }
-    }
-  } else {
-    const left = nodeIndex32 + 8;
-    const right = uint32Array2[nodeIndex32 + 6];
-    arrayToBox(BOUNDING_DATA_INDEX(left), float32Array2, boundingBox$1);
-    const leftIntersection = cachedObb.intersectsBox(boundingBox$1) && _intersectsGeometry$1(left, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (leftIntersection) return true;
-    arrayToBox(BOUNDING_DATA_INDEX(right), float32Array2, boundingBox$1);
-    const rightIntersection = cachedObb.intersectsBox(boundingBox$1) && _intersectsGeometry$1(right, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (rightIntersection) return true;
-    return false;
-  }
-}
-const tempMatrix$1 = /* @__PURE__ */ new Matrix4();
-const obb$3 = /* @__PURE__ */ new OrientedBox();
-const obb2$2 = /* @__PURE__ */ new OrientedBox();
-const temp1$1 = /* @__PURE__ */ new Vector3();
-const temp2$1 = /* @__PURE__ */ new Vector3();
-const temp3$1 = /* @__PURE__ */ new Vector3();
-const temp4$1 = /* @__PURE__ */ new Vector3();
-function closestPointToGeometry(bvh, otherGeometry, geometryToBvh, target1 = {}, target2 = {}, minThreshold = 0, maxThreshold = Infinity) {
-  if (!otherGeometry.boundingBox) {
-    otherGeometry.computeBoundingBox();
-  }
-  obb$3.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-  obb$3.needsUpdate = true;
-  const geometry = bvh.geometry;
-  const pos = geometry.attributes.position;
-  const index2 = geometry.index;
-  const otherPos = otherGeometry.attributes.position;
-  const otherIndex = otherGeometry.index;
-  const triangle3 = ExtendedTrianglePool.getPrimitive();
-  const triangle22 = ExtendedTrianglePool.getPrimitive();
-  let tempTarget1 = temp1$1;
-  let tempTargetDest1 = temp2$1;
-  let tempTarget2 = null;
-  let tempTargetDest2 = null;
-  if (target2) {
-    tempTarget2 = temp3$1;
-    tempTargetDest2 = temp4$1;
-  }
-  let closestDistance = Infinity;
-  let closestDistanceTriIndex = null;
-  let closestDistanceOtherTriIndex = null;
-  tempMatrix$1.copy(geometryToBvh).invert();
-  obb2$2.matrix.copy(tempMatrix$1);
-  bvh.shapecast(
-    {
-      boundsTraverseOrder: (box) => {
-        return obb$3.distanceToBox(box);
-      },
-      intersectsBounds: (box, isLeaf, score) => {
-        if (score < closestDistance && score < maxThreshold) {
-          if (isLeaf) {
-            obb2$2.min.copy(box.min);
-            obb2$2.max.copy(box.max);
-            obb2$2.needsUpdate = true;
-          }
-          return true;
-        }
-        return false;
-      },
-      intersectsRange: (offset, count) => {
-        if (otherGeometry.boundsTree) {
-          const otherBvh = otherGeometry.boundsTree;
-          return otherBvh.shapecast({
-            boundsTraverseOrder: (box) => {
-              return obb2$2.distanceToBox(box);
-            },
-            intersectsBounds: (box, isLeaf, score) => {
-              return score < closestDistance && score < maxThreshold;
-            },
-            intersectsRange: (otherOffset, otherCount) => {
-              for (let i2 = otherOffset, l2 = otherOffset + otherCount; i2 < l2; i2++) {
-                setTriangle(triangle22, 3 * i2, otherIndex, otherPos);
-                triangle22.a.applyMatrix4(geometryToBvh);
-                triangle22.b.applyMatrix4(geometryToBvh);
-                triangle22.c.applyMatrix4(geometryToBvh);
-                triangle22.needsUpdate = true;
-                for (let i = offset, l = offset + count; i < l; i++) {
-                  setTriangle(triangle3, 3 * i, index2, pos);
-                  triangle3.needsUpdate = true;
-                  const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-                  if (dist < closestDistance) {
-                    tempTargetDest1.copy(tempTarget1);
-                    if (tempTargetDest2) {
-                      tempTargetDest2.copy(tempTarget2);
-                    }
-                    closestDistance = dist;
-                    closestDistanceTriIndex = i;
-                    closestDistanceOtherTriIndex = i2;
-                  }
-                  if (dist < minThreshold) {
-                    return true;
-                  }
-                }
-              }
-            }
-          });
-        } else {
-          const triCount = getTriCount(otherGeometry);
-          for (let i2 = 0, l2 = triCount; i2 < l2; i2++) {
-            setTriangle(triangle22, 3 * i2, otherIndex, otherPos);
-            triangle22.a.applyMatrix4(geometryToBvh);
-            triangle22.b.applyMatrix4(geometryToBvh);
-            triangle22.c.applyMatrix4(geometryToBvh);
-            triangle22.needsUpdate = true;
-            for (let i = offset, l = offset + count; i < l; i++) {
-              setTriangle(triangle3, 3 * i, index2, pos);
-              triangle3.needsUpdate = true;
-              const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-              if (dist < closestDistance) {
-                tempTargetDest1.copy(tempTarget1);
-                if (tempTargetDest2) {
-                  tempTargetDest2.copy(tempTarget2);
-                }
-                closestDistance = dist;
-                closestDistanceTriIndex = i;
-                closestDistanceOtherTriIndex = i2;
-              }
-              if (dist < minThreshold) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-  );
-  ExtendedTrianglePool.releasePrimitive(triangle3);
-  ExtendedTrianglePool.releasePrimitive(triangle22);
-  if (closestDistance === Infinity) {
-    return null;
-  }
-  if (!target1.point) {
-    target1.point = tempTargetDest1.clone();
-  } else {
-    target1.point.copy(tempTargetDest1);
-  }
-  target1.distance = closestDistance, target1.faceIndex = closestDistanceTriIndex;
-  if (target2) {
-    if (!target2.point) target2.point = tempTargetDest2.clone();
-    else target2.point.copy(tempTargetDest2);
-    target2.point.applyMatrix4(tempMatrix$1);
-    tempTargetDest1.applyMatrix4(tempMatrix$1);
-    target2.distance = tempTargetDest1.sub(target2.point).length();
-    target2.faceIndex = closestDistanceOtherTriIndex;
-  }
-  return target1;
-}
-function refit_indirect(bvh, nodeIndices = null) {
-  if (nodeIndices && Array.isArray(nodeIndices)) {
-    nodeIndices = new Set(nodeIndices);
-  }
-  const geometry = bvh.geometry;
-  const indexArr = geometry.index ? geometry.index.array : null;
-  const posAttr = geometry.attributes.position;
-  let buffer, uint32Array2, uint16Array2, float32Array2;
-  let byteOffset = 0;
-  const roots = bvh._roots;
-  for (let i = 0, l = roots.length; i < l; i++) {
-    buffer = roots[i];
-    uint32Array2 = new Uint32Array(buffer);
-    uint16Array2 = new Uint16Array(buffer);
-    float32Array2 = new Float32Array(buffer);
-    _traverse2(0, byteOffset);
-    byteOffset += buffer.byteLength;
-  }
-  function _traverse2(node32Index, byteOffset2, force = false) {
-    const node16Index = node32Index * 2;
-    const isLeaf = uint16Array2[node16Index + 15] === IS_LEAFNODE_FLAG;
-    if (isLeaf) {
-      const offset = uint32Array2[node32Index + 6];
-      const count = uint16Array2[node16Index + 14];
-      let minx = Infinity;
-      let miny = Infinity;
-      let minz = Infinity;
-      let maxx = -Infinity;
-      let maxy = -Infinity;
-      let maxz = -Infinity;
-      for (let i = offset, l = offset + count; i < l; i++) {
-        const t = 3 * bvh.resolveTriangleIndex(i);
-        for (let j = 0; j < 3; j++) {
-          let index2 = t + j;
-          index2 = indexArr ? indexArr[index2] : index2;
-          const x = posAttr.getX(index2);
-          const y = posAttr.getY(index2);
-          const z = posAttr.getZ(index2);
-          if (x < minx) minx = x;
-          if (x > maxx) maxx = x;
-          if (y < miny) miny = y;
-          if (y > maxy) maxy = y;
-          if (z < minz) minz = z;
-          if (z > maxz) maxz = z;
-        }
-      }
-      if (float32Array2[node32Index + 0] !== minx || float32Array2[node32Index + 1] !== miny || float32Array2[node32Index + 2] !== minz || float32Array2[node32Index + 3] !== maxx || float32Array2[node32Index + 4] !== maxy || float32Array2[node32Index + 5] !== maxz) {
-        float32Array2[node32Index + 0] = minx;
-        float32Array2[node32Index + 1] = miny;
-        float32Array2[node32Index + 2] = minz;
-        float32Array2[node32Index + 3] = maxx;
-        float32Array2[node32Index + 4] = maxy;
-        float32Array2[node32Index + 5] = maxz;
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      const left = node32Index + 8;
-      const right = uint32Array2[node32Index + 6];
-      const offsetLeft = left + byteOffset2;
-      const offsetRight = right + byteOffset2;
-      let forceChildren = force;
-      let includesLeft = false;
-      let includesRight = false;
-      if (nodeIndices) {
-        if (!forceChildren) {
-          includesLeft = nodeIndices.has(offsetLeft);
-          includesRight = nodeIndices.has(offsetRight);
-          forceChildren = !includesLeft && !includesRight;
-        }
-      } else {
-        includesLeft = true;
-        includesRight = true;
-      }
-      const traverseLeft = forceChildren || includesLeft;
-      const traverseRight = forceChildren || includesRight;
-      let leftChange = false;
-      if (traverseLeft) {
-        leftChange = _traverse2(left, byteOffset2, forceChildren);
-      }
-      let rightChange = false;
-      if (traverseRight) {
-        rightChange = _traverse2(right, byteOffset2, forceChildren);
-      }
-      const didChange = leftChange || rightChange;
-      if (didChange) {
-        for (let i = 0; i < 3; i++) {
-          const lefti = left + i;
-          const righti = right + i;
-          const minLeftValue = float32Array2[lefti];
-          const maxLeftValue = float32Array2[lefti + 3];
-          const minRightValue = float32Array2[righti];
-          const maxRightValue = float32Array2[righti + 3];
-          float32Array2[node32Index + i] = minLeftValue < minRightValue ? minLeftValue : minRightValue;
-          float32Array2[node32Index + i + 3] = maxLeftValue > maxRightValue ? maxLeftValue : maxRightValue;
-        }
-      }
-      return didChange;
-    }
-  }
-}
-function raycast_indirect(bvh, root, side, ray2, intersects, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  _raycast(0, bvh, side, ray2, intersects, near, far);
-  BufferStack.clearBuffer();
-}
-function _raycast(nodeIndex32, bvh, side, ray2, intersects, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  const nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    intersectTris_indirect(bvh, side, ray2, offset, count, intersects, near, far);
-  } else {
-    const leftIndex = LEFT_NODE(nodeIndex32);
-    if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
-      _raycast(leftIndex, bvh, side, ray2, intersects, near, far);
-    }
-    const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
-    if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
-      _raycast(rightIndex, bvh, side, ray2, intersects, near, far);
-    }
-  }
-}
-const _xyzFields = ["x", "y", "z"];
-function raycastFirst_indirect(bvh, root, side, ray2, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _raycastFirst(0, bvh, side, ray2, near, far);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _raycastFirst(nodeIndex32, bvh, side, ray2, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    return intersectClosestTri_indirect(bvh, side, ray2, offset, count, near, far);
-  } else {
-    const splitAxis = SPLIT_AXIS(nodeIndex32, uint32Array2);
-    const xyzAxis = _xyzFields[splitAxis];
-    const rayDir = ray2.direction[xyzAxis];
-    const leftToRight = rayDir >= 0;
-    let c1, c2;
-    if (leftToRight) {
-      c1 = LEFT_NODE(nodeIndex32);
-      c2 = RIGHT_NODE(nodeIndex32, uint32Array2);
-    } else {
-      c1 = RIGHT_NODE(nodeIndex32, uint32Array2);
-      c2 = LEFT_NODE(nodeIndex32);
-    }
-    const c1Intersection = intersectRay(c1, float32Array2, ray2, near, far);
-    const c1Result = c1Intersection ? _raycastFirst(c1, bvh, side, ray2, near, far) : null;
-    if (c1Result) {
-      const point = c1Result.point[xyzAxis];
-      const isOutside = leftToRight ? point <= float32Array2[c2 + splitAxis] : (
-        // min bounding data
-        point >= float32Array2[c2 + splitAxis + 3]
-      );
-      if (isOutside) {
-        return c1Result;
-      }
-    }
-    const c2Intersection = intersectRay(c2, float32Array2, ray2, near, far);
-    const c2Result = c2Intersection ? _raycastFirst(c2, bvh, side, ray2, near, far) : null;
-    if (c1Result && c2Result) {
-      return c1Result.distance <= c2Result.distance ? c1Result : c2Result;
-    } else {
-      return c1Result || c2Result || null;
-    }
-  }
-}
-const boundingBox = /* @__PURE__ */ new Box3();
-const triangle = /* @__PURE__ */ new ExtendedTriangle();
-const triangle2 = /* @__PURE__ */ new ExtendedTriangle();
-const invertedMat = /* @__PURE__ */ new Matrix4();
-const obb$2 = /* @__PURE__ */ new OrientedBox();
-const obb2$1 = /* @__PURE__ */ new OrientedBox();
-function intersectsGeometry_indirect(bvh, root, otherGeometry, geometryToBvh) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _intersectsGeometry(0, bvh, otherGeometry, geometryToBvh);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _intersectsGeometry(nodeIndex32, bvh, otherGeometry, geometryToBvh, cachedObb = null) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  if (cachedObb === null) {
-    if (!otherGeometry.boundingBox) {
-      otherGeometry.computeBoundingBox();
-    }
-    obb$2.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-    cachedObb = obb$2;
-  }
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const thisGeometry = bvh.geometry;
-    const thisIndex = thisGeometry.index;
-    const thisPos = thisGeometry.attributes.position;
-    const index2 = otherGeometry.index;
-    const pos = otherGeometry.attributes.position;
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    invertedMat.copy(geometryToBvh).invert();
-    if (otherGeometry.boundsTree) {
-      arrayToBox(BOUNDING_DATA_INDEX(nodeIndex32), float32Array2, obb2$1);
-      obb2$1.matrix.copy(invertedMat);
-      obb2$1.needsUpdate = true;
-      const res = otherGeometry.boundsTree.shapecast({
-        intersectsBounds: (box) => obb2$1.intersectsBox(box),
-        intersectsTriangle: (tri) => {
-          tri.a.applyMatrix4(geometryToBvh);
-          tri.b.applyMatrix4(geometryToBvh);
-          tri.c.applyMatrix4(geometryToBvh);
-          tri.needsUpdate = true;
-          for (let i = offset, l = count + offset; i < l; i++) {
-            setTriangle(triangle2, 3 * bvh.resolveTriangleIndex(i), thisIndex, thisPos);
-            triangle2.needsUpdate = true;
-            if (tri.intersectsTriangle(triangle2)) {
-              return true;
-            }
-          }
-          return false;
-        }
-      });
-      return res;
-    } else {
-      for (let i = offset, l = count + offset; i < l; i++) {
-        const ti = bvh.resolveTriangleIndex(i);
-        setTriangle(triangle, 3 * ti, thisIndex, thisPos);
-        triangle.a.applyMatrix4(invertedMat);
-        triangle.b.applyMatrix4(invertedMat);
-        triangle.c.applyMatrix4(invertedMat);
-        triangle.needsUpdate = true;
-        for (let i2 = 0, l2 = index2.count; i2 < l2; i2 += 3) {
-          setTriangle(triangle2, i2, index2, pos);
-          triangle2.needsUpdate = true;
-          if (triangle.intersectsTriangle(triangle2)) {
-            return true;
-          }
-        }
-      }
-    }
-  } else {
-    const left = nodeIndex32 + 8;
-    const right = uint32Array2[nodeIndex32 + 6];
-    arrayToBox(BOUNDING_DATA_INDEX(left), float32Array2, boundingBox);
-    const leftIntersection = cachedObb.intersectsBox(boundingBox) && _intersectsGeometry(left, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (leftIntersection) return true;
-    arrayToBox(BOUNDING_DATA_INDEX(right), float32Array2, boundingBox);
-    const rightIntersection = cachedObb.intersectsBox(boundingBox) && _intersectsGeometry(right, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (rightIntersection) return true;
-    return false;
-  }
-}
-const tempMatrix = /* @__PURE__ */ new Matrix4();
-const obb$1 = /* @__PURE__ */ new OrientedBox();
-const obb2 = /* @__PURE__ */ new OrientedBox();
-const temp1 = /* @__PURE__ */ new Vector3();
-const temp2 = /* @__PURE__ */ new Vector3();
-const temp3 = /* @__PURE__ */ new Vector3();
-const temp4 = /* @__PURE__ */ new Vector3();
-function closestPointToGeometry_indirect(bvh, otherGeometry, geometryToBvh, target1 = {}, target2 = {}, minThreshold = 0, maxThreshold = Infinity) {
-  if (!otherGeometry.boundingBox) {
-    otherGeometry.computeBoundingBox();
-  }
-  obb$1.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-  obb$1.needsUpdate = true;
-  const geometry = bvh.geometry;
-  const pos = geometry.attributes.position;
-  const index2 = geometry.index;
-  const otherPos = otherGeometry.attributes.position;
-  const otherIndex = otherGeometry.index;
-  const triangle3 = ExtendedTrianglePool.getPrimitive();
-  const triangle22 = ExtendedTrianglePool.getPrimitive();
-  let tempTarget1 = temp1;
-  let tempTargetDest1 = temp2;
-  let tempTarget2 = null;
-  let tempTargetDest2 = null;
-  if (target2) {
-    tempTarget2 = temp3;
-    tempTargetDest2 = temp4;
-  }
-  let closestDistance = Infinity;
-  let closestDistanceTriIndex = null;
-  let closestDistanceOtherTriIndex = null;
-  tempMatrix.copy(geometryToBvh).invert();
-  obb2.matrix.copy(tempMatrix);
-  bvh.shapecast(
-    {
-      boundsTraverseOrder: (box) => {
-        return obb$1.distanceToBox(box);
-      },
-      intersectsBounds: (box, isLeaf, score) => {
-        if (score < closestDistance && score < maxThreshold) {
-          if (isLeaf) {
-            obb2.min.copy(box.min);
-            obb2.max.copy(box.max);
-            obb2.needsUpdate = true;
-          }
-          return true;
-        }
-        return false;
-      },
-      intersectsRange: (offset, count) => {
-        if (otherGeometry.boundsTree) {
-          const otherBvh = otherGeometry.boundsTree;
-          return otherBvh.shapecast({
-            boundsTraverseOrder: (box) => {
-              return obb2.distanceToBox(box);
-            },
-            intersectsBounds: (box, isLeaf, score) => {
-              return score < closestDistance && score < maxThreshold;
-            },
-            intersectsRange: (otherOffset, otherCount) => {
-              for (let i2 = otherOffset, l2 = otherOffset + otherCount; i2 < l2; i2++) {
-                const ti2 = otherBvh.resolveTriangleIndex(i2);
-                setTriangle(triangle22, 3 * ti2, otherIndex, otherPos);
-                triangle22.a.applyMatrix4(geometryToBvh);
-                triangle22.b.applyMatrix4(geometryToBvh);
-                triangle22.c.applyMatrix4(geometryToBvh);
-                triangle22.needsUpdate = true;
-                for (let i = offset, l = offset + count; i < l; i++) {
-                  const ti = bvh.resolveTriangleIndex(i);
-                  setTriangle(triangle3, 3 * ti, index2, pos);
-                  triangle3.needsUpdate = true;
-                  const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-                  if (dist < closestDistance) {
-                    tempTargetDest1.copy(tempTarget1);
-                    if (tempTargetDest2) {
-                      tempTargetDest2.copy(tempTarget2);
-                    }
-                    closestDistance = dist;
-                    closestDistanceTriIndex = i;
-                    closestDistanceOtherTriIndex = i2;
-                  }
-                  if (dist < minThreshold) {
-                    return true;
-                  }
-                }
-              }
-            }
-          });
-        } else {
-          const triCount = getTriCount(otherGeometry);
-          for (let i2 = 0, l2 = triCount; i2 < l2; i2++) {
-            setTriangle(triangle22, 3 * i2, otherIndex, otherPos);
-            triangle22.a.applyMatrix4(geometryToBvh);
-            triangle22.b.applyMatrix4(geometryToBvh);
-            triangle22.c.applyMatrix4(geometryToBvh);
-            triangle22.needsUpdate = true;
-            for (let i = offset, l = offset + count; i < l; i++) {
-              const ti = bvh.resolveTriangleIndex(i);
-              setTriangle(triangle3, 3 * ti, index2, pos);
-              triangle3.needsUpdate = true;
-              const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-              if (dist < closestDistance) {
-                tempTargetDest1.copy(tempTarget1);
-                if (tempTargetDest2) {
-                  tempTargetDest2.copy(tempTarget2);
-                }
-                closestDistance = dist;
-                closestDistanceTriIndex = i;
-                closestDistanceOtherTriIndex = i2;
-              }
-              if (dist < minThreshold) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-  );
-  ExtendedTrianglePool.releasePrimitive(triangle3);
-  ExtendedTrianglePool.releasePrimitive(triangle22);
-  if (closestDistance === Infinity) {
-    return null;
-  }
-  if (!target1.point) {
-    target1.point = tempTargetDest1.clone();
-  } else {
-    target1.point.copy(tempTargetDest1);
-  }
-  target1.distance = closestDistance, target1.faceIndex = closestDistanceTriIndex;
-  if (target2) {
-    if (!target2.point) target2.point = tempTargetDest2.clone();
-    else target2.point.copy(tempTargetDest2);
-    target2.point.applyMatrix4(tempMatrix);
-    tempTargetDest1.applyMatrix4(tempMatrix);
-    target2.distance = tempTargetDest1.sub(target2.point).length();
-    target2.faceIndex = closestDistanceOtherTriIndex;
-  }
-  return target1;
-}
-function isSharedArrayBufferSupported() {
-  return typeof SharedArrayBuffer !== "undefined";
-}
-const _bufferStack1 = new BufferStack.constructor();
-const _bufferStack2 = new BufferStack.constructor();
-const _boxPool = new PrimitivePool(() => new Box3());
-const _leftBox1 = new Box3();
-const _rightBox1 = new Box3();
-const _leftBox2 = new Box3();
-const _rightBox2 = new Box3();
-let _active = false;
-function bvhcast(bvh, otherBvh, matrixToLocal, intersectsRanges) {
-  if (_active) {
-    throw new Error("MeshBVH: Recursive calls to bvhcast not supported.");
-  }
-  _active = true;
-  const roots = bvh._roots;
-  const otherRoots = otherBvh._roots;
-  let result;
-  let offset1 = 0;
-  let offset2 = 0;
-  const invMat = new Matrix4().copy(matrixToLocal).invert();
-  for (let i = 0, il = roots.length; i < il; i++) {
-    _bufferStack1.setBuffer(roots[i]);
-    offset2 = 0;
-    const localBox = _boxPool.getPrimitive();
-    arrayToBox(BOUNDING_DATA_INDEX(0), _bufferStack1.float32Array, localBox);
-    localBox.applyMatrix4(invMat);
-    for (let j = 0, jl = otherRoots.length; j < jl; j++) {
-      _bufferStack2.setBuffer(otherRoots[j]);
-      result = _traverse(
-        0,
-        0,
-        matrixToLocal,
-        invMat,
-        intersectsRanges,
-        offset1,
-        offset2,
-        0,
-        0,
-        localBox
-      );
-      _bufferStack2.clearBuffer();
-      offset2 += otherRoots[j].length;
-      if (result) {
-        break;
-      }
-    }
-    _boxPool.releasePrimitive(localBox);
-    _bufferStack1.clearBuffer();
-    offset1 += roots[i].length;
-    if (result) {
-      break;
-    }
-  }
-  _active = false;
-  return result;
-}
-function _traverse(node1Index32, node2Index32, matrix2to1, matrix1to2, intersectsRangesFunc, node1IndexByteOffset = 0, node2IndexByteOffset = 0, depth1 = 0, depth2 = 0, currBox = null, reversed = false) {
-  let bufferStack1, bufferStack2;
-  if (reversed) {
-    bufferStack1 = _bufferStack2;
-    bufferStack2 = _bufferStack1;
-  } else {
-    bufferStack1 = _bufferStack1;
-    bufferStack2 = _bufferStack2;
-  }
-  const float32Array1 = bufferStack1.float32Array, uint32Array1 = bufferStack1.uint32Array, uint16Array1 = bufferStack1.uint16Array, float32Array2 = bufferStack2.float32Array, uint32Array2 = bufferStack2.uint32Array, uint16Array2 = bufferStack2.uint16Array;
-  const node1Index16 = node1Index32 * 2;
-  const node2Index16 = node2Index32 * 2;
-  const isLeaf1 = IS_LEAF(node1Index16, uint16Array1);
-  const isLeaf2 = IS_LEAF(node2Index16, uint16Array2);
-  let result = false;
-  if (isLeaf2 && isLeaf1) {
-    if (reversed) {
-      result = intersectsRangesFunc(
-        OFFSET(node2Index32, uint32Array2),
-        COUNT(node2Index32 * 2, uint16Array2),
-        OFFSET(node1Index32, uint32Array1),
-        COUNT(node1Index32 * 2, uint16Array1),
-        depth2,
-        node2IndexByteOffset + node2Index32,
-        depth1,
-        node1IndexByteOffset + node1Index32
-      );
-    } else {
-      result = intersectsRangesFunc(
-        OFFSET(node1Index32, uint32Array1),
-        COUNT(node1Index32 * 2, uint16Array1),
-        OFFSET(node2Index32, uint32Array2),
-        COUNT(node2Index32 * 2, uint16Array2),
-        depth1,
-        node1IndexByteOffset + node1Index32,
-        depth2,
-        node2IndexByteOffset + node2Index32
-      );
-    }
-  } else if (isLeaf2) {
-    const newBox = _boxPool.getPrimitive();
-    arrayToBox(BOUNDING_DATA_INDEX(node2Index32), float32Array2, newBox);
-    newBox.applyMatrix4(matrix2to1);
-    const cl1 = LEFT_NODE(node1Index32);
-    const cr1 = RIGHT_NODE(node1Index32, uint32Array1);
-    arrayToBox(BOUNDING_DATA_INDEX(cl1), float32Array1, _leftBox1);
-    arrayToBox(BOUNDING_DATA_INDEX(cr1), float32Array1, _rightBox1);
-    const intersectCl1 = newBox.intersectsBox(_leftBox1);
-    const intersectCr1 = newBox.intersectsBox(_rightBox1);
-    result = intersectCl1 && _traverse(
-      node2Index32,
-      cl1,
-      matrix1to2,
-      matrix2to1,
-      intersectsRangesFunc,
-      node2IndexByteOffset,
-      node1IndexByteOffset,
-      depth2,
-      depth1 + 1,
-      newBox,
-      !reversed
-    ) || intersectCr1 && _traverse(
-      node2Index32,
-      cr1,
-      matrix1to2,
-      matrix2to1,
-      intersectsRangesFunc,
-      node2IndexByteOffset,
-      node1IndexByteOffset,
-      depth2,
-      depth1 + 1,
-      newBox,
-      !reversed
-    );
-    _boxPool.releasePrimitive(newBox);
-  } else {
-    const cl2 = LEFT_NODE(node2Index32);
-    const cr2 = RIGHT_NODE(node2Index32, uint32Array2);
-    arrayToBox(BOUNDING_DATA_INDEX(cl2), float32Array2, _leftBox2);
-    arrayToBox(BOUNDING_DATA_INDEX(cr2), float32Array2, _rightBox2);
-    const leftIntersects = currBox.intersectsBox(_leftBox2);
-    const rightIntersects = currBox.intersectsBox(_rightBox2);
-    if (leftIntersects && rightIntersects) {
-      result = _traverse(
-        node1Index32,
-        cl2,
-        matrix2to1,
-        matrix1to2,
-        intersectsRangesFunc,
-        node1IndexByteOffset,
-        node2IndexByteOffset,
-        depth1,
-        depth2 + 1,
-        currBox,
-        reversed
-      ) || _traverse(
-        node1Index32,
-        cr2,
-        matrix2to1,
-        matrix1to2,
-        intersectsRangesFunc,
-        node1IndexByteOffset,
-        node2IndexByteOffset,
-        depth1,
-        depth2 + 1,
-        currBox,
-        reversed
-      );
-    } else if (leftIntersects) {
-      if (isLeaf1) {
-        result = _traverse(
-          node1Index32,
-          cl2,
-          matrix2to1,
-          matrix1to2,
-          intersectsRangesFunc,
-          node1IndexByteOffset,
-          node2IndexByteOffset,
-          depth1,
-          depth2 + 1,
-          currBox,
-          reversed
-        );
-      } else {
-        const newBox = _boxPool.getPrimitive();
-        newBox.copy(_leftBox2).applyMatrix4(matrix2to1);
-        const cl1 = LEFT_NODE(node1Index32);
-        const cr1 = RIGHT_NODE(node1Index32, uint32Array1);
-        arrayToBox(BOUNDING_DATA_INDEX(cl1), float32Array1, _leftBox1);
-        arrayToBox(BOUNDING_DATA_INDEX(cr1), float32Array1, _rightBox1);
-        const intersectCl1 = newBox.intersectsBox(_leftBox1);
-        const intersectCr1 = newBox.intersectsBox(_rightBox1);
-        result = intersectCl1 && _traverse(
-          cl2,
-          cl1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        ) || intersectCr1 && _traverse(
-          cl2,
-          cr1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        );
-        _boxPool.releasePrimitive(newBox);
-      }
-    } else if (rightIntersects) {
-      if (isLeaf1) {
-        result = _traverse(
-          node1Index32,
-          cr2,
-          matrix2to1,
-          matrix1to2,
-          intersectsRangesFunc,
-          node1IndexByteOffset,
-          node2IndexByteOffset,
-          depth1,
-          depth2 + 1,
-          currBox,
-          reversed
-        );
-      } else {
-        const newBox = _boxPool.getPrimitive();
-        newBox.copy(_rightBox2).applyMatrix4(matrix2to1);
-        const cl1 = LEFT_NODE(node1Index32);
-        const cr1 = RIGHT_NODE(node1Index32, uint32Array1);
-        arrayToBox(BOUNDING_DATA_INDEX(cl1), float32Array1, _leftBox1);
-        arrayToBox(BOUNDING_DATA_INDEX(cr1), float32Array1, _rightBox1);
-        const intersectCl1 = newBox.intersectsBox(_leftBox1);
-        const intersectCr1 = newBox.intersectsBox(_rightBox1);
-        result = intersectCl1 && _traverse(
-          cr2,
-          cl1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        ) || intersectCr1 && _traverse(
-          cr2,
-          cr1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        );
-        _boxPool.releasePrimitive(newBox);
-      }
-    }
-  }
-  return result;
-}
-const obb = /* @__PURE__ */ new OrientedBox();
-const tempBox = /* @__PURE__ */ new Box3();
-const DEFAULT_OPTIONS = {
-  strategy: CENTER,
-  maxDepth: 40,
-  maxLeafTris: 10,
-  useSharedArrayBuffer: false,
-  setBoundingBox: true,
-  onProgress: null,
-  indirect: false,
-  verbose: true,
-  range: null
-};
-class MeshBVH {
-  static serialize(bvh, options = {}) {
-    options = {
-      cloneBuffers: true,
-      ...options
-    };
-    const geometry = bvh.geometry;
-    const rootData = bvh._roots;
-    const indirectBuffer = bvh._indirectBuffer;
-    const indexAttribute = geometry.getIndex();
-    let result;
-    if (options.cloneBuffers) {
-      result = {
-        roots: rootData.map((root) => root.slice()),
-        index: indexAttribute ? indexAttribute.array.slice() : null,
-        indirectBuffer: indirectBuffer ? indirectBuffer.slice() : null
-      };
-    } else {
-      result = {
-        roots: rootData,
-        index: indexAttribute ? indexAttribute.array : null,
-        indirectBuffer
-      };
-    }
-    return result;
-  }
-  static deserialize(data, geometry, options = {}) {
-    options = {
-      setIndex: true,
-      indirect: Boolean(data.indirectBuffer),
-      ...options
-    };
-    const { index: index2, roots, indirectBuffer } = data;
-    const bvh = new MeshBVH(geometry, { ...options, [SKIP_GENERATION]: true });
-    bvh._roots = roots;
-    bvh._indirectBuffer = indirectBuffer || null;
-    if (options.setIndex) {
-      const indexAttribute = geometry.getIndex();
-      if (indexAttribute === null) {
-        const newIndex = new BufferAttribute(data.index, 1, false);
-        geometry.setIndex(newIndex);
-      } else if (indexAttribute.array !== index2) {
-        indexAttribute.array.set(index2);
-        indexAttribute.needsUpdate = true;
-      }
-    }
-    return bvh;
-  }
-  get indirect() {
-    return !!this._indirectBuffer;
-  }
-  constructor(geometry, options = {}) {
-    if (!geometry.isBufferGeometry) {
-      throw new Error("MeshBVH: Only BufferGeometries are supported.");
-    } else if (geometry.index && geometry.index.isInterleavedBufferAttribute) {
-      throw new Error("MeshBVH: InterleavedBufferAttribute is not supported for the index attribute.");
-    }
-    options = Object.assign({
-      ...DEFAULT_OPTIONS,
-      // undocumented options
-      // Whether to skip generating the tree. Used for deserialization.
-      [SKIP_GENERATION]: false
-    }, options);
-    if (options.useSharedArrayBuffer && !isSharedArrayBufferSupported()) {
-      throw new Error("MeshBVH: SharedArrayBuffer is not available.");
-    }
-    this.geometry = geometry;
-    this._roots = null;
-    this._indirectBuffer = null;
-    if (!options[SKIP_GENERATION]) {
-      buildPackedTree(this, options);
-      if (!geometry.boundingBox && options.setBoundingBox) {
-        geometry.boundingBox = this.getBoundingBox(new Box3());
-      }
-    }
-    this.resolveTriangleIndex = options.indirect ? (i) => this._indirectBuffer[i] : (i) => i;
-  }
-  refit(nodeIndices = null) {
-    const refitFunc = this.indirect ? refit_indirect : refit;
-    return refitFunc(this, nodeIndices);
-  }
-  traverse(callback, rootIndex = 0) {
-    const buffer = this._roots[rootIndex];
-    const uint32Array2 = new Uint32Array(buffer);
-    const uint16Array2 = new Uint16Array(buffer);
-    _traverse2(0);
-    function _traverse2(node32Index, depth = 0) {
-      const node16Index = node32Index * 2;
-      const isLeaf = uint16Array2[node16Index + 15] === IS_LEAFNODE_FLAG;
-      if (isLeaf) {
-        const offset = uint32Array2[node32Index + 6];
-        const count = uint16Array2[node16Index + 14];
-        callback(depth, isLeaf, new Float32Array(buffer, node32Index * 4, 6), offset, count);
-      } else {
-        const left = node32Index + BYTES_PER_NODE / 4;
-        const right = uint32Array2[node32Index + 6];
-        const splitAxis = uint32Array2[node32Index + 7];
-        const stopTraversal = callback(depth, isLeaf, new Float32Array(buffer, node32Index * 4, 6), splitAxis);
-        if (!stopTraversal) {
-          _traverse2(left, depth + 1);
-          _traverse2(right, depth + 1);
-        }
-      }
-    }
-  }
-  /* Core Cast Functions */
-  raycast(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
-    const roots = this._roots;
-    const geometry = this.geometry;
-    const intersects = [];
-    const isMaterial = materialOrSide.isMaterial;
-    const isArrayMaterial = Array.isArray(materialOrSide);
-    const groups = geometry.groups;
-    const side = isMaterial ? materialOrSide.side : materialOrSide;
-    const raycastFunc = this.indirect ? raycast_indirect : raycast;
-    for (let i = 0, l = roots.length; i < l; i++) {
-      const materialSide = isArrayMaterial ? materialOrSide[groups[i].materialIndex].side : side;
-      const startCount = intersects.length;
-      raycastFunc(this, i, materialSide, ray2, intersects, near, far);
-      if (isArrayMaterial) {
-        const materialIndex = groups[i].materialIndex;
-        for (let j = startCount, jl = intersects.length; j < jl; j++) {
-          intersects[j].face.materialIndex = materialIndex;
-        }
-      }
-    }
-    return intersects;
-  }
-  raycastFirst(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
-    const roots = this._roots;
-    const geometry = this.geometry;
-    const isMaterial = materialOrSide.isMaterial;
-    const isArrayMaterial = Array.isArray(materialOrSide);
-    let closestResult = null;
-    const groups = geometry.groups;
-    const side = isMaterial ? materialOrSide.side : materialOrSide;
-    const raycastFirstFunc = this.indirect ? raycastFirst_indirect : raycastFirst;
-    for (let i = 0, l = roots.length; i < l; i++) {
-      const materialSide = isArrayMaterial ? materialOrSide[groups[i].materialIndex].side : side;
-      const result = raycastFirstFunc(this, i, materialSide, ray2, near, far);
-      if (result != null && (closestResult == null || result.distance < closestResult.distance)) {
-        closestResult = result;
-        if (isArrayMaterial) {
-          result.face.materialIndex = groups[i].materialIndex;
-        }
-      }
-    }
-    return closestResult;
-  }
-  intersectsGeometry(otherGeometry, geomToMesh) {
-    let result = false;
-    const roots = this._roots;
-    const intersectsGeometryFunc = this.indirect ? intersectsGeometry_indirect : intersectsGeometry;
-    for (let i = 0, l = roots.length; i < l; i++) {
-      result = intersectsGeometryFunc(this, i, otherGeometry, geomToMesh);
-      if (result) {
-        break;
-      }
-    }
-    return result;
-  }
-  shapecast(callbacks) {
-    const triangle3 = ExtendedTrianglePool.getPrimitive();
-    const iterateFunc = this.indirect ? iterateOverTriangles_indirect : iterateOverTriangles;
-    let {
-      boundsTraverseOrder,
-      intersectsBounds,
-      intersectsRange,
-      intersectsTriangle
-    } = callbacks;
-    if (intersectsRange && intersectsTriangle) {
-      const originalIntersectsRange = intersectsRange;
-      intersectsRange = (offset, count, contained, depth, nodeIndex) => {
-        if (!originalIntersectsRange(offset, count, contained, depth, nodeIndex)) {
-          return iterateFunc(offset, count, this, intersectsTriangle, contained, depth, triangle3);
-        }
-        return true;
-      };
-    } else if (!intersectsRange) {
-      if (intersectsTriangle) {
-        intersectsRange = (offset, count, contained, depth) => {
-          return iterateFunc(offset, count, this, intersectsTriangle, contained, depth, triangle3);
-        };
-      } else {
-        intersectsRange = (offset, count, contained) => {
-          return contained;
-        };
-      }
-    }
-    let result = false;
-    let byteOffset = 0;
-    const roots = this._roots;
-    for (let i = 0, l = roots.length; i < l; i++) {
-      const root = roots[i];
-      result = shapecast(this, i, intersectsBounds, intersectsRange, boundsTraverseOrder, byteOffset);
-      if (result) {
-        break;
-      }
-      byteOffset += root.byteLength;
-    }
-    ExtendedTrianglePool.releasePrimitive(triangle3);
-    return result;
-  }
-  bvhcast(otherBvh, matrixToLocal, callbacks) {
-    let {
-      intersectsRanges,
-      intersectsTriangles
-    } = callbacks;
-    const triangle1 = ExtendedTrianglePool.getPrimitive();
-    const indexAttr1 = this.geometry.index;
-    const positionAttr1 = this.geometry.attributes.position;
-    const assignTriangle1 = this.indirect ? (i1) => {
-      const ti = this.resolveTriangleIndex(i1);
-      setTriangle(triangle1, ti * 3, indexAttr1, positionAttr1);
-    } : (i1) => {
-      setTriangle(triangle1, i1 * 3, indexAttr1, positionAttr1);
-    };
-    const triangle22 = ExtendedTrianglePool.getPrimitive();
-    const indexAttr2 = otherBvh.geometry.index;
-    const positionAttr2 = otherBvh.geometry.attributes.position;
-    const assignTriangle2 = otherBvh.indirect ? (i2) => {
-      const ti2 = otherBvh.resolveTriangleIndex(i2);
-      setTriangle(triangle22, ti2 * 3, indexAttr2, positionAttr2);
-    } : (i2) => {
-      setTriangle(triangle22, i2 * 3, indexAttr2, positionAttr2);
-    };
-    if (intersectsTriangles) {
-      const iterateOverDoubleTriangles = (offset1, count1, offset2, count2, depth1, index1, depth2, index2) => {
-        for (let i2 = offset2, l2 = offset2 + count2; i2 < l2; i2++) {
-          assignTriangle2(i2);
-          triangle22.a.applyMatrix4(matrixToLocal);
-          triangle22.b.applyMatrix4(matrixToLocal);
-          triangle22.c.applyMatrix4(matrixToLocal);
-          triangle22.needsUpdate = true;
-          for (let i1 = offset1, l1 = offset1 + count1; i1 < l1; i1++) {
-            assignTriangle1(i1);
-            triangle1.needsUpdate = true;
-            if (intersectsTriangles(triangle1, triangle22, i1, i2, depth1, index1, depth2, index2)) {
-              return true;
-            }
-          }
-        }
-        return false;
-      };
-      if (intersectsRanges) {
-        const originalIntersectsRanges = intersectsRanges;
-        intersectsRanges = function(offset1, count1, offset2, count2, depth1, index1, depth2, index2) {
-          if (!originalIntersectsRanges(offset1, count1, offset2, count2, depth1, index1, depth2, index2)) {
-            return iterateOverDoubleTriangles(offset1, count1, offset2, count2, depth1, index1, depth2, index2);
-          }
-          return true;
-        };
-      } else {
-        intersectsRanges = iterateOverDoubleTriangles;
-      }
-    }
-    return bvhcast(this, otherBvh, matrixToLocal, intersectsRanges);
-  }
-  /* Derived Cast Functions */
-  intersectsBox(box, boxToMesh) {
-    obb.set(box.min, box.max, boxToMesh);
-    obb.needsUpdate = true;
-    return this.shapecast(
-      {
-        intersectsBounds: (box2) => obb.intersectsBox(box2),
-        intersectsTriangle: (tri) => obb.intersectsTriangle(tri)
-      }
-    );
-  }
-  intersectsSphere(sphere) {
-    return this.shapecast(
-      {
-        intersectsBounds: (box) => sphere.intersectsBox(box),
-        intersectsTriangle: (tri) => tri.intersectsSphere(sphere)
-      }
-    );
-  }
-  closestPointToGeometry(otherGeometry, geometryToBvh, target1 = {}, target2 = {}, minThreshold = 0, maxThreshold = Infinity) {
-    const closestPointToGeometryFunc = this.indirect ? closestPointToGeometry_indirect : closestPointToGeometry;
-    return closestPointToGeometryFunc(
-      this,
-      otherGeometry,
-      geometryToBvh,
-      target1,
-      target2,
-      minThreshold,
-      maxThreshold
-    );
-  }
-  closestPointToPoint(point, target = {}, minThreshold = 0, maxThreshold = Infinity) {
-    return closestPointToPoint(
-      this,
-      point,
-      target,
-      minThreshold,
-      maxThreshold
-    );
-  }
-  getBoundingBox(target) {
-    target.makeEmpty();
-    const roots = this._roots;
-    roots.forEach((buffer) => {
-      arrayToBox(0, new Float32Array(buffer), tempBox);
-      target.union(tempBox);
-    });
-    return target;
-  }
-}
-function convertRaycastIntersect(hit, object, raycaster) {
-  if (hit === null) {
-    return null;
-  }
-  hit.point.applyMatrix4(object.matrixWorld);
-  hit.distance = hit.point.distanceTo(raycaster.ray.origin);
-  hit.object = object;
-  return hit;
-}
-const ray = /* @__PURE__ */ new Ray();
-const direction = /* @__PURE__ */ new Vector3();
-const tmpInverseMatrix = /* @__PURE__ */ new Matrix4();
-const origMeshRaycastFunc = Mesh.prototype.raycast;
-const origBatchedRaycastFunc = BatchedMesh.prototype.raycast;
-const _worldScale = /* @__PURE__ */ new Vector3();
-const _mesh = /* @__PURE__ */ new Mesh();
-const _batchIntersects = [];
-function acceleratedRaycast(raycaster, intersects) {
-  if (this.isBatchedMesh) {
-    acceleratedBatchedMeshRaycast.call(this, raycaster, intersects);
-  } else {
-    acceleratedMeshRaycast.call(this, raycaster, intersects);
-  }
-}
-function acceleratedBatchedMeshRaycast(raycaster, intersects) {
-  if (this.boundsTrees) {
-    const boundsTrees = this.boundsTrees;
-    const drawInfo = this._drawInfo || this._instanceInfo;
-    const drawRanges = this._drawRanges || this._geometryInfo;
-    const matrixWorld = this.matrixWorld;
-    _mesh.material = this.material;
-    _mesh.geometry = this.geometry;
-    const oldBoundsTree = _mesh.geometry.boundsTree;
-    const oldDrawRange = _mesh.geometry.drawRange;
-    if (_mesh.geometry.boundingSphere === null) {
-      _mesh.geometry.boundingSphere = new Sphere();
-    }
-    for (let i = 0, l = drawInfo.length; i < l; i++) {
-      if (!this.getVisibleAt(i)) {
-        continue;
-      }
-      const geometryId = drawInfo[i].geometryIndex;
-      _mesh.geometry.boundsTree = boundsTrees[geometryId];
-      this.getMatrixAt(i, _mesh.matrixWorld).premultiply(matrixWorld);
-      if (!_mesh.geometry.boundsTree) {
-        this.getBoundingBoxAt(geometryId, _mesh.geometry.boundingBox);
-        this.getBoundingSphereAt(geometryId, _mesh.geometry.boundingSphere);
-        const drawRange = drawRanges[geometryId];
-        _mesh.geometry.setDrawRange(drawRange.start, drawRange.count);
-      }
-      _mesh.raycast(raycaster, _batchIntersects);
-      for (let j = 0, l2 = _batchIntersects.length; j < l2; j++) {
-        const intersect = _batchIntersects[j];
-        intersect.object = this;
-        intersect.batchId = i;
-        intersects.push(intersect);
-      }
-      _batchIntersects.length = 0;
-    }
-    _mesh.geometry.boundsTree = oldBoundsTree;
-    _mesh.geometry.drawRange = oldDrawRange;
-    _mesh.material = null;
-    _mesh.geometry = null;
-  } else {
-    origBatchedRaycastFunc.call(this, raycaster, intersects);
-  }
-}
-function acceleratedMeshRaycast(raycaster, intersects) {
-  if (this.geometry.boundsTree) {
-    if (this.material === void 0) return;
-    tmpInverseMatrix.copy(this.matrixWorld).invert();
-    ray.copy(raycaster.ray).applyMatrix4(tmpInverseMatrix);
-    _worldScale.setFromMatrixScale(this.matrixWorld);
-    direction.copy(ray.direction).multiply(_worldScale);
-    const scaleFactor = direction.length();
-    const near = raycaster.near / scaleFactor;
-    const far = raycaster.far / scaleFactor;
-    const bvh = this.geometry.boundsTree;
-    if (raycaster.firstHitOnly === true) {
-      const hit = convertRaycastIntersect(bvh.raycastFirst(ray, this.material, near, far), this, raycaster);
-      if (hit) {
-        intersects.push(hit);
-      }
-    } else {
-      const hits = bvh.raycast(ray, this.material, near, far);
-      for (let i = 0, l = hits.length; i < l; i++) {
-        const hit = convertRaycastIntersect(hits[i], this, raycaster);
-        if (hit) {
-          intersects.push(hit);
-        }
-      }
-    }
-  } else {
-    origMeshRaycastFunc.call(this, raycaster, intersects);
-  }
-}
-function computeBoundsTree(options = {}) {
-  this.boundsTree = new MeshBVH(this, options);
-  return this.boundsTree;
-}
-function disposeBoundsTree() {
-  this.boundsTree = null;
-}
-THREE.BufferGeometry.prototype.computeBoundsTree = computeBoundsTree;
-THREE.BufferGeometry.prototype.disposeBoundsTree = disposeBoundsTree;
-THREE.Mesh.prototype.raycast = acceleratedRaycast;
-THREE.Object3D.DEFAULT_UP = new THREE.Vector3(0, 0, 1);
-class Renderer extends Component {
-  static name = "Renderer";
-  static CSS2DObject = CSS2DObject;
-  static CSS3DObject = CSS3DObject;
-  static CSS3DSprite = CSS3DSprite;
-  static Group = THREE.Group;
-  static Object3D = THREE.Object3D;
-  static Mesh = THREE.Mesh;
-  static Line = THREE.Line;
-  static LineSegments = THREE.LineSegments;
-  static Points = THREE.Points;
-  scene;
-  camera;
-  renderer;
-  orbitControls;
-  resizeObserver;
-  description;
-  html2DRenderer;
-  html3DRenderer;
-  container = new THREE.Group();
-  onUpdate;
-  onResize;
-  tweenTaskList = [];
-  constructor(description) {
-    super();
-    this.description = description;
-    const {
-      scene = new THREE.Scene(),
-      camera = new THREE.PerspectiveCamera(45, 1, 0.01, 1e3)
-    } = description;
-    this.camera = camera;
-    this.scene = scene;
-    scene.add(this.container);
-    this.renderer = new THREE.WebGLRenderer({
-      canvas: this.description.canvas,
-      antialias: true
-    });
-    this.renderer.setPixelRatio(window.devicePixelRatio);
-    if (description.htmlRenderer) {
-      if (description.htmlRenderer["2d"]) {
-        this.html2DRenderer = new CSS2DRenderer();
-        Object.assign(this.html2DRenderer.domElement.style, { position: "absolute", left: "0px", top: "0px" });
-        description.htmlRenderer["2d"].appendChild(this.html2DRenderer.domElement);
-      }
-      if (description.htmlRenderer["3d"]) {
-        this.html3DRenderer = new CSS3DRenderer();
-        Object.assign(this.html3DRenderer.domElement.style, { position: "absolute", left: "0px", top: "0px" });
-        description.htmlRenderer["3d"].appendChild(this.html3DRenderer.domElement);
-      }
-    }
-    if (description.orbitControls) {
-      this.orbitControls = new OrbitControls(this.camera, description.orbitControls.domElement);
-      Object.assign(this.orbitControls, description.orbitControls);
-    }
-    if (this.description.resizeObserver) {
-      const dom = this.description.resizeObserver;
-      this.resizeObserver = new ResizeObserver(() => {
-        const camera2 = this.camera;
-        const { width, height } = dom.getBoundingClientRect();
-        this.renderer.setSize(width, height);
-        if (this.html2DRenderer) this.html2DRenderer.setSize(width, height);
-        if (this.html3DRenderer) this.html3DRenderer.setSize(width, height);
-        if (camera2 instanceof THREE.PerspectiveCamera) {
-          camera2.aspect = width / height;
-        } else if (camera2 instanceof THREE.OrthographicCamera) {
-          camera2.left = -width * 0.5;
-          camera2.right = width * 0.5;
-          camera2.top = height * 0.5;
-          camera2.bottom = -height * 0.5;
-        }
-        camera2.updateProjectionMatrix();
-        this.onResize && this.onResize(width, height);
-        this.dispatchEvent({ type: "resize", width, height });
-      });
-      this.resizeObserver.observe(dom);
-    }
-    this.renderer.setAnimationLoop(() => {
-      if (this.html2DRenderer) this.html2DRenderer.render(this.scene, this.camera);
-      if (this.html3DRenderer) this.html3DRenderer.render(this.scene, this.camera);
-      this.renderer.render(this.scene, this.camera);
-      if (this.orbitControls && this.orbitControls.enabled) this.orbitControls.update();
-      this.tweenTaskList.forEach((tween) => tween.update());
-      this.onUpdate && this.onUpdate();
-      this.parent?.components.forEach((c) => c.dispatchEvent({ type: "update" }));
-    });
-    this.scene.add(new THREE.AmbientLight(16777215, 0.5));
-    this.scene.background = new THREE.Color(3355443);
-    const directLight = new THREE.DirectionalLight(16777215, 4);
-    directLight.position.set(100, -100, 100);
-    this.scene.add(directLight);
-    camera.position.set(10, 10, 10);
-  }
-  /**
-   * 世界坐标转屏幕坐标
-   * @param worldPosition 
-   * @param camera 
-   * @param renderer 
-   * @returns 
-   */
-  worldToScreenPosition(worldPosition) {
-    const vector = new THREE.Vector3();
-    vector.copy(worldPosition);
-    vector.project(this.camera);
-    const x = (vector.x * 0.5 + 0.5) * this.renderer.domElement.clientWidth;
-    const z = (-vector.z * 0.5 + 0.5) * this.renderer.domElement.clientHeight;
-    return new THREE.Vector2(x, z);
-  }
-  cameraPositionRecord = [];
-  /**
-   * 相机
-   * @param position 
-   * @param lookAt 
-   * @param onEnd 
-   */
-  cameraTo(position, lookAt, onEnd) {
-    this.cameraPositionRecord.push([
-      this.camera.position.clone(),
-      this.camera.quaternion.clone()
-    ]);
-    const tween = new TWEEN.Tween(this.camera.position);
-    tween.to(position, 600);
-    tween.start();
-    tween.onUpdate(() => {
-      this.camera.lookAt(lookAt);
-    });
-    tween.onComplete(() => {
-      const i = this.tweenTaskList.indexOf(tween);
-      this.tweenTaskList.splice(i, 1);
-      onEnd && onEnd();
-    });
-    this.tweenTaskList.push(tween);
-  }
-  cameraBack() {
-    if (this.cameraPositionRecord.length) {
-      const [pos, quat] = this.cameraPositionRecord.pop();
-      this.camera.position.copy(pos);
-      this.camera.quaternion.copy(quat);
-    }
-  }
-  /**
-   * 创建点
-   * @param pos 
-   */
-  createPointMesh(pos, size = 0.02, parameters, parent = this.container) {
-    const box = new THREE.Mesh(
-      new THREE.SphereGeometry(size),
-      new THREE.MeshBasicMaterial(parameters)
-    );
-    if (pos instanceof Point) box.position.set(pos.x, pos.y, 0);
-    else if (pos instanceof THREE.Vector3) box.position.copy(pos);
-    parent.add(box);
-    return box;
-  }
-  /**
-   * 创建文本
-   * @param text 
-   * @param pos 
-   * @param style 
-   */
-  createText(text, pos, style, parent = this.container) {
-    const div = document.createElement("div");
-    div.innerHTML = text;
-    div.style.pointerEvents = "none";
-    Object.assign(div.style, { fontSize: "10px", color: "#ffffff", ...style });
-    const css2DObject = new Renderer.CSS2DObject(div);
-    if (pos instanceof Point) css2DObject.position.set(pos.x, pos.y, 0);
-    else if (pos instanceof THREE.Vector3) css2DObject.position.copy(pos);
-    parent.add(css2DObject);
-    return css2DObject;
-  }
-  /**
-   * 创建几何缓冲区
-   * @param map 
-   * @param count 
-   */
-  createLineSegments(map, count, parameters, parent = this.container) {
-    const geometry = new THREE.BufferGeometry();
-    Object.keys(map).forEach((key) => {
-      const value = map[key];
-      geometry.setAttribute(key, new THREE.BufferAttribute(new Float32Array(value), value.length / count));
-    });
-    const lineSegmentList = new THREE.LineSegments(geometry, new THREE.LineBasicMaterial({ ...parameters }));
-    parent.add(lineSegmentList);
-    return lineSegmentList;
-  }
-  destroy() {
-    if (this.resizeObserver) {
-      this.renderer.dispose();
-      this.resizeObserver.disconnect();
-      this.resizeObserver = void 0;
-    }
-  }
-}
 function drawLinePathToPng(points, width, height, color = "#fff", lineWidth = 2) {
   const can = document.createElement("canvas"), ctx = can.getContext("2d");
   can.width = width;
@@ -3789,41 +258,6 @@ class DetailsPointRender extends Component {
     renderer.camera.updateProjectionMatrix();
   }
 }
-class DomContainer extends Component {
-  static name = "DomContainer";
-  domElement = document.createElement("div");
-  canvas = document.createElement("canvas");
-  html2DRenderer = document.createElement("div");
-  html3DRenderer = document.createElement("div");
-  constructor() {
-    super();
-    this.domElement.appendChild(this.canvas);
-    this.domElement.appendChild(this.html3DRenderer);
-    this.domElement.appendChild(this.html2DRenderer);
-    Object.assign(this.domElement.style, {
-      width: "100%",
-      height: "100%",
-      position: "relative",
-      userSelect: "none"
-    });
-    Object.assign(this.html3DRenderer.style, {
-      position: "absolute",
-      left: 0,
-      top: 0,
-      zIndex: 9,
-      width: "100%",
-      height: "100%"
-    });
-    Object.assign(this.html2DRenderer.style, {
-      position: "absolute",
-      left: 0,
-      top: 0,
-      zIndex: 10,
-      width: "100%",
-      height: "100%"
-    });
-  }
-}
 class OriginalLineRender extends Component {
   static name = "OriginalLineRender";
   Dxf = null;
@@ -3950,103 +384,6 @@ class ModelDataRender extends Component {
     variable?.addEventListener("currentKeyUp", (e) => e.value === "e" && variable.set("whiteModelVisible", !variable.whiteModelVisible));
   }
 }
-class DomEventRegister extends Component {
-  static name = "DomEventRegister";
-  cancelDefaultBehaviorList = [];
-  pointer = new Vector2();
-  /**
-   * 
-   * @param parent 
-   */
-  onAddFromParent(parent) {
-    const domContainer = parent.findComponentByType(DomContainer);
-    const variable = parent.findComponentByType(Variable);
-    const domElement = domContainer.domElement;
-    domElement.tabIndex = 1;
-    domElement.addEventListener("keyup", (e) => {
-      const key = e.key.toLocaleLowerCase();
-      variable.set("currentKeyUp", key);
-      for (let i = 0; i < this.cancelDefaultBehaviorList.length; i++) {
-        const element = this.cancelDefaultBehaviorList[i];
-        if (element(e)) e.preventDefault();
-      }
-    });
-    domElement.addEventListener("keydown", (e) => {
-      const key = e.key.toLocaleLowerCase();
-      variable.set("currentKeyDown", key);
-      for (let i = 0; i < this.cancelDefaultBehaviorList.length; i++) {
-        const element = this.cancelDefaultBehaviorList[i];
-        if (element(e)) e.preventDefault();
-      }
-    });
-    domElement.addEventListener("mousedown", (e) => {
-      variable.set("currentMouseDown", "mouse_" + e.button);
-    });
-    domElement.addEventListener("mouseup", (e) => {
-      variable.set("currentMouseUp", "mouse_" + e.button);
-    });
-    domElement.addEventListener("wheel", (e) => {
-      variable.set("currentWheel", e.wheelDelta);
-    });
-    domElement.addEventListener("focus", () => {
-      variable.set("focus", true);
-    });
-    domElement.addEventListener("blur", () => {
-      variable.set("focus", false);
-    });
-    this.dragMoveHelper(domElement, (_0, x, y) => variable.set("pointerMove", { x, y }), { x: 0, y: 0 });
-    domElement.addEventListener("mousemove", (e) => {
-      this.pointer.set(e.offsetX, e.offsetY);
-      this.dispatchEvent({
-        type: "mousemove",
-        x: e.offsetX,
-        y: e.offsetY,
-        moveX: e.movementX,
-        moveY: e.movementY
-      });
-    });
-    domElement.addEventListener("mousedown", (e) => {
-      this.pointer.set(e.offsetX, e.offsetY);
-      this.dispatchEvent({
-        type: "mousedown",
-        x: e.offsetX,
-        y: e.offsetY
-      });
-    });
-  }
-  /**
-   * 
-   * @param callBack 
-   */
-  addCancelDefaultBehavior(callBack) {
-    this.cancelDefaultBehaviorList.push(callBack);
-    return this;
-  }
-  /**
-   * 
-   * @param el 
-   * @param callBack 
-   * @param offset 
-   * @param condition 
-   */
-  dragMoveHelper(el, callBack, offset = { x: 0, y: 0 }, condition = () => true) {
-    el.addEventListener("mousedown", () => {
-      if (!condition()) return;
-      const move = (e) => {
-        offset.x += e.movementX;
-        offset.y += e.movementY;
-        callBack({ ...offset }, e.movementX, e.movementY);
-      };
-      const end = () => {
-        document.removeEventListener("mousemove", move);
-        document.removeEventListener("mouseup", end);
-      };
-      document.addEventListener("mousemove", move);
-      document.addEventListener("mouseup", end);
-    });
-    callBack({ ...offset }, 0, 0);
-  }
-}
 class EventInput extends Component {
   static name = "EventInput";
   keyList = /* @__PURE__ */ new Set();
@@ -4085,6 +422,8 @@ class EventInput extends Component {
       this.mouseList.clear();
     });
     this.addEventListener("codeChange", this._computedkeyCombination.bind(this));
+    this.addKeyCombination("save", ["control", "s"]);
+    this.addCancelDefaultBehavior((input) => input.isOnlyKeyDowns(["control", "s"]));
   }
   /** 添加取消浏览器默认行为规则
    * @param callBack 
@@ -4353,6 +692,7 @@ function RenderPlugin_(dxfSystem, option = {}) {
     originalLine = true,
     modelData = true,
     detailsPoint = true,
+    orbitControls = true,
     camera = new THREE.PerspectiveCamera(45, 1, 0.01, 1e3)
   } = option;
   const domContainer = new DomContainer();
@@ -4365,11 +705,11 @@ function RenderPlugin_(dxfSystem, option = {}) {
       "3d": domContainer.html3DRenderer
     },
     resizeObserver: domContainer.domElement,
-    orbitControls: {
+    orbitControls: orbitControls ? {
       domElement: domContainer.domElement,
       enableDamping: true,
       dampingFactor: 0.15
-    }
+    } : void 0
   }));
   originalLine && dxfSystem.addComponent(new OriginalLineRender());
   modelData && dxfSystem.addComponent(new ModelDataRender());