@jbroll/jscad-modeling 2.12.7 → 2.12.8

package/bench/booleans.bench.js

@@ -0,0 +1,103 @@
+/**
+ * Benchmarks for boolean operations
+ *
+ * Run with: node bench/booleans.bench.js
+ */
+
+const { cube, cuboid, sphere, cylinder, torus } = require('../src/primitives')
+const { union, subtract, intersect } = require('../src/operations/booleans')
+const { translate } = require('../src/operations/transforms')
+
+// Simple benchmark runner
+const benchmark = (name, fn, iterations = 10) => {
+  // Warmup
+  for (let i = 0; i < 2; i++) fn()
+
+  const start = process.hrtime.bigint()
+  for (let i = 0; i < iterations; i++) {
+    fn()
+  }
+  const end = process.hrtime.bigint()
+  const totalMs = Number(end - start) / 1e6
+  const avgMs = totalMs / iterations
+
+  console.log(`${name.padEnd(50)} ${avgMs.toFixed(1).padStart(10)} ms/op  (${iterations} iterations)`)
+  return avgMs
+}
+
+console.log('='.repeat(80))
+console.log('Boolean Operation Benchmarks')
+console.log('='.repeat(80))
+console.log()
+
+// Prepare test geometries
+const smallCube = cube({ size: 10 })
+const smallCubeOffset = translate([5, 0, 0], cube({ size: 10 }))
+const medCube = cube({ size: 20 })
+const medCubeOffset = translate([10, 0, 0], cube({ size: 20 }))
+
+const smallSphere = sphere({ radius: 5, segments: 16 })
+const smallSphereOffset = translate([3, 0, 0], sphere({ radius: 5, segments: 16 }))
+const medSphere = sphere({ radius: 5, segments: 32 })
+const medSphereOffset = translate([3, 0, 0], sphere({ radius: 5, segments: 32 }))
+
+const smallCyl = cylinder({ radius: 5, height: 10, segments: 16 })
+const smallCylOffset = translate([3, 0, 0], cylinder({ radius: 5, height: 10, segments: 16 }))
+const medCyl = cylinder({ radius: 5, height: 10, segments: 32 })
+const medCylOffset = translate([3, 0, 0], cylinder({ radius: 5, height: 10, segments: 32 }))
+
+const smallTorus = torus({ innerRadius: 1, outerRadius: 4, innerSegments: 16, outerSegments: 16 })
+const smallTorusOffset = translate([2, 0, 0], torus({ innerRadius: 1, outerRadius: 4, innerSegments: 16, outerSegments: 16 }))
+const medTorus = torus({ innerRadius: 1, outerRadius: 4, innerSegments: 32, outerSegments: 32 })
+const medTorusOffset = translate([2, 0, 0], torus({ innerRadius: 1, outerRadius: 4, innerSegments: 32, outerSegments: 32 }))
+
+console.log('--- Union Operations ---')
+benchmark('union: cube + cube', () => union(smallCube, smallCubeOffset), 50)
+benchmark('union: sphere(16) + sphere(16)', () => union(smallSphere, smallSphereOffset), 20)
+benchmark('union: sphere(32) + sphere(32)', () => union(medSphere, medSphereOffset), 10)
+benchmark('union: cylinder(16) + cylinder(16)', () => union(smallCyl, smallCylOffset), 20)
+benchmark('union: cylinder(32) + cylinder(32)', () => union(medCyl, medCylOffset), 10)
+benchmark('union: torus(16) + torus(16)', () => union(smallTorus, smallTorusOffset), 5)
+benchmark('union: torus(32) + torus(32)', () => union(medTorus, medTorusOffset), 3)
+console.log()
+
+console.log('--- Subtract Operations ---')
+benchmark('subtract: cube - cube', () => subtract(smallCube, smallCubeOffset), 50)
+benchmark('subtract: sphere(16) - sphere(16)', () => subtract(smallSphere, smallSphereOffset), 20)
+benchmark('subtract: sphere(32) - sphere(32)', () => subtract(medSphere, medSphereOffset), 10)
+benchmark('subtract: cylinder(16) - cylinder(16)', () => subtract(smallCyl, smallCylOffset), 20)
+benchmark('subtract: cylinder(32) - cylinder(32)', () => subtract(medCyl, medCylOffset), 10)
+benchmark('subtract: torus(16) - torus(16)', () => subtract(smallTorus, smallTorusOffset), 5)
+benchmark('subtract: torus(32) - torus(32)', () => subtract(medTorus, medTorusOffset), 3)
+console.log()
+
+console.log('--- Intersect Operations ---')
+benchmark('intersect: cube & cube', () => intersect(smallCube, smallCubeOffset), 50)
+benchmark('intersect: sphere(16) & sphere(16)', () => intersect(smallSphere, smallSphereOffset), 20)
+benchmark('intersect: sphere(32) & sphere(32)', () => intersect(medSphere, medSphereOffset), 10)
+benchmark('intersect: cylinder(16) & cylinder(16)', () => intersect(smallCyl, smallCylOffset), 20)
+benchmark('intersect: cylinder(32) & cylinder(32)', () => intersect(medCyl, medCylOffset), 10)
+benchmark('intersect: torus(16) & torus(16)', () => intersect(smallTorus, smallTorusOffset), 5)
+benchmark('intersect: torus(32) & torus(32)', () => intersect(medTorus, medTorusOffset), 3)
+console.log()
+
+// Multiple operations (chain)
+console.log('--- Chained Operations ---')
+const cube1 = cube({ size: 10 })
+const cube2 = translate([5, 0, 0], cube({ size: 10 }))
+const cube3 = translate([0, 5, 0], cube({ size: 10 }))
+const cube4 = translate([0, 0, 5], cube({ size: 10 }))
+
+benchmark('union: 4 cubes', () => union(cube1, cube2, cube3, cube4), 20)
+benchmark('subtract: cube - 3 cubes', () => subtract(cube1, cube2, cube3, cube4), 20)
+console.log()
+
+// Non-overlapping (fast path)
+console.log('--- Non-overlapping (fast path) ---')
+const farCube1 = cube({ size: 5 })
+const farCube2 = translate([20, 0, 0], cube({ size: 5 }))
+benchmark('union: non-overlapping cubes', () => union(farCube1, farCube2), 100)
+console.log()
+
+console.log('='.repeat(80))
+console.log('Benchmark complete')

package/bench/primitives.bench.js

@@ -0,0 +1,108 @@
+/**
+ * Benchmarks for primitive shapes
+ *
+ * Run with: node bench/primitives.bench.js
+ */
+
+const {
+  cube, cuboid, roundedCuboid,
+  sphere, geodesicSphere, ellipsoid,
+  cylinder, roundedCylinder, cylinderElliptic,
+  torus,
+  polyhedron
+} = require('../src/primitives')
+
+// Simple benchmark runner
+const benchmark = (name, fn, iterations = 100) => {
+  // Warmup
+  for (let i = 0; i < 10; i++) fn()
+
+  const start = process.hrtime.bigint()
+  for (let i = 0; i < iterations; i++) {
+    fn()
+  }
+  const end = process.hrtime.bigint()
+  const totalMs = Number(end - start) / 1e6
+  const avgMs = totalMs / iterations
+
+  console.log(`${name.padEnd(40)} ${avgMs.toFixed(3).padStart(10)} ms/op  (${iterations} iterations, ${totalMs.toFixed(1)} ms total)`)
+  return avgMs
+}
+
+console.log('='.repeat(80))
+console.log('Primitive Shape Benchmarks')
+console.log('='.repeat(80))
+console.log()
+
+// Box primitives
+console.log('--- Box Primitives ---')
+benchmark('cube (default)', () => cube())
+benchmark('cube (size: 10)', () => cube({ size: 10 }))
+benchmark('cuboid (default)', () => cuboid())
+benchmark('cuboid (size: [10, 20, 30])', () => cuboid({ size: [10, 20, 30] }))
+benchmark('roundedCuboid (default)', () => roundedCuboid())
+benchmark('roundedCuboid (roundRadius: 2)', () => roundedCuboid({ size: [10, 10, 10], roundRadius: 2 }))
+benchmark('roundedCuboid (segments: 32)', () => roundedCuboid({ size: [10, 10, 10], roundRadius: 2, segments: 32 }))
+console.log()
+
+// Sphere primitives
+console.log('--- Sphere Primitives ---')
+benchmark('sphere (default, 32 seg)', () => sphere())
+benchmark('sphere (segments: 16)', () => sphere({ segments: 16 }))
+benchmark('sphere (segments: 64)', () => sphere({ segments: 64 }), 50)
+benchmark('sphere (segments: 128)', () => sphere({ segments: 128 }), 20)
+benchmark('geodesicSphere (default)', () => geodesicSphere())
+benchmark('geodesicSphere (frequency: 6)', () => geodesicSphere({ frequency: 6 }))
+benchmark('geodesicSphere (frequency: 12)', () => geodesicSphere({ frequency: 12 }), 20)
+benchmark('ellipsoid (default)', () => ellipsoid())
+benchmark('ellipsoid (segments: 64)', () => ellipsoid({ segments: 64 }), 50)
+console.log()
+
+// Cylinder primitives
+console.log('--- Cylinder Primitives ---')
+benchmark('cylinder (default)', () => cylinder())
+benchmark('cylinder (segments: 16)', () => cylinder({ segments: 16 }))
+benchmark('cylinder (segments: 64)', () => cylinder({ segments: 64 }))
+benchmark('cylinder (segments: 128)', () => cylinder({ segments: 128 }), 50)
+benchmark('roundedCylinder (default)', () => roundedCylinder())
+benchmark('roundedCylinder (segments: 64)', () => roundedCylinder({ segments: 64 }), 50)
+benchmark('cylinderElliptic (default)', () => cylinderElliptic())
+benchmark('cylinderElliptic (segments: 64)', () => cylinderElliptic({ segments: 64 }), 50)
+console.log()
+
+// Torus primitives (uses extrudeRotate internally)
+console.log('--- Torus Primitives ---')
+benchmark('torus (default 32x32)', () => torus())
+benchmark('torus (16x16)', () => torus({ innerSegments: 16, outerSegments: 16 }))
+benchmark('torus (32x32)', () => torus({ innerSegments: 32, outerSegments: 32 }))
+benchmark('torus (48x48)', () => torus({ innerSegments: 48, outerSegments: 48 }), 50)
+benchmark('torus (64x64)', () => torus({ innerSegments: 64, outerSegments: 64 }), 20)
+benchmark('torus (partial, 180deg)', () => torus({ outerRotation: Math.PI }))
+benchmark('torus (partial, 90deg)', () => torus({ outerRotation: Math.PI / 2 }))
+console.log()
+
+// Polyhedron
+console.log('--- Polyhedron Primitives ---')
+// Tetrahedron
+const tetraPoints = [[1, 1, 1], [-1, -1, 1], [-1, 1, -1], [1, -1, -1]]
+const tetraFaces = [[0, 1, 2], [0, 3, 1], [0, 2, 3], [1, 3, 2]]
+benchmark('polyhedron (tetrahedron)', () => polyhedron({ points: tetraPoints, faces: tetraFaces }))
+
+// Larger polyhedron (icosahedron-like)
+const phi = (1 + Math.sqrt(5)) / 2
+const icoPoints = [
+  [-1, phi, 0], [1, phi, 0], [-1, -phi, 0], [1, -phi, 0],
+  [0, -1, phi], [0, 1, phi], [0, -1, -phi], [0, 1, -phi],
+  [phi, 0, -1], [phi, 0, 1], [-phi, 0, -1], [-phi, 0, 1]
+]
+const icoFaces = [
+  [0, 11, 5], [0, 5, 1], [0, 1, 7], [0, 7, 10], [0, 10, 11],
+  [1, 5, 9], [5, 11, 4], [11, 10, 2], [10, 7, 6], [7, 1, 8],
+  [3, 9, 4], [3, 4, 2], [3, 2, 6], [3, 6, 8], [3, 8, 9],
+  [4, 9, 5], [2, 4, 11], [6, 2, 10], [8, 6, 7], [9, 8, 1]
+]
+benchmark('polyhedron (icosahedron)', () => polyhedron({ points: icoPoints, faces: icoFaces }))
+console.log()
+
+console.log('='.repeat(80))
+console.log('Benchmark complete')

package/benchmarks/memory-test.js

@@ -0,0 +1,103 @@
+/**
+ * Memory impact test for PolygonTreeNode optimization
+ *
+ * Measures heap usage before and after boolean operations
+ */
+
+const { primitives, booleans } = require('../src')
+const { sphere, cube } = primitives
+const { union, subtract, intersect } = booleans
+
+// Force GC if available
+const gc = global.gc || (() => {})
+
+const formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`
+}
+
+const measureMemory = (label, fn, iterations = 5) => {
+  gc()
+  const before = process.memoryUsage()
+
+  const results = []
+  for (let i = 0; i < iterations; i++) {
+    results.push(fn())
+  }
+
+  gc()
+  const after = process.memoryUsage()
+
+  const heapDiff = after.heapUsed - before.heapUsed
+  const externalDiff = after.external - before.external
+
+  console.log(`${label}:`)
+  console.log(`  Heap used: ${formatBytes(before.heapUsed)} -> ${formatBytes(after.heapUsed)} (${heapDiff >= 0 ? '+' : ''}${formatBytes(heapDiff)})`)
+  console.log(`  Iterations: ${iterations}, Results retained: ${results.length}`)
+
+  // Return results to prevent GC from collecting them during measurement
+  return { heapDiff, results }
+}
+
+const runMemoryTests = () => {
+  console.log('Memory Impact Test')
+  console.log('==================')
+  console.log(`Node ${process.version}, GC available: ${!!global.gc}`)
+  if (!global.gc) {
+    console.log('Run with: node --expose-gc benchmarks/memory-test.js')
+  }
+  console.log()
+
+  // Test 1: Union of spheres (many polygons clipped)
+  console.log('--- Union Operations (high clip count) ---')
+  const s32a = sphere({ segments: 32 })
+  const s32b = sphere({ segments: 32, center: [0.5, 0, 0] })
+
+  measureMemory('union-sphere-32 x5', () => union(s32a, s32b), 5)
+  console.log()
+
+  // Test 2: Larger spheres
+  const s64a = sphere({ segments: 64 })
+  const s64b = sphere({ segments: 64, center: [0.5, 0, 0] })
+
+  measureMemory('union-sphere-64 x3', () => union(s64a, s64b), 3)
+  console.log()
+
+  // Test 3: Subtract (fewer clips)
+  console.log('--- Subtract Operations (moderate clip count) ---')
+  measureMemory('subtract-sphere-32 x5', () => subtract(s32a, s32b), 5)
+  console.log()
+
+  // Test 4: Chain of operations (accumulating dead nodes)
+  console.log('--- Chained Operations (accumulating) ---')
+  measureMemory('union-chain-10-cubes', () => {
+    let result = cube({ size: 2 })
+    for (let i = 1; i < 10; i++) {
+      result = union(result, cube({ size: 2, center: [i * 1.5, 0, 0] }))
+    }
+    return result
+  }, 3)
+  console.log()
+
+  // Test 5: Many small operations
+  console.log('--- Many Small Operations ---')
+  measureMemory('union-25-cubes-array', () => {
+    const cubes = []
+    for (let i = 0; i < 25; i++) {
+      cubes.push(cube({ size: 1, center: [i * 1.2, 0, 0] }))
+    }
+    return union(cubes)
+  }, 3)
+  console.log()
+
+  // Test 6: Measure polygon counts
+  console.log('--- Result Polygon Counts ---')
+  const unionResult = union(s32a, s32b)
+  const subtractResult = subtract(s32a, s32b)
+  console.log(`  sphere-32 polygons: ${s32a.polygons.length}`)
+  console.log(`  union result polygons: ${unionResult.polygons.length}`)
+  console.log(`  subtract result polygons: ${subtractResult.polygons.length}`)
+}
+
+runMemoryTests()

package/benchmarks/primitives.bench.js

@@ -0,0 +1,83 @@
+/**
+ * Primitive shape benchmarks
+ *
+ * Tests sphere, cylinder, torus creation - the key primitives
+ * that involve trigonometry and significant vertex generation.
+ */
+
+const { primitives } = require('../src')
+const { cube, sphere, cylinder, cylinderElliptic, torus, geodesicSphere, roundedCuboid, roundedCylinder } = primitives
+
+const name = 'Primitives'
+
+const benchmarks = [
+  // Cubes (baseline - very fast)
+  {
+    name: 'cube-default',
+    fn: () => cube()
+  },
+  {
+    name: 'roundedCuboid-default',
+    fn: () => roundedCuboid()
+  },
+
+  // Spheres - key optimization target (trig + many vertices)
+  {
+    name: 'sphere-16-segments',
+    fn: () => sphere({ segments: 16 })
+  },
+  {
+    name: 'sphere-32-segments',
+    fn: () => sphere({ segments: 32 })
+  },
+  {
+    name: 'sphere-64-segments',
+    fn: () => sphere({ segments: 64 })
+  },
+  {
+    name: 'sphere-128-segments',
+    fn: () => sphere({ segments: 128 })
+  },
+  {
+    name: 'geodesicSphere-frequency-6',
+    fn: () => geodesicSphere({ frequency: 6 })
+  },
+
+  // Cylinders - common primitive
+  {
+    name: 'cylinder-16-segments',
+    fn: () => cylinder({ segments: 16 })
+  },
+  {
+    name: 'cylinder-32-segments',
+    fn: () => cylinder({ segments: 32 })
+  },
+  {
+    name: 'cylinder-64-segments',
+    fn: () => cylinder({ segments: 64 })
+  },
+  {
+    name: 'cylinderElliptic-32-segments',
+    fn: () => cylinderElliptic({ segments: 32 })
+  },
+  {
+    name: 'roundedCylinder-32-segments',
+    fn: () => roundedCylinder({ segments: 32 })
+  },
+
+  // Torus - uses extrudeRotate internally
+  {
+    name: 'torus-16x16',
+    fn: () => torus({ innerSegments: 16, outerSegments: 16 })
+  },
+  {
+    name: 'torus-32x32',
+    fn: () => torus({ innerSegments: 32, outerSegments: 32 })
+  },
+  {
+    name: 'torus-64x64',
+    fn: () => torus({ innerSegments: 64, outerSegments: 64 })
+  }
+]
+
+module.exports = { name, benchmarks }

package/benchmarks/run.js

@@ -85,12 +85,46 @@ const runSuite = (name, benchmarks) => {
   return results
 }
 
+/**
+ * Generate timestamp for output file
+ */
+const getTimestamp = () => {
+  const now = new Date()
+  return now.toISOString().replace(/[:.]/g, '-').slice(0, 19)
+}
+
+/**
+ * Save results to JSON file
+ */
+const saveResults = (allResults, outputDir) => {
+  const timestamp = getTimestamp()
+  const outputFile = path.join(outputDir, `bench-${timestamp}.json`)
+
+  const output = {
+    timestamp: new Date().toISOString(),
+    node: process.version,
+    runs: BENCHMARK_RUNS,
+    warmup: WARMUP_RUNS,
+    results: allResults
+  }
+
+  fs.writeFileSync(outputFile, JSON.stringify(output, null, 2))
+  console.log(`Results saved to: ${outputFile}`)
+  return outputFile
+}
+
 /**
  * Load and run benchmark files
  */
 const main = () => {
   const args = process.argv.slice(2)
   const benchDir = __dirname
+  const outputDir = path.join(benchDir, 'results')
+
+  // Ensure results directory exists
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true })
+  }
 
   console.log('@jscad/modeling benchmarks')
   console.log(`Runs: ${BENCHMARK_RUNS} (+ ${WARMUP_RUNS} warmup)`)
@@ -134,6 +168,9 @@ const main = () => {
 
   console.log('\n' + '═'.repeat(60))
   console.log('Benchmark complete')
+
+  // Save results to timestamped file
+  saveResults(allResults, outputDir)
 }
 
 // Export for programmatic use

package/benchmarks/workflows.bench.js

@@ -0,0 +1,105 @@
+/**
+ * Typical workflow benchmarks
+ *
+ * Tests common modeling patterns that users actually do:
+ * - Create primitive, boolean op, transform
+ * - Multiple booleans in sequence
+ * - Mixed geometry types (cube vs cylinder)
+ */
+
+const { primitives, booleans, transforms } = require('../src')
+const { cube, sphere, cylinder, torus } = primitives
+const { union, subtract, intersect } = booleans
+const { translate, rotate, scale } = transforms
+
+const name = 'Workflows'
+
+// Pre-create some geometries for fair comparison
+const cube10 = cube({ size: 10 })
+const cyl16 = cylinder({ radius: 3, height: 15, segments: 16 })
+const cyl32 = cylinder({ radius: 3, height: 15, segments: 32 })
+const sphere16 = sphere({ radius: 5, segments: 16 })
+const sphere32 = sphere({ radius: 5, segments: 32 })
+
+const benchmarks = [
+  // Classic workflow: cube with hole
+  {
+    name: 'workflow-cube-subtract-cylinder-16',
+    fn: () => subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 }))
+  },
+  {
+    name: 'workflow-cube-subtract-cylinder-32',
+    fn: () => subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 32 }))
+  },
+
+  // Pre-created geometry (isolates boolean cost)
+  {
+    name: 'workflow-precreated-cube-subtract-cyl16',
+    fn: () => subtract(cube10, cyl16)
+  },
+  {
+    name: 'workflow-precreated-cube-subtract-cyl32',
+    fn: () => subtract(cube10, cyl32)
+  },
+
+  // Full pipeline: create, boolean, transform
+  {
+    name: 'workflow-full-cube-subtract-cyl-rotate',
+    fn: () => rotate([0, Math.PI / 4, 0], subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 })))
+  },
+  {
+    name: 'workflow-full-cube-subtract-cyl-translate',
+    fn: () => translate([10, 0, 0], subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 })))
+  },
+
+  // Multiple holes (common pattern)
+  {
+    name: 'workflow-cube-3-holes',
+    fn: () => {
+      const box = cube({ size: 10 })
+      const hole1 = cylinder({ radius: 1.5, height: 15, segments: 16 })
+      const hole2 = translate([3, 0, 0], hole1)
+      const hole3 = translate([-3, 0, 0], hole1)
+      return subtract(box, hole1, hole2, hole3)
+    }
+  },
+
+  // Union of shapes (assembly pattern)
+  {
+    name: 'workflow-union-cube-sphere-16',
+    fn: () => union(cube({ size: 8 }), translate([0, 0, 6], sphere({ radius: 5, segments: 16 })))
+  },
+  {
+    name: 'workflow-union-cube-sphere-32',
+    fn: () => union(cube({ size: 8 }), translate([0, 0, 6], sphere({ radius: 5, segments: 32 })))
+  },
+
+  // Intersect (less common but important)
+  {
+    name: 'workflow-intersect-cube-sphere-16',
+    fn: () => intersect(cube({ size: 10 }), sphere({ radius: 7, segments: 16 }))
+  },
+  {
+    name: 'workflow-intersect-cube-sphere-32',
+    fn: () => intersect(cube({ size: 10 }), sphere({ radius: 7, segments: 32 }))
+  },
+
+  // Chained operations
+  {
+    name: 'workflow-chain-subtract-union',
+    fn: () => {
+      const base = cube({ size: 10 })
+      const hole = cylinder({ radius: 3, height: 15, segments: 16 })
+      const top = translate([0, 0, 5], sphere({ radius: 3, segments: 16 }))
+      return union(subtract(base, hole), top)
+    }
+  },
+
+  // Scaling after boolean (tests transform application)
+  {
+    name: 'workflow-subtract-then-scale',
+    fn: () => scale([2, 2, 2], subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 })))
+  }
+]
+
+module.exports = { name, benchmarks }

package/dist/jscad-modeling.min.js

@@ -836,7 +836,7 @@ const vec3=require("../../maths/vec3"),geom2=require("../../geometries/geom2"),g
 const plane=require("../../../maths/plane"),poly3=require("../../../geometries/poly3");class Node{constructor(e){this.plane=null,this.front=null,this.back=null,this.polygontreenodes=[],this.parent=e}invert(){const e=[this];let o;for(let n=0;n<e.length;n++){(o=e[n]).plane&&(o.plane=plane.flip(plane.create(),o.plane)),o.front&&e.push(o.front),o.back&&e.push(o.back);const t=o.front;o.front=o.back,o.back=t}}clipPolygons(e,o){let n,t={node:this,polygontreenodes:e};const l=[];do{if(n=t.node,e=t.polygontreenodes,n.plane){const t=n.plane,s=[],p=[],r=o?s:p,d=e.length;for(let o=0;o<d;o++){const n=e[o];n.isRemoved()||n.splitByPlane(t,r,s,p,s)}n.front&&p.length>0&&l.push({node:n.front,polygontreenodes:p});const h=s.length;if(n.back&&h>0)l.push({node:n.back,polygontreenodes:s});else for(let e=0;e<h;e++)s[e].remove()}t=l.pop()}while(void 0!==t)}clipTo(e,o){let n=this;const t=[];do{n.polygontreenodes.length>0&&e.rootnode.clipPolygons(n.polygontreenodes,o),n.front&&t.push(n.front),n.back&&t.push(n.back),n=t.pop()}while(void 0!==n)}addPolygonTreeNodes(e){let o={node:this,polygontreenodes:e};const n=[];do{const e=o.node,t=o.polygontreenodes;if(0===t.length){o=n.pop();continue}if(!e.plane){let o=0;const n=t[o=Math.floor(t.length/2)].getPolygon();e.plane=poly3.plane(n)}const l=[],s=[],p=t.length;for(let o=0;o<p;++o)t[o].splitByPlane(e.plane,e.polygontreenodes,s,l,s);if(l.length>0){e.front||(e.front=new Node(e)),p===l.length&&0===s.length?e.front.polygontreenodes=l:n.push({node:e.front,polygontreenodes:l})}if(s.length>0){e.back||(e.back=new Node(e)),p===s.length&&0===l.length?e.back.polygontreenodes=s:n.push({node:e.back,polygontreenodes:s})}o=n.pop()}while(void 0!==o)}}module.exports=Node;
 
 },{"../../../geometries/poly3":79,"../../../maths/plane":163}],280:[function(require,module,exports){
-const{EPS:EPS}=require("../../../maths/constants"),vec3=require("../../../maths/vec3"),poly3=require("../../../geometries/poly3"),splitPolygonByPlane=require("./splitPolygonByPlane");class PolygonTreeNode{constructor(e,t){this.parent=e,this.children=[],this.polygon=t,this.removed=!1}addPolygons(e){if(!this.isRootNode())throw new Error("Assertion failed");const t=this;e.forEach(e=>{t.addChild(e)})}remove(){if(!this.removed){this.removed=!0,this.polygon=null;const e=this.parent.children,t=e.indexOf(this);if(t<0)throw new Error("Assertion failed");e.splice(t,1),this.parent.recursivelyInvalidatePolygon()}}isRemoved(){return this.removed}isRootNode(){return!this.parent}invert(){if(!this.isRootNode())throw new Error("Assertion failed");this.invertSub()}getPolygon(){if(!this.polygon)throw new Error("Assertion failed");return this.polygon}getPolygons(e){let t=[this];const o=[t];let n,l,s,i;for(n=0;n<o.length;++n)for(l=0,s=(t=o[n]).length;l<s;l++)(i=t[l]).polygon?e.push(i.polygon):i.children.length>0&&o.push(i.children)}splitByPlane(e,t,o,n,l){if(this.children.length){const s=[this.children];let i,r,h,c,d;for(i=0;i<s.length;i++)for(d=s[i],r=0,h=d.length;r<h;r++)(c=d[r]).children.length>0?s.push(c.children):c._splitByPlane(e,t,o,n,l)}else this._splitByPlane(e,t,o,n,l)}_splitByPlane(e,t,o,n,l){const s=this.polygon;if(s){const i=poly3.measureBoundingSphere(s),r=i[3]+EPS,h=i,c=vec3.dot(e,h)-e[3];if(c>r)n.push(this);else if(c<-r)l.push(this);else{const i=splitPolygonByPlane(e,s);switch(i.type){case 0:t.push(this);break;case 1:o.push(this);break;case 2:n.push(this);break;case 3:l.push(this);break;case 4:if(i.front){const e=this.addChild(i.front);n.push(e)}if(i.back){const e=this.addChild(i.back);l.push(e)}}}}}addChild(e){const t=new PolygonTreeNode(this,e);return this.children.push(t),t}invertSub(){let e=[this];const t=[e];let o,n,l,s;for(o=0;o<t.length;o++)for(n=0,l=(e=t[o]).length;n<l;n++)(s=e[n]).polygon&&(s.polygon=poly3.invert(s.polygon)),s.children.length>0&&t.push(s.children)}recursivelyInvalidatePolygon(){this.polygon=null,this.parent&&this.parent.recursivelyInvalidatePolygon()}clear(){let e=[this];const t=[e];for(let o=0;o<t.length;++o){const n=(e=t[o]).length;for(let o=0;o<n;o++){const n=e[o];n.polygon&&(n.polygon=null),n.parent&&(n.parent=null),n.children.length>0&&t.push(n.children),n.children=[]}}}toString(){let e="",t=[this];const o=[t];let n,l,s,i;for(n=0;n<o.length;++n){t=o[n];const r=" ".repeat(n);for(l=0,s=t.length;l<s;l++)e+=`${r}PolygonTreeNode (${(i=t[l]).isRootNode()}): ${i.children.length}`,i.polygon?e+=`\n ${r}polygon: ${i.polygon.vertices}\n`:e+="\n",i.children.length>0&&o.push(i.children)}return e}}module.exports=PolygonTreeNode;
+const{EPS:EPS}=require("../../../maths/constants"),vec3=require("../../../maths/vec3"),poly3=require("../../../geometries/poly3"),splitPolygonByPlane=require("./splitPolygonByPlane");class PolygonTreeNode{constructor(e,t){this.parent=e,this.children=[],this.polygon=t,this.removed=!1}addPolygons(e){if(!this.isRootNode())throw new Error("Assertion failed");const t=this;e.forEach(e=>{t.addChild(e)})}remove(){this.removed||(this.removed=!0,this.polygon=null,this.parent.recursivelyInvalidatePolygon())}isRemoved(){return this.removed}isRootNode(){return!this.parent}invert(){if(!this.isRootNode())throw new Error("Assertion failed");this.invertSub()}getPolygon(){if(!this.polygon)throw new Error("Assertion failed");return this.polygon}getPolygons(e){this.isRootNode()&&this.children.length>0&&(this.children=this.children.filter(e=>!e.removed));let t=[this];const o=[t];let n,l,s,i;for(n=0;n<o.length;++n)for(l=0,s=(t=o[n]).length;l<s;l++)(i=t[l]).polygon?e.push(i.polygon):i.children.length>0&&o.push(i.children)}splitByPlane(e,t,o,n,l){if(this.children.length){const s=[this.children];let i,r,h,d,c;for(i=0;i<s.length;i++)for(c=s[i],r=0,h=c.length;r<h;r++)(d=c[r]).children.length>0?s.push(d.children):d._splitByPlane(e,t,o,n,l)}else this._splitByPlane(e,t,o,n,l)}_splitByPlane(e,t,o,n,l){const s=this.polygon;if(s){const i=poly3.measureBoundingSphere(s),r=i[3]+EPS,h=i,d=vec3.dot(e,h)-e[3];if(d>r)n.push(this);else if(d<-r)l.push(this);else{const i=splitPolygonByPlane(e,s);switch(i.type){case 0:t.push(this);break;case 1:o.push(this);break;case 2:n.push(this);break;case 3:l.push(this);break;case 4:if(i.front){const e=this.addChild(i.front);n.push(e)}if(i.back){const e=this.addChild(i.back);l.push(e)}}}}}addChild(e){const t=new PolygonTreeNode(this,e);return this.children.push(t),t}invertSub(){let e=[this];const t=[e];let o,n,l,s;for(o=0;o<t.length;o++)for(n=0,l=(e=t[o]).length;n<l;n++)(s=e[n]).polygon&&(s.polygon=poly3.invert(s.polygon)),s.children.length>0&&t.push(s.children)}recursivelyInvalidatePolygon(){this.polygon=null,this.parent&&this.parent.recursivelyInvalidatePolygon()}clear(){let e=[this];const t=[e];for(let o=0;o<t.length;++o){const n=(e=t[o]).length;for(let o=0;o<n;o++){const n=e[o];n.polygon&&(n.polygon=null),n.parent&&(n.parent=null),n.children.length>0&&t.push(n.children),n.children=[]}}}toString(){let e="",t=[this];const o=[t];let n,l,s,i;for(n=0;n<o.length;++n){t=o[n];const r=" ".repeat(n);for(l=0,s=t.length;l<s;l++)e+=`${r}PolygonTreeNode (${(i=t[l]).isRootNode()}): ${i.children.length}`,i.polygon?e+=`\n ${r}polygon: ${i.polygon.vertices}\n`:e+="\n",i.children.length>0&&o.push(i.children)}return e}}module.exports=PolygonTreeNode;
 
 },{"../../../geometries/poly3":79,"../../../maths/constants":94,"../../../maths/vec3":222,"./splitPolygonByPlane":284}],281:[function(require,module,exports){
 const Node=require("./Node"),PolygonTreeNode=require("./PolygonTreeNode");class Tree{constructor(o){this.polygonTree=new PolygonTreeNode,this.rootnode=new Node(null),o&&this.addPolygons(o)}invert(){this.polygonTree.invert(),this.rootnode.invert()}clipTo(o,e=!1){this.rootnode.clipTo(o,e)}allPolygons(){const o=[];return this.polygonTree.getPolygons(o),o}addPolygons(o){const e=new Array(o.length);for(let r=0;r<o.length;r++)e[r]=this.polygonTree.addChild(o[r]);this.rootnode.addPolygonTreeNodes(e)}clear(){this.polygonTree.clear()}toString(){return"Tree: "+this.polygonTree.toString("")}}module.exports=Tree;
@@ -848,7 +848,7 @@ module.exports={Tree:require("./Tree")};
 const vec3=require("../../../maths/vec3"),splitLineSegmentByPlane=(e,t,c)=>{const n=vec3.subtract(vec3.create(),c,t);let s=(e[3]-vec3.dot(e,t))/vec3.dot(e,n);return Number.isNaN(s)&&(s=0),s>1&&(s=1),s<0&&(s=0),vec3.scale(n,n,s),vec3.add(n,t,n),n};module.exports=splitLineSegmentByPlane;
 
 },{"../../../maths/vec3":222}],284:[function(require,module,exports){
-const{EPS:EPS}=require("../../../maths/constants"),plane=require("../../../maths/plane"),vec3=require("../../../maths/vec3"),poly3=require("../../../geometries/poly3"),splitLineSegmentByPlane=require("./splitLineSegmentByPlane"),splitPolygonByPlane=(e,t)=>{const l={type:null,front:null,back:null},n=t.vertices,s=n.length,o=poly3.plane(t);if(plane.equals(o,e))l.type=0;else{let t=!1,p=!1;const i=[],c=-EPS;for(let l=0;l<s;l++){const s=vec3.dot(e,n[l])-e[3],o=s<c;i.push(o),s>EPS&&(t=!0),s<c&&(p=!0)}if(t||p)if(p)if(t){l.type=4;const t=[],p=[];let c=i[0];for(let l=0;l<s;l++){const o=n[l];let r=l+1;r>=s&&(r=0);const a=i[r];if(c===a)c?p.push(o):t.push(o);else{const l=n[r],s=splitLineSegmentByPlane(e,o,l);c?(p.push(o),p.push(s),t.push(s)):(t.push(o),t.push(s),p.push(s))}c=a}const r=EPS*EPS;if(p.length>=3){let e=p[p.length-1];for(let t=0;t<p.length;t++){const l=p[t];vec3.squaredDistance(l,e)<r&&(p.splice(t,1),t--),e=l}}if(t.length>=3){let e=t[t.length-1];for(let l=0;l<t.length;l++){const n=t[l];vec3.squaredDistance(n,e)<r&&(t.splice(l,1),l--),e=n}}t.length>=3&&(l.front=poly3.fromPointsAndPlane(t,o)),p.length>=3&&(l.back=poly3.fromPointsAndPlane(p,o))}else l.type=3;else l.type=2;else{const t=vec3.dot(e,o);l.type=t>=0?0:1}}return l};module.exports=splitPolygonByPlane;
+const{EPS:EPS}=require("../../../maths/constants"),plane=require("../../../maths/plane"),vec3=require("../../../maths/vec3"),poly3=require("../../../geometries/poly3"),splitLineSegmentByPlane=require("./splitLineSegmentByPlane"),EPS_SQUARED=EPS*EPS,removeConsecutiveDuplicates=e=>{if(e.length<3)return e;const t=[];let n=e[e.length-1];for(let l=0;l<e.length;l++){const s=e[l];vec3.squaredDistance(s,n)>=EPS_SQUARED&&t.push(s),n=s}return t},splitPolygonByPlane=(e,t)=>{const n={type:null,front:null,back:null},l=t.vertices,s=l.length,o=poly3.plane(t);if(plane.equals(o,e))n.type=0;else{let t=!1,p=!1;const i=[],r=-EPS;for(let n=0;n<s;n++){const s=vec3.dot(e,l[n])-e[3],o=s<r;i.push(o),s>EPS&&(t=!0),s<r&&(p=!0)}if(t||p)if(p)if(t){n.type=4;const t=[],p=[];let r=i[0];for(let n=0;n<s;n++){const o=l[n];let u=n+1;u>=s&&(u=0);const c=i[u];if(r===c)r?p.push(o):t.push(o);else{const n=l[u],s=splitLineSegmentByPlane(e,o,n);r?(p.push(o),p.push(s),t.push(s)):(t.push(o),t.push(s),p.push(s))}r=c}const u=removeConsecutiveDuplicates(p),c=removeConsecutiveDuplicates(t);c.length>=3&&(n.front=poly3.fromPointsAndPlane(c,o)),u.length>=3&&(n.back=poly3.fromPointsAndPlane(u,o))}else n.type=3;else n.type=2;else{const t=vec3.dot(e,o);n.type=t>=0?0:1}}return n};module.exports=splitPolygonByPlane;
 
 },{"../../../geometries/poly3":79,"../../../maths/constants":94,"../../../maths/plane":163,"../../../maths/vec3":222,"./splitLineSegmentByPlane":283}],285:[function(require,module,exports){
 const flatten=require("../../utils/flatten"),areAllShapesTheSameType=require("../../utils/areAllShapesTheSameType"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),unionGeom2=require("./unionGeom2"),unionGeom3=require("./unionGeom3"),union=(...e)=>{if(0===(e=flatten(e)).length)throw new Error("wrong number of arguments");if(!areAllShapesTheSameType(e))throw new Error("only unions of the same type are supported");const o=e[0];return geom2.isA(o)?unionGeom2(e):geom3.isA(o)?unionGeom3(e):o};module.exports=union;
@@ -920,7 +920,7 @@ const geom2=require("../../../geometries/geom2"),plane=require("../../../maths/p
 const pointInTriangle=(n,a,e,r,i,o,t,x)=>(i-t)*(a-x)-(n-t)*(o-x)>=0&&(n-t)*(r-x)-(e-t)*(a-x)>=0&&(e-t)*(o-x)-(i-t)*(r-x)>=0,area=(n,a,e)=>(a.y-n.y)*(e.x-a.x)-(a.x-n.x)*(e.y-a.y);module.exports={area:area,pointInTriangle:pointInTriangle};
 
 },{}],308:[function(require,module,exports){
-const mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),repairSlice=require("./slice/repair"),extrudeWalls=require("./extrudeWalls"),defaultCallback=(e,r,l)=>{let t=null;return geom2.isA(l)&&(t=slice.fromSides(geom2.toSides(l))),poly3.isA(l)&&(t=slice.fromPoints(poly3.toPoints(l))),0===e||1===e?slice.transform(mat4.fromTranslation(mat4.create(),[0,0,e]),t):null},extrudeFromSlices=(e,r)=>{const l={numberOfSlices:2,capStart:!0,capEnd:!0,close:!1,repair:!0,callback:defaultCallback},{numberOfSlices:t,capStart:o,capEnd:c,close:s,repair:i,callback:a}=Object.assign({},l,e);if(t<2)throw new Error("numberOfSlices must be 2 or more");i&&(r=repairSlice(r));const n=t-1;let u=null,m=null,f=null,g=[];for(let e=0;e<t;e++){const l=a(e/n,e,r);if(l){if(!slice.isA(l))throw new Error("the callback function must return slice objects");if(0===slice.toEdges(l).length)throw new Error("the callback function must return slices with one or more edges");f&&(g=g.concat(extrudeWalls(f,l))),0===e&&(u=l),e===t-1&&(m=l),f=l}}if(c){const e=slice.toPolygons(m);g=g.concat(e)}if(o){const e=slice.toPolygons(u).map(poly3.invert);g=g.concat(e)}return o||c||s&&!slice.equals(m,u)&&(g=g.concat(extrudeWalls(m,u))),geom3.create(g)};module.exports=extrudeFromSlices;
+const mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),repairSlice=require("./slice/repair"),extrudeWalls=require("./extrudeWalls"),defaultCallback=(e,r,l)=>{let t=null;return geom2.isA(l)&&(t=slice.fromSides(geom2.toSides(l))),poly3.isA(l)&&(t=slice.fromPoints(poly3.toPoints(l))),0===e||1===e?slice.transform(mat4.fromTranslation(mat4.create(),[0,0,e]),t):null},extrudeFromSlices=(e,r)=>{const l={numberOfSlices:2,capStart:!0,capEnd:!0,close:!1,repair:!0,callback:defaultCallback},{numberOfSlices:t,capStart:o,capEnd:s,close:i,repair:c,callback:n}=Object.assign({},l,e);if(t<2)throw new Error("numberOfSlices must be 2 or more");c&&(r=repairSlice(r));const a=t-1;let u=null,m=null,f=null,g=[];for(let e=0;e<t;e++){const l=n(e/a,e,r);if(l){if(!slice.isA(l))throw new Error("the callback function must return slice objects");if(0===slice.toEdges(l).length)throw new Error("the callback function must return slices with one or more edges");if(f){const e=extrudeWalls(f,l);for(let r=0;r<e.length;r++)g.push(e[r])}0===e&&(u=l),e===t-1&&(m=l),f=l}}if(s){const e=slice.toPolygons(m);for(let r=0;r<e.length;r++)g.push(e[r])}if(o){const e=slice.toPolygons(u).map(poly3.invert);for(let r=0;r<e.length;r++)g.push(e[r])}if(!o&&!s&&i&&!slice.equals(m,u)){const e=extrudeWalls(m,u);for(let r=0;r<e.length;r++)g.push(e[r])}return geom3.create(g)};module.exports=extrudeFromSlices;
 
 },{"../../geometries/geom2":25,"../../geometries/geom3":41,"../../geometries/poly3":79,"../../maths/mat4":143,"./extrudeWalls":317,"./slice":326,"./slice/repair":328}],309:[function(require,module,exports){
 const{TAU:TAU}=require("../../maths/constants"),mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),extrudeFromSlices=require("./extrudeFromSlices"),slice=require("./slice"),extrudeHelical=(e,t)=>{const r={angle:TAU,startAngle:0,pitch:10,height:0,endOffset:0,segmentsPerRotation:32};let{angle:a,startAngle:s,pitch:o,height:n,endOffset:i,segmentsPerRotation:m}=Object.assign({},r,e);0!=n&&(o=n/(a/TAU));if(m<3)throw new Error("The number of segments per rotation needs to be at least 3.");const l=geom2.toSides(t);if(0===l.length)throw new Error("The given geometry cannot be empty");const c=l.filter(e=>e[0][0]>=0);let g=slice.fromSides(l);0===c.length&&(g=slice.reverse(g));const h=Math.round(m/TAU*Math.abs(a)),u=h>=2?h:2,f=mat4.create(),d=mat4.create();return extrudeFromSlices({numberOfSlices:u+1,callback:(e,t,r)=>{const n=s+a/u*t,m=i/u*t,l=(n-s)/TAU*o;return mat4.multiply(f,mat4.fromTranslation(mat4.create(),[m,0,l*Math.sign(a)]),mat4.fromXRotation(mat4.create(),-TAU/4*Math.sign(a))),mat4.multiply(d,mat4.fromZRotation(mat4.create(),n),f),slice.transform(d,r)}},g)};module.exports=extrudeHelical;
@@ -944,10 +944,10 @@ const{area:area}=require("../../maths/utils"),geom2=require("../../geometries/ge
 const path2=require("../../geometries/path2"),expand=require("../expansions/expand"),extrudeLinearGeom2=require("./extrudeLinearGeom2"),extrudeRectangularPath2=(e,t)=>{const{size:r,height:n}=Object.assign({},{size:1,height:1},e);if(e.delta=r,e.offset=[0,0,n],0===path2.toPoints(t).length)throw new Error("the given geometry cannot be empty");const a=expand(e,t);return extrudeLinearGeom2(e,a)};module.exports=extrudeRectangularPath2;
 
 },{"../../geometries/path2":62,"../expansions/expand":289,"./extrudeLinearGeom2":311}],316:[function(require,module,exports){
-const{TAU:TAU}=require("../../maths/constants"),mat4=require("../../maths/mat4"),{mirrorX:mirrorX}=require("../transforms/mirror"),geom2=require("../../geometries/geom2"),slice=require("./slice"),extrudeFromSlices=require("./extrudeFromSlices"),extrudeRotate=(e,t)=>{const r={segments:12,startAngle:0,angle:TAU,overflow:"cap"};let{segments:a,startAngle:o,angle:s,overflow:m}=Object.assign({},r,e);if(a<3)throw new Error("segments must be greater then 3");o=Math.abs(o)>TAU?o%TAU:o,s=Math.abs(s)>TAU?s%TAU:s;let n=o+s;if((n=Math.abs(n)>TAU?n%TAU:n)<o){const e=o;o=n,n=e}let l=n-o;if(l<=0&&(l=TAU),Math.abs(l)<TAU){const e=TAU/a;a=Math.floor(Math.abs(l)/e),Math.abs(l)>a*e&&a++}let i=geom2.toSides(t);if(0===i.length)throw new Error("the given geometry cannot be empty");const c=i.filter(e=>e[0][0]<0),g=i.filter(e=>e[0][0]>=0);c.length>0&&g.length>0&&"cap"===m&&(c.length>g.length?(i=i.map(e=>{let t=e[0],r=e[1];return[t=[Math.min(t[0],0),t[1]],r=[Math.min(r[0],0),r[1]]]}),t=geom2.create(i),t=mirrorX(t)):g.length>=c.length&&(i=i.map(e=>{let t=e[0],r=e[1];return[t=[Math.max(t[0],0),t[1]],r=[Math.max(r[0],0),r[1]]]}),t=geom2.create(i)));const h=l/a,u=Math.abs(l)<TAU,A=slice.fromSides(geom2.toSides(t));slice.reverse(A,A);const f=mat4.create();return extrudeFromSlices(e={numberOfSlices:a+1,capStart:u,capEnd:u,close:!u,callback:(e,t,r)=>{let s=h*t+o;return l===TAU&&t===a&&(s=o),mat4.multiply(f,mat4.fromZRotation(f,s),mat4.fromXRotation(mat4.create(),TAU/4)),slice.transform(f,r)}},A)};module.exports=extrudeRotate;
+const{TAU:TAU}=require("../../maths/constants"),mat4=require("../../maths/mat4"),{mirrorX:mirrorX}=require("../transforms/mirror"),geom2=require("../../geometries/geom2"),slice=require("./slice"),extrudeFromSlices=require("./extrudeFromSlices"),extrudeRotate=(e,t)=>{const r={segments:12,startAngle:0,angle:TAU,overflow:"cap"};let{segments:a,startAngle:o,angle:s,overflow:m}=Object.assign({},r,e);if(a<3)throw new Error("segments must be greater then 3");o=Math.abs(o)>TAU?o%TAU:o,s=Math.abs(s)>TAU?s%TAU:s;let n=o+s;if((n=Math.abs(n)>TAU?n%TAU:n)<o){const e=o;o=n,n=e}let l=n-o;if(l<=0&&(l=TAU),Math.abs(l)<TAU){const e=TAU/a;a=Math.floor(Math.abs(l)/e),Math.abs(l)>a*e&&a++}let i=geom2.toSides(t);if(0===i.length)throw new Error("the given geometry cannot be empty");const c=i.filter(e=>e[0][0]<0),g=i.filter(e=>e[0][0]>=0);c.length>0&&g.length>0&&"cap"===m&&(c.length>g.length?(i=i.map(e=>{let t=e[0],r=e[1];return[t=[Math.min(t[0],0),t[1]],r=[Math.min(r[0],0),r[1]]]}),t=geom2.create(i),t=mirrorX(t)):g.length>=c.length&&(i=i.map(e=>{let t=e[0],r=e[1];return[t=[Math.max(t[0],0),t[1]],r=[Math.max(r[0],0),r[1]]]}),t=geom2.create(i)));const h=l/a,u=Math.abs(l)<TAU,A=slice.fromSides(geom2.toSides(t));slice.reverse(A,A);const f=mat4.create(),T=mat4.fromXRotation(mat4.create(),TAU/4),U=mat4.create();return extrudeFromSlices(e={numberOfSlices:a+1,capStart:u,capEnd:u,close:!u,callback:(e,t,r)=>{let s=h*t+o;return l===TAU&&t===a&&(s=o),mat4.fromZRotation(U,s),mat4.multiply(f,U,T),slice.transform(f,r)}},A)};module.exports=extrudeRotate;
 
 },{"../../geometries/geom2":25,"../../maths/constants":94,"../../maths/mat4":143,"../transforms/mirror":363,"./extrudeFromSlices":308,"./slice":326}],317:[function(require,module,exports){
-const{EPS:EPS}=require("../../maths/constants"),vec3=require("../../maths/vec3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),gcd=(e,t)=>e===t?e:e<t?gcd(t,e):1===t?1:0===t?e:gcd(t,e%t),lcm=(e,t)=>e*t/gcd(e,t),repartitionEdges=(e,t)=>{const r=e/t.length;if(1===r)return t;const s=vec3.fromValues(r,r,r),c=[];return t.forEach(e=>{const t=vec3.subtract(vec3.create(),e[1],e[0]);vec3.divide(t,t,s);let l=e[0];for(let e=1;e<=r;++e){const e=vec3.add(vec3.create(),l,t);c.push([l,e]),l=e}}),c},EPSAREA=EPS*EPS/2*Math.sin(Math.PI/3),extrudeWalls=(e,t)=>{let r=slice.toEdges(e),s=slice.toEdges(t);if(r.length!==s.length){const e=lcm(r.length,s.length);e!==r.length&&(r=repartitionEdges(e,r)),e!==s.length&&(s=repartitionEdges(e,s))}const c=[];return r.forEach((e,t)=>{const r=s[t],l=poly3.create([e[0],e[1],r[1]]),o=poly3.measureArea(l);Number.isFinite(o)&&o>EPSAREA&&c.push(l);const n=poly3.create([e[0],r[1],r[0]]),i=poly3.measureArea(n);Number.isFinite(i)&&i>EPSAREA&&c.push(n)}),c};module.exports=extrudeWalls;
+const{EPS:EPS}=require("../../maths/constants"),vec3=require("../../maths/vec3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),gcd=(e,t)=>e===t?e:e<t?gcd(t,e):1===t?1:0===t?e:gcd(t,e%t),lcm=(e,t)=>e*t/gcd(e,t),repartitionEdges=(e,t)=>{const r=e/t.length;if(1===r)return t;const s=vec3.fromValues(r,r,r),c=vec3.create(),l=[];return t.forEach(e=>{vec3.subtract(c,e[1],e[0]),vec3.divide(c,c,s);let t=e[0];for(let e=1;e<=r;++e){const e=vec3.add(vec3.create(),t,c);l.push([t,e]),t=e}}),l},EPSAREA=EPS*EPS/2*Math.sin(Math.PI/3),extrudeWalls=(e,t)=>{let r=slice.toEdges(e),s=slice.toEdges(t);if(r.length!==s.length){const e=lcm(r.length,s.length);e!==r.length&&(r=repartitionEdges(e,r)),e!==s.length&&(s=repartitionEdges(e,s))}const c=[];return r.forEach((e,t)=>{const r=s[t],l=poly3.create([e[0],e[1],r[1]]),o=poly3.measureArea(l);Number.isFinite(o)&&o>EPSAREA&&c.push(l);const i=poly3.create([e[0],r[1],r[0]]),n=poly3.measureArea(i);Number.isFinite(n)&&n>EPSAREA&&c.push(i)}),c};module.exports=extrudeWalls;
 
 },{"../../geometries/poly3":79,"../../maths/constants":94,"../../maths/vec3":222,"./slice":326}],318:[function(require,module,exports){
 module.exports={extrudeFromSlices:require("./extrudeFromSlices"),extrudeLinear:require("./extrudeLinear"),extrudeRectangular:require("./extrudeRectangular"),extrudeRotate:require("./extrudeRotate"),extrudeHelical:require("./extrudeHelical"),project:require("./project"),slice:require("./slice")};
@@ -1061,10 +1061,10 @@ const constants=require("../../maths/constants"),vec3=require("../../maths/vec3"
 const aboutEqualNormals=require("../../maths/utils/aboutEqualNormals"),vec3=require("../../maths/vec3"),poly3=require("../../geometries/poly3"),createEdges=e=>{const n=poly3.toPoints(e),t=[];for(let e=0;e<n.length;e++){const l=(e+1)%n.length,r={v1:n[e],v2:n[l]};t.push(r)}for(let e=0;e<t.length;e++){const l=(e+1)%n.length;t[e].next=t[l],t[l].prev=t[e]}return t},insertEdge=(e,n)=>{const t=`${n.v1}:${n.v2}`;e.set(t,n)},deleteEdge=(e,n)=>{const t=`${n.v1}:${n.v2}`;e.delete(t)},findOppositeEdge=(e,n)=>{const t=`${n.v2}:${n.v1}`;return e.get(t)},calculateAnglesBetween=(e,n,t)=>{let l=e.prev.v1,r=e.prev.v2,o=n.next.v2;const v=calculateAngle(l,r,o,t);return l=n.prev.v1,r=n.prev.v2,o=e.next.v2,[v,calculateAngle(l,r,o,t)]},v1=vec3.create(),v2=vec3.create(),calculateAngle=(e,n,t,l)=>{const r=vec3.subtract(v1,n,e),o=vec3.subtract(v2,t,n);return vec3.cross(r,r,o),vec3.dot(r,l)},createPolygonAnd=e=>{let n;const t=[];for(;e.next;){const n=e.next;t.push(e.v1),e.v1=null,e.v2=null,e.next=null,e.prev=null,e=n}return t.length>0&&(n=poly3.create(t)),n},mergeCoplanarPolygons=e=>{if(e.length<2)return e;const n=e[0].plane,t=e.slice(),l=new Map;for(;t.length>0;){const e=t.shift(),r=createEdges(e);for(let e=0;e<r.length;e++){const t=r[e],o=findOppositeEdge(l,t);if(o){const e=calculateAnglesBetween(t,o,n);if(e[0]>=0&&e[1]>=0){const n=o.next,r=t.next;t.prev.next=o.next,t.next.prev=o.prev,o.prev.next=t.next,o.next.prev=t.prev,t.v1=null,t.v2=null,t.next=null,t.prev=null,deleteEdge(l,o),o.v1=null,o.v2=null,o.next=null,o.prev=null;const v=(e,n,t)=>{const l={v1:t.v1,v2:n.v2,next:n.next,prev:t.prev};t.prev.next=l,n.next.prev=l,deleteEdge(e,n),n.v1=null,n.v2=null,n.next=null,n.prev=null,deleteEdge(e,t),t.v1=null,t.v2=null,t.next=null,t.prev=null};0===e[0]&&v(l,n,n.prev),0===e[1]&&v(l,r,r.prev)}}else t.next&&insertEdge(l,t)}}const r=[];return l.forEach(e=>{const n=createPolygonAnd(e);n&&r.push(n)}),l.clear(),r},coplanar=(e,n)=>Math.abs(e[3]-n[3])<1.5e-7&&aboutEqualNormals(e,n),mergePolygons=(e,n)=>{const t=[];n.forEach(e=>{const n=t.find(n=>coplanar(n[0],poly3.plane(e)));if(n){n[1].push(e)}else t.push([poly3.plane(e),[e]])});let l=[];return t.forEach(e=>{const n=e[1],t=mergeCoplanarPolygons(n);l=l.concat(t)}),l};module.exports=mergePolygons;
 
 },{"../../geometries/poly3":79,"../../maths/utils/aboutEqualNormals":167,"../../maths/vec3":222}],355:[function(require,module,exports){
-const{EPS:EPS}=require("../../maths/constants"),line2=require("../../maths/line2"),vec2=require("../../maths/vec2"),OrthoNormalBasis=require("../../maths/OrthoNormalBasis"),interpolateBetween2DPointsForY=require("../../maths/utils/interpolateBetween2DPointsForY"),{insertSorted:insertSorted,fnNumberSort:fnNumberSort}=require("../../utils"),poly3=require("../../geometries/poly3"),reTesselateCoplanarPolygons=t=>{if(t.length<2)return t;const e=[],o=t.length,n=poly3.plane(t[0]),l=new OrthoNormalBasis(n),i=[],r=[],s=new Map,f=new Map,p=new Map,h=10/EPS;for(let e=0;e<o;e++){const o=t[e];let n=[],g=o.vertices.length,c=-1;if(g>0){let t,i;for(let r=0;r<g;r++){let s=l.to2D(o.vertices[r]);const g=Math.floor(s[1]*h);let a;p.has(g)?a=p.get(g):p.has(g+1)?a=p.get(g+1):p.has(g-1)?a=p.get(g-1):(a=s[1],p.set(g,s[1])),s=vec2.fromValues(s[0],a),n.push(s);const u=s[1];(0===r||u<t)&&(t=u,c=r),(0===r||u>i)&&(i=u);let m=f.get(u);m||(m={},f.set(u,m)),m[e]=!0}if(t>=i)n=[],g=0,c=-1;else{let o=s.get(t);o||(o=[],s.set(t,o)),o.push(e)}}n.reverse(),c=g-c-1,i.push(n),r.push(c)}const g=[];f.forEach((t,e)=>g.push(e)),g.sort(fnNumberSort);let c=[],a=[];for(let t=0;t<g.length;t++){const o=[],p=g[t],h=f.get(p);for(let t=0;t<c.length;++t){const e=c[t],o=e.polygonindex;if(h[o]){const n=i[o],l=n.length;let r=e.leftvertexindex,s=e.rightvertexindex;for(;;){let t=r+1;if(t>=l&&(t=0),n[t][1]!==p)break;r=t}let f=s-1;if(f<0&&(f=l-1),n[f][1]===p&&(s=f),r!==e.leftvertexindex&&r===s)c.splice(t,1),--t;else{e.leftvertexindex=r,e.rightvertexindex=s,e.topleft=n[r],e.topright=n[s];let t=r+1;t>=l&&(t=0),e.bottomleft=n[t];let o=s-1;o<0&&(o=l-1),e.bottomright=n[o]}}}let u;if(t>=g.length-1)c=[],u=null;else{const e=.5*(p+(u=Number(g[t+1]))),o=s.get(p);for(const t in o){const n=o[t],l=i[n],s=l.length,f=r[n];let h=f;for(;;){let t=h+1;if(t>=s&&(t=0),l[t][1]!==p)break;if(t===f)break;h=t}let g=f;for(;;){let t=g-1;if(t<0&&(t=s-1),l[t][1]!==p)break;if(t===h)break;g=t}let a=h+1;a>=s&&(a=0);let u=g-1;u<0&&(u=s-1);const m={polygonindex:n,leftvertexindex:h,rightvertexindex:g,topleft:l[h],topright:l[g],bottomleft:l[a],bottomright:l[u]};insertSorted(c,m,(t,o)=>{const n=interpolateBetween2DPointsForY(t.topleft,t.bottomleft,e),l=interpolateBetween2DPointsForY(o.topleft,o.bottomleft,e);return n>l?1:n<l?-1:0})}}for(const t in c){const e=c[t];let n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,p);const l=vec2.fromValues(n,p);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,p);const i=vec2.fromValues(n,p);n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,u);const r=vec2.fromValues(n,u);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,u);const s=vec2.fromValues(n,u),f={topleft:l,topright:i,bottomleft:r,bottomright:s,leftline:line2.fromPoints(line2.create(),l,r),rightline:line2.fromPoints(line2.create(),s,i)};if(o.length>0){const t=o[o.length-1],e=vec2.distance(f.topleft,t.topright),n=vec2.distance(f.bottomleft,t.bottomright);e<EPS&&n<EPS&&(f.topleft=t.topleft,f.leftline=t.leftline,f.bottomleft=t.bottomleft,o.splice(o.length-1,1))}o.push(f)}if(t>0){const t=new Set,i=new Set;for(let e=0;e<o.length;e++){const n=o[e];for(let e=0;e<a.length;e++)if(!i.has(e)){const o=a[e];if(vec2.distance(o.bottomleft,n.topleft)<EPS&&vec2.distance(o.bottomright,n.topright)<EPS){i.add(e);const l=line2.direction(n.leftline),r=line2.direction(o.leftline),s=l[0]-r[0],f=line2.direction(n.rightline),p=line2.direction(o.rightline),h=f[0]-p[0],g=Math.abs(s)<EPS,c=Math.abs(h)<EPS,a=c||h>=0;(g||s>=0)&&a&&(n.outpolygon=o.outpolygon,n.leftlinecontinues=g,n.rightlinecontinues=c,t.add(e));break}}}for(let o=0;o<a.length;o++)if(!t.has(o)){const t=a[o];t.outpolygon.rightpoints.push(t.bottomright),vec2.distance(t.bottomright,t.bottomleft)>EPS&&t.outpolygon.leftpoints.push(t.bottomleft),t.outpolygon.leftpoints.reverse();const i=t.outpolygon.rightpoints.concat(t.outpolygon.leftpoints).map(t=>l.to3D(t)),r=poly3.fromPointsAndPlane(i,n);r.vertices.length&&e.push(r)}}for(let t=0;t<o.length;t++){const e=o[t];e.outpolygon?(e.leftlinecontinues||e.outpolygon.leftpoints.push(e.topleft),e.rightlinecontinues||e.outpolygon.rightpoints.push(e.topright)):(e.outpolygon={leftpoints:[],rightpoints:[]},e.outpolygon.leftpoints.push(e.topleft),vec2.distance(e.topleft,e.topright)>EPS&&e.outpolygon.rightpoints.push(e.topright))}a=o}return e};module.exports=reTesselateCoplanarPolygons;
+const{EPS:EPS}=require("../../maths/constants"),line2=require("../../maths/line2"),vec2=require("../../maths/vec2"),OrthoNormalBasis=require("../../maths/OrthoNormalBasis"),interpolateBetween2DPointsForY=require("../../maths/utils/interpolateBetween2DPointsForY"),{insertSorted:insertSorted,fnNumberSort:fnNumberSort}=require("../../utils"),poly3=require("../../geometries/poly3"),reTesselateCoplanarPolygons=t=>{if(t.length<2)return t;const e=[],o=t.length,n=poly3.plane(t[0]),l=new OrthoNormalBasis(n),i=[],r=[],s=new Map,f=new Map,p=new Map,h=10/EPS;for(let e=0;e<o;e++){const o=t[e];let n=[],g=o.vertices.length,a=-1;if(g>0){let t,i;for(let r=0;r<g;r++){let s=l.to2D(o.vertices[r]);const g=Math.floor(s[1]*h);let c;p.has(g)?c=p.get(g):p.has(g+1)?c=p.get(g+1):p.has(g-1)?c=p.get(g-1):(c=s[1],p.set(g,s[1])),s=vec2.fromValues(s[0],c),n.push(s);const u=s[1];(0===r||u<t)&&(t=u,a=r),(0===r||u>i)&&(i=u);let m=f.get(u);m||(m={},f.set(u,m)),m[e]=!0}if(t>=i)n=[],g=0,a=-1;else{let o=s.get(t);o||(o=[],s.set(t,o)),o.push(e)}}n.reverse(),a=g-a-1,i.push(n),r.push(a)}const g=[];f.forEach((t,e)=>g.push(e)),g.sort(fnNumberSort);let a=[],c=[];for(let t=0;t<g.length;t++){const o=[],p=g[t],h=f.get(p);let u,m=0;for(let t=0;t<a.length;++t){const e=a[t],o=e.polygonindex;if(h[o]){const t=i[o],n=t.length;let l=e.leftvertexindex,r=e.rightvertexindex;for(;;){let e=l+1;if(e>=n&&(e=0),t[e][1]!==p)break;l=e}let s=r-1;if(s<0&&(s=n-1),t[s][1]===p&&(r=s),l!==e.leftvertexindex&&l===r)e._remove=!0,m++;else{e.leftvertexindex=l,e.rightvertexindex=r,e.topleft=t[l],e.topright=t[r];let o=l+1;o>=n&&(o=0),e.bottomleft=t[o];let i=r-1;i<0&&(i=n-1),e.bottomright=t[i]}}}if(m>0&&(a=a.filter(t=>!t._remove)),t>=g.length-1)a=[],u=null;else{const e=.5*(p+(u=Number(g[t+1]))),o=s.get(p);for(const t in o){const n=o[t],l=i[n],s=l.length,f=r[n];let h=f;for(;;){let t=h+1;if(t>=s&&(t=0),l[t][1]!==p)break;if(t===f)break;h=t}let g=f;for(;;){let t=g-1;if(t<0&&(t=s-1),l[t][1]!==p)break;if(t===h)break;g=t}let c=h+1;c>=s&&(c=0);let u=g-1;u<0&&(u=s-1);const m={polygonindex:n,leftvertexindex:h,rightvertexindex:g,topleft:l[h],topright:l[g],bottomleft:l[c],bottomright:l[u]};insertSorted(a,m,(t,o)=>{const n=interpolateBetween2DPointsForY(t.topleft,t.bottomleft,e),l=interpolateBetween2DPointsForY(o.topleft,o.bottomleft,e);return n>l?1:n<l?-1:0})}}for(const t in a){const e=a[t];let n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,p);const l=vec2.fromValues(n,p);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,p);const i=vec2.fromValues(n,p);n=interpolateBetween2DPointsForY(e.topleft,e.bottomleft,u);const r=vec2.fromValues(n,u);n=interpolateBetween2DPointsForY(e.topright,e.bottomright,u);const s=vec2.fromValues(n,u),f={topleft:l,topright:i,bottomleft:r,bottomright:s,leftline:line2.fromPoints(line2.create(),l,r),rightline:line2.fromPoints(line2.create(),s,i)};if(o.length>0){const t=o[o.length-1],e=vec2.distance(f.topleft,t.topright),n=vec2.distance(f.bottomleft,t.bottomright);e<EPS&&n<EPS&&(f.topleft=t.topleft,f.leftline=t.leftline,f.bottomleft=t.bottomleft,o.splice(o.length-1,1))}o.push(f)}if(t>0){const t=new Set,i=new Set;for(let e=0;e<o.length;e++){const n=o[e];for(let e=0;e<c.length;e++)if(!i.has(e)){const o=c[e];if(vec2.distance(o.bottomleft,n.topleft)<EPS&&vec2.distance(o.bottomright,n.topright)<EPS){i.add(e);const l=line2.direction(n.leftline),r=line2.direction(o.leftline),s=l[0]-r[0],f=line2.direction(n.rightline),p=line2.direction(o.rightline),h=f[0]-p[0],g=Math.abs(s)<EPS,a=Math.abs(h)<EPS,c=a||h>=0;(g||s>=0)&&c&&(n.outpolygon=o.outpolygon,n.leftlinecontinues=g,n.rightlinecontinues=a,t.add(e));break}}}for(let o=0;o<c.length;o++)if(!t.has(o)){const t=c[o];t.outpolygon.rightpoints.push(t.bottomright),vec2.distance(t.bottomright,t.bottomleft)>EPS&&t.outpolygon.leftpoints.push(t.bottomleft),t.outpolygon.leftpoints.reverse();const i=t.outpolygon.rightpoints.concat(t.outpolygon.leftpoints).map(t=>l.to3D(t)),r=poly3.fromPointsAndPlane(i,n);r.vertices.length&&e.push(r)}}for(let t=0;t<o.length;t++){const e=o[t];e.outpolygon?(e.leftlinecontinues||e.outpolygon.leftpoints.push(e.topleft),e.rightlinecontinues||e.outpolygon.rightpoints.push(e.topright)):(e.outpolygon={leftpoints:[],rightpoints:[]},e.outpolygon.leftpoints.push(e.topleft),vec2.distance(e.topleft,e.topright)>EPS&&e.outpolygon.rightpoints.push(e.topright))}c=o}return e};module.exports=reTesselateCoplanarPolygons;
 
 },{"../../geometries/poly3":79,"../../maths/OrthoNormalBasis":93,"../../maths/constants":94,"../../maths/line2":105,"../../maths/utils/interpolateBetween2DPointsForY":170,"../../maths/vec2":191,"../../utils":400}],356:[function(require,module,exports){
-const geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),{NEPS:NEPS}=require("../../maths/constants"),reTesselateCoplanarPolygons=require("./reTesselateCoplanarPolygons"),retessellate=e=>{if(e.isRetesselated)return e;const s=geom3.toPolygons(e).map((e,s)=>({vertices:e.vertices,plane:poly3.plane(e),index:s})),o=classifyPolygons(s),l=[];o.forEach(e=>{if(Array.isArray(e)){const s=reTesselateCoplanarPolygons(e);l.push(...s)}else l.push(e)});const n=geom3.create(l);return n.isRetesselated=!0,n},classifyPolygons=e=>{let s=[e];const o=[];for(let e=3;e>=0;e--){const l=[],n=3===e?1.5e-8:NEPS;s.forEach(s=>{s.sort(byPlaneComponent(e,n));let t=0;for(let r=1;r<s.length;r++)s[r].plane[e]-s[t].plane[e]>n&&(r-t==1?o.push(s[t]):l.push(s.slice(t,r)),t=r);s.length-t==1?o.push(s[t]):l.push(s.slice(t))}),s=l}const l=[];return s.forEach(e=>{e[0]&&(l[e[0].index]=e)}),o.forEach(e=>{l[e.index]=e}),l},byPlaneComponent=(e,s)=>(o,l)=>o.plane[e]-l.plane[e]>s?1:l.plane[e]-o.plane[e]>s?-1:0;module.exports=retessellate;
+const geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),{NEPS:NEPS}=require("../../maths/constants"),reTesselateCoplanarPolygons=require("./reTesselateCoplanarPolygons"),retessellate=e=>{if(e.isRetesselated)return e;const s=geom3.toPolygons(e).map((e,s)=>({vertices:e.vertices,plane:poly3.plane(e),index:s})),o=classifyPolygons(s),l=[];o.forEach(e=>{if(Array.isArray(e)){const s=reTesselateCoplanarPolygons(e);for(let e=0;e<s.length;e++)l.push(s[e])}else l.push(e)});const t=geom3.create(l);return t.isRetesselated=!0,t},classifyPolygons=e=>{let s=[e];const o=[];for(let e=3;e>=0;e--){const l=[],t=3===e?1.5e-8:NEPS;s.forEach(s=>{s.sort(byPlaneComponent(e,t));let n=0;for(let r=1;r<s.length;r++)s[r].plane[e]-s[n].plane[e]>t&&(r-n==1?o.push(s[n]):l.push(s.slice(n,r)),n=r);s.length-n==1?o.push(s[n]):l.push(s.slice(n))}),s=l}const l=[];return s.forEach(e=>{e[0]&&(l[e[0].index]=e)}),o.forEach(e=>{l[e.index]=e}),l},byPlaneComponent=(e,s)=>(o,l)=>o.plane[e]-l.plane[e]>s?1:l.plane[e]-o.plane[e]>s?-1:0;module.exports=retessellate;
 
 },{"../../geometries/geom3":41,"../../geometries/poly3":79,"../../maths/constants":94,"./reTesselateCoplanarPolygons":355}],357:[function(require,module,exports){
 const flatten=require("../../utils/flatten"),vec2=require("../../maths/vec2"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),path2=require("../../geometries/path2"),measureEpsilon=require("../../measurements/measureEpsilon"),snapPolygons=require("./snapPolygons"),snapPath2=e=>{const s=measureEpsilon(e),r=path2.toPoints(e).map(e=>vec2.snap(vec2.create(),e,s));return path2.create(r)},snapGeom2=e=>{const s=measureEpsilon(e);let r=geom2.toSides(e).map(e=>[vec2.snap(vec2.create(),e[0],s),vec2.snap(vec2.create(),e[1],s)]);return r=r.filter(e=>!vec2.equals(e[0],e[1])),geom2.create(r)},snapGeom3=e=>{const s=measureEpsilon(e),r=geom3.toPolygons(e),o=snapPolygons(s,r);return geom3.create(o)},snap=(...e)=>{if(0===(e=flatten(e)).length)throw new Error("wrong number of arguments");const s=e.map(e=>path2.isA(e)?snapPath2(e):geom2.isA(e)?snapGeom2(e):geom3.isA(e)?snapGeom3(e):e);return 1===s.length?s[0]:s};module.exports=snap;
@@ -1190,7 +1190,7 @@ const geom2=require("../geometries/geom2"),geom3=require("../geometries/geom3"),
 const degToRad=d=>.017453292519943295*d;module.exports=degToRad;
 
 },{}],398:[function(require,module,exports){
-const flatten=t=>t.reduce((t,a)=>Array.isArray(a)?t.concat(flatten(a)):t.concat(a),[]);module.exports=flatten;
+const flatten=t=>{const e=[],r=[t];for(;r.length;){const t=r.pop();if(Array.isArray(t))for(let e=t.length-1;e>=0;e--)r.push(t[e]);else e.push(t)}return e};module.exports=flatten;
 
 },{}],399:[function(require,module,exports){
 const fnNumberSort=(o,r)=>o-r;module.exports=fnNumberSort;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbroll/jscad-modeling",
-  "version": "2.12.7",
+  "version": "2.12.8",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD (performance-optimized fork)",
   "homepage": "https://github.com/jbroll/OpenJSCAD.org",
   "repository": "https://github.com/jbroll/OpenJSCAD.org",

package/src/operations/booleans/trees/PolygonTreeNode.js

@@ -49,11 +49,11 @@ class PolygonTreeNode {
       this.removed = true
       this.polygon = null
 
-      // remove ourselves from the parent's children list:
-      const parentschildren = this.parent.children
-      const i = parentschildren.indexOf(this)
-      if (i < 0) throw new Error('Assertion failed')
-      parentschildren.splice(i, 1)
+      // Note: We intentionally do NOT splice from parent.children here.
+      // All iteration paths (getPolygons, splitByPlane, clipPolygons) already
+      // check isRemoved() or polygon !== null, so removed nodes are skipped.
+      // Avoiding splice eliminates O(n²) cost when many nodes are removed.
+      // Dead nodes are cleaned up lazily in getPolygons().
 
       // invalidate the parent's polygon, and of all parents above it:
       this.parent.recursivelyInvalidatePolygon()
@@ -80,6 +80,15 @@ class PolygonTreeNode {
   }
 
   getPolygons (result) {
+    // Compact root's children array to remove dead nodes (lazy cleanup from remove()).
+    // Note: This method is only called on the root node via Tree.allPolygons() at the
+    // end of boolean operations. The children array is internal and not exposed, so
+    // mutating it here is safe. Non-root nodes are traversed via the queue below,
+    // which skips removed nodes via the `if (node.polygon)` check.
+    if (this.isRootNode() && this.children.length > 0) {
+      this.children = this.children.filter((c) => !c.removed)
+    }
+
     let children = [this]
     const queue = [children]
     let i, j, l, node

package/src/operations/booleans/unionGeom3.test.js

@@ -131,3 +131,38 @@ test('union of geom3 with rounding issues #137', (t) => {
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6) // number of polygons in union
 })
+
+// Test for push loop optimization: verify union works correctly with multiple geometries
+// This ensures the concat-to-push-loop optimization handles array merging properly
+test('union of geom3 with multiple overlapping geometries', (t) => {
+  // Create several overlapping cuboids to generate a complex union
+  const geometry1 = cuboid({ size: [10, 10, 10] })
+  const geometry2 = center({ relativeTo: [5, 0, 0] }, cuboid({ size: [10, 10, 10] }))
+  const geometry3 = center({ relativeTo: [0, 5, 0] }, cuboid({ size: [10, 10, 10] }))
+
+  // Union should work correctly with multiple geometries
+  const obs = union(geometry1, geometry2, geometry3)
+  const pts = geom3.toPoints(obs)
+
+  // Skip manifold validation - focus on testing polygon merging works correctly
+  // (CSG on overlapping boxes can produce non-manifold edges at coplanar faces)
+  // Should produce a merged geometry with polygons from all inputs
+  t.true(pts.length > 6) // more than a single cube
+})
+
+// Test for push loop optimization: verify non-overlapping geometries combine correctly
+test('union of multiple non-overlapping geom3 preserves all polygons', (t) => {
+  // Create multiple small cuboids that don't overlap
+  const cubes = []
+  for (let i = 0; i < 10; i++) {
+    cubes.push(center({ relativeTo: [i * 5, 0, 0] }, cuboid({ size: [2, 2, 2] })))
+  }
+
+  // Union all of them
+  const obs = union(...cubes)
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  // Each cuboid has 6 faces, so 10 cuboids = 60 polygons
+  t.is(pts.length, 60)
+})

package/src/operations/extrusions/extrudeRotate.js

@@ -114,13 +114,16 @@ const extrudeRotate = (options, geometry) => {
   slice.reverse(baseSlice, baseSlice)
 
   const matrix = mat4.create()
+  const xRotationMatrix = mat4.fromXRotation(mat4.create(), TAU / 4) // compute once, reuse
+  const zRotationMatrix = mat4.create() // reuse for Z rotation
   const createSlice = (progress, index, base) => {
     let Zrotation = rotationPerSlice * index + startAngle
     // fix rounding error when rotating TAU radians
     if (totalRotation === TAU && index === segments) {
       Zrotation = startAngle
     }
-    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), TAU / 4))
+    mat4.fromZRotation(zRotationMatrix, Zrotation)
+    mat4.multiply(matrix, zRotationMatrix, xRotationMatrix)
 
     return slice.transform(matrix, base)
   }

package/src/operations/extrusions/extrudeRotate.test.js

@@ -158,4 +158,37 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
+// Test for mat4 reuse optimization: verify rotation matrices are computed correctly
+// This ensures the optimization of computing xRotationMatrix once doesn't break anything
+test('extrudeRotate: (mat4 reuse) rotation matrices produce correct geometry', (t) => {
+  // Simple rectangle that will be rotated to form a tube-like shape
+  const geometry2 = geom2.fromPoints([[5, -1], [5, 1], [6, 1], [6, -1]])
+
+  // Full rotation with many segments to test matrix reuse across iterations
+  const geometry3 = extrudeRotate({ segments: 32 }, geometry2)
+  const pts = geom3.toPoints(geometry3)
+
+  t.notThrows(() => geom3.validate(geometry3))
+  // 32 segments * 8 walls per segment (4 edges * 2 triangles) = 256 polygons
+  t.is(pts.length, 256)
+
+  // Verify the geometry is closed (first and last slices connect properly)
+  // This tests the Zrotation rounding error fix at index === segments
+  const geometry3b = extrudeRotate({ segments: 16 }, geometry2)
+  t.notThrows(() => geom3.validate(geometry3b))
+})
+
+// Test for mat4 reuse with partial rotation (tests both capped and matrix reuse)
+test('extrudeRotate: (mat4 reuse) partial rotation produces correct caps', (t) => {
+  const geometry2 = geom2.fromPoints([[5, -1], [5, 1], [6, 1], [6, -1]])
+
+  // Quarter rotation - should have start and end caps
+  const geometry3 = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry2)
+  const pts = geom3.toPoints(geometry3)
+
+  t.notThrows(() => geom3.validate(geometry3))
+  // Should produce valid geometry with caps
+  t.true(pts.length > 0)
+})
+
 // TEST HOLES

package/src/operations/extrusions/extrudeWalls.js

@@ -26,10 +26,11 @@ const repartitionEdges = (newlength, edges) => {
   }
 
   const divisor = vec3.fromValues(multiple, multiple, multiple)
+  const increment = vec3.create() // reuse across all edge iterations
 
   const newEdges = []
   edges.forEach((edge) => {
-    const increment = vec3.subtract(vec3.create(), edge[1], edge[0])
+    vec3.subtract(increment, edge[1], edge[0])
     vec3.divide(increment, increment, divisor)
 
     // repartition the edge

package/src/operations/extrusions/extrudeWalls.test.js

@@ -80,3 +80,75 @@ test('extrudeWalls (different shapes)', (t) => {
   walls = extrudeWalls(slice3, slice.transform(matrix, slice2))
   t.is(walls.length, 24)
 })
+
+// Test for vec3 reuse optimization in repartitionEdges
+// When shapes have different edge counts, edges are repartitioned using vec3 operations
+test('extrudeWalls (repartitionEdges vec3 reuse)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 5])
+
+  // Triangle (3 edges)
+  const triangle = [
+    [[0, 10], [-8.66, -5]],
+    [[-8.66, -5], [8.66, -5]],
+    [[8.66, -5], [0, 10]]
+  ]
+
+  // Hexagon (6 edges) - LCM with triangle is 6, so triangle edges get split
+  const hexagon = [
+    [[0, 10], [-8.66, 5]],
+    [[-8.66, 5], [-8.66, -5]],
+    [[-8.66, -5], [0, -10]],
+    [[0, -10], [8.66, -5]],
+    [[8.66, -5], [8.66, 5]],
+    [[8.66, 5], [0, 10]]
+  ]
+
+  const sliceTriangle = slice.fromSides(triangle)
+  const sliceHexagon = slice.fromSides(hexagon)
+
+  // Triangle to hexagon requires repartitioning (3 -> 6 edges)
+  // This exercises the vec3 reuse optimization in repartitionEdges
+  const walls = extrudeWalls(sliceTriangle, slice.transform(matrix, sliceHexagon))
+
+  // 6 edges * 2 triangles per edge = 12 wall polygons
+  t.is(walls.length, 12)
+
+  // Verify all walls are valid triangles
+  walls.forEach((wall) => {
+    t.is(wall.vertices.length, 3)
+  })
+})
+
+// Test for vec3 reuse with higher repartition multiple
+test('extrudeWalls (repartitionEdges with high multiple)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
+
+  // Square (4 edges)
+  const square = [
+    [[-5, 5], [-5, -5]],
+    [[-5, -5], [5, -5]],
+    [[5, -5], [5, 5]],
+    [[5, 5], [-5, 5]]
+  ]
+
+  // Octagon (8 edges) - LCM with square is 8, so square edges get doubled
+  const octagon = [
+    [[0, 5], [-3.54, 3.54]],
+    [[-3.54, 3.54], [-5, 0]],
+    [[-5, 0], [-3.54, -3.54]],
+    [[-3.54, -3.54], [0, -5]],
+    [[0, -5], [3.54, -3.54]],
+    [[3.54, -3.54], [5, 0]],
+    [[5, 0], [3.54, 3.54]],
+    [[3.54, 3.54], [0, 5]]
+  ]
+
+  const sliceSquare = slice.fromSides(square)
+  const sliceOctagon = slice.fromSides(octagon)
+
+  // Square to octagon requires repartitioning (4 -> 8 edges)
+  const walls = extrudeWalls(sliceSquare, slice.transform(matrix, sliceOctagon))
+
+  // 8 edges * 2 triangles per edge = 16 wall polygons
+  t.is(walls.length, 16)
+})

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -120,6 +120,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
     //   at the the left and right side of the polygon
     // Iterate over all polygons that have a corner at this y coordinate:
     const polygonindexeswithcorner = ycoordinatetopolygonindexes.get(ycoordinate)
+    let removeCount = 0 // track removals to filter at end (avoids O(n²) splice)
     for (let activepolygonindex = 0; activepolygonindex < activepolygons.length; ++activepolygonindex) {
       const activepolygon = activepolygons[activepolygonindex]
       const polygonindex = activepolygon.polygonindex
@@ -143,9 +144,9 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         }
         if ((newleftvertexindex !== activepolygon.leftvertexindex) && (newleftvertexindex === newrightvertexindex)) {
           // We have increased leftvertexindex or decreased rightvertexindex, and now they point to the same vertex
-          // This means that this is the bottom point of the polygon. We'll remove it:
-          activepolygons.splice(activepolygonindex, 1)
-          --activepolygonindex
+          // This means that this is the bottom point of the polygon. Mark it for removal:
+          activepolygon._remove = true
+          removeCount++
         } else {
           activepolygon.leftvertexindex = newleftvertexindex
           activepolygon.rightvertexindex = newrightvertexindex
@@ -160,6 +161,10 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         }
       } // if polygon has corner here
     } // for activepolygonindex
+    // Filter out marked polygons in single pass (O(n) instead of O(n²) splice)
+    if (removeCount > 0) {
+      activepolygons = activepolygons.filter((p) => !p._remove)
+    }
     let nextycoordinate
     if (yindex >= ycoordinates.length - 1) {
       // last row, all polygons must be finished here:

package/src/operations/modifiers/reTesselateCoplanarPolygons.test.js

@@ -16,7 +16,7 @@ const rotatePoly3 = (angles, polygon) => {
   return poly3.transform(matrix, polygon)
 }
 
-test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
+test('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
   const polyA = poly3.create([[-5, -5, 0], [5, -5, 0], [5, 5, 0], [-5, 5, 0]])
   const polyB = poly3.create([[5, -5, 0], [8, 0, 0], [5, 5, 0]])
   const polyC = poly3.create([[-5, 5, 0], [-8, 0, 0], [-5, -5, 0]])
@@ -68,3 +68,38 @@ test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) =>
   obs = reTesselateCoplanarPolygons([polyH, polyI, polyJ, polyK, polyL])
   t.is(obs.length, 1)
 })
+
+// Test for mark-and-filter optimization: multiple polygons that reach their
+// bottom point at the same y-coordinate (triggering the removal code path)
+test('retessellateCoplanarPolygons: should correctly handle multiple polygon removals', (t) => {
+  // Create multiple triangular polygons that all end at the same y-coordinate
+  // This exercises the mark-and-filter removal optimization
+  const poly1 = poly3.create([[0, 0, 0], [2, 0, 0], [1, 3, 0]]) // triangle pointing up
+  const poly2 = poly3.create([[3, 0, 0], [5, 0, 0], [4, 3, 0]]) // triangle pointing up
+  const poly3a = poly3.create([[6, 0, 0], [8, 0, 0], [7, 3, 0]]) // triangle pointing up
+
+  // These polygons share the same plane and have vertices at y=0 and y=3
+  // During retessellation, all three will be active and then removed at y=3
+  const obs = reTesselateCoplanarPolygons([poly1, poly2, poly3a])
+
+  // Each triangle should be preserved (they don't overlap)
+  t.is(obs.length, 3)
+
+  // Verify each polygon has 3 vertices (triangles)
+  obs.forEach((polygon) => {
+    t.is(polygon.vertices.length, 3)
+  })
+})
+
+// Test for mark-and-filter with overlapping polygons that get merged
+test('retessellateCoplanarPolygons: should merge adjacent polygons with shared edges', (t) => {
+  // Two adjacent squares sharing an edge at x=5
+  const poly1 = poly3.create([[0, 0, 0], [5, 0, 0], [5, 5, 0], [0, 5, 0]])
+  const poly2 = poly3.create([[5, 0, 0], [10, 0, 0], [10, 5, 0], [5, 5, 0]])
+
+  const obs = reTesselateCoplanarPolygons([poly1, poly2])
+
+  // Should merge into a single rectangle
+  t.is(obs.length, 1)
+  t.is(obs[0].vertices.length, 4) // rectangle has 4 vertices
+})

package/src/operations/modifiers/retessellate.js

@@ -22,8 +22,11 @@ const retessellate = (geometry) => {
   const destPolygons = []
   classified.forEach((group) => {
     if (Array.isArray(group)) {
-      const reTessellateCoplanarPolygons = reTesselateCoplanarPolygons(group)
-      destPolygons.push(...reTessellateCoplanarPolygons)
+      const coplanarPolygons = reTesselateCoplanarPolygons(group)
+      // Use loop instead of spread to avoid stack overflow with large arrays
+      for (let i = 0; i < coplanarPolygons.length; i++) {
+        destPolygons.push(coplanarPolygons[i])
+      }
     } else {
       destPolygons.push(group)
     }