brepjs 2.0.1 → 2.0.3

package/dist/brepjs.cjs

@@ -53,921 +53,1017 @@ function uniqueIOFilename(prefix, ext) {
 function uniqueId() {
   return `_io_${++_counter}`;
 }
+function exportSTEP$2(oc, shapes) {
+  const writer = new oc.STEPControl_Writer_1();
+  oc.Interface_Static.SetIVal("write.step.schema", 5);
+  writer.Model(true).delete();
+  const progress = new oc.Message_ProgressRange_1();
+  for (const shape of shapes) {
+    writer.Transfer(shape, oc.STEPControl_StepModelType.STEPControl_AsIs, true, progress);
+  }
+  const filename = uniqueIOFilename("_export", "step");
+  const done = writer.Write(filename);
+  writer.delete();
+  progress.delete();
+  if (done === oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+    const file = oc.FS.readFile("/" + filename);
+    oc.FS.unlink("/" + filename);
+    return new TextDecoder().decode(file);
+  }
+  throw new Error("STEP export failed: writer did not complete successfully");
+}
+function exportSTL$1(oc, shape, binary = false) {
+  const filename = uniqueIOFilename("_export", "stl");
+  const done = oc.StlAPI.Write(shape, filename, !binary);
+  if (done) {
+    const file = oc.FS.readFile("/" + filename);
+    oc.FS.unlink("/" + filename);
+    if (binary) return file.buffer;
+    return new TextDecoder().decode(file);
+  }
+  throw new Error("STL export failed: StlAPI.Write returned false");
+}
+function importSTEP$2(oc, data) {
+  const filename = uniqueIOFilename("_import", "step");
+  const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+  oc.FS.writeFile("/" + filename, buffer);
+  const reader = new oc.STEPControl_Reader_1();
+  if (reader.ReadFile(filename)) {
+    oc.FS.unlink("/" + filename);
+    const progress = new oc.Message_ProgressRange_1();
+    reader.TransferRoots(progress);
+    progress.delete();
+    const shape = reader.OneShape();
+    reader.delete();
+    return [shape];
+  }
+  oc.FS.unlink("/" + filename);
+  reader.delete();
+  throw new Error("Failed to import STEP file: reader could not parse the input data");
+}
+function importSTL$2(oc, data) {
+  const filename = uniqueIOFilename("_import", "stl");
+  const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+  oc.FS.writeFile("/" + filename, buffer);
+  const reader = new oc.StlAPI_Reader();
+  const readShape = new oc.TopoDS_Shell();
+  if (reader.Read(readShape, filename)) {
+    oc.FS.unlink("/" + filename);
+    const upgrader = new oc.ShapeUpgrade_UnifySameDomain_2(readShape, true, true, false);
+    upgrader.Build();
+    const upgraded = upgrader.Shape();
+    const solidBuilder = new oc.BRepBuilderAPI_MakeSolid_1();
+    solidBuilder.Add(oc.TopoDS.Shell_1(upgraded));
+    const solid = solidBuilder.Solid();
+    readShape.delete();
+    upgrader.delete();
+    solidBuilder.delete();
+    reader.delete();
+    return solid;
+  }
+  oc.FS.unlink("/" + filename);
+  readShape.delete();
+  reader.delete();
+  throw new Error("Failed to import STL file: reader could not parse the input data");
+}
 const HASH_CODE_MAX$1 = 2147483647;
+function volume(oc, shape) {
+  const props = new oc.GProp_GProps_1();
+  oc.BRepGProp.VolumeProperties_1(shape, props, true, false, false);
+  const vol = props.Mass();
+  props.delete();
+  return vol;
+}
+function area(oc, shape) {
+  const props = new oc.GProp_GProps_1();
+  oc.BRepGProp.SurfaceProperties_2(shape, props, 1e-7, true);
+  const a = props.Mass();
+  props.delete();
+  return a;
+}
+function length(oc, shape) {
+  const props = new oc.GProp_GProps_1();
+  oc.BRepGProp.LinearProperties(shape, props, true, false);
+  const len = props.Mass();
+  props.delete();
+  return len;
+}
+function centerOfMass(oc, shape) {
+  const props = new oc.GProp_GProps_1();
+  oc.BRepGProp.VolumeProperties_1(shape, props, true, false, false);
+  const center = props.CentreOfMass();
+  const result = [center.X(), center.Y(), center.Z()];
+  center.delete();
+  props.delete();
+  return result;
+}
+function boundingBox(oc, shape) {
+  const box = new oc.Bnd_Box_1();
+  oc.BRepBndLib.Add(shape, box, true);
+  const xMin = { current: 0 };
+  const yMin = { current: 0 };
+  const zMin = { current: 0 };
+  const xMax = { current: 0 };
+  const yMax = { current: 0 };
+  const zMax = { current: 0 };
+  box.Get(xMin, yMin, zMin, xMax, yMax, zMax);
+  box.delete();
+  return {
+    min: [xMin.current, yMin.current, zMin.current],
+    max: [xMax.current, yMax.current, zMax.current]
+  };
+}
+function transform(oc, shape, trsf) {
+  const transformer = new oc.BRepBuilderAPI_Transform_2(shape, trsf, true);
+  const result = transformer.ModifiedShape(shape);
+  transformer.delete();
+  return result;
+}
+function translate$1(oc, shape, x, y, z) {
+  const trsf = new oc.gp_Trsf_1();
+  const vec2 = new oc.gp_Vec_4(x, y, z);
+  trsf.SetTranslation_1(vec2);
+  const result = transform(oc, shape, trsf);
+  trsf.delete();
+  vec2.delete();
+  return result;
+}
+function rotate$1(oc, shape, angle, axis = [0, 0, 1], center = [0, 0, 0]) {
+  const trsf = new oc.gp_Trsf_1();
+  const origin = new oc.gp_Pnt_3(...center);
+  const dir = new oc.gp_Dir_4(...axis);
+  const ax1 = new oc.gp_Ax1_2(origin, dir);
+  trsf.SetRotation_1(ax1, angle * Math.PI / 180);
+  const result = transform(oc, shape, trsf);
+  trsf.delete();
+  ax1.delete();
+  origin.delete();
+  dir.delete();
+  return result;
+}
+function mirror$1(oc, shape, origin, normal) {
+  const trsf = new oc.gp_Trsf_1();
+  const pnt2 = new oc.gp_Pnt_3(...origin);
+  const dir = new oc.gp_Dir_4(...normal);
+  const ax2 = new oc.gp_Ax2_3(pnt2, dir);
+  trsf.SetMirror_3(ax2);
+  const result = transform(oc, shape, trsf);
+  trsf.delete();
+  ax2.delete();
+  pnt2.delete();
+  dir.delete();
+  return result;
+}
+function scale$1(oc, shape, center, factor) {
+  const trsf = new oc.gp_Trsf_1();
+  const pnt2 = new oc.gp_Pnt_3(...center);
+  trsf.SetScale(pnt2, factor);
+  const result = transform(oc, shape, trsf);
+  trsf.delete();
+  pnt2.delete();
+  return result;
+}
+function simplify(oc, shape) {
+  const upgrader = new oc.ShapeUpgrade_UnifySameDomain_2(shape, true, true, false);
+  upgrader.Build();
+  const result = upgrader.Shape();
+  upgrader.delete();
+  return result;
+}
+function applyGlue$2(oc, op, optimisation) {
+  if (optimisation === "commonFace") {
+    op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueShift);
+  }
+  if (optimisation === "sameFace") {
+    op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
+  }
+}
+function buildCompound$2(oc, shapes) {
+  const builder = new oc.TopoDS_Builder();
+  const compound = new oc.TopoDS_Compound();
+  builder.MakeCompound(compound);
+  for (const s of shapes) {
+    builder.Add(compound, s);
+  }
+  builder.delete();
+  return compound;
+}
+function fuse(oc, shape, tool, options = {}) {
+  const { optimisation, simplify: simplify2 = false } = options;
+  const progress = new oc.Message_ProgressRange_1();
+  const fuseOp = new oc.BRepAlgoAPI_Fuse_3(shape, tool, progress);
+  applyGlue$2(oc, fuseOp, optimisation);
+  fuseOp.Build(progress);
+  if (simplify2) fuseOp.SimplifyResult(true, true, 1e-3);
+  const result = fuseOp.Shape();
+  fuseOp.delete();
+  progress.delete();
+  return result;
+}
+function cut(oc, shape, tool, options = {}) {
+  const { optimisation, simplify: simplify2 = false } = options;
+  const progress = new oc.Message_ProgressRange_1();
+  const cutOp = new oc.BRepAlgoAPI_Cut_3(shape, tool, progress);
+  applyGlue$2(oc, cutOp, optimisation);
+  cutOp.Build(progress);
+  if (simplify2) cutOp.SimplifyResult(true, true, 1e-3);
+  const result = cutOp.Shape();
+  cutOp.delete();
+  progress.delete();
+  return result;
+}
+function intersect(oc, shape, tool, options = {}) {
+  const { optimisation, simplify: simplify2 = false } = options;
+  const progress = new oc.Message_ProgressRange_1();
+  const commonOp = new oc.BRepAlgoAPI_Common_3(shape, tool, progress);
+  applyGlue$2(oc, commonOp, optimisation);
+  commonOp.Build(progress);
+  if (simplify2) commonOp.SimplifyResult(true, true, 1e-3);
+  const result = commonOp.Shape();
+  commonOp.delete();
+  progress.delete();
+  return result;
+}
+function fuseAllBatch(oc, shapes, options = {}) {
+  const { optimisation, simplify: simplify2 = false } = options;
+  const batch = new oc.BooleanBatch();
+  for (const s of shapes) {
+    batch.addShape(s);
+  }
+  const glueMode = optimisation === "commonFace" ? 1 : optimisation === "sameFace" ? 2 : 0;
+  const result = batch.fuseAll(glueMode, simplify2);
+  batch.delete();
+  return result;
+}
+function fuseAllNative(oc, shapes, options = {}) {
+  const { optimisation, simplify: simplify2 = false } = options;
+  const argList = new oc.TopTools_ListOfShape_1();
+  for (const s of shapes) {
+    argList.Append_1(s);
+  }
+  const builder = new oc.BRepAlgoAPI_BuilderAlgo_1();
+  builder.SetArguments(argList);
+  applyGlue$2(oc, builder, optimisation);
+  const progress = new oc.Message_ProgressRange_1();
+  builder.Build(progress);
+  let result = builder.Shape();
+  if (simplify2) {
+    const upgrader = new oc.ShapeUpgrade_UnifySameDomain_2(result, true, true, false);
+    upgrader.Build();
+    result = upgrader.Shape();
+    upgrader.delete();
+  }
+  argList.delete();
+  builder.delete();
+  progress.delete();
+  return result;
+}
+function fuseAllPairwise(oc, shapes, options = {}) {
+  const mid = Math.ceil(shapes.length / 2);
+  const left = fuseAll$3(oc, shapes.slice(0, mid), {
+    ...options,
+    simplify: false,
+    strategy: "pairwise"
+  });
+  const right = fuseAll$3(oc, shapes.slice(mid), {
+    ...options,
+    simplify: false,
+    strategy: "pairwise"
+  });
+  return fuse(oc, left, right, options);
+}
+function fuseAll$3(oc, shapes, options = {}) {
+  if (shapes.length === 0) throw new Error("fuseAll requires at least one shape");
+  if (shapes.length === 1) return shapes[0];
+  const { strategy = "native" } = options;
+  if (strategy === "pairwise") {
+    return fuseAllPairwise(oc, shapes, options);
+  }
+  if (oc.BooleanBatch) {
+    return fuseAllBatch(oc, shapes, options);
+  }
+  return fuseAllNative(oc, shapes, options);
+}
+function cutAllBatch(oc, shape, tools, options = {}) {
+  const { optimisation, simplify: simplify2 = false } = options;
+  const batch = new oc.BooleanBatch();
+  for (const t of tools) {
+    batch.addShape(t);
+  }
+  const glueMode = optimisation === "commonFace" ? 1 : optimisation === "sameFace" ? 2 : 0;
+  const result = batch.cutAll(shape, glueMode, simplify2);
+  batch.delete();
+  return result;
+}
+function cutAll$2(oc, shape, tools, options = {}) {
+  if (tools.length === 0) return shape;
+  if (oc.BooleanBatch) {
+    return cutAllBatch(oc, shape, tools, options);
+  }
+  const toolCompound = buildCompound$2(oc, tools);
+  const result = cut(oc, shape, toolCompound, options);
+  toolCompound.delete();
+  return result;
+}
+function meshBulk(oc, shape, options) {
+  const raw = oc.MeshExtractor.extract(
+    shape,
+    options.tolerance,
+    options.angularTolerance,
+    !!options.skipNormals
+  );
+  const verticesSize = raw.getVerticesSize();
+  const normalsSize = raw.getNormalsSize();
+  const trianglesSize = raw.getTrianglesSize();
+  const faceGroupsSize = raw.getFaceGroupsSize();
+  const verticesPtr = raw.getVerticesPtr() / 4;
+  const vertices = oc.HEAPF32.slice(verticesPtr, verticesPtr + verticesSize);
+  let normals;
+  if (options.skipNormals || normalsSize === 0) {
+    normals = new Float32Array(0);
+  } else {
+    const normalsPtr = raw.getNormalsPtr() / 4;
+    normals = oc.HEAPF32.slice(normalsPtr, normalsPtr + normalsSize);
+  }
+  const trianglesPtr = raw.getTrianglesPtr() / 4;
+  const triangles = oc.HEAPU32.slice(trianglesPtr, trianglesPtr + trianglesSize);
+  const faceGroups = [];
+  if (faceGroupsSize > 0) {
+    const fgPtr = raw.getFaceGroupsPtr() / 4;
+    const fgRaw = oc.HEAP32.slice(fgPtr, fgPtr + faceGroupsSize);
+    for (let i = 0; i < fgRaw.length; i += 3) {
+      faceGroups.push({
+        start: fgRaw[i],
+        count: fgRaw[i + 1],
+        faceHash: fgRaw[i + 2]
+      });
+    }
+  }
+  raw.delete();
+  return { vertices, normals, triangles, faceGroups };
+}
+function meshJS(oc, shape, options) {
+  const mesher = new oc.BRepMesh_IncrementalMesh_2(
+    shape,
+    options.tolerance,
+    false,
+    options.angularTolerance,
+    false
+  );
+  mesher.delete();
+  let totalNodes = 0;
+  let totalTris = 0;
+  const explorer = new oc.TopExp_Explorer_2(
+    shape,
+    oc.TopAbs_ShapeEnum.TopAbs_FACE,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  while (explorer.More()) {
+    const face = oc.TopoDS.Face_1(explorer.Current());
+    const loc = new oc.TopLoc_Location_1();
+    const tri = oc.BRep_Tool.Triangulation(face, loc, 0);
+    if (!tri.IsNull()) {
+      const t = tri.get();
+      totalNodes += t.NbNodes();
+      totalTris += t.NbTriangles();
+    }
+    loc.delete();
+    tri.delete();
+    explorer.Next();
+  }
+  const vertices = new Float32Array(totalNodes * 3);
+  const normals = options.skipNormals ? new Float32Array(0) : new Float32Array(totalNodes * 3);
+  const triangles = new Uint32Array(totalTris * 3);
+  const faceGroups = [];
+  let vIdx = 0;
+  let nIdx = 0;
+  let tIdx = 0;
+  explorer.Init(shape, oc.TopAbs_ShapeEnum.TopAbs_FACE, oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+  while (explorer.More()) {
+    const face = oc.TopoDS.Face_1(explorer.Current());
+    const location = new oc.TopLoc_Location_1();
+    const triangulation = oc.BRep_Tool.Triangulation(face, location, 0);
+    if (!triangulation.IsNull()) {
+      const tri = triangulation.get();
+      const transformation = location.Transformation();
+      const nbNodes = tri.NbNodes();
+      const vertexOffset = vIdx / 3;
+      const triStart = tIdx;
+      for (let i = 1; i <= nbNodes; i++) {
+        const p = tri.Node(i).Transformed(transformation);
+        vertices[vIdx++] = p.X();
+        vertices[vIdx++] = p.Y();
+        vertices[vIdx++] = p.Z();
+        p.delete();
+      }
+      if (!options.skipNormals) {
+        const normalsArray = new oc.TColgp_Array1OfDir_2(1, nbNodes);
+        const pc = new oc.Poly_Connect_2(triangulation);
+        oc.StdPrs_ToolTriangulatedShape.Normal(face, pc, normalsArray);
+        for (let i = normalsArray.Lower(); i <= normalsArray.Upper(); i++) {
+          const d = normalsArray.Value(i).Transformed(transformation);
+          normals[nIdx++] = d.X();
+          normals[nIdx++] = d.Y();
+          normals[nIdx++] = d.Z();
+          d.delete();
+        }
+        normalsArray.delete();
+        pc.delete();
+      }
+      const orient = face.Orientation_1();
+      const isForward = orient === oc.TopAbs_Orientation.TopAbs_FORWARD;
+      const nbTriangles = tri.NbTriangles();
+      for (let nt = 1; nt <= nbTriangles; nt++) {
+        const t = tri.Triangle(nt);
+        let n1 = t.Value(1);
+        let n2 = t.Value(2);
+        const n3 = t.Value(3);
+        if (!isForward) {
+          const tmp = n1;
+          n1 = n2;
+          n2 = tmp;
+        }
+        triangles[tIdx++] = n1 - 1 + vertexOffset;
+        triangles[tIdx++] = n2 - 1 + vertexOffset;
+        triangles[tIdx++] = n3 - 1 + vertexOffset;
+        t.delete();
+      }
+      faceGroups.push({
+        start: triStart,
+        count: tIdx - triStart,
+        faceHash: face.HashCode(HASH_CODE_MAX$1)
+      });
+      transformation.delete();
+    }
+    location.delete();
+    triangulation.delete();
+    explorer.Next();
+  }
+  explorer.delete();
+  return { vertices, normals, triangles, faceGroups };
+}
+function mesh(oc, shape, options) {
+  if (oc.MeshExtractor) {
+    return meshBulk(oc, shape, options);
+  }
+  return meshJS(oc, shape, options);
+}
+function meshEdgesBulk(oc, shape, tolerance, angularTolerance) {
+  const raw = oc.EdgeMeshExtractor.extract(shape, tolerance, angularTolerance);
+  const linesSize = raw.getLinesSize();
+  const edgeGroupsSize = raw.getEdgeGroupsSize();
+  let lines;
+  if (linesSize > 0) {
+    const linesPtr = raw.getLinesPtr() / 4;
+    lines = oc.HEAPF32.slice(linesPtr, linesPtr + linesSize);
+  } else {
+    lines = new Float32Array(0);
+  }
+  const edgeGroups = [];
+  if (edgeGroupsSize > 0) {
+    const egPtr = raw.getEdgeGroupsPtr() / 4;
+    const egRaw = oc.HEAP32.slice(egPtr, egPtr + edgeGroupsSize);
+    for (let i = 0; i < egRaw.length; i += 3) {
+      edgeGroups.push({
+        start: egRaw[i],
+        count: egRaw[i + 1],
+        edgeHash: egRaw[i + 2]
+      });
+    }
+  }
+  raw.delete();
+  return { lines, edgeGroups };
+}
+function meshEdgesJS(oc, shape, tolerance, angularTolerance) {
+  const mesher = new oc.BRepMesh_IncrementalMesh_2(
+    shape,
+    tolerance,
+    false,
+    angularTolerance,
+    false
+  );
+  mesher.delete();
+  const lines = [];
+  const edgeGroups = [];
+  const seenHashes = /* @__PURE__ */ new Set();
+  const faceExplorer = new oc.TopExp_Explorer_2(
+    shape,
+    oc.TopAbs_ShapeEnum.TopAbs_FACE,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  while (faceExplorer.More()) {
+    const face = oc.TopoDS.Face_1(faceExplorer.Current());
+    const faceLoc = new oc.TopLoc_Location_1();
+    const tri = oc.BRep_Tool.Triangulation(face, faceLoc, 0);
+    if (!tri.IsNull()) {
+      const triObj = tri.get();
+      const edgeExplorer2 = new oc.TopExp_Explorer_2(
+        face,
+        oc.TopAbs_ShapeEnum.TopAbs_EDGE,
+        oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+      );
+      while (edgeExplorer2.More()) {
+        const edgeShape = edgeExplorer2.Current();
+        const edge = oc.TopoDS.Edge_1(edgeShape);
+        const edgeHash = edge.HashCode(HASH_CODE_MAX$1);
+        if (!seenHashes.has(edgeHash)) {
+          seenHashes.add(edgeHash);
+          const edgeLoc = new oc.TopLoc_Location_1();
+          const polygon = oc.BRep_Tool.PolygonOnTriangulation_1(edge, tri, edgeLoc);
+          const edgeNodes = polygon && !polygon.IsNull() ? polygon.get().Nodes() : null;
+          if (edgeNodes) {
+            const lineStart = lines.length / 3;
+            let prevX = 0, prevY = 0, prevZ = 0;
+            let hasPrev = false;
+            for (let i = edgeNodes.Lower(); i <= edgeNodes.Upper(); i++) {
+              const p = triObj.Node(edgeNodes.Value(i)).Transformed(edgeLoc.Transformation());
+              const x = p.X(), y = p.Y(), z = p.Z();
+              if (hasPrev) {
+                lines.push(prevX, prevY, prevZ, x, y, z);
+              }
+              prevX = x;
+              prevY = y;
+              prevZ = z;
+              hasPrev = true;
+              p.delete();
+            }
+            edgeGroups.push({
+              start: lineStart,
+              count: lines.length / 3 - lineStart,
+              edgeHash
+            });
+            edgeNodes.delete();
+          }
+          if (polygon && !polygon.IsNull()) polygon.delete();
+          edgeLoc.delete();
+        }
+        edgeExplorer2.Next();
+      }
+      edgeExplorer2.delete();
+    }
+    tri.delete();
+    faceLoc.delete();
+    faceExplorer.Next();
+  }
+  faceExplorer.delete();
+  const edgeExplorer = new oc.TopExp_Explorer_2(
+    shape,
+    oc.TopAbs_ShapeEnum.TopAbs_EDGE,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  while (edgeExplorer.More()) {
+    const edgeShape = edgeExplorer.Current();
+    const edge = oc.TopoDS.Edge_1(edgeShape);
+    const edgeHash = edge.HashCode(HASH_CODE_MAX$1);
+    if (!seenHashes.has(edgeHash)) {
+      seenHashes.add(edgeHash);
+      const adaptor = new oc.BRepAdaptor_Curve_2(edge);
+      const tangDef = new oc.GCPnts_TangentialDeflection_2(
+        adaptor,
+        tolerance,
+        angularTolerance,
+        2,
+        1e-9,
+        1e-7
+      );
+      const lineStart = lines.length / 3;
+      let prevX = 0, prevY = 0, prevZ = 0;
+      let hasPrev = false;
+      for (let j = 1; j <= tangDef.NbPoints(); j++) {
+        const p = tangDef.Value(j);
+        const x = p.X(), y = p.Y(), z = p.Z();
+        if (hasPrev) {
+          lines.push(prevX, prevY, prevZ, x, y, z);
+        }
+        prevX = x;
+        prevY = y;
+        prevZ = z;
+        hasPrev = true;
+        p.delete();
+      }
+      edgeGroups.push({
+        start: lineStart,
+        count: lines.length / 3 - lineStart,
+        edgeHash
+      });
+      tangDef.delete();
+      adaptor.delete();
+    }
+    edgeExplorer.Next();
+  }
+  edgeExplorer.delete();
+  return { lines: new Float32Array(lines), edgeGroups };
+}
+function meshEdges(oc, shape, tolerance, angularTolerance) {
+  if (oc.EdgeMeshExtractor) {
+    return meshEdgesBulk(oc, shape, tolerance, angularTolerance);
+  }
+  return meshEdgesJS(oc, shape, tolerance, angularTolerance);
+}
+function iterShapesBulk(oc, shape, type) {
+  const typeEnumMap = {
+    vertex: 7,
+    edge: 6,
+    wire: 5,
+    face: 4,
+    shell: 3,
+    solid: 2,
+    compsolid: 1,
+    compound: 0
+  };
+  const raw = oc.TopologyExtractor.extract(shape, typeEnumMap[type]);
+  const count = raw.getShapesCount();
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(raw.getShape(i));
+  }
+  raw.delete();
+  return result;
+}
+function iterShapesJS(oc, shape, type) {
+  const typeMap = {
+    vertex: oc.TopAbs_ShapeEnum.TopAbs_VERTEX,
+    edge: oc.TopAbs_ShapeEnum.TopAbs_EDGE,
+    wire: oc.TopAbs_ShapeEnum.TopAbs_WIRE,
+    face: oc.TopAbs_ShapeEnum.TopAbs_FACE,
+    shell: oc.TopAbs_ShapeEnum.TopAbs_SHELL,
+    solid: oc.TopAbs_ShapeEnum.TopAbs_SOLID,
+    compsolid: oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID,
+    compound: oc.TopAbs_ShapeEnum.TopAbs_COMPOUND
+  };
+  const explorer = new oc.TopExp_Explorer_2(shape, typeMap[type], oc.TopAbs_ShapeEnum.TopAbs_SHAPE);
+  const result = [];
+  const seen = /* @__PURE__ */ new Map();
+  while (explorer.More()) {
+    const item = explorer.Current();
+    const hash = item.HashCode(HASH_CODE_MAX$1);
+    const bucket = seen.get(hash);
+    if (!bucket) {
+      seen.set(hash, [item]);
+      result.push(item);
+    } else if (!bucket.some((s) => s.IsSame(item))) {
+      bucket.push(item);
+      result.push(item);
+    }
+    explorer.Next();
+  }
+  explorer.delete();
+  return result;
+}
+function iterShapes(oc, shape, type) {
+  if (oc.TopologyExtractor) {
+    return iterShapesBulk(oc, shape, type);
+  }
+  return iterShapesJS(oc, shape, type);
+}
+const shapeTypeMaps = /* @__PURE__ */ new WeakMap();
+function getShapeTypeMap(oc) {
+  let map2 = shapeTypeMaps.get(oc);
+  if (!map2) {
+    const ta = oc.TopAbs_ShapeEnum;
+    map2 = /* @__PURE__ */ new Map([
+      [ta.TopAbs_VERTEX, "vertex"],
+      [ta.TopAbs_EDGE, "edge"],
+      [ta.TopAbs_WIRE, "wire"],
+      [ta.TopAbs_FACE, "face"],
+      [ta.TopAbs_SHELL, "shell"],
+      [ta.TopAbs_SOLID, "solid"],
+      [ta.TopAbs_COMPSOLID, "compsolid"],
+      [ta.TopAbs_COMPOUND, "compound"]
+    ]);
+    shapeTypeMaps.set(oc, map2);
+  }
+  return map2;
+}
+function shapeType$1(oc, shape) {
+  if (shape.IsNull()) throw new Error("Cannot determine shape type: shape is null");
+  const result = getShapeTypeMap(oc).get(shape.ShapeType());
+  if (!result) throw new Error(`Unknown shape type enum value: ${shape.ShapeType()}`);
+  return result;
+}
+function isSame(a, b) {
+  return a.IsSame(b);
+}
+function isEqual(a, b) {
+  return a.IsEqual(b);
+}
+function makeVertex$1(oc, x, y, z) {
+  const pnt2 = new oc.gp_Pnt_3(x, y, z);
+  const maker = new oc.BRepBuilderAPI_MakeVertex(pnt2);
+  const vertex = maker.Vertex();
+  maker.delete();
+  pnt2.delete();
+  return vertex;
+}
+function makeEdge(oc, curve, start, end) {
+  const maker = start !== void 0 && end !== void 0 ? new oc.BRepBuilderAPI_MakeEdge_24(curve, start, end) : new oc.BRepBuilderAPI_MakeEdge_24(curve);
+  const edge = maker.Edge();
+  maker.delete();
+  return edge;
+}
+function makeWire(oc, edges) {
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  for (const edge of edges) {
+    wireBuilder.Add_1(edge);
+  }
+  const progress = new oc.Message_ProgressRange_1();
+  wireBuilder.Build(progress);
+  const wire = wireBuilder.Wire();
+  wireBuilder.delete();
+  progress.delete();
+  return wire;
+}
+function makeFace$1(oc, wire, planar = true) {
+  if (planar) {
+    const builder2 = new oc.BRepBuilderAPI_MakeFace_15(wire, false);
+    const face = builder2.Face();
+    builder2.delete();
+    return face;
+  }
+  const builder = new oc.BRepOffsetAPI_MakeFilling(3, 15, 2, false, 1e-5, 1e-4, 0.01, 0.1, 8, 9);
+  const edges = iterShapes(oc, wire, "edge");
+  for (const edge of edges) {
+    builder.Add_1(edge, oc.GeomAbs_Shape.GeomAbs_C0, true);
+  }
+  const progress = new oc.Message_ProgressRange_1();
+  builder.Build(progress);
+  const shape = builder.Shape();
+  builder.delete();
+  progress.delete();
+  return shape;
+}
+function makeBox$1(oc, width, height, depth) {
+  const maker = new oc.BRepPrimAPI_MakeBox_2(width, height, depth);
+  const solid = maker.Solid();
+  maker.delete();
+  return solid;
+}
+function makeCylinder$1(oc, radius, height, center = [0, 0, 0], direction = [0, 0, 1]) {
+  const origin = new oc.gp_Pnt_3(...center);
+  const dir = new oc.gp_Dir_4(...direction);
+  const axis = new oc.gp_Ax2_3(origin, dir);
+  const maker = new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height);
+  const solid = maker.Shape();
+  maker.delete();
+  axis.delete();
+  origin.delete();
+  dir.delete();
+  return solid;
+}
+function makeSphere$1(oc, radius, center = [0, 0, 0]) {
+  const origin = new oc.gp_Pnt_3(...center);
+  const maker = new oc.BRepPrimAPI_MakeSphere_2(origin, radius);
+  const solid = maker.Shape();
+  maker.delete();
+  origin.delete();
+  return solid;
+}
+function extrude(oc, face, direction, length2) {
+  const vec2 = new oc.gp_Vec_4(direction[0] * length2, direction[1] * length2, direction[2] * length2);
+  const maker = new oc.BRepPrimAPI_MakePrism_1(face, vec2, false, true);
+  const result = maker.Shape();
+  maker.delete();
+  vec2.delete();
+  return result;
+}
+function revolve(oc, shape, axis, angle) {
+  const maker = new oc.BRepPrimAPI_MakeRevol_1(shape, axis, angle, false);
+  const result = maker.Shape();
+  maker.delete();
+  return result;
+}
+function loft$1(oc, wires, ruled = false, startShape, endShape) {
+  const loftBuilder = new oc.BRepOffsetAPI_ThruSections(true, ruled, 1e-6);
+  if (startShape) loftBuilder.AddVertex(startShape);
+  for (const wire of wires) {
+    loftBuilder.AddWire(wire);
+  }
+  if (endShape) loftBuilder.AddVertex(endShape);
+  const progress = new oc.Message_ProgressRange_1();
+  loftBuilder.Build(progress);
+  const result = loftBuilder.Shape();
+  loftBuilder.delete();
+  progress.delete();
+  return result;
+}
+function sweep$1(oc, wire, spine, options = {}) {
+  const { transitionMode } = options;
+  const sweepBuilder = new oc.BRepOffsetAPI_MakePipeShell(spine);
+  if (transitionMode !== void 0) {
+    sweepBuilder.SetTransitionMode(transitionMode);
+  }
+  sweepBuilder.Add_1(wire, false, false);
+  const progress = new oc.Message_ProgressRange_1();
+  sweepBuilder.Build(progress);
+  progress.delete();
+  sweepBuilder.MakeSolid();
+  const result = sweepBuilder.Shape();
+  sweepBuilder.delete();
+  return result;
+}
+function fillet(oc, shape, edges, radius) {
+  const builder = new oc.BRepFilletAPI_MakeFillet(shape, oc.ChFi3d_FilletShape.ChFi3d_Rational);
+  for (const edge of edges) {
+    const r = typeof radius === "function" ? radius(edge) : radius;
+    if (r > 0) builder.Add_2(r, edge);
+  }
+  const result = builder.Shape();
+  builder.delete();
+  return result;
+}
+function chamfer(oc, shape, edges, distance) {
+  const builder = new oc.BRepFilletAPI_MakeChamfer(shape);
+  for (const edge of edges) {
+    const d = typeof distance === "function" ? distance(edge) : distance;
+    if (d > 0) builder.Add_2(d, edge);
+  }
+  const result = builder.Shape();
+  builder.delete();
+  return result;
+}
+function shell(oc, shape, faces, thickness, tolerance = 1e-3) {
+  const facesToRemove = new oc.TopTools_ListOfShape_1();
+  for (const face of faces) {
+    facesToRemove.Append_1(face);
+  }
+  const progress = new oc.Message_ProgressRange_1();
+  const builder = new oc.BRepOffsetAPI_MakeThickSolid();
+  builder.MakeThickSolidByJoin(
+    shape,
+    facesToRemove,
+    -thickness,
+    tolerance,
+    oc.BRepOffset_Mode.BRepOffset_Skin,
+    false,
+    false,
+    oc.GeomAbs_JoinType.GeomAbs_Arc,
+    false,
+    progress
+  );
+  const result = builder.Shape();
+  builder.delete();
+  facesToRemove.delete();
+  progress.delete();
+  return result;
+}
+function offset$1(oc, shape, distance, tolerance = 1e-6) {
+  const progress = new oc.Message_ProgressRange_1();
+  const builder = new oc.BRepOffsetAPI_MakeOffsetShape();
+  builder.PerformByJoin(
+    shape,
+    distance,
+    tolerance,
+    oc.BRepOffset_Mode.BRepOffset_Skin,
+    false,
+    false,
+    oc.GeomAbs_JoinType.GeomAbs_Arc,
+    false,
+    progress
+  );
+  const result = builder.Shape();
+  builder.delete();
+  progress.delete();
+  return result;
+}
 class OCCTAdapter {
   oc;
   constructor(oc) {
     this.oc = oc;
   }
-  // --- Boolean operations ---
+  // --- Boolean operations (delegates to booleanOps.ts) ---
   fuse(shape, tool, options = {}) {
-    const { optimisation, simplify = false } = options;
-    const progress = new this.oc.Message_ProgressRange_1();
-    const fuseOp = new this.oc.BRepAlgoAPI_Fuse_3(shape, tool, progress);
-    this._applyGlue(fuseOp, optimisation);
-    fuseOp.Build(progress);
-    if (simplify) fuseOp.SimplifyResult(true, true, 1e-3);
-    const result = fuseOp.Shape();
-    fuseOp.delete();
-    progress.delete();
-    return result;
+    return fuse(this.oc, shape, tool, options);
   }
   cut(shape, tool, options = {}) {
-    const { optimisation, simplify = false } = options;
-    const progress = new this.oc.Message_ProgressRange_1();
-    const cutOp = new this.oc.BRepAlgoAPI_Cut_3(shape, tool, progress);
-    this._applyGlue(cutOp, optimisation);
-    cutOp.Build(progress);
-    if (simplify) cutOp.SimplifyResult(true, true, 1e-3);
-    const result = cutOp.Shape();
-    cutOp.delete();
-    progress.delete();
-    return result;
+    return cut(this.oc, shape, tool, options);
   }
   intersect(shape, tool, options = {}) {
-    const { optimisation, simplify = false } = options;
-    const progress = new this.oc.Message_ProgressRange_1();
-    const commonOp = new this.oc.BRepAlgoAPI_Common_3(shape, tool, progress);
-    this._applyGlue(commonOp, optimisation);
-    commonOp.Build(progress);
-    if (simplify) commonOp.SimplifyResult(true, true, 1e-3);
-    const result = commonOp.Shape();
-    commonOp.delete();
-    progress.delete();
-    return result;
+    return intersect(this.oc, shape, tool, options);
   }
   fuseAll(shapes, options = {}) {
-    if (shapes.length === 0) throw new Error("fuseAll requires at least one shape");
-    if (shapes.length === 1) return shapes[0];
-    const { strategy = "native" } = options;
-    if (strategy === "pairwise") {
-      return this._fuseAllPairwise(shapes, options);
-    }
-    if (this.oc.BooleanBatch) {
-      return this._fuseAllBatch(shapes, options);
-    }
-    return this._fuseAllNative(shapes, options);
-  }
-  _fuseAllBatch(shapes, options = {}) {
-    const { optimisation, simplify = false } = options;
-    const batch = new this.oc.BooleanBatch();
-    for (const s of shapes) {
-      batch.addShape(s);
-    }
-    const glueMode = optimisation === "commonFace" ? 1 : optimisation === "sameFace" ? 2 : 0;
-    const result = batch.fuseAll(glueMode, simplify);
-    batch.delete();
-    return result;
-  }
-  _fuseAllNative(shapes, options = {}) {
-    const { optimisation, simplify = false } = options;
-    const argList = new this.oc.TopTools_ListOfShape_1();
-    for (const s of shapes) {
-      argList.Append_1(s);
-    }
-    const builder = new this.oc.BRepAlgoAPI_BuilderAlgo_1();
-    builder.SetArguments(argList);
-    this._applyGlue(builder, optimisation);
-    const progress = new this.oc.Message_ProgressRange_1();
-    builder.Build(progress);
-    let result = builder.Shape();
-    if (simplify) {
-      const upgrader = new this.oc.ShapeUpgrade_UnifySameDomain_2(result, true, true, false);
-      upgrader.Build();
-      result = upgrader.Shape();
-      upgrader.delete();
-    }
-    argList.delete();
-    builder.delete();
-    progress.delete();
-    return result;
-  }
-  _fuseAllPairwise(shapes, options = {}) {
-    const mid = Math.ceil(shapes.length / 2);
-    const left = this.fuseAll(shapes.slice(0, mid), {
-      ...options,
-      simplify: false,
-      strategy: "pairwise"
-    });
-    const right = this.fuseAll(shapes.slice(mid), {
-      ...options,
-      simplify: false,
-      strategy: "pairwise"
-    });
-    return this.fuse(left, right, options);
+    return fuseAll$3(this.oc, shapes, options);
   }
   cutAll(shape, tools, options = {}) {
-    if (tools.length === 0) return shape;
-    if (this.oc.BooleanBatch) {
-      return this._cutAllBatch(shape, tools, options);
-    }
-    const toolCompound = this._buildCompound(tools);
-    const result = this.cut(shape, toolCompound, options);
-    toolCompound.delete();
-    return result;
+    return cutAll$2(this.oc, shape, tools, options);
   }
-  _cutAllBatch(shape, tools, options = {}) {
-    const { optimisation, simplify = false } = options;
-    const batch = new this.oc.BooleanBatch();
-    for (const t of tools) {
-      batch.addShape(t);
-    }
-    const glueMode = optimisation === "commonFace" ? 1 : optimisation === "sameFace" ? 2 : 0;
-    const result = batch.cutAll(shape, glueMode, simplify);
-    batch.delete();
-    return result;
-  }
-  // --- Shape construction ---
+  // --- Shape construction (delegates to constructorOps.ts) ---
   makeVertex(x, y, z) {
-    const pnt2 = new this.oc.gp_Pnt_3(x, y, z);
-    const maker = new this.oc.BRepBuilderAPI_MakeVertex(pnt2);
-    const vertex = maker.Vertex();
-    maker.delete();
-    pnt2.delete();
-    return vertex;
+    return makeVertex$1(this.oc, x, y, z);
   }
   makeEdge(curve, start, end) {
-    const maker = start !== void 0 && end !== void 0 ? new this.oc.BRepBuilderAPI_MakeEdge_24(curve, start, end) : new this.oc.BRepBuilderAPI_MakeEdge_24(curve);
-    const edge = maker.Edge();
-    maker.delete();
-    return edge;
+    return makeEdge(this.oc, curve, start, end);
   }
   makeWire(edges) {
-    const wireBuilder = new this.oc.BRepBuilderAPI_MakeWire_1();
-    for (const edge of edges) {
-      wireBuilder.Add_1(edge);
-    }
-    const progress = new this.oc.Message_ProgressRange_1();
-    wireBuilder.Build(progress);
-    const wire = wireBuilder.Wire();
-    wireBuilder.delete();
-    progress.delete();
-    return wire;
+    return makeWire(this.oc, edges);
   }
   makeFace(wire, planar = true) {
-    if (planar) {
-      const builder2 = new this.oc.BRepBuilderAPI_MakeFace_15(wire, false);
-      const face = builder2.Face();
-      builder2.delete();
-      return face;
-    }
-    const builder = new this.oc.BRepOffsetAPI_MakeFilling(
-      3,
-      15,
-      2,
-      false,
-      1e-5,
-      1e-4,
-      0.01,
-      0.1,
-      8,
-      9
-    );
-    const edges = this.iterShapes(wire, "edge");
-    for (const edge of edges) {
-      builder.Add_1(edge, this.oc.GeomAbs_Shape.GeomAbs_C0, true);
-    }
-    const progress = new this.oc.Message_ProgressRange_1();
-    builder.Build(progress);
-    const shape = builder.Shape();
-    builder.delete();
-    progress.delete();
-    return shape;
+    return makeFace$1(this.oc, wire, planar);
   }
   makeBox(width, height, depth) {
-    const maker = new this.oc.BRepPrimAPI_MakeBox_2(width, height, depth);
-    const solid = maker.Solid();
-    maker.delete();
-    return solid;
+    return makeBox$1(this.oc, width, height, depth);
   }
   makeCylinder(radius, height, center = [0, 0, 0], direction = [0, 0, 1]) {
-    const origin = new this.oc.gp_Pnt_3(...center);
-    const dir = new this.oc.gp_Dir_4(...direction);
-    const axis = new this.oc.gp_Ax2_3(origin, dir);
-    const maker = new this.oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height);
-    const solid = maker.Shape();
-    maker.delete();
-    axis.delete();
-    origin.delete();
-    dir.delete();
-    return solid;
+    return makeCylinder$1(this.oc, radius, height, center, direction);
   }
   makeSphere(radius, center = [0, 0, 0]) {
-    const origin = new this.oc.gp_Pnt_3(...center);
-    const maker = new this.oc.BRepPrimAPI_MakeSphere_2(origin, radius);
-    const solid = maker.Shape();
-    maker.delete();
-    origin.delete();
-    return solid;
+    return makeSphere$1(this.oc, radius, center);
   }
-  // --- Extrusion / sweep / loft / revolution ---
-  extrude(face, direction, length) {
-    const vec2 = new this.oc.gp_Vec_4(
-      direction[0] * length,
-      direction[1] * length,
-      direction[2] * length
-    );
-    const maker = new this.oc.BRepPrimAPI_MakePrism_1(face, vec2, false, true);
-    const result = maker.Shape();
-    maker.delete();
-    vec2.delete();
-    return result;
+  // --- Extrusion / sweep / loft / revolution (delegates to sweepOps.ts) ---
+  extrude(face, direction, length2) {
+    return extrude(this.oc, face, direction, length2);
   }
   revolve(shape, axis, angle) {
-    const maker = new this.oc.BRepPrimAPI_MakeRevol_1(shape, axis, angle, false);
-    const result = maker.Shape();
-    maker.delete();
-    return result;
+    return revolve(this.oc, shape, axis, angle);
   }
-  loft(wires, ruled = false, startShape, endShape) {
-    const loftBuilder = new this.oc.BRepOffsetAPI_ThruSections(true, ruled, 1e-6);
-    if (startShape) loftBuilder.AddVertex(startShape);
-    for (const wire of wires) {
-      loftBuilder.AddWire(wire);
-    }
-    if (endShape) loftBuilder.AddVertex(endShape);
-    const progress = new this.oc.Message_ProgressRange_1();
-    loftBuilder.Build(progress);
-    const result = loftBuilder.Shape();
-    loftBuilder.delete();
-    progress.delete();
-    return result;
+  loft(wires, ruled = false, startShape, endShape) {
+    return loft$1(this.oc, wires, ruled, startShape, endShape);
   }
   sweep(wire, spine, options = {}) {
-    const { transitionMode } = options;
-    const sweepBuilder = new this.oc.BRepOffsetAPI_MakePipeShell(spine);
-    if (transitionMode !== void 0) {
-      sweepBuilder.SetTransitionMode(transitionMode);
-    }
-    sweepBuilder.Add_1(wire, false, false);
-    const progress = new this.oc.Message_ProgressRange_1();
-    sweepBuilder.Build(progress);
-    progress.delete();
-    sweepBuilder.MakeSolid();
-    const result = sweepBuilder.Shape();
-    sweepBuilder.delete();
-    return result;
+    return sweep$1(this.oc, wire, spine, options);
   }
-  // --- Modification ---
+  // --- Modification (delegates to modifierOps.ts) ---
   fillet(shape, edges, radius) {
-    const builder = new this.oc.BRepFilletAPI_MakeFillet(
-      shape,
-      this.oc.ChFi3d_FilletShape.ChFi3d_Rational
-    );
-    for (const edge of edges) {
-      const r = typeof radius === "function" ? radius(edge) : radius;
-      if (r > 0) builder.Add_2(r, edge);
-    }
-    const result = builder.Shape();
-    builder.delete();
-    return result;
+    return fillet(this.oc, shape, edges, radius);
   }
   chamfer(shape, edges, distance) {
-    const builder = new this.oc.BRepFilletAPI_MakeChamfer(shape);
-    for (const edge of edges) {
-      const d = typeof distance === "function" ? distance(edge) : distance;
-      if (d > 0) builder.Add_2(d, edge);
-    }
-    const result = builder.Shape();
-    builder.delete();
-    return result;
+    return chamfer(this.oc, shape, edges, distance);
   }
   shell(shape, faces, thickness, tolerance = 1e-3) {
-    const facesToRemove = new this.oc.TopTools_ListOfShape_1();
-    for (const face of faces) {
-      facesToRemove.Append_1(face);
-    }
-    const progress = new this.oc.Message_ProgressRange_1();
-    const builder = new this.oc.BRepOffsetAPI_MakeThickSolid();
-    builder.MakeThickSolidByJoin(
-      shape,
-      facesToRemove,
-      -thickness,
-      tolerance,
-      this.oc.BRepOffset_Mode.BRepOffset_Skin,
-      false,
-      false,
-      this.oc.GeomAbs_JoinType.GeomAbs_Arc,
-      false,
-      progress
-    );
-    const result = builder.Shape();
-    builder.delete();
-    facesToRemove.delete();
-    progress.delete();
-    return result;
+    return shell(this.oc, shape, faces, thickness, tolerance);
   }
   offset(shape, distance, tolerance = 1e-6) {
-    const progress = new this.oc.Message_ProgressRange_1();
-    const builder = new this.oc.BRepOffsetAPI_MakeOffsetShape();
-    builder.PerformByJoin(
-      shape,
-      distance,
-      tolerance,
-      this.oc.BRepOffset_Mode.BRepOffset_Skin,
-      false,
-      false,
-      this.oc.GeomAbs_JoinType.GeomAbs_Arc,
-      false,
-      progress
-    );
-    const result = builder.Shape();
-    builder.delete();
-    progress.delete();
-    return result;
+    return offset$1(this.oc, shape, distance, tolerance);
   }
-  // --- Transforms ---
+  // --- Transforms (delegates to transformOps.ts) ---
   transform(shape, trsf) {
-    const transformer = new this.oc.BRepBuilderAPI_Transform_2(shape, trsf, true);
-    const result = transformer.ModifiedShape(shape);
-    transformer.delete();
-    return result;
+    return transform(this.oc, shape, trsf);
   }
   translate(shape, x, y, z) {
-    const trsf = new this.oc.gp_Trsf_1();
-    const vec2 = new this.oc.gp_Vec_4(x, y, z);
-    trsf.SetTranslation_1(vec2);
-    const result = this.transform(shape, trsf);
-    trsf.delete();
-    vec2.delete();
-    return result;
+    return translate$1(this.oc, shape, x, y, z);
   }
   rotate(shape, angle, axis = [0, 0, 1], center = [0, 0, 0]) {
-    const trsf = new this.oc.gp_Trsf_1();
-    const origin = new this.oc.gp_Pnt_3(...center);
-    const dir = new this.oc.gp_Dir_4(...axis);
-    const ax1 = new this.oc.gp_Ax1_2(origin, dir);
-    trsf.SetRotation_1(ax1, angle * Math.PI / 180);
-    const result = this.transform(shape, trsf);
-    trsf.delete();
-    ax1.delete();
-    origin.delete();
-    dir.delete();
-    return result;
+    return rotate$1(this.oc, shape, angle, axis, center);
   }
   mirror(shape, origin, normal) {
-    const trsf = new this.oc.gp_Trsf_1();
-    const pnt2 = new this.oc.gp_Pnt_3(...origin);
-    const dir = new this.oc.gp_Dir_4(...normal);
-    const ax2 = new this.oc.gp_Ax2_3(pnt2, dir);
-    trsf.SetMirror_3(ax2);
-    const result = this.transform(shape, trsf);
-    trsf.delete();
-    ax2.delete();
-    pnt2.delete();
-    dir.delete();
-    return result;
+    return mirror$1(this.oc, shape, origin, normal);
   }
   scale(shape, center, factor) {
-    const trsf = new this.oc.gp_Trsf_1();
-    const pnt2 = new this.oc.gp_Pnt_3(...center);
-    trsf.SetScale(pnt2, factor);
-    const result = this.transform(shape, trsf);
-    trsf.delete();
-    pnt2.delete();
-    return result;
+    return scale$1(this.oc, shape, center, factor);
   }
-  // --- Meshing ---
+  // --- Meshing (delegates to meshOps.ts) ---
   mesh(shape, options) {
-    if (this.oc.MeshExtractor) {
-      return this._meshBulk(shape, options);
-    }
-    return this._meshJS(shape, options);
-  }
-  _meshBulk(shape, options) {
-    const raw = this.oc.MeshExtractor.extract(
-      shape,
-      options.tolerance,
-      options.angularTolerance,
-      !!options.skipNormals
-    );
-    const verticesSize = raw.getVerticesSize();
-    const normalsSize = raw.getNormalsSize();
-    const trianglesSize = raw.getTrianglesSize();
-    const faceGroupsSize = raw.getFaceGroupsSize();
-    const verticesPtr = raw.getVerticesPtr() / 4;
-    const vertices = this.oc.HEAPF32.slice(verticesPtr, verticesPtr + verticesSize);
-    let normals;
-    if (options.skipNormals || normalsSize === 0) {
-      normals = new Float32Array(0);
-    } else {
-      const normalsPtr = raw.getNormalsPtr() / 4;
-      normals = this.oc.HEAPF32.slice(normalsPtr, normalsPtr + normalsSize);
-    }
-    const trianglesPtr = raw.getTrianglesPtr() / 4;
-    const triangles = this.oc.HEAPU32.slice(
-      trianglesPtr,
-      trianglesPtr + trianglesSize
-    );
-    const faceGroups = [];
-    if (faceGroupsSize > 0) {
-      const fgPtr = raw.getFaceGroupsPtr() / 4;
-      const fgRaw = this.oc.HEAP32.slice(fgPtr, fgPtr + faceGroupsSize);
-      for (let i = 0; i < fgRaw.length; i += 3) {
-        faceGroups.push({
-          start: fgRaw[i],
-          count: fgRaw[i + 1],
-          faceHash: fgRaw[i + 2]
-        });
-      }
-    }
-    raw.delete();
-    return { vertices, normals, triangles, faceGroups };
-  }
-  _meshJS(shape, options) {
-    const mesher = new this.oc.BRepMesh_IncrementalMesh_2(
-      shape,
-      options.tolerance,
-      false,
-      options.angularTolerance,
-      false
-    );
-    mesher.delete();
-    let totalNodes = 0;
-    let totalTris = 0;
-    const explorer = new this.oc.TopExp_Explorer_2(
-      shape,
-      this.oc.TopAbs_ShapeEnum.TopAbs_FACE,
-      this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    while (explorer.More()) {
-      const face = this.oc.TopoDS.Face_1(explorer.Current());
-      const loc = new this.oc.TopLoc_Location_1();
-      const tri = this.oc.BRep_Tool.Triangulation(face, loc, 0);
-      if (!tri.IsNull()) {
-        const t = tri.get();
-        totalNodes += t.NbNodes();
-        totalTris += t.NbTriangles();
-      }
-      loc.delete();
-      tri.delete();
-      explorer.Next();
-    }
-    const vertices = new Float32Array(totalNodes * 3);
-    const normals = options.skipNormals ? new Float32Array(0) : new Float32Array(totalNodes * 3);
-    const triangles = new Uint32Array(totalTris * 3);
-    const faceGroups = [];
-    let vIdx = 0;
-    let nIdx = 0;
-    let tIdx = 0;
-    explorer.Init(
-      shape,
-      this.oc.TopAbs_ShapeEnum.TopAbs_FACE,
-      this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    while (explorer.More()) {
-      const face = this.oc.TopoDS.Face_1(explorer.Current());
-      const location = new this.oc.TopLoc_Location_1();
-      const triangulation = this.oc.BRep_Tool.Triangulation(face, location, 0);
-      if (!triangulation.IsNull()) {
-        const tri = triangulation.get();
-        const transformation = location.Transformation();
-        const nbNodes = tri.NbNodes();
-        const vertexOffset = vIdx / 3;
-        const triStart = tIdx;
-        for (let i = 1; i <= nbNodes; i++) {
-          const p = tri.Node(i).Transformed(transformation);
-          vertices[vIdx++] = p.X();
-          vertices[vIdx++] = p.Y();
-          vertices[vIdx++] = p.Z();
-          p.delete();
-        }
-        if (!options.skipNormals) {
-          const normalsArray = new this.oc.TColgp_Array1OfDir_2(1, nbNodes);
-          const pc = new this.oc.Poly_Connect_2(triangulation);
-          this.oc.StdPrs_ToolTriangulatedShape.Normal(face, pc, normalsArray);
-          for (let i = normalsArray.Lower(); i <= normalsArray.Upper(); i++) {
-            const d = normalsArray.Value(i).Transformed(transformation);
-            normals[nIdx++] = d.X();
-            normals[nIdx++] = d.Y();
-            normals[nIdx++] = d.Z();
-            d.delete();
-          }
-          normalsArray.delete();
-          pc.delete();
-        }
-        const orient = face.Orientation_1();
-        const isForward = orient === this.oc.TopAbs_Orientation.TopAbs_FORWARD;
-        const nbTriangles = tri.NbTriangles();
-        for (let nt = 1; nt <= nbTriangles; nt++) {
-          const t = tri.Triangle(nt);
-          let n1 = t.Value(1);
-          let n2 = t.Value(2);
-          const n3 = t.Value(3);
-          if (!isForward) {
-            const tmp = n1;
-            n1 = n2;
-            n2 = tmp;
-          }
-          triangles[tIdx++] = n1 - 1 + vertexOffset;
-          triangles[tIdx++] = n2 - 1 + vertexOffset;
-          triangles[tIdx++] = n3 - 1 + vertexOffset;
-          t.delete();
-        }
-        faceGroups.push({
-          start: triStart,
-          count: tIdx - triStart,
-          faceHash: face.HashCode(HASH_CODE_MAX$1)
-        });
-        transformation.delete();
-      }
-      location.delete();
-      triangulation.delete();
-      explorer.Next();
-    }
-    explorer.delete();
-    return { vertices, normals, triangles, faceGroups };
+    return mesh(this.oc, shape, options);
   }
   meshEdges(shape, tolerance, angularTolerance) {
-    if (this.oc.EdgeMeshExtractor) {
-      return this._meshEdgesBulk(shape, tolerance, angularTolerance);
-    }
-    return this._meshEdgesJS(shape, tolerance, angularTolerance);
-  }
-  _meshEdgesBulk(shape, tolerance, angularTolerance) {
-    const raw = this.oc.EdgeMeshExtractor.extract(shape, tolerance, angularTolerance);
-    const linesSize = raw.getLinesSize();
-    const edgeGroupsSize = raw.getEdgeGroupsSize();
-    let lines;
-    if (linesSize > 0) {
-      const linesPtr = raw.getLinesPtr() / 4;
-      lines = this.oc.HEAPF32.slice(linesPtr, linesPtr + linesSize);
-    } else {
-      lines = new Float32Array(0);
-    }
-    const edgeGroups = [];
-    if (edgeGroupsSize > 0) {
-      const egPtr = raw.getEdgeGroupsPtr() / 4;
-      const egRaw = this.oc.HEAP32.slice(egPtr, egPtr + edgeGroupsSize);
-      for (let i = 0; i < egRaw.length; i += 3) {
-        edgeGroups.push({
-          start: egRaw[i],
-          count: egRaw[i + 1],
-          edgeHash: egRaw[i + 2]
-        });
-      }
-    }
-    raw.delete();
-    return { lines, edgeGroups };
-  }
-  _meshEdgesJS(shape, tolerance, angularTolerance) {
-    const mesher = new this.oc.BRepMesh_IncrementalMesh_2(
-      shape,
-      tolerance,
-      false,
-      angularTolerance,
-      false
-    );
-    mesher.delete();
-    const lines = [];
-    const edgeGroups = [];
-    const seenHashes = /* @__PURE__ */ new Set();
-    const faceExplorer = new this.oc.TopExp_Explorer_2(
-      shape,
-      this.oc.TopAbs_ShapeEnum.TopAbs_FACE,
-      this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    while (faceExplorer.More()) {
-      const face = this.oc.TopoDS.Face_1(faceExplorer.Current());
-      const faceLoc = new this.oc.TopLoc_Location_1();
-      const tri = this.oc.BRep_Tool.Triangulation(face, faceLoc, 0);
-      if (!tri.IsNull()) {
-        const triObj = tri.get();
-        const edgeExplorer2 = new this.oc.TopExp_Explorer_2(
-          face,
-          this.oc.TopAbs_ShapeEnum.TopAbs_EDGE,
-          this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-        );
-        while (edgeExplorer2.More()) {
-          const edgeShape = edgeExplorer2.Current();
-          const edge = this.oc.TopoDS.Edge_1(edgeShape);
-          const edgeHash = edge.HashCode(HASH_CODE_MAX$1);
-          if (!seenHashes.has(edgeHash)) {
-            seenHashes.add(edgeHash);
-            const edgeLoc = new this.oc.TopLoc_Location_1();
-            const polygon = this.oc.BRep_Tool.PolygonOnTriangulation_1(edge, tri, edgeLoc);
-            const edgeNodes = polygon && !polygon.IsNull() ? polygon.get().Nodes() : null;
-            if (edgeNodes) {
-              const lineStart = lines.length / 3;
-              let prevX = 0, prevY = 0, prevZ = 0;
-              let hasPrev = false;
-              for (let i = edgeNodes.Lower(); i <= edgeNodes.Upper(); i++) {
-                const p = triObj.Node(edgeNodes.Value(i)).Transformed(edgeLoc.Transformation());
-                const x = p.X(), y = p.Y(), z = p.Z();
-                if (hasPrev) {
-                  lines.push(prevX, prevY, prevZ, x, y, z);
-                }
-                prevX = x;
-                prevY = y;
-                prevZ = z;
-                hasPrev = true;
-                p.delete();
-              }
-              edgeGroups.push({
-                start: lineStart,
-                count: lines.length / 3 - lineStart,
-                edgeHash
-              });
-              edgeNodes.delete();
-            }
-            if (polygon && !polygon.IsNull()) polygon.delete();
-            edgeLoc.delete();
-          }
-          edgeExplorer2.Next();
-        }
-        edgeExplorer2.delete();
-      }
-      tri.delete();
-      faceLoc.delete();
-      faceExplorer.Next();
-    }
-    faceExplorer.delete();
-    const edgeExplorer = new this.oc.TopExp_Explorer_2(
-      shape,
-      this.oc.TopAbs_ShapeEnum.TopAbs_EDGE,
-      this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    while (edgeExplorer.More()) {
-      const edgeShape = edgeExplorer.Current();
-      const edge = this.oc.TopoDS.Edge_1(edgeShape);
-      const edgeHash = edge.HashCode(HASH_CODE_MAX$1);
-      if (!seenHashes.has(edgeHash)) {
-        seenHashes.add(edgeHash);
-        const adaptor = new this.oc.BRepAdaptor_Curve_2(edge);
-        const tangDef = new this.oc.GCPnts_TangentialDeflection_2(
-          adaptor,
-          tolerance,
-          angularTolerance,
-          2,
-          1e-9,
-          1e-7
-        );
-        const lineStart = lines.length / 3;
-        let prevX = 0, prevY = 0, prevZ = 0;
-        let hasPrev = false;
-        for (let j = 1; j <= tangDef.NbPoints(); j++) {
-          const p = tangDef.Value(j);
-          const x = p.X(), y = p.Y(), z = p.Z();
-          if (hasPrev) {
-            lines.push(prevX, prevY, prevZ, x, y, z);
-          }
-          prevX = x;
-          prevY = y;
-          prevZ = z;
-          hasPrev = true;
-          p.delete();
-        }
-        edgeGroups.push({
-          start: lineStart,
-          count: lines.length / 3 - lineStart,
-          edgeHash
-        });
-        tangDef.delete();
-        adaptor.delete();
-      }
-      edgeExplorer.Next();
-    }
-    edgeExplorer.delete();
-    return { lines: new Float32Array(lines), edgeGroups };
+    return meshEdges(this.oc, shape, tolerance, angularTolerance);
   }
-  // --- File I/O ---
+  // --- File I/O (delegates to ioOps.ts) ---
   exportSTEP(shapes) {
-    const writer = new this.oc.STEPControl_Writer_1();
-    this.oc.Interface_Static.SetIVal("write.step.schema", 5);
-    writer.Model(true).delete();
-    const progress = new this.oc.Message_ProgressRange_1();
-    for (const shape of shapes) {
-      writer.Transfer(shape, this.oc.STEPControl_StepModelType.STEPControl_AsIs, true, progress);
-    }
-    const filename = uniqueIOFilename("_export", "step");
-    const done = writer.Write(filename);
-    writer.delete();
-    progress.delete();
-    if (done === this.oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
-      const file = this.oc.FS.readFile("/" + filename);
-      this.oc.FS.unlink("/" + filename);
-      return new TextDecoder().decode(file);
-    }
-    throw new Error("STEP export failed: writer did not complete successfully");
+    return exportSTEP$2(this.oc, shapes);
   }
   exportSTL(shape, binary = false) {
-    const filename = uniqueIOFilename("_export", "stl");
-    const done = this.oc.StlAPI.Write(shape, filename, !binary);
-    if (done) {
-      const file = this.oc.FS.readFile("/" + filename);
-      this.oc.FS.unlink("/" + filename);
-      if (binary) return file.buffer;
-      return new TextDecoder().decode(file);
-    }
-    throw new Error("STL export failed: StlAPI.Write returned false");
+    return exportSTL$1(this.oc, shape, binary);
   }
   importSTEP(data) {
-    const filename = uniqueIOFilename("_import", "step");
-    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
-    this.oc.FS.writeFile("/" + filename, buffer);
-    const reader = new this.oc.STEPControl_Reader_1();
-    if (reader.ReadFile(filename)) {
-      this.oc.FS.unlink("/" + filename);
-      const progress = new this.oc.Message_ProgressRange_1();
-      reader.TransferRoots(progress);
-      progress.delete();
-      const shape = reader.OneShape();
-      reader.delete();
-      return [shape];
-    }
-    this.oc.FS.unlink("/" + filename);
-    reader.delete();
-    throw new Error("Failed to import STEP file: reader could not parse the input data");
+    return importSTEP$2(this.oc, data);
   }
   importSTL(data) {
-    const filename = uniqueIOFilename("_import", "stl");
-    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
-    this.oc.FS.writeFile("/" + filename, buffer);
-    const reader = new this.oc.StlAPI_Reader();
-    const readShape = new this.oc.TopoDS_Shell();
-    if (reader.Read(readShape, filename)) {
-      this.oc.FS.unlink("/" + filename);
-      const upgrader = new this.oc.ShapeUpgrade_UnifySameDomain_2(readShape, true, true, false);
-      upgrader.Build();
-      const upgraded = upgrader.Shape();
-      const solidBuilder = new this.oc.BRepBuilderAPI_MakeSolid_1();
-      solidBuilder.Add(this.oc.TopoDS.Shell_1(upgraded));
-      const solid = solidBuilder.Solid();
-      readShape.delete();
-      upgrader.delete();
-      solidBuilder.delete();
-      reader.delete();
-      return solid;
-    }
-    this.oc.FS.unlink("/" + filename);
-    readShape.delete();
-    reader.delete();
-    throw new Error("Failed to import STL file: reader could not parse the input data");
+    return importSTL$2(this.oc, data);
   }
-  // --- Measurement ---
+  // --- Measurement (delegates to measureOps.ts) ---
   volume(shape) {
-    const props = new this.oc.GProp_GProps_1();
-    this.oc.BRepGProp.VolumeProperties_1(shape, props, true, false, false);
-    const vol = props.Mass();
-    props.delete();
-    return vol;
+    return volume(this.oc, shape);
   }
   area(shape) {
-    const props = new this.oc.GProp_GProps_1();
-    this.oc.BRepGProp.SurfaceProperties_2(shape, props, 1e-7, true);
-    const a = props.Mass();
-    props.delete();
-    return a;
+    return area(this.oc, shape);
   }
   length(shape) {
-    const props = new this.oc.GProp_GProps_1();
-    this.oc.BRepGProp.LinearProperties(shape, props, true, false);
-    const len = props.Mass();
-    props.delete();
-    return len;
+    return length(this.oc, shape);
   }
   centerOfMass(shape) {
-    const props = new this.oc.GProp_GProps_1();
-    this.oc.BRepGProp.VolumeProperties_1(shape, props, true, false, false);
-    const center = props.CentreOfMass();
-    const result = [center.X(), center.Y(), center.Z()];
-    center.delete();
-    props.delete();
-    return result;
+    return centerOfMass(this.oc, shape);
   }
   boundingBox(shape) {
-    const box = new this.oc.Bnd_Box_1();
-    this.oc.BRepBndLib.Add(shape, box, true);
-    const xMin = { current: 0 };
-    const yMin = { current: 0 };
-    const zMin = { current: 0 };
-    const xMax = { current: 0 };
-    const yMax = { current: 0 };
-    const zMax = { current: 0 };
-    box.Get(xMin, yMin, zMin, xMax, yMax, zMax);
-    box.delete();
-    return {
-      min: [xMin.current, yMin.current, zMin.current],
-      max: [xMax.current, yMax.current, zMax.current]
-    };
+    return boundingBox(this.oc, shape);
   }
-  // --- Topology iteration ---
+  // --- Topology iteration (delegates to topologyOps.ts) ---
   iterShapes(shape, type) {
-    if (this.oc.TopologyExtractor) {
-      return this._iterShapesBulk(shape, type);
-    }
-    return this._iterShapesJS(shape, type);
-  }
-  _iterShapesBulk(shape, type) {
-    const typeEnumMap = {
-      vertex: 7,
-      edge: 6,
-      wire: 5,
-      face: 4,
-      shell: 3,
-      solid: 2,
-      compsolid: 1,
-      compound: 0
-    };
-    const raw = this.oc.TopologyExtractor.extract(shape, typeEnumMap[type]);
-    const count = raw.getShapesCount();
-    const result = [];
-    for (let i = 0; i < count; i++) {
-      result.push(raw.getShape(i));
-    }
-    raw.delete();
-    return result;
-  }
-  _iterShapesJS(shape, type) {
-    const typeMap = {
-      vertex: this.oc.TopAbs_ShapeEnum.TopAbs_VERTEX,
-      edge: this.oc.TopAbs_ShapeEnum.TopAbs_EDGE,
-      wire: this.oc.TopAbs_ShapeEnum.TopAbs_WIRE,
-      face: this.oc.TopAbs_ShapeEnum.TopAbs_FACE,
-      shell: this.oc.TopAbs_ShapeEnum.TopAbs_SHELL,
-      solid: this.oc.TopAbs_ShapeEnum.TopAbs_SOLID,
-      compsolid: this.oc.TopAbs_ShapeEnum.TopAbs_COMPSOLID,
-      compound: this.oc.TopAbs_ShapeEnum.TopAbs_COMPOUND
-    };
-    const explorer = new this.oc.TopExp_Explorer_2(
-      shape,
-      typeMap[type],
-      this.oc.TopAbs_ShapeEnum.TopAbs_SHAPE
-    );
-    const result = [];
-    const seen = /* @__PURE__ */ new Map();
-    while (explorer.More()) {
-      const item = explorer.Current();
-      const hash = item.HashCode(HASH_CODE_MAX$1);
-      const bucket = seen.get(hash);
-      if (!bucket) {
-        seen.set(hash, [item]);
-        result.push(item);
-      } else if (!bucket.some((s) => s.IsSame(item))) {
-        bucket.push(item);
-        result.push(item);
-      }
-      explorer.Next();
-    }
-    explorer.delete();
-    return result;
-  }
-  _shapeTypeMap = null;
-  _getShapeTypeMap() {
-    if (!this._shapeTypeMap) {
-      const ta = this.oc.TopAbs_ShapeEnum;
-      this._shapeTypeMap = /* @__PURE__ */ new Map([
-        [ta.TopAbs_VERTEX, "vertex"],
-        [ta.TopAbs_EDGE, "edge"],
-        [ta.TopAbs_WIRE, "wire"],
-        [ta.TopAbs_FACE, "face"],
-        [ta.TopAbs_SHELL, "shell"],
-        [ta.TopAbs_SOLID, "solid"],
-        [ta.TopAbs_COMPSOLID, "compsolid"],
-        [ta.TopAbs_COMPOUND, "compound"]
-      ]);
-    }
-    return this._shapeTypeMap;
+    return iterShapes(this.oc, shape, type);
   }
   shapeType(shape) {
-    if (shape.IsNull()) throw new Error("Cannot determine shape type: shape is null");
-    const result = this._getShapeTypeMap().get(shape.ShapeType());
-    if (!result) throw new Error(`Unknown shape type enum value: ${shape.ShapeType()}`);
-    return result;
+    return shapeType$1(this.oc, shape);
   }
   isSame(a, b) {
-    return a.IsSame(b);
+    return isSame(a, b);
   }
   isEqual(a, b) {
-    return a.IsEqual(b);
+    return isEqual(a, b);
   }
   // --- Simplification ---
   simplify(shape) {
-    const upgrader = new this.oc.ShapeUpgrade_UnifySameDomain_2(shape, true, true, false);
-    upgrader.Build();
-    const result = upgrader.Shape();
-    upgrader.delete();
-    return result;
+    return simplify(this.oc, shape);
   }
   // --- Private helpers ---
-  _buildCompound(shapes) {
-    const builder = new this.oc.TopoDS_Builder();
-    const compound = new this.oc.TopoDS_Compound();
-    builder.MakeCompound(compound);
-    for (const s of shapes) {
-      builder.Add(compound, s);
-    }
-    builder.delete();
-    return compound;
-  }
-  _applyGlue(op, optimisation) {
-    if (optimisation === "commonFace") {
-      op.SetGlue(this.oc.BOPAlgo_GlueEnum.BOPAlgo_GlueShift);
-    }
-    if (optimisation === "sameFace") {
-      op.SetGlue(this.oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
-    }
-  }
 }
 let _kernel = null;
 function getKernel() {
@@ -1589,9 +1685,9 @@ function asDir(coords) {
   return dir;
 }
 class Transformation extends WrappingObj {
-  constructor(transform) {
+  constructor(transform2) {
     const oc = getKernel().oc;
-    super(transform || new oc.gp_Trsf_1());
+    super(transform2 || new oc.gp_Trsf_1());
   }
   translate(xDistOrVector, yDist = 0, zDist = 0) {
     const translation = new Vector(
@@ -1999,7 +2095,7 @@ function meshShape(shape, {
     angularTolerance,
     skipNormals
   });
-  const mesh = {
+  const mesh2 = {
     vertices: result.vertices,
     normals: result.normals,
     triangles: result.triangles,
@@ -2010,9 +2106,9 @@ function meshShape(shape, {
     }))
   };
   if (cache) {
-    setMeshForShape(shape.wrapped, cacheKey, mesh);
+    setMeshForShape(shape.wrapped, cacheKey, mesh2);
   }
-  return mesh;
+  return mesh2;
 }
 function meshShapeEdges(shape, { tolerance = 1e-3, angularTolerance = 0.1, cache = true } = {}) {
   const cacheKey = buildEdgeMeshCacheKey(0, tolerance, angularTolerance);
@@ -2205,6 +2301,73 @@ function deserializeShape(data) {
   const oc = getKernel().oc;
   return cast(oc.BRepToolsWrapper.Read(data));
 }
+function isShape3DInternal(shape) {
+  const name = shape.constructor.name;
+  return name === "Shell" || name === "Solid" || name === "CompSolid" || name === "Compound";
+}
+function buildCompoundOc(shapes) {
+  const oc = getKernel().oc;
+  const builder = new oc.TopoDS_Builder();
+  const compound = new oc.TopoDS_Compound();
+  builder.MakeCompound(compound);
+  for (const s of shapes) {
+    builder.Add(compound, s);
+  }
+  builder.delete();
+  return compound;
+}
+function buildCompound$1(shapes) {
+  return buildCompoundOc(shapes.map((s) => s.wrapped));
+}
+function applyGlue$1(op, optimisation) {
+  const oc = getKernel().oc;
+  if (optimisation === "commonFace") {
+    op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueShift);
+  }
+  if (optimisation === "sameFace") {
+    op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
+  }
+}
+function fuseAll$2(shapes, { optimisation = "none", simplify: simplify2 = false, strategy = "native" } = {}) {
+  if (shapes.length === 0)
+    return err(validationError("FUSE_ALL_EMPTY", "fuseAll requires at least one shape"));
+  if (shapes.length === 1) return ok(shapes[0]);
+  if (strategy === "native") {
+    const result = getKernel().fuseAll(
+      shapes.map((s) => s.wrapped),
+      { optimisation, simplify: simplify2, strategy }
+    );
+    return andThen(cast(result), (newShape) => {
+      if (!isShape3DInternal(newShape))
+        return err(typeCastError("FUSE_ALL_NOT_3D", "fuseAll did not produce a 3D shape"));
+      return ok(newShape);
+    });
+  }
+  const mid = Math.ceil(shapes.length / 2);
+  const leftResult = fuseAll$2(shapes.slice(0, mid), { optimisation, simplify: false, strategy });
+  if (isErr(leftResult)) return leftResult;
+  const rightResult = fuseAll$2(shapes.slice(mid), { optimisation, simplify: false, strategy });
+  if (isErr(rightResult)) return rightResult;
+  return leftResult.value.fuse(rightResult.value, { optimisation, simplify: simplify2 });
+}
+function cutAll$1(base, tools, { optimisation = "none", simplify: simplify2 = false } = {}) {
+  if (tools.length === 0) return ok(base);
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const toolCompound = r(buildCompound$1(tools));
+  const progress = r(new oc.Message_ProgressRange_1());
+  const cutOp = r(new oc.BRepAlgoAPI_Cut_3(base.wrapped, toolCompound, progress));
+  applyGlue$1(cutOp, optimisation);
+  cutOp.Build(progress);
+  if (simplify2) {
+    cutOp.SimplifyResult(true, true, 1e-3);
+  }
+  return andThen(cast(cutOp.Shape()), (newShape) => {
+    if (!isShape3DInternal(newShape))
+      return err(typeCastError("CUT_ALL_NOT_3D", "cutAll did not produce a 3D shape"));
+    return ok(newShape);
+  });
+}
 let _queryModule = null;
 function getQueryModule() {
   if (!_queryModule) {
@@ -2585,9 +2748,9 @@ class _1DShape extends Shape {
   get length() {
     const properties = new this.oc.GProp_GProps_1();
     this.oc.BRepGProp.LinearProperties(this.wrapped, properties, true, false);
-    const length = properties.Mass();
+    const length2 = properties.Mass();
     properties.delete();
-    return length;
+    return length2;
   }
   get orientation() {
     const orient = this.wrapped.Orientation_1();
@@ -2818,13 +2981,13 @@ class _3DShape extends Shape {
    *
    * @category Shape Modifications
    */
-  fuse(other, { optimisation = "none", simplify = false } = {}) {
+  fuse(other, { optimisation = "none", simplify: simplify2 = false } = {}) {
     const r = gcWithScope();
     const progress = r(new this.oc.Message_ProgressRange_1());
     const newBody = r(new this.oc.BRepAlgoAPI_Fuse_3(this.wrapped, other.wrapped, progress));
     applyGlue$1(newBody, optimisation);
     newBody.Build(progress);
-    if (simplify) {
+    if (simplify2) {
       newBody.SimplifyResult(true, true, 1e-3);
     }
     return andThen(cast(newBody.Shape()), (newShape) => {
@@ -2838,13 +3001,13 @@ class _3DShape extends Shape {
    *
    * @category Shape Modifications
    */
-  cut(tool, { optimisation = "none", simplify = false } = {}) {
+  cut(tool, { optimisation = "none", simplify: simplify2 = false } = {}) {
     const r = gcWithScope();
     const progress = r(new this.oc.Message_ProgressRange_1());
     const cutter = r(new this.oc.BRepAlgoAPI_Cut_3(this.wrapped, tool.wrapped, progress));
     applyGlue$1(cutter, optimisation);
     cutter.Build(progress);
-    if (simplify) {
+    if (simplify2) {
       cutter.SimplifyResult(true, true, 1e-3);
     }
     return andThen(cast(cutter.Shape()), (newShape) => {
@@ -2858,12 +3021,12 @@ class _3DShape extends Shape {
    *
    * @category Shape Modifications
    */
-  intersect(tool, { simplify = false } = {}) {
+  intersect(tool, { simplify: simplify2 = false } = {}) {
     const r = gcWithScope();
     const progress = r(new this.oc.Message_ProgressRange_1());
     const intersector = r(new this.oc.BRepAlgoAPI_Common_3(this.wrapped, tool.wrapped, progress));
     intersector.Build(progress);
-    if (simplify) {
+    if (simplify2) {
       intersector.SimplifyResult(true, true, 1e-3);
     }
     return andThen(cast(intersector.Shape()), (newShape) => {
@@ -3042,69 +3205,6 @@ class Compound extends _3DShape {
 function isShape3D$1(shape) {
   return shape instanceof Shell || shape instanceof Solid || shape instanceof CompSolid || shape instanceof Compound;
 }
-function buildCompoundOc(shapes) {
-  const oc = getKernel().oc;
-  const builder = new oc.TopoDS_Builder();
-  const compound = new oc.TopoDS_Compound();
-  builder.MakeCompound(compound);
-  for (const s of shapes) {
-    builder.Add(compound, s);
-  }
-  builder.delete();
-  return compound;
-}
-function buildCompound$1(shapes) {
-  return buildCompoundOc(shapes.map((s) => s.wrapped));
-}
-function applyGlue$1(op, optimisation) {
-  const oc = getKernel().oc;
-  if (optimisation === "commonFace") {
-    op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueShift);
-  }
-  if (optimisation === "sameFace") {
-    op.SetGlue(oc.BOPAlgo_GlueEnum.BOPAlgo_GlueFull);
-  }
-}
-function fuseAll$2(shapes, { optimisation = "none", simplify = false, strategy = "native" } = {}) {
-  if (shapes.length === 0)
-    return err(validationError("FUSE_ALL_EMPTY", "fuseAll requires at least one shape"));
-  if (shapes.length === 1) return ok(shapes[0]);
-  if (strategy === "native") {
-    const result = getKernel().fuseAll(
-      shapes.map((s) => s.wrapped),
-      { optimisation, simplify, strategy }
-    );
-    return andThen(cast(result), (newShape) => {
-      if (!isShape3D$1(newShape))
-        return err(typeCastError("FUSE_ALL_NOT_3D", "fuseAll did not produce a 3D shape"));
-      return ok(newShape);
-    });
-  }
-  const mid = Math.ceil(shapes.length / 2);
-  const leftResult = fuseAll$2(shapes.slice(0, mid), { optimisation, simplify: false, strategy });
-  if (isErr(leftResult)) return leftResult;
-  const rightResult = fuseAll$2(shapes.slice(mid), { optimisation, simplify: false, strategy });
-  if (isErr(rightResult)) return rightResult;
-  return leftResult.value.fuse(rightResult.value, { optimisation, simplify });
-}
-function cutAll$1(base, tools, { optimisation = "none", simplify = false } = {}) {
-  if (tools.length === 0) return ok(base);
-  const oc = getKernel().oc;
-  const r = gcWithScope();
-  const toolCompound = r(buildCompound$1(tools));
-  const progress = r(new oc.Message_ProgressRange_1());
-  const cutOp = r(new oc.BRepAlgoAPI_Cut_3(base.wrapped, toolCompound, progress));
-  applyGlue$1(cutOp, optimisation);
-  cutOp.Build(progress);
-  if (simplify) {
-    cutOp.SimplifyResult(true, true, 1e-3);
-  }
-  return andThen(cast(cutOp.Shape()), (newShape) => {
-    if (!isShape3D$1(newShape))
-      return err(typeCastError("CUT_ALL_NOT_3D", "cutAll did not produce a 3D shape"));
-    return ok(newShape);
-  });
-}
 const shapesModule = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   CompSolid,
@@ -3411,15 +3511,15 @@ class EllipsoidTransform extends WrappingObj {
     const ax1 = r(makeAx1([0, 0, 0], [0, 1, 0]));
     const ax2 = r(makeAx1([0, 0, 0], [0, 0, 1]));
     const ax3 = r(makeAx1([0, 0, 0], [1, 0, 0]));
-    const transform = new oc.gp_GTrsf_1();
-    transform.SetAffinity_1(ax1, xzRatio);
+    const transform2 = new oc.gp_GTrsf_1();
+    transform2.SetAffinity_1(ax1, xzRatio);
     const xy = r(new oc.gp_GTrsf_1());
     xy.SetAffinity_1(ax2, xyRatio);
     const yz = r(new oc.gp_GTrsf_1());
     yz.SetAffinity_1(ax3, yzRatio);
-    transform.Multiply(xy);
-    transform.Multiply(yz);
-    super(transform);
+    transform2.Multiply(xy);
+    transform2.Multiply(yz);
+    super(transform2);
   }
   applyToPoint(p) {
     const oc = getKernel().oc;
@@ -3450,18 +3550,18 @@ const makeEllipsoid = (aLength, bLength, cLength) => {
   const baseSurface = oc.GeomConvert.SurfaceToBSplineSurface(sphericalSurface.UReversed()).get();
   try {
     const poles = convertToJSArray(baseSurface.Poles_2());
-    const transform = new EllipsoidTransform(aLength, bLength, cLength);
+    const transform2 = new EllipsoidTransform(aLength, bLength, cLength);
     poles.forEach((columns, rowIdx) => {
       columns.forEach((value, colIdx) => {
-        const newPoint = transform.applyToPoint(value);
+        const newPoint = transform2.applyToPoint(value);
         baseSurface.SetPole_1(rowIdx + 1, colIdx + 1, newPoint);
         newPoint.delete();
       });
     });
-    const shell = unwrap(
+    const shell2 = unwrap(
       cast(r(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell())
     );
-    return unwrap(makeSolid([shell]));
+    return unwrap(makeSolid([shell2]));
   } finally {
     baseSurface.delete();
   }
@@ -3537,16 +3637,16 @@ function _weld(facesOrShells) {
   return unwrap(cast(unwrap(downcast(shellBuilder.SewedShape()))));
 }
 function weldShellsAndFaces(facesOrShells, ignoreType = false) {
-  const shell = _weld(facesOrShells);
-  if (!ignoreType && !(shell instanceof Shell))
+  const shell2 = _weld(facesOrShells);
+  if (!ignoreType && !(shell2 instanceof Shell))
     return err(typeCastError("WELD_NOT_SHELL", "Could not make a shell from faces and shells"));
-  return ok(shell);
+  return ok(shell2);
 }
 function makeSolid(facesOrShells) {
   const r = gcWithScope();
   const oc = getKernel().oc;
-  const shell = _weld(facesOrShells);
-  return andThen(cast(r(new oc.ShapeFix_Solid_1()).SolidFromShell(shell.wrapped)), (solid) => {
+  const shell2 = _weld(facesOrShells);
+  return andThen(cast(r(new oc.ShapeFix_Solid_1()).SolidFromShell(shell2.wrapped)), (solid) => {
     if (!(solid instanceof Solid))
       return err(typeCastError("SOLID_BUILD_FAILED", "Could not make a solid of faces and shells"));
     return ok(solid);
@@ -4099,43 +4199,43 @@ function castToShape3D(shape, errorCode, errorMsg) {
   }
   return ok(wrapped);
 }
-function fuseShapes(a, b, { optimisation = "none", simplify = false } = {}) {
+function fuseShapes(a, b, { optimisation = "none", simplify: simplify2 = false } = {}) {
   const oc = getKernel().oc;
   const r = gcWithScope();
   const progress = r(new oc.Message_ProgressRange_1());
   const fuseOp = r(new oc.BRepAlgoAPI_Fuse_3(a.wrapped, b.wrapped, progress));
   applyGlue(fuseOp, optimisation);
   fuseOp.Build(progress);
-  if (simplify) fuseOp.SimplifyResult(true, true, 1e-3);
+  if (simplify2) fuseOp.SimplifyResult(true, true, 1e-3);
   return castToShape3D(fuseOp.Shape(), "FUSE_NOT_3D", "Fuse did not produce a 3D shape");
 }
-function cutShape(base, tool, { optimisation = "none", simplify = false } = {}) {
+function cutShape(base, tool, { optimisation = "none", simplify: simplify2 = false } = {}) {
   const oc = getKernel().oc;
   const r = gcWithScope();
   const progress = r(new oc.Message_ProgressRange_1());
   const cutOp = r(new oc.BRepAlgoAPI_Cut_3(base.wrapped, tool.wrapped, progress));
   applyGlue(cutOp, optimisation);
   cutOp.Build(progress);
-  if (simplify) cutOp.SimplifyResult(true, true, 1e-3);
+  if (simplify2) cutOp.SimplifyResult(true, true, 1e-3);
   return castToShape3D(cutOp.Shape(), "CUT_NOT_3D", "Cut did not produce a 3D shape");
 }
-function intersectShapes(a, b, { simplify = false } = {}) {
+function intersectShapes(a, b, { simplify: simplify2 = false } = {}) {
   const oc = getKernel().oc;
   const r = gcWithScope();
   const progress = r(new oc.Message_ProgressRange_1());
   const intOp = r(new oc.BRepAlgoAPI_Common_3(a.wrapped, b.wrapped, progress));
   intOp.Build(progress);
-  if (simplify) intOp.SimplifyResult(true, true, 1e-3);
+  if (simplify2) intOp.SimplifyResult(true, true, 1e-3);
   return castToShape3D(intOp.Shape(), "INTERSECT_NOT_3D", "Intersect did not produce a 3D shape");
 }
-function fuseAll$1(shapes, { optimisation = "none", simplify = false, strategy = "native" } = {}) {
+function fuseAll$1(shapes, { optimisation = "none", simplify: simplify2 = false, strategy = "native" } = {}) {
   if (shapes.length === 0)
     return err(validationError("FUSE_ALL_EMPTY", "fuseAll requires at least one shape"));
   if (shapes.length === 1) return ok(shapes[0]);
   if (strategy === "native") {
     const result = getKernel().fuseAll(
       shapes.map((s) => s.wrapped),
-      { optimisation, simplify, strategy }
+      { optimisation, simplify: simplify2, strategy }
     );
     return castToShape3D(result, "FUSE_ALL_NOT_3D", "fuseAll did not produce a 3D shape");
   }
@@ -4144,9 +4244,9 @@ function fuseAll$1(shapes, { optimisation = "none", simplify = false, strategy =
   if (isErr(leftResult)) return leftResult;
   const rightResult = fuseAll$1(shapes.slice(mid), { optimisation, simplify: false, strategy });
   if (isErr(rightResult)) return rightResult;
-  return fuseShapes(leftResult.value, rightResult.value, { optimisation, simplify });
+  return fuseShapes(leftResult.value, rightResult.value, { optimisation, simplify: simplify2 });
 }
-function cutAll(base, tools, { optimisation = "none", simplify = false } = {}) {
+function cutAll(base, tools, { optimisation = "none", simplify: simplify2 = false } = {}) {
   if (tools.length === 0) return ok(base);
   const oc = getKernel().oc;
   const r = gcWithScope();
@@ -4155,7 +4255,7 @@ function cutAll(base, tools, { optimisation = "none", simplify = false } = {}) {
   const cutOp = r(new oc.BRepAlgoAPI_Cut_3(base.wrapped, toolCompound, progress));
   applyGlue(cutOp, optimisation);
   cutOp.Build(progress);
-  if (simplify) cutOp.SimplifyResult(true, true, 1e-3);
+  if (simplify2) cutOp.SimplifyResult(true, true, 1e-3);
   return castToShape3D(cutOp.Shape(), "CUT_ALL_NOT_3D", "cutAll did not produce a 3D shape");
 }
 function buildCompound(shapes) {
@@ -4423,12 +4523,12 @@ function exportSTEP(shapes = [], { unit, modelUnit } = {}) {
     doc.delete();
   }
 }
-function fuseAllShapes(shapes, { optimisation = "none", simplify = false, strategy = "native" } = {}) {
+function fuseAllShapes(shapes, { optimisation = "none", simplify: simplify2 = false, strategy = "native" } = {}) {
   if (shapes.length === 0)
     return err(validationError("FUSE_ALL_EMPTY", "fuseAll requires at least one shape"));
   if (shapes.length === 1) return ok(shapes[0]);
   if (strategy === "native") {
-    const result = getKernel().fuseAll(shapes, { optimisation, simplify, strategy });
+    const result = getKernel().fuseAll(shapes, { optimisation, simplify: simplify2, strategy });
     return ok(result);
   }
   const oc = getKernel().oc;
@@ -4446,12 +4546,12 @@ function fuseAllShapes(shapes, { optimisation = "none", simplify = false, strate
   const fuseOp = r(new oc.BRepAlgoAPI_Fuse_3(leftResult.value, rightResult.value, progress));
   applyGlue$1(fuseOp, optimisation);
   fuseOp.Build(progress);
-  if (simplify) {
+  if (simplify2) {
     fuseOp.SimplifyResult(true, true, 1e-3);
   }
   return ok(fuseOp.Shape());
 }
-function cutAllShapes(base, tools, { optimisation = "none", simplify = false } = {}) {
+function cutAllShapes(base, tools, { optimisation = "none", simplify: simplify2 = false } = {}) {
   if (tools.length === 0) return ok(base);
   const oc = getKernel().oc;
   const r = gcWithScope();
@@ -4460,7 +4560,7 @@ function cutAllShapes(base, tools, { optimisation = "none", simplify = false } =
   const cutOp = r(new oc.BRepAlgoAPI_Cut_3(base, toolCompound, progress));
   applyGlue$1(cutOp, optimisation);
   cutOp.Build(progress);
-  if (simplify) {
+  if (simplify2) {
     cutOp.SimplifyResult(true, true, 1e-3);
   }
   return ok(cutOp.Shape());
@@ -5824,19 +5924,19 @@ class Transformation2D extends WrappingObj {
 const stretchTransform2d = (ratio, direction, origin = [0, 0]) => {
   const oc = getKernel().oc;
   const ax = axis2d(origin, direction);
-  const transform = new oc.gp_GTrsf2d_1();
-  transform.SetAffinity(ax, ratio);
+  const transform2 = new oc.gp_GTrsf2d_1();
+  transform2.SetAffinity(ax, ratio);
   ax.delete();
-  return new Transformation2D(transform);
+  return new Transformation2D(transform2);
 };
 const translationTransform2d = (translation) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
   const rotation = new oc.gp_Trsf2d_1();
   rotation.SetTranslation_1(r(vec(translation)));
-  const transform = new oc.gp_GTrsf2d_2(rotation);
+  const transform2 = new oc.gp_GTrsf2d_2(rotation);
   gc();
-  return new Transformation2D(transform);
+  return new Transformation2D(transform2);
 };
 const mirrorTransform2d = (centerOrDirection, origin = [0, 0], mode = "center") => {
   const oc = getKernel().oc;
@@ -5847,27 +5947,27 @@ const mirrorTransform2d = (centerOrDirection, origin = [0, 0], mode = "center")
   } else {
     rotation.SetMirror_2(r(axis2d(origin, centerOrDirection)));
   }
-  const transform = new oc.gp_GTrsf2d_2(rotation);
+  const transform2 = new oc.gp_GTrsf2d_2(rotation);
   gc();
-  return new Transformation2D(transform);
+  return new Transformation2D(transform2);
 };
 const rotateTransform2d = (angle, center = [0, 0]) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
   const rotation = new oc.gp_Trsf2d_1();
   rotation.SetRotation(r(pnt(center)), angle);
-  const transform = new oc.gp_GTrsf2d_2(rotation);
+  const transform2 = new oc.gp_GTrsf2d_2(rotation);
   gc();
-  return new Transformation2D(transform);
+  return new Transformation2D(transform2);
 };
 const scaleTransform2d = (scaleFactor, center = [0, 0]) => {
   const oc = getKernel().oc;
   const [r, gc] = localGC();
   const scaling = new oc.gp_Trsf2d_1();
   scaling.SetScale(r(pnt(center)), scaleFactor);
-  const transform = new oc.gp_GTrsf2d_2(scaling);
+  const transform2 = new oc.gp_GTrsf2d_2(scaling);
   gc();
-  return new Transformation2D(transform);
+  return new Transformation2D(transform2);
 };
 function curvesAsEdgesOnFace(curves, face, scale2 = "original") {
   const [r, gc] = localGC();
@@ -5936,8 +6036,8 @@ const viewbox = (bbox, margin = 1) => {
   const minY = -bbox.bounds[1][1] - margin;
   return `${minX} ${minY} ${bbox.width + 2 * margin} ${bbox.height + 2 * margin}`;
 };
-const asSVG = (body, boundingBox, margin = 1) => {
-  const vbox = viewbox(boundingBox, margin);
+const asSVG = (body, boundingBox2, margin = 1) => {
+  const vbox = viewbox(boundingBox2, margin);
   return `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${vbox}" fill="none" stroke="black" stroke-width="0.6%" vector-effect="non-scaling-stroke">
     ${body}
 </svg>`;
@@ -7486,7 +7586,7 @@ const rotateToStartAtSegment = (curves, segment) => {
   const end = curves.slice(startIndex);
   return end.concat(start);
 };
-const hashPoint = (p) => `${p[0].toFixed(6)},${p[1].toFixed(6)}`;
+const hashPoint = (p) => `${p[0].toFixed(9)},${p[1].toFixed(9)}`;
 const hashSegment = (first, last) => {
   const h1 = hashPoint(first);
   const h2 = hashPoint(last);
@@ -8013,8 +8113,8 @@ function intersect2D(first, second) {
       return intersect2D(wrapper, second);
     }
     let result = intersect2D(wrapper, second);
-    for (const cut of cuts) {
-      result = cut2D(result, cut);
+    for (const cut2 of cuts) {
+      result = cut2D(result, cut2);
     }
     return result;
   }
@@ -8028,8 +8128,8 @@ function intersect2D(first, second) {
       return intersect2D(wrapper, first);
     }
     let result = intersect2D(wrapper, first);
-    for (const cut of cuts) {
-      result = cut2D(result, cut);
+    for (const cut2 of cuts) {
+      result = cut2D(result, cut2);
     }
     return result;
   }
@@ -8123,10 +8223,10 @@ class EdgeFinder extends Finder3d {
    *
    * @category Filter
    */
-  ofLength(length) {
+  ofLength(length2) {
     const check = ({ element }) => {
-      if (typeof length === "number") return Math.abs(element.length - length) < 1e-9;
-      return length(element.length);
+      if (typeof length2 === "number") return Math.abs(element.length - length2) < 1e-9;
+      return length2(element.length);
     };
     this.filters.push(check);
     return this;
@@ -8837,8 +8937,8 @@ const solidFromShellGenerator = (sketches, shellGenerator) => {
   const startWires = [];
   const endWires = [];
   sketches.forEach((sketch) => {
-    const [shell, startWire, endWire] = unwrap(shellGenerator(sketch));
-    shells.push(shell);
+    const [shell2, startWire, endWire] = unwrap(shellGenerator(sketch));
+    shells.push(shell2);
     startWires.push(startWire);
     endWires.push(endWire);
   });
@@ -10380,7 +10480,7 @@ function createEdgeFinder(filters) {
         return Math.abs(ang - DEG2RAD * angle) < 1e-6;
       });
     },
-    ofLength: (length, tolerance = 1e-3) => withFilter((edge) => Math.abs(curveLength(edge) - length) < tolerance),
+    ofLength: (length2, tolerance = 1e-3) => withFilter((edge) => Math.abs(curveLength(edge) - length2) < tolerance),
     ofCurveType: (curveType) => withFilter((edge) => getCurveType(edge) === curveType),
     parallelTo: (dir = "Z") => createEdgeFinder([...filters]).inDirection(dir, 0),
     atDistance: (distance, point = [0, 0, 0]) => withFilter((edge) => {