@thatopen/components 2.4.1 → 2.4.3

package/dist/index.cjs

@@ -2041,27 +2041,27 @@ function iterateOverTriangles_indirect(offset, count, bvh, intersectsTriangleFun
   return false;
 }
 const _boxIntersection$3 = /* @__PURE__ */ new THREE$1.Vector3();
-function raycast(bvh, root, side, ray2, intersects) {
+function raycast(bvh, root, side, ray2, intersects2) {
   BufferStack.setBuffer(bvh._roots[root]);
-  _raycast$1(0, bvh, side, ray2, intersects);
+  _raycast$1(0, bvh, side, ray2, intersects2);
   BufferStack.clearBuffer();
 }
-function _raycast$1(nodeIndex32, bvh, side, ray2, intersects) {
+function _raycast$1(nodeIndex32, bvh, side, ray2, intersects2) {
   const { float32Array, uint16Array, uint32Array } = BufferStack;
   const nodeIndex16 = nodeIndex32 * 2;
   const isLeaf = IS_LEAF(nodeIndex16, uint16Array);
   if (isLeaf) {
     const offset = OFFSET(nodeIndex32, uint32Array);
     const count = COUNT(nodeIndex16, uint16Array);
-    intersectTris(bvh, side, ray2, offset, count, intersects);
+    intersectTris(bvh, side, ray2, offset, count, intersects2);
   } else {
     const leftIndex = LEFT_NODE(nodeIndex32);
     if (intersectRay(leftIndex, float32Array, ray2, _boxIntersection$3)) {
-      _raycast$1(leftIndex, bvh, side, ray2, intersects);
+      _raycast$1(leftIndex, bvh, side, ray2, intersects2);
     }
     const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array);
     if (intersectRay(rightIndex, float32Array, ray2, _boxIntersection$3)) {
-      _raycast$1(rightIndex, bvh, side, ray2, intersects);
+      _raycast$1(rightIndex, bvh, side, ray2, intersects2);
     }
   }
 }
@@ -2447,27 +2447,27 @@ function refit_indirect(bvh, nodeIndices = null) {
   }
 }
 const _boxIntersection$1 = /* @__PURE__ */ new THREE$1.Vector3();
-function raycast_indirect(bvh, root, side, ray2, intersects) {
+function raycast_indirect(bvh, root, side, ray2, intersects2) {
   BufferStack.setBuffer(bvh._roots[root]);
-  _raycast(0, bvh, side, ray2, intersects);
+  _raycast(0, bvh, side, ray2, intersects2);
   BufferStack.clearBuffer();
 }
-function _raycast(nodeIndex32, bvh, side, ray2, intersects) {
+function _raycast(nodeIndex32, bvh, side, ray2, intersects2) {
   const { float32Array, uint16Array, uint32Array } = BufferStack;
   const nodeIndex16 = nodeIndex32 * 2;
   const isLeaf = IS_LEAF(nodeIndex16, uint16Array);
   if (isLeaf) {
     const offset = OFFSET(nodeIndex32, uint32Array);
     const count = COUNT(nodeIndex16, uint16Array);
-    intersectTris_indirect(bvh, side, ray2, offset, count, intersects);
+    intersectTris_indirect(bvh, side, ray2, offset, count, intersects2);
   } else {
     const leftIndex = LEFT_NODE(nodeIndex32);
     if (intersectRay(leftIndex, float32Array, ray2, _boxIntersection$1)) {
-      _raycast(leftIndex, bvh, side, ray2, intersects);
+      _raycast(leftIndex, bvh, side, ray2, intersects2);
     }
     const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array);
     if (intersectRay(rightIndex, float32Array, ray2, _boxIntersection$1)) {
-      _raycast(rightIndex, bvh, side, ray2, intersects);
+      _raycast(rightIndex, bvh, side, ray2, intersects2);
     }
   }
 }
@@ -3139,7 +3139,7 @@ class MeshBVH {
   raycast(ray2, materialOrSide = THREE$1.FrontSide) {
     const roots = this._roots;
     const geometry = this.geometry;
-    const intersects = [];
+    const intersects2 = [];
     const isMaterial = materialOrSide.isMaterial;
     const isArrayMaterial = Array.isArray(materialOrSide);
     const groups = geometry.groups;
@@ -3147,16 +3147,16 @@ class MeshBVH {
     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);
+      const startCount = intersects2.length;
+      raycastFunc(this, i, materialSide, ray2, intersects2);
       if (isArrayMaterial) {
         const materialIndex = groups[i].materialIndex;
-        for (let j = startCount, jl = intersects.length; j < jl; j++) {
-          intersects[j].face.materialIndex = materialIndex;
+        for (let j = startCount, jl = intersects2.length; j < jl; j++) {
+          intersects2[j].face.materialIndex = materialIndex;
         }
       }
     }
-    return intersects;
+    return intersects2;
   }
   raycastFirst(ray2, materialOrSide = THREE$1.FrontSide) {
     const roots = this._roots;
@@ -3354,7 +3354,7 @@ function convertRaycastIntersect(hit, object, raycaster) {
 const ray = /* @__PURE__ */ new THREE$1.Ray();
 const tmpInverseMatrix = /* @__PURE__ */ new THREE$1.Matrix4();
 const origMeshRaycastFunc = THREE$1.Mesh.prototype.raycast;
-function acceleratedRaycast(raycaster, intersects) {
+function acceleratedRaycast(raycaster, intersects2) {
   if (this.geometry.boundsTree) {
     if (this.material === void 0)
       return;
@@ -3364,19 +3364,19 @@ function acceleratedRaycast(raycaster, intersects) {
     if (raycaster.firstHitOnly === true) {
       const hit = convertRaycastIntersect(bvh.raycastFirst(ray, this.material), this, raycaster);
       if (hit) {
-        intersects.push(hit);
+        intersects2.push(hit);
       }
     } else {
       const hits = bvh.raycast(ray, this.material);
       for (let i = 0, l = hits.length; i < l; i++) {
         const hit = convertRaycastIntersect(hits[i], this, raycaster);
         if (hit) {
-          intersects.push(hit);
+          intersects2.push(hit);
         }
       }
     }
   } else {
-    origMeshRaycastFunc.call(this, raycaster, intersects);
+    origMeshRaycastFunc.call(this, raycaster, intersects2);
   }
 }
 function computeBoundsTree(options) {
@@ -4751,15 +4751,15 @@ function obbFromPoints(vertices) {
     mean.add(p).add(q).add(r).divideScalar(3);
     qp.subVectors(q, p);
     rp.subVectors(r, p);
-    const area = v.crossVectors(qp, rp).length() / 2;
-    weightedMean.add(v.copy(mean).multiplyScalar(area));
-    areaSum += area;
-    cxx += (9 * mean.x * mean.x + p.x * p.x + q.x * q.x + r.x * r.x) * (area / 12);
-    cxy += (9 * mean.x * mean.y + p.x * p.y + q.x * q.y + r.x * r.y) * (area / 12);
-    cxz += (9 * mean.x * mean.z + p.x * p.z + q.x * q.z + r.x * r.z) * (area / 12);
-    cyy += (9 * mean.y * mean.y + p.y * p.y + q.y * q.y + r.y * r.y) * (area / 12);
-    cyz += (9 * mean.y * mean.z + p.y * p.z + q.y * q.z + r.y * r.z) * (area / 12);
-    czz += (9 * mean.z * mean.z + p.z * p.z + q.z * q.z + r.z * r.z) * (area / 12);
+    const area2 = v.crossVectors(qp, rp).length() / 2;
+    weightedMean.add(v.copy(mean).multiplyScalar(area2));
+    areaSum += area2;
+    cxx += (9 * mean.x * mean.x + p.x * p.x + q.x * q.x + r.x * r.x) * (area2 / 12);
+    cxy += (9 * mean.x * mean.y + p.x * p.y + q.x * q.y + r.x * r.y) * (area2 / 12);
+    cxz += (9 * mean.x * mean.z + p.x * p.z + q.x * q.z + r.x * r.z) * (area2 / 12);
+    cyy += (9 * mean.y * mean.y + p.y * p.y + q.y * q.y + r.y * r.y) * (area2 / 12);
+    cyz += (9 * mean.y * mean.z + p.y * p.z + q.y * q.z + r.y * r.z) * (area2 / 12);
+    czz += (9 * mean.z * mean.z + p.z * p.z + q.z * q.z + r.z * r.z) * (area2 / 12);
   }
   weightedMean.divideScalar(areaSum);
   cxx /= areaSum;
@@ -5251,15 +5251,15 @@ class VertexPicker extends Component {
       return this._pickedPoint;
     const casters = this.components.get(Raycasters);
     const caster = casters.get(world);
-    const intersects = caster.castRay();
-    if (!intersects) {
+    const intersects2 = caster.castRay();
+    if (!intersects2) {
       if (this._pickedPoint !== null) {
         this.onVertexLost.trigger();
         this._pickedPoint = null;
       }
       return this._pickedPoint;
     }
-    const point = this.getClosestVertex(intersects);
+    const point = this.getClosestVertex(intersects2);
     if (!point) {
       if (this._pickedPoint !== null) {
         this.onVertexLost.trigger();
@@ -5278,11 +5278,11 @@ class VertexPicker extends Component {
     }
     return this._pickedPoint;
   }
-  getClosestVertex(intersects) {
+  getClosestVertex(intersects2) {
     let closestVertex = new THREE__namespace.Vector3();
     let vertexFound = false;
     let closestDistance = Number.MAX_SAFE_INTEGER;
-    const vertices = this.getVertices(intersects);
+    const vertices = this.getVertices(intersects2);
     if (vertices === null) {
       return null;
     }
@@ -5290,35 +5290,35 @@ class VertexPicker extends Component {
       if (!vertex) {
         continue;
       }
-      const distance = intersects.point.distanceTo(vertex);
+      const distance = intersects2.point.distanceTo(vertex);
       if (distance > closestDistance || distance > this._config.snapDistance) {
         continue;
       }
       vertexFound = true;
       closestVertex = vertex;
-      closestDistance = intersects.point.distanceTo(vertex);
+      closestDistance = intersects2.point.distanceTo(vertex);
     }
     if (vertexFound) {
       return closestVertex;
     }
-    return this.config.showOnlyVertex ? null : intersects.point;
+    return this.config.showOnlyVertex ? null : intersects2.point;
   }
-  getVertices(intersects) {
-    const mesh = intersects.object;
-    if (!intersects.face || !mesh)
+  getVertices(intersects2) {
+    const mesh = intersects2.object;
+    if (!intersects2.face || !mesh)
       return null;
     const geom = mesh.geometry;
     const instanceTransform = new THREE__namespace.Matrix4();
-    const { instanceId } = intersects;
+    const { instanceId } = intersects2;
     const instanceFound = instanceId !== void 0;
     const isInstance = mesh instanceof THREE__namespace.InstancedMesh;
     if (isInstance && instanceFound) {
       mesh.getMatrixAt(instanceId, instanceTransform);
     }
     return [
-      this.getVertex(intersects.face.a, geom),
-      this.getVertex(intersects.face.b, geom),
-      this.getVertex(intersects.face.c, geom)
+      this.getVertex(intersects2.face.a, geom),
+      this.getVertex(intersects2.face.b, geom),
+      this.getVertex(intersects2.face.c, geom)
     ].map((vertex) => {
       if (vertex) {
         if (isInstance && instanceFound) {
@@ -5340,6 +5340,840 @@ class VertexPicker extends Component {
     );
   }
 }
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var earcut$2 = { exports: {} };
+earcut$2.exports = earcut;
+earcut$2.exports.default = earcut;
+function earcut(data, holeIndices, dim) {
+  dim = dim || 2;
+  var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = [];
+  if (!outerNode || outerNode.next === outerNode.prev)
+    return triangles;
+  var minX, minY, maxX, maxY, x, y, invSize;
+  if (hasHoles)
+    outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+  if (data.length > 80 * dim) {
+    minX = maxX = data[0];
+    minY = maxY = data[1];
+    for (var i = dim; i < outerLen; i += dim) {
+      x = data[i];
+      y = data[i + 1];
+      if (x < minX)
+        minX = x;
+      if (y < minY)
+        minY = y;
+      if (x > maxX)
+        maxX = x;
+      if (y > maxY)
+        maxY = y;
+    }
+    invSize = Math.max(maxX - minX, maxY - minY);
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
+  }
+  earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+  return triangles;
+}
+function linkedList(data, start, end, dim, clockwise) {
+  var i, last;
+  if (clockwise === signedArea(data, start, end, dim) > 0) {
+    for (i = start; i < end; i += dim)
+      last = insertNode(i, data[i], data[i + 1], last);
+  } else {
+    for (i = end - dim; i >= start; i -= dim)
+      last = insertNode(i, data[i], data[i + 1], last);
+  }
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
+  }
+  return last;
+}
+function filterPoints(start, end) {
+  if (!start)
+    return start;
+  if (!end)
+    end = start;
+  var p = start, again;
+  do {
+    again = false;
+    if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      removeNode(p);
+      p = end = p.prev;
+      if (p === p.next)
+        break;
+      again = true;
+    } else {
+      p = p.next;
+    }
+  } while (again || p !== end);
+  return end;
+}
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+  if (!ear)
+    return;
+  if (!pass && invSize)
+    indexCurve(ear, minX, minY, invSize);
+  var stop = ear, prev, next;
+  while (ear.prev !== ear.next) {
+    prev = ear.prev;
+    next = ear.next;
+    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+      triangles.push(prev.i / dim | 0);
+      triangles.push(ear.i / dim | 0);
+      triangles.push(next.i / dim | 0);
+      removeNode(ear);
+      ear = next.next;
+      stop = next.next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop) {
+      if (!pass) {
+        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+      } else if (pass === 1) {
+        ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+      } else if (pass === 2) {
+        splitEarcut(ear, triangles, dim, minX, minY, invSize);
+      }
+      break;
+    }
+  }
+}
+function isEar(ear) {
+  var a = ear.prev, b = ear, c = ear.next;
+  if (area(a, b, c) >= 0)
+    return false;
+  var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+  var p = c.next;
+  while (p !== a) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.next;
+  }
+  return true;
+}
+function isEarHashed(ear, minX, minY, invSize) {
+  var a = ear.prev, b = ear, c = ear.next;
+  if (area(a, b, c) >= 0)
+    return false;
+  var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+  var minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+  var p = ear.prevZ, n = ear.nextZ;
+  while (p && p.z >= minZ && n && n.z <= maxZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  while (p && p.z >= minZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+  }
+  while (n && n.z <= maxZ) {
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  return true;
+}
+function cureLocalIntersections(start, triangles, dim) {
+  var p = start;
+  do {
+    var a = p.prev, b = p.next.next;
+    if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i / dim | 0);
+      triangles.push(p.i / dim | 0);
+      triangles.push(b.i / dim | 0);
+      removeNode(p);
+      removeNode(p.next);
+      p = start = b;
+    }
+    p = p.next;
+  } while (p !== start);
+  return filterPoints(p);
+}
+function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+  var a = start;
+  do {
+    var b = a.next.next;
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        var c = splitPolygon(a, b);
+        a = filterPoints(a, a.next);
+        c = filterPoints(c, c.next);
+        earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+        earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+        return;
+      }
+      b = b.next;
+    }
+    a = a.next;
+  } while (a !== start);
+}
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+  var queue = [], i, len, start, end, list;
+  for (i = 0, len = holeIndices.length; i < len; i++) {
+    start = holeIndices[i] * dim;
+    end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    list = linkedList(data, start, end, dim, false);
+    if (list === list.next)
+      list.steiner = true;
+    queue.push(getLeftmost(list));
+  }
+  queue.sort(compareX);
+  for (i = 0; i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
+  }
+  return outerNode;
+}
+function compareX(a, b) {
+  return a.x - b.x;
+}
+function eliminateHole(hole, outerNode) {
+  var bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
+  }
+  var bridgeReverse = splitPolygon(bridge, hole);
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
+}
+function findHoleBridge(hole, outerNode) {
+  var p = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m;
+  do {
+    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+      var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+      if (x <= hx && x > qx) {
+        qx = x;
+        m = p.x < p.next.x ? p : p.next;
+        if (x === hx)
+          return m;
+      }
+    }
+    p = p.next;
+  } while (p !== outerNode);
+  if (!m)
+    return null;
+  var stop = m, mx = m.x, my = m.y, tanMin = Infinity, tan;
+  p = m;
+  do {
+    if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+      tan = Math.abs(hy - p.y) / (hx - p.x);
+      if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+        m = p;
+        tanMin = tan;
+      }
+    }
+    p = p.next;
+  } while (p !== stop);
+  return m;
+}
+function sectorContainsSector(m, p) {
+  return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+}
+function indexCurve(start, minX, minY, invSize) {
+  var p = start;
+  do {
+    if (p.z === 0)
+      p.z = zOrder(p.x, p.y, minX, minY, invSize);
+    p.prevZ = p.prev;
+    p.nextZ = p.next;
+    p = p.next;
+  } while (p !== start);
+  p.prevZ.nextZ = null;
+  p.prevZ = null;
+  sortLinked(p);
+}
+function sortLinked(list) {
+  var i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+  do {
+    p = list;
+    list = null;
+    tail = null;
+    numMerges = 0;
+    while (p) {
+      numMerges++;
+      q = p;
+      pSize = 0;
+      for (i = 0; i < inSize; i++) {
+        pSize++;
+        q = q.nextZ;
+        if (!q)
+          break;
+      }
+      qSize = inSize;
+      while (pSize > 0 || qSize > 0 && q) {
+        if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+          e = p;
+          p = p.nextZ;
+          pSize--;
+        } else {
+          e = q;
+          q = q.nextZ;
+          qSize--;
+        }
+        if (tail)
+          tail.nextZ = e;
+        else
+          list = e;
+        e.prevZ = tail;
+        tail = e;
+      }
+      p = q;
+    }
+    tail.nextZ = null;
+    inSize *= 2;
+  } while (numMerges > 1);
+  return list;
+}
+function zOrder(x, y, minX, minY, invSize) {
+  x = (x - minX) * invSize | 0;
+  y = (y - minY) * invSize | 0;
+  x = (x | x << 8) & 16711935;
+  x = (x | x << 4) & 252645135;
+  x = (x | x << 2) & 858993459;
+  x = (x | x << 1) & 1431655765;
+  y = (y | y << 8) & 16711935;
+  y = (y | y << 4) & 252645135;
+  y = (y | y << 2) & 858993459;
+  y = (y | y << 1) & 1431655765;
+  return x | y << 1;
+}
+function getLeftmost(start) {
+  var p = start, leftmost = start;
+  do {
+    if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+      leftmost = p;
+    p = p.next;
+  } while (p !== start);
+  return leftmost;
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function isValidDiagonal(a, b) {
+  return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+  (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+  (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+  equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+}
+function area(p, q, r) {
+  return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+}
+function equals(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y;
+}
+function intersects(p1, q1, p2, q2) {
+  var o1 = sign(area(p1, q1, p2));
+  var o2 = sign(area(p1, q1, q2));
+  var o3 = sign(area(p2, q2, p1));
+  var o4 = sign(area(p2, q2, q1));
+  if (o1 !== o2 && o3 !== o4)
+    return true;
+  if (o1 === 0 && onSegment(p1, p2, q1))
+    return true;
+  if (o2 === 0 && onSegment(p1, q2, q1))
+    return true;
+  if (o3 === 0 && onSegment(p2, p1, q2))
+    return true;
+  if (o4 === 0 && onSegment(p2, q1, q2))
+    return true;
+  return false;
+}
+function onSegment(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function sign(num) {
+  return num > 0 ? 1 : num < 0 ? -1 : 0;
+}
+function intersectsPolygon(a, b) {
+  var p = a;
+  do {
+    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+      return true;
+    p = p.next;
+  } while (p !== a);
+  return false;
+}
+function locallyInside(a, b) {
+  return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+}
+function middleInside(a, b) {
+  var p = a, inside = false, px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+  do {
+    if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+      inside = !inside;
+    p = p.next;
+  } while (p !== a);
+  return inside;
+}
+function splitPolygon(a, b) {
+  var a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+  a.next = b;
+  b.prev = a;
+  a2.next = an;
+  an.prev = a2;
+  b2.next = a2;
+  a2.prev = b2;
+  bp.next = b2;
+  b2.prev = bp;
+  return b2;
+}
+function insertNode(i, x, y, last) {
+  var p = new Node(i, x, y);
+  if (!last) {
+    p.prev = p;
+    p.next = p;
+  } else {
+    p.next = last.next;
+    p.prev = last;
+    last.next.prev = p;
+    last.next = p;
+  }
+  return p;
+}
+function removeNode(p) {
+  p.next.prev = p.prev;
+  p.prev.next = p.next;
+  if (p.prevZ)
+    p.prevZ.nextZ = p.nextZ;
+  if (p.nextZ)
+    p.nextZ.prevZ = p.prevZ;
+}
+function Node(i, x, y) {
+  this.i = i;
+  this.x = x;
+  this.y = y;
+  this.prev = null;
+  this.next = null;
+  this.z = 0;
+  this.prevZ = null;
+  this.nextZ = null;
+  this.steiner = false;
+}
+earcut.deviation = function(data, holeIndices, dim, triangles) {
+  var hasHoles = holeIndices && holeIndices.length;
+  var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+  if (hasHoles) {
+    for (var i = 0, len = holeIndices.length; i < len; i++) {
+      var start = holeIndices[i] * dim;
+      var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      polygonArea -= Math.abs(signedArea(data, start, end, dim));
+    }
+  }
+  var trianglesArea = 0;
+  for (i = 0; i < triangles.length; i += 3) {
+    var a = triangles[i] * dim;
+    var b = triangles[i + 1] * dim;
+    var c = triangles[i + 2] * dim;
+    trianglesArea += Math.abs(
+      (data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1])
+    );
+  }
+  return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
+};
+function signedArea(data, start, end, dim) {
+  var sum = 0;
+  for (var i = start, j = end - dim; i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    j = i;
+  }
+  return sum;
+}
+earcut.flatten = function(data) {
+  var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0;
+  for (var i = 0; i < data.length; i++) {
+    for (var j = 0; j < data[i].length; j++) {
+      for (var d = 0; d < dim; d++)
+        result.vertices.push(data[i][j][d]);
+    }
+    if (i > 0) {
+      holeIndex += data[i - 1].length;
+      result.holes.push(holeIndex);
+    }
+  }
+  return result;
+};
+var earcutExports = earcut$2.exports;
+const earcut$1 = /* @__PURE__ */ getDefaultExportFromCjs(earcutExports);
+class SectionGenerator extends Component {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "enabled", true);
+    __publicField(this, "_inverseMatrix", new THREE__namespace.Matrix4());
+    __publicField(this, "_localPlane", new THREE__namespace.Plane());
+    __publicField(this, "_tempLine", new THREE__namespace.Line3());
+    __publicField(this, "_tempVector", new THREE__namespace.Vector3());
+    __publicField(this, "_plane");
+    __publicField(this, "_plane2DCoordinateSystem", new THREE__namespace.Matrix4());
+    __publicField(this, "_precission", 1e4);
+    // Used if the plane is orthogonal to the cartesian planes
+    __publicField(this, "_planeAxis");
+  }
+  get plane() {
+    if (!this._plane) {
+      throw new Error("Plane not set");
+    }
+    return this._plane;
+  }
+  set plane(plane) {
+    this._plane = plane;
+  }
+  // This assumes that the mesh that contains the posAttr is aligned with the current plane
+  createEdges(data) {
+    const { meshes, posAttr } = data;
+    let index = 0;
+    posAttr.array.fill(0);
+    const indexes = [];
+    let lastIndex = 0;
+    const tempMesh = new THREE__namespace.Mesh();
+    for (const mesh of meshes) {
+      if (!mesh.geometry) {
+        continue;
+      }
+      if (!mesh.geometry.boundsTree) {
+        mesh.geometry.computeBoundsTree();
+      }
+      if (!mesh.geometry.boundsTree) {
+        throw new Error("Bounds tree not found for edges generation.");
+      }
+      if (mesh instanceof THREE__namespace.InstancedMesh) {
+        if (mesh.count === 0) {
+          continue;
+        }
+        const instanced = mesh;
+        for (let i = 0; i < instanced.count; i++) {
+          tempMesh.geometry = mesh.geometry;
+          tempMesh.matrix.copy(mesh.matrix);
+          const tempMatrix2 = new THREE__namespace.Matrix4();
+          instanced.getMatrixAt(i, tempMatrix2);
+          tempMesh.applyMatrix4(tempMatrix2);
+          tempMesh.applyMatrix4(mesh.matrixWorld);
+          tempMesh.updateMatrix();
+          tempMesh.updateMatrixWorld();
+          this._inverseMatrix.copy(tempMesh.matrixWorld).invert();
+          this._localPlane.copy(this.plane).applyMatrix4(this._inverseMatrix);
+          index = this.shapecast(tempMesh, posAttr, index);
+          if (index !== lastIndex) {
+            indexes.push(index);
+            lastIndex = index;
+          }
+        }
+      } else {
+        this._inverseMatrix.copy(mesh.matrixWorld).invert();
+        this._localPlane.copy(this.plane).applyMatrix4(this._inverseMatrix);
+        index = this.shapecast(mesh, posAttr, index);
+        if (index !== lastIndex) {
+          indexes.push(index);
+          lastIndex = index;
+        }
+      }
+    }
+    return { indexes, index };
+  }
+  createFills(buffer, trianglesIndices) {
+    this.updatePlane2DCoordinateSystem();
+    const allIndices = [];
+    let currentTriangle = 0;
+    for (let i = 0; i < trianglesIndices.length; i++) {
+      const nextTriangle = trianglesIndices[i];
+      const vertices = [];
+      for (let j = currentTriangle; j < nextTriangle; j += 2) {
+        vertices.push(j * 3);
+      }
+      const indices = this.computeFill(vertices, buffer);
+      for (const index of indices) {
+        allIndices.push(index);
+      }
+      currentTriangle = nextTriangle;
+    }
+    return allIndices;
+  }
+  computeFill(vertices, buffer) {
+    const indices = /* @__PURE__ */ new Map();
+    const all2DVertices = {};
+    const shapes = /* @__PURE__ */ new Map();
+    let nextShapeID = 0;
+    const shapesEnds = /* @__PURE__ */ new Map();
+    const shapesStarts = /* @__PURE__ */ new Map();
+    const openShapes = /* @__PURE__ */ new Set();
+    const p = this._precission;
+    for (let i = 0; i < vertices.length; i++) {
+      const startVertexIndex = vertices[i];
+      let x1 = 0;
+      let y1 = 0;
+      let x2 = 0;
+      let y2 = 0;
+      const globalX1 = buffer[startVertexIndex];
+      const globalY1 = buffer[startVertexIndex + 1];
+      const globalZ1 = buffer[startVertexIndex + 2];
+      const globalX2 = buffer[startVertexIndex + 3];
+      const globalY2 = buffer[startVertexIndex + 4];
+      const globalZ2 = buffer[startVertexIndex + 5];
+      this._tempVector.set(globalX1, globalY1, globalZ1);
+      this._tempVector.applyMatrix4(this._plane2DCoordinateSystem);
+      x1 = Math.trunc(this._tempVector.x * p) / p;
+      y1 = Math.trunc(this._tempVector.y * p) / p;
+      this._tempVector.set(globalX2, globalY2, globalZ2);
+      this._tempVector.applyMatrix4(this._plane2DCoordinateSystem);
+      x2 = Math.trunc(this._tempVector.x * p) / p;
+      y2 = Math.trunc(this._tempVector.y * p) / p;
+      if (x1 === x2 && y1 === y2) {
+        continue;
+      }
+      const startCode = `${x1}|${y1}`;
+      const endCode = `${x2}|${y2}`;
+      if (!indices.has(startCode)) {
+        indices.set(startCode, startVertexIndex / 3);
+      }
+      if (!indices.has(endCode)) {
+        indices.set(endCode, startVertexIndex / 3 + 1);
+      }
+      const start = indices.get(startCode);
+      const end = indices.get(endCode);
+      all2DVertices[start] = [x1, y1];
+      all2DVertices[end] = [x2, y2];
+      const startMatchesStart = shapesStarts.has(start);
+      const startMatchesEnd = shapesEnds.has(start);
+      const endMatchesStart = shapesStarts.has(end);
+      const endMatchesEnd = shapesEnds.has(end);
+      const noMatches = !startMatchesStart && !startMatchesEnd && !endMatchesStart && !endMatchesEnd;
+      if (noMatches) {
+        shapesStarts.set(start, nextShapeID);
+        shapesEnds.set(end, nextShapeID);
+        openShapes.add(nextShapeID);
+        shapes.set(nextShapeID, [start, end]);
+        nextShapeID++;
+      } else if (startMatchesStart && endMatchesEnd) {
+        const startIndex = shapesStarts.get(start);
+        const endIndex = shapesEnds.get(end);
+        const isShapeMerge = startIndex !== endIndex;
+        if (isShapeMerge) {
+          const endShape = shapes.get(endIndex);
+          const startShape = shapes.get(startIndex);
+          if (!endShape || !startShape) {
+            continue;
+          }
+          shapes.delete(startIndex);
+          openShapes.delete(startIndex);
+          shapesEnds.set(startShape[startShape.length - 1], endIndex);
+          shapesEnds.delete(endShape[endShape.length - 1]);
+          for (const index of startShape) {
+            endShape.push(index);
+          }
+        } else {
+          openShapes.delete(endIndex);
+        }
+        shapesStarts.delete(start);
+        shapesEnds.delete(end);
+      } else if (startMatchesEnd && endMatchesStart) {
+        const startIndex = shapesStarts.get(end);
+        const endIndex = shapesEnds.get(start);
+        const isShapeMerge = startIndex !== endIndex;
+        if (isShapeMerge) {
+          const endShape = shapes.get(endIndex);
+          const startShape = shapes.get(startIndex);
+          if (!endShape || !startShape) {
+            continue;
+          }
+          shapes.delete(startIndex);
+          openShapes.delete(startIndex);
+          shapesEnds.set(startShape[startShape.length - 1], endIndex);
+          shapesEnds.delete(endShape[endShape.length - 1]);
+          for (const index of startShape) {
+            endShape.push(index);
+          }
+        } else {
+          openShapes.delete(endIndex);
+        }
+        shapesStarts.delete(end);
+        shapesEnds.delete(start);
+      } else if (startMatchesStart && endMatchesStart) {
+        const startIndex1 = shapesStarts.get(end);
+        const startIndex2 = shapesStarts.get(start);
+        const startShape2 = shapes.get(startIndex2);
+        const startShape1 = shapes.get(startIndex1);
+        if (!startShape2 || !startShape1) {
+          continue;
+        }
+        shapes.delete(startIndex1);
+        openShapes.delete(startIndex1);
+        shapesStarts.delete(startShape2[0]);
+        shapesStarts.delete(startShape1[0]);
+        shapesEnds.delete(startShape1[startShape1.length - 1]);
+        shapesStarts.set(startShape1[startShape1.length - 1], startIndex2);
+        startShape1.reverse();
+        startShape2.splice(0, 0, ...startShape1);
+      } else if (startMatchesEnd && endMatchesEnd) {
+        const endIndex1 = shapesEnds.get(end);
+        const endIndex2 = shapesEnds.get(start);
+        const endShape2 = shapes.get(endIndex2);
+        const endShape1 = shapes.get(endIndex1);
+        if (!endShape2 || !endShape1) {
+          continue;
+        }
+        shapes.delete(endIndex1);
+        openShapes.delete(endIndex1);
+        shapesEnds.delete(endShape2[endShape2.length - 1]);
+        shapesEnds.delete(endShape1[endShape1.length - 1]);
+        shapesStarts.delete(endShape1[0]);
+        shapesEnds.set(endShape1[0], endIndex2);
+        endShape1.reverse();
+        endShape2.push(...endShape1);
+      } else if (startMatchesStart) {
+        const shapeIndex = shapesStarts.get(start);
+        const shape = shapes.get(shapeIndex);
+        if (!shape) {
+          continue;
+        }
+        shape.unshift(end);
+        shapesStarts.delete(start);
+        shapesStarts.set(end, shapeIndex);
+      } else if (startMatchesEnd) {
+        const shapeIndex = shapesEnds.get(start);
+        const shape = shapes.get(shapeIndex);
+        if (!shape) {
+          continue;
+        }
+        shape.push(end);
+        shapesEnds.delete(start);
+        shapesEnds.set(end, shapeIndex);
+      } else if (endMatchesStart) {
+        const shapeIndex = shapesStarts.get(end);
+        const shape = shapes.get(shapeIndex);
+        if (!shape) {
+          continue;
+        }
+        shape.unshift(start);
+        shapesStarts.delete(end);
+        shapesStarts.set(start, shapeIndex);
+      } else if (endMatchesEnd) {
+        const shapeIndex = shapesEnds.get(end);
+        const shape = shapes.get(shapeIndex);
+        if (!shape) {
+          continue;
+        }
+        shape.push(start);
+        shapesEnds.delete(end);
+        shapesEnds.set(start, shapeIndex);
+      }
+    }
+    const trueIndices = [];
+    for (const [id, shape] of shapes) {
+      if (openShapes.has(id)) {
+        continue;
+      }
+      const vertices2 = [];
+      const indexMap = /* @__PURE__ */ new Map();
+      let counter = 0;
+      for (const index of shape) {
+        const vertex = all2DVertices[index];
+        vertices2.push(vertex[0], vertex[1]);
+        indexMap.set(counter++, index);
+      }
+      const result = earcut$1(vertices2);
+      for (const index of result) {
+        const trueIndex = indexMap.get(index);
+        if (trueIndex === void 0) {
+          throw new Error("Map error!");
+        }
+        trueIndices.push(trueIndex);
+      }
+    }
+    return trueIndices;
+  }
+  updatePlane2DCoordinateSystem() {
+    this._plane2DCoordinateSystem = new THREE__namespace.Matrix4();
+    const xAxis = new THREE__namespace.Vector3(1, 0, 0);
+    const yAxis = new THREE__namespace.Vector3(0, 1, 0);
+    const zAxis = this.plane.normal;
+    const pos = new THREE__namespace.Vector3();
+    this.plane.coplanarPoint(pos);
+    if (this._planeAxis === "x") {
+      xAxis.crossVectors(yAxis, zAxis);
+    } else if (this._planeAxis === "y") {
+      yAxis.crossVectors(zAxis, xAxis);
+    } else if (this._planeAxis === "z")
+      ;
+    else {
+      xAxis.crossVectors(yAxis, zAxis).normalize();
+      yAxis.crossVectors(zAxis, xAxis);
+    }
+    this._plane2DCoordinateSystem.fromArray([
+      xAxis.x,
+      xAxis.y,
+      xAxis.z,
+      0,
+      yAxis.x,
+      yAxis.y,
+      yAxis.z,
+      0,
+      zAxis.x,
+      zAxis.y,
+      zAxis.z,
+      0,
+      pos.x,
+      pos.y,
+      pos.z,
+      1
+    ]);
+    this._plane2DCoordinateSystem.invert();
+  }
+  shapecast(mesh, posAttr, index) {
+    mesh.geometry.boundsTree.shapecast({
+      intersectsBounds: (box) => {
+        return this._localPlane.intersectsBox(box);
+      },
+      // @ts-ignore
+      intersectsTriangle: (tri) => {
+        let count = 0;
+        this._tempLine.start.copy(tri.a);
+        this._tempLine.end.copy(tri.b);
+        if (this._localPlane.intersectLine(this._tempLine, this._tempVector)) {
+          const result = this._tempVector.applyMatrix4(mesh.matrixWorld);
+          posAttr.setXYZ(index, result.x, result.y, result.z);
+          count++;
+          index++;
+        }
+        this._tempLine.start.copy(tri.b);
+        this._tempLine.end.copy(tri.c);
+        if (this._localPlane.intersectLine(this._tempLine, this._tempVector)) {
+          const result = this._tempVector.applyMatrix4(mesh.matrixWorld);
+          posAttr.setXYZ(index, result.x, result.y, result.z);
+          count++;
+          index++;
+        }
+        this._tempLine.start.copy(tri.c);
+        this._tempLine.end.copy(tri.a);
+        if (this._localPlane.intersectLine(this._tempLine, this._tempVector)) {
+          const result = this._tempVector.applyMatrix4(mesh.matrixWorld);
+          posAttr.setXYZ(index, result.x, result.y, result.z);
+          count++;
+          index++;
+        }
+        if (count !== 2) {
+          index -= count;
+        }
+      }
+    });
+    return index;
+  }
+}
+/**
+ * A unique identifier for the component.
+ * This UUID is used to register the component within the Components system.
+ */
+__publicField(SectionGenerator, "uuid", "1a193b87-6376-46c8-9e65-62a1576fdb64");
 const _Components = class _Components {
   constructor() {
     /** {@link Disposable.onDisposed} */
@@ -5478,7 +6312,7 @@ const _Components = class _Components {
 /**
  * The version of the @thatopen/components library.
  */
-__publicField(_Components, "release", "2.4.1");
+__publicField(_Components, "release", "2.4.3");
 let Components = _Components;
 class SimpleWorld extends Base {
   constructor() {
@@ -8141,9 +8975,9 @@ class CameraControls extends EventDispatcher {
       const origin = _v3C.addVectors(this._target, nearPlaneCorner);
       _raycaster$1.set(origin, rayDirection);
       _raycaster$1.far = this._spherical.radius + 1;
-      const intersects = _raycaster$1.intersectObjects(this.colliderMeshes);
-      if (intersects.length !== 0 && intersects[0].distance < distance) {
-        distance = intersects[0].distance;
+      const intersects2 = _raycaster$1.intersectObjects(this.colliderMeshes);
+      if (intersects2.length !== 0 && intersects2[0].distance < distance) {
+        distance = intersects2[0].distance;
       }
     }
     return distance;
@@ -11567,9 +12401,9 @@ const _Clipper = class _Clipper extends Component {
   create(world) {
     const casters = this.components.get(Raycasters);
     const caster = casters.get(world);
-    const intersects = caster.castRay();
-    if (intersects) {
-      return this.createPlaneFromIntersection(world, intersects);
+    const intersects2 = caster.castRay();
+    if (intersects2) {
+      return this.createPlaneFromIntersection(world, intersects2);
     }
     return null;
   }
@@ -11646,9 +12480,9 @@ const _Clipper = class _Clipper extends Component {
     const casters = this.components.get(Raycasters);
     const caster = casters.get(world);
     const meshes = this.getAllPlaneMeshes();
-    const intersects = caster.castRay(meshes);
-    if (intersects) {
-      const found = intersects.object;
+    const intersects2 = caster.castRay(meshes);
+    if (intersects2) {
+      const found = intersects2.object;
       return this.list.find((p) => p.meshes.includes(found));
     }
     return void 0;
@@ -17162,10 +17996,6 @@ const _FragmentsManager = class _FragmentsManager extends Component {
  */
 __publicField(_FragmentsManager, "uuid", "fef46874-46a3-461b-8c44-2922ab77c806");
 let FragmentsManager = _FragmentsManager;
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
 function commonjsRequire(path) {
   throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
@@ -20382,13 +21212,13 @@ function toNumber$1(str, options = {}) {
   } else {
     const match = numRegex.exec(trimmedStr);
     if (match) {
-      const sign = match[1];
+      const sign2 = match[1];
       const leadingZeros = match[2];
       let numTrimmedByZeros = trimZeros(match[3]);
       const eNotation = match[4] || match[6];
-      if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".")
+      if (!options.leadingZeros && leadingZeros.length > 0 && sign2 && trimmedStr[2] !== ".")
         return str;
-      else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".")
+      else if (!options.leadingZeros && leadingZeros.length > 0 && !sign2 && trimmedStr[1] !== ".")
         return str;
       else {
         const num = Number(trimmedStr);
@@ -20408,7 +21238,7 @@ function toNumber$1(str, options = {}) {
             return num;
           else if (numStr === numTrimmedByZeros)
             return num;
-          else if (sign && numStr === "-" + numTrimmedByZeros)
+          else if (sign2 && numStr === "-" + numTrimmedByZeros)
             return num;
           else
             return str;
@@ -20416,14 +21246,14 @@ function toNumber$1(str, options = {}) {
         if (leadingZeros) {
           if (numTrimmedByZeros === numStr)
             return num;
-          else if (sign + numTrimmedByZeros === numStr)
+          else if (sign2 + numTrimmedByZeros === numStr)
             return num;
           else
             return str;
         }
         if (trimmedStr === numStr)
           return num;
-        else if (trimmedStr === sign + numStr)
+        else if (trimmedStr === sign2 + numStr)
           return num;
         return str;
       }
@@ -27820,6 +28650,7 @@ exports.PlanMode = PlanMode;
 exports.ProjectionManager = ProjectionManager;
 exports.PropertiesStreamingSettings = PropertiesStreamingSettings;
 exports.Raycasters = Raycasters;
+exports.SectionGenerator = SectionGenerator;
 exports.ShadowedScene = ShadowedScene;
 exports.SimpleCamera = SimpleCamera;
 exports.SimpleGrid = SimpleGrid;