@richardmcquiston01/more-open-scad 0.2.0

package/dist/index.js

@@ -0,0 +1,1016 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/geometry/polygon.ts
+var exports_polygon = {};
+__export(exports_polygon, {
+  flip: () => flip3,
+  polygon: () => polygon
+});
+
+// src/geometry/plane.ts
+var exports_plane = {};
+__export(exports_plane, {
+  equals: () => equals2,
+  flip: () => flip,
+  fromPoints: () => fromPoints,
+  signedDistance: () => signedDistance
+});
+
+// src/math/epsilon.ts
+var EPSILON = 0.000000001;
+function almostEqual(a, b, tolerance = EPSILON) {
+  return Math.abs(a - b) <= tolerance;
+}
+
+// src/math/vec3.ts
+var exports_vec3 = {};
+__export(exports_vec3, {
+  ZERO: () => ZERO,
+  add: () => add,
+  cross: () => cross,
+  dot: () => dot,
+  equals: () => equals,
+  length: () => length,
+  lerp: () => lerp,
+  negate: () => negate,
+  normalize: () => normalize,
+  scale: () => scale,
+  sub: () => sub,
+  vec3: () => vec3
+});
+function vec3(x, y, z) {
+  return { x, y, z };
+}
+var ZERO = vec3(0, 0, 0);
+function add(a, b) {
+  return vec3(a.x + b.x, a.y + b.y, a.z + b.z);
+}
+function sub(a, b) {
+  return vec3(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+function scale(v, s) {
+  return vec3(v.x * s, v.y * s, v.z * s);
+}
+function negate(v) {
+  return vec3(-v.x, -v.y, -v.z);
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function cross(a, b) {
+  return vec3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+}
+function length(v) {
+  return Math.hypot(v.x, v.y, v.z);
+}
+function normalize(v) {
+  const len = length(v);
+  if (len <= EPSILON) {
+    return ZERO;
+  }
+  return scale(v, 1 / len);
+}
+function lerp(a, b, t) {
+  return add(a, scale(sub(b, a), t));
+}
+function equals(a, b, tolerance = EPSILON) {
+  return almostEqual(a.x, b.x, tolerance) && almostEqual(a.y, b.y, tolerance) && almostEqual(a.z, b.z, tolerance);
+}
+
+// src/geometry/plane.ts
+function fromPoints(a, b, c) {
+  const normal = normalize(cross(sub(b, a), sub(c, a)));
+  return { normal, w: dot(normal, a) };
+}
+function signedDistance(plane, point) {
+  return dot(plane.normal, point) - plane.w;
+}
+function flip(plane) {
+  return { normal: negate(plane.normal), w: -plane.w };
+}
+function equals2(a, b, tolerance = EPSILON) {
+  return equals(a.normal, b.normal, tolerance) && Math.abs(a.w - b.w) <= tolerance;
+}
+
+// src/geometry/vertex.ts
+var exports_vertex = {};
+__export(exports_vertex, {
+  equals: () => equals3,
+  flip: () => flip2,
+  lerp: () => lerp2,
+  vertex: () => vertex
+});
+function vertex(pos, normal) {
+  return { pos, normal };
+}
+function lerp2(a, b, t) {
+  return vertex(lerp(a.pos, b.pos, t), normalize(lerp(a.normal, b.normal, t)));
+}
+function flip2(v) {
+  return vertex(v.pos, negate(v.normal));
+}
+function equals3(a, b, tolerance) {
+  return equals(a.pos, b.pos, tolerance) && equals(a.normal, b.normal, tolerance);
+}
+
+// src/geometry/polygon.ts
+function polygon(vertices) {
+  const [v0, v1, v2] = vertices;
+  if (!v0 || !v1 || !v2) {
+    throw new Error(`Polygon requires at least 3 vertices, got ${vertices.length}`);
+  }
+  return { vertices, plane: fromPoints(v0.pos, v1.pos, v2.pos) };
+}
+function flip3(p) {
+  return {
+    vertices: [...p.vertices].reverse().map(flip2),
+    plane: flip(p.plane)
+  };
+}
+
+// src/math/mat4.ts
+var exports_mat4 = {};
+__export(exports_mat4, {
+  IDENTITY: () => IDENTITY,
+  determinant: () => determinant,
+  equals: () => equals4,
+  invert: () => invert,
+  multiply: () => multiply,
+  reflection: () => reflection,
+  rotationAxisAngle: () => rotationAxisAngle,
+  rotationX: () => rotationX,
+  rotationY: () => rotationY,
+  rotationZ: () => rotationZ,
+  scaling: () => scaling,
+  transformDirection: () => transformDirection,
+  transformPoint: () => transformPoint,
+  translation: () => translation,
+  transpose: () => transpose
+});
+function mat4(e) {
+  return { e };
+}
+var IDENTITY = mat4([
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+function translation(v) {
+  return mat4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, v.x, v.y, v.z, 1]);
+}
+function scaling(v) {
+  return mat4([v.x, 0, 0, 0, 0, v.y, 0, 0, 0, 0, v.z, 0, 0, 0, 0, 1]);
+}
+function rotationX(radians) {
+  const c = Math.cos(radians);
+  const s = Math.sin(radians);
+  return mat4([1, 0, 0, 0, 0, c, s, 0, 0, -s, c, 0, 0, 0, 0, 1]);
+}
+function rotationY(radians) {
+  const c = Math.cos(radians);
+  const s = Math.sin(radians);
+  return mat4([c, 0, -s, 0, 0, 1, 0, 0, s, 0, c, 0, 0, 0, 0, 1]);
+}
+function rotationZ(radians) {
+  const c = Math.cos(radians);
+  const s = Math.sin(radians);
+  return mat4([c, s, 0, 0, -s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+}
+function rotationAxisAngle(axis, radians) {
+  const len = Math.hypot(axis.x, axis.y, axis.z);
+  if (len <= EPSILON) {
+    return IDENTITY;
+  }
+  const x = axis.x / len;
+  const y = axis.y / len;
+  const z = axis.z / len;
+  const c = Math.cos(radians);
+  const s = Math.sin(radians);
+  const t = 1 - c;
+  return mat4([
+    t * x * x + c,
+    t * x * y + s * z,
+    t * x * z - s * y,
+    0,
+    t * x * y - s * z,
+    t * y * y + c,
+    t * y * z + s * x,
+    0,
+    t * x * z + s * y,
+    t * y * z - s * x,
+    t * z * z + c,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+}
+function reflection(normal) {
+  const len = Math.hypot(normal.x, normal.y, normal.z);
+  if (len <= EPSILON) {
+    return IDENTITY;
+  }
+  const x = normal.x / len;
+  const y = normal.y / len;
+  const z = normal.z / len;
+  return mat4([
+    1 - 2 * x * x,
+    -2 * x * y,
+    -2 * x * z,
+    0,
+    -2 * x * y,
+    1 - 2 * y * y,
+    -2 * y * z,
+    0,
+    -2 * x * z,
+    -2 * y * z,
+    1 - 2 * z * z,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+}
+function multiply(a, b) {
+  const [
+    a00,
+    a01,
+    a02,
+    a03,
+    a10,
+    a11,
+    a12,
+    a13,
+    a20,
+    a21,
+    a22,
+    a23,
+    a30,
+    a31,
+    a32,
+    a33
+  ] = a.e;
+  const [
+    b00,
+    b01,
+    b02,
+    b03,
+    b10,
+    b11,
+    b12,
+    b13,
+    b20,
+    b21,
+    b22,
+    b23,
+    b30,
+    b31,
+    b32,
+    b33
+  ] = b.e;
+  return mat4([
+    a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03,
+    a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03,
+    a02 * b00 + a12 * b01 + a22 * b02 + a32 * b03,
+    a03 * b00 + a13 * b01 + a23 * b02 + a33 * b03,
+    a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13,
+    a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13,
+    a02 * b10 + a12 * b11 + a22 * b12 + a32 * b13,
+    a03 * b10 + a13 * b11 + a23 * b12 + a33 * b13,
+    a00 * b20 + a10 * b21 + a20 * b22 + a30 * b23,
+    a01 * b20 + a11 * b21 + a21 * b22 + a31 * b23,
+    a02 * b20 + a12 * b21 + a22 * b22 + a32 * b23,
+    a03 * b20 + a13 * b21 + a23 * b22 + a33 * b23,
+    a00 * b30 + a10 * b31 + a20 * b32 + a30 * b33,
+    a01 * b30 + a11 * b31 + a21 * b32 + a31 * b33,
+    a02 * b30 + a12 * b31 + a22 * b32 + a32 * b33,
+    a03 * b30 + a13 * b31 + a23 * b32 + a33 * b33
+  ]);
+}
+function transpose(m) {
+  const [
+    m00,
+    m01,
+    m02,
+    m03,
+    m10,
+    m11,
+    m12,
+    m13,
+    m20,
+    m21,
+    m22,
+    m23,
+    m30,
+    m31,
+    m32,
+    m33
+  ] = m.e;
+  return mat4([
+    m00,
+    m10,
+    m20,
+    m30,
+    m01,
+    m11,
+    m21,
+    m31,
+    m02,
+    m12,
+    m22,
+    m32,
+    m03,
+    m13,
+    m23,
+    m33
+  ]);
+}
+function minors(m) {
+  const [
+    m00,
+    m01,
+    m02,
+    m03,
+    m10,
+    m11,
+    m12,
+    m13,
+    m20,
+    m21,
+    m22,
+    m23,
+    m30,
+    m31,
+    m32,
+    m33
+  ] = m.e;
+  const b00 = m00 * m11 - m01 * m10;
+  const b01 = m00 * m12 - m02 * m10;
+  const b02 = m00 * m13 - m03 * m10;
+  const b03 = m01 * m12 - m02 * m11;
+  const b04 = m01 * m13 - m03 * m11;
+  const b05 = m02 * m13 - m03 * m12;
+  const b06 = m20 * m31 - m21 * m30;
+  const b07 = m20 * m32 - m22 * m30;
+  const b08 = m20 * m33 - m23 * m30;
+  const b09 = m21 * m32 - m22 * m31;
+  const b10 = m21 * m33 - m23 * m31;
+  const b11 = m22 * m33 - m23 * m32;
+  const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  return {
+    m00,
+    m01,
+    m02,
+    m03,
+    m10,
+    m11,
+    m12,
+    m13,
+    m20,
+    m21,
+    m22,
+    m23,
+    m30,
+    m31,
+    m32,
+    m33,
+    b00,
+    b01,
+    b02,
+    b03,
+    b04,
+    b05,
+    b06,
+    b07,
+    b08,
+    b09,
+    b10,
+    b11,
+    det
+  };
+}
+function determinant(m) {
+  return minors(m).det;
+}
+function invert(m) {
+  const {
+    m00,
+    m01,
+    m02,
+    m03,
+    m10,
+    m11,
+    m12,
+    m13,
+    m20,
+    m21,
+    m22,
+    m23,
+    m30,
+    m31,
+    m32,
+    m33,
+    b00,
+    b01,
+    b02,
+    b03,
+    b04,
+    b05,
+    b06,
+    b07,
+    b08,
+    b09,
+    b10,
+    b11,
+    det
+  } = minors(m);
+  if (Math.abs(det) <= EPSILON) {
+    return null;
+  }
+  const invDet = 1 / det;
+  return mat4([
+    (m11 * b11 - m12 * b10 + m13 * b09) * invDet,
+    (m02 * b10 - m01 * b11 - m03 * b09) * invDet,
+    (m31 * b05 - m32 * b04 + m33 * b03) * invDet,
+    (m22 * b04 - m21 * b05 - m23 * b03) * invDet,
+    (m12 * b08 - m10 * b11 - m13 * b07) * invDet,
+    (m00 * b11 - m02 * b08 + m03 * b07) * invDet,
+    (m32 * b02 - m30 * b05 - m33 * b01) * invDet,
+    (m20 * b05 - m22 * b02 + m23 * b01) * invDet,
+    (m10 * b10 - m11 * b08 + m13 * b06) * invDet,
+    (m01 * b08 - m00 * b10 - m03 * b06) * invDet,
+    (m30 * b04 - m31 * b02 + m33 * b00) * invDet,
+    (m21 * b02 - m20 * b04 - m23 * b00) * invDet,
+    (m11 * b07 - m10 * b09 - m12 * b06) * invDet,
+    (m00 * b09 - m01 * b07 + m02 * b06) * invDet,
+    (m31 * b01 - m30 * b03 - m32 * b00) * invDet,
+    (m20 * b03 - m21 * b01 + m22 * b00) * invDet
+  ]);
+}
+function equals4(a, b, tolerance = EPSILON) {
+  return a.e.every((value, i) => Math.abs(value - b.e[i]) <= tolerance);
+}
+function transformPoint(m, v) {
+  const [
+    m00,
+    m01,
+    m02,
+    _m03,
+    m10,
+    m11,
+    m12,
+    _m13,
+    m20,
+    m21,
+    m22,
+    _m23,
+    m30,
+    m31,
+    m32,
+    _m33
+  ] = m.e;
+  return vec3(m00 * v.x + m10 * v.y + m20 * v.z + m30, m01 * v.x + m11 * v.y + m21 * v.z + m31, m02 * v.x + m12 * v.y + m22 * v.z + m32);
+}
+function transformDirection(m, v) {
+  const [m00, m01, m02, _m03, m10, m11, m12, _m13, m20, m21, m22, _m23] = m.e;
+  return vec3(m00 * v.x + m10 * v.y + m20 * v.z, m01 * v.x + m11 * v.y + m21 * v.z, m02 * v.x + m12 * v.y + m22 * v.z);
+}
+
+// src/geometry/solid.ts
+function applyMatrix(solid, matrix) {
+  const inverse = invert(matrix);
+  const normalMatrix = inverse ? transpose(inverse) : matrix;
+  const reverseWinding = determinant(matrix) < 0;
+  const polygons = solid.polygons.map((polygon2) => {
+    const vertices = polygon2.vertices.map((v) => vertex(transformPoint(matrix, v.pos), normalize(transformDirection(normalMatrix, v.normal))));
+    return polygon(reverseWinding ? [...vertices].reverse() : vertices);
+  });
+  return new Solid(polygons);
+}
+function eulerRotation(radians) {
+  return multiply(rotationZ(radians.z), multiply(rotationY(radians.y), rotationX(radians.x)));
+}
+
+class Solid {
+  polygons;
+  constructor(polygons) {
+    this.polygons = polygons;
+  }
+  translate(offset) {
+    return applyMatrix(this, translation(offset));
+  }
+  rotate(radians) {
+    return applyMatrix(this, eulerRotation(radians));
+  }
+  rotateAxisAngle(axis, radians) {
+    return applyMatrix(this, rotationAxisAngle(axis, radians));
+  }
+  scale(factor) {
+    const v = typeof factor === "number" ? vec3(factor, factor, factor) : factor;
+    return applyMatrix(this, scaling(v));
+  }
+  mirror(normal) {
+    return applyMatrix(this, reflection(normal));
+  }
+  multmatrix(matrix) {
+    return applyMatrix(this, matrix);
+  }
+}
+
+// src/primitives/cube.ts
+function cube(size, options) {
+  const dims = typeof size === "number" ? vec3(size, size, size) : size;
+  const center = options?.center ?? false;
+  const minX = center ? -dims.x / 2 : 0;
+  const minY = center ? -dims.y / 2 : 0;
+  const minZ = center ? -dims.z / 2 : 0;
+  const maxX = minX + dims.x;
+  const maxY = minY + dims.y;
+  const maxZ = minZ + dims.z;
+  const p = (x, y, z) => vec3(x, y, z);
+  const face = (normal, ...positions) => polygon(positions.map((pos) => vertex(pos, normal)));
+  return new Solid([
+    face(vec3(0, 0, -1), p(minX, minY, minZ), p(minX, maxY, minZ), p(maxX, maxY, minZ), p(maxX, minY, minZ)),
+    face(vec3(0, 0, 1), p(minX, minY, maxZ), p(maxX, minY, maxZ), p(maxX, maxY, maxZ), p(minX, maxY, maxZ)),
+    face(vec3(0, -1, 0), p(minX, minY, minZ), p(maxX, minY, minZ), p(maxX, minY, maxZ), p(minX, minY, maxZ)),
+    face(vec3(0, 1, 0), p(maxX, maxY, minZ), p(minX, maxY, minZ), p(minX, maxY, maxZ), p(maxX, maxY, maxZ)),
+    face(vec3(-1, 0, 0), p(minX, maxY, minZ), p(minX, minY, minZ), p(minX, minY, maxZ), p(minX, maxY, maxZ)),
+    face(vec3(1, 0, 0), p(maxX, minY, minZ), p(maxX, maxY, minZ), p(maxX, maxY, maxZ), p(maxX, minY, maxZ))
+  ]);
+}
+// src/primitives/sphere.ts
+function sphere(r, options) {
+  const fn = options?.fn ?? 32;
+  if (fn < 3) {
+    throw new Error(`sphere requires fn >= 3, got ${fn}`);
+  }
+  const segments = Math.max(3, Math.floor(fn));
+  const rings = Math.max(2, Math.floor(fn / 2));
+  const northPole = vec3(0, 0, r);
+  const southPole = vec3(0, 0, -r);
+  const ringPositions = [];
+  for (let i = 1;i < rings; i++) {
+    const phi = i * Math.PI / rings;
+    const row = [];
+    for (let j = 0;j < segments; j++) {
+      const theta = j * 2 * Math.PI / segments;
+      row.push(vec3(r * Math.sin(phi) * Math.cos(theta), r * Math.sin(phi) * Math.sin(theta), r * Math.cos(phi)));
+    }
+    ringPositions.push(row);
+  }
+  const face = (...positions) => polygon(positions.map((pos) => vertex(pos, normalize(pos))));
+  const polygons = [];
+  const firstRing = ringPositions[0];
+  for (let j = 0;j < segments; j++) {
+    const jNext = (j + 1) % segments;
+    polygons.push(face(northPole, firstRing[j], firstRing[jNext]));
+  }
+  for (let i = 0;i < ringPositions.length - 1; i++) {
+    const ringA = ringPositions[i];
+    const ringB = ringPositions[i + 1];
+    for (let j = 0;j < segments; j++) {
+      const jNext = (j + 1) % segments;
+      const a0 = ringA[j];
+      const a1 = ringA[jNext];
+      const b0 = ringB[j];
+      const b1 = ringB[jNext];
+      polygons.push(face(a0, b0, b1));
+      polygons.push(face(a0, b1, a1));
+    }
+  }
+  const lastRing = ringPositions[ringPositions.length - 1];
+  for (let j = 0;j < segments; j++) {
+    const jNext = (j + 1) % segments;
+    polygons.push(face(southPole, lastRing[jNext], lastRing[j]));
+  }
+  return new Solid(polygons);
+}
+// src/primitives/cylinder.ts
+function faceNormal(a, b, c) {
+  return normalize(cross(sub(b, a), sub(c, a)));
+}
+function triangleFace(a, b, c) {
+  const normal = faceNormal(a, b, c);
+  return polygon([
+    vertex(a, normal),
+    vertex(b, normal),
+    vertex(c, normal)
+  ]);
+}
+function ringPoint(r, theta, z) {
+  return vec3(r * Math.cos(theta), r * Math.sin(theta), z);
+}
+function cylinder(h, options = {}) {
+  const { center = false, fn = 32 } = options;
+  const r1 = options.r1 ?? options.r ?? 1;
+  const r2 = options.r2 ?? options.r ?? 1;
+  if (!(h > 0)) {
+    throw new Error(`cylinder height must be > 0, got ${h}`);
+  }
+  if (r1 < 0 || r2 < 0) {
+    throw new Error(`cylinder radii must be >= 0, got r1=${r1}, r2=${r2}`);
+  }
+  if (almostEqual(r1, 0) && almostEqual(r2, 0)) {
+    throw new Error("cylinder radii r1 and r2 cannot both be 0");
+  }
+  if (fn < 3) {
+    throw new Error(`cylinder fn must be >= 3, got ${fn}`);
+  }
+  const z0 = center ? -h / 2 : 0;
+  const z1 = z0 + h;
+  const bottomIsPoint = almostEqual(r1, 0);
+  const topIsPoint = almostEqual(r2, 0);
+  const thetas = Array.from({ length: fn }, (_, i) => i * 2 * Math.PI / fn);
+  const bottomRing = thetas.map((theta) => ringPoint(r1, theta, z0));
+  const topRing = thetas.map((theta) => ringPoint(r2, theta, z1));
+  const polygons = [];
+  for (let i = 0;i < fn; i++) {
+    const i2 = (i + 1) % fn;
+    const b0 = bottomRing[i];
+    const b1 = bottomRing[i2];
+    const t0 = topRing[i];
+    const t1 = topRing[i2];
+    if (!bottomIsPoint && !topIsPoint) {
+      polygons.push(triangleFace(b0, b1, t1));
+      polygons.push(triangleFace(b0, t1, t0));
+    } else if (bottomIsPoint) {
+      polygons.push(triangleFace(b0, t1, t0));
+    } else {
+      polygons.push(triangleFace(b0, b1, t1));
+    }
+  }
+  if (!bottomIsPoint) {
+    const bottomCapVertices = [...bottomRing].reverse().map((pos) => vertex(pos, vec3(0, 0, -1)));
+    polygons.push(polygon(bottomCapVertices));
+  }
+  if (!topIsPoint) {
+    const topCapVertices = topRing.map((pos) => vertex(pos, vec3(0, 0, 1)));
+    polygons.push(polygon(topCapVertices));
+  }
+  return new Solid(polygons);
+}
+// src/primitives/polyhedron.ts
+function polyhedron(points, faces) {
+  const polygons = faces.map((face, faceIndex) => {
+    if (face.length < 3) {
+      throw new Error(`polyhedron: face ${faceIndex} has ${face.length} indices, but each face requires at least 3`);
+    }
+    for (const index of face) {
+      if (index < 0 || index >= points.length) {
+        throw new Error(`polyhedron: face ${faceIndex} references index ${index}, out of bounds for ${points.length} points`);
+      }
+    }
+    const [i0, i1, i2] = face;
+    const plane = fromPoints(points[i0], points[i1], points[i2]);
+    const vertices = face.map((index) => vertex(points[index], plane.normal));
+    return polygon(vertices);
+  });
+  return new Solid(polygons);
+}
+// src/csg/split-polygon.ts
+var COPLANAR = 0;
+var FRONT = 1;
+var BACK = 2;
+var SPANNING = 3;
+var EMPTY = {
+  coplanarFront: [],
+  coplanarBack: [],
+  front: [],
+  back: []
+};
+function splitPolygon(plane, polygon2) {
+  const distances = polygon2.vertices.map((v) => signedDistance(plane, v.pos));
+  const types = distances.map((d) => d < -EPSILON ? BACK : d > EPSILON ? FRONT : COPLANAR);
+  const polygonType = types.reduce((acc, t) => acc | t, COPLANAR);
+  switch (polygonType) {
+    case COPLANAR: {
+      const sameDirection = dot(plane.normal, polygon2.plane.normal) > 0;
+      return sameDirection ? { ...EMPTY, coplanarFront: [polygon2] } : { ...EMPTY, coplanarBack: [polygon2] };
+    }
+    case FRONT:
+      return { ...EMPTY, front: [polygon2] };
+    case BACK:
+      return { ...EMPTY, back: [polygon2] };
+    case SPANNING: {
+      const front = [];
+      const back = [];
+      const n = polygon2.vertices.length;
+      for (let i = 0;i < n; i++) {
+        const j = (i + 1) % n;
+        const ti = types[i];
+        const tj = types[j];
+        const vi = polygon2.vertices[i];
+        const vj = polygon2.vertices[j];
+        if (ti !== BACK)
+          front.push(vi);
+        if (ti !== FRONT)
+          back.push(vi);
+        if ((ti | tj) === SPANNING) {
+          const di = distances[i];
+          const dj = distances[j];
+          const t = di / (di - dj);
+          const crossing = lerp2(vi, vj, t);
+          front.push(crossing);
+          back.push(crossing);
+        }
+      }
+      return {
+        ...EMPTY,
+        front: front.length >= 3 ? [polygon(front)] : [],
+        back: back.length >= 3 ? [polygon(back)] : []
+      };
+    }
+    default: {
+      const unreachable = polygonType;
+      throw new Error(`splitPolygon: impossible classification ${unreachable}`);
+    }
+  }
+}
+
+// src/csg/bsp-tree.ts
+function build(polygons, node = null) {
+  if (polygons.length === 0)
+    return node;
+  const plane = node ? node.plane : polygons[0].plane;
+  const coplanar = node ? [...node.polygons] : [];
+  const front = [];
+  const back = [];
+  for (const polygon of polygons) {
+    const split = splitPolygon(plane, polygon);
+    coplanar.push(...split.coplanarFront, ...split.coplanarBack);
+    front.push(...split.front);
+    back.push(...split.back);
+  }
+  return {
+    plane,
+    polygons: coplanar,
+    front: build(front, node ? node.front : null),
+    back: build(back, node ? node.back : null)
+  };
+}
+function clipPolygons(node, polygons) {
+  if (node === null)
+    return [...polygons];
+  if (polygons.length === 0)
+    return [];
+  const front = [];
+  const back = [];
+  for (const polygon of polygons) {
+    const split = splitPolygon(node.plane, polygon);
+    front.push(...split.front, ...split.coplanarFront);
+    back.push(...split.back, ...split.coplanarBack);
+  }
+  return [
+    ...clipPolygons(node.front, front),
+    ...node.back ? clipPolygons(node.back, back) : []
+  ];
+}
+function clipTo(node, other) {
+  if (node === null)
+    return null;
+  return {
+    plane: node.plane,
+    polygons: clipPolygons(other, node.polygons),
+    front: clipTo(node.front, other),
+    back: clipTo(node.back, other)
+  };
+}
+function invert2(node) {
+  if (node === null)
+    return null;
+  return {
+    plane: flip(node.plane),
+    polygons: node.polygons.map(flip3),
+    front: invert2(node.back),
+    back: invert2(node.front)
+  };
+}
+function allPolygons(node) {
+  if (node === null)
+    return [];
+  return [
+    ...node.polygons,
+    ...allPolygons(node.front),
+    ...allPolygons(node.back)
+  ];
+}
+
+// src/csg/boolean.ts
+function union(a, b) {
+  let nodeA = build(a.polygons);
+  let nodeB = build(b.polygons);
+  nodeA = clipTo(nodeA, nodeB);
+  nodeB = clipTo(nodeB, nodeA);
+  nodeB = invert2(nodeB);
+  nodeB = clipTo(nodeB, nodeA);
+  nodeB = invert2(nodeB);
+  nodeA = build(allPolygons(nodeB), nodeA);
+  return new Solid(allPolygons(nodeA));
+}
+function difference(a, b) {
+  let nodeA = build(a.polygons);
+  let nodeB = build(b.polygons);
+  nodeA = invert2(nodeA);
+  nodeA = clipTo(nodeA, nodeB);
+  nodeB = clipTo(nodeB, nodeA);
+  nodeB = invert2(nodeB);
+  nodeB = clipTo(nodeB, nodeA);
+  nodeB = invert2(nodeB);
+  nodeA = build(allPolygons(nodeB), nodeA);
+  nodeA = invert2(nodeA);
+  return new Solid(allPolygons(nodeA));
+}
+function intersect(a, b) {
+  let nodeA = build(a.polygons);
+  let nodeB = build(b.polygons);
+  nodeA = invert2(nodeA);
+  nodeB = clipTo(nodeB, nodeA);
+  nodeB = invert2(nodeB);
+  nodeA = clipTo(nodeA, nodeB);
+  nodeB = clipTo(nodeB, nodeA);
+  nodeA = build(allPolygons(nodeB), nodeA);
+  nodeA = invert2(nodeA);
+  return new Solid(allPolygons(nodeA));
+}
+// src/geometry/triangulate.ts
+function triangulate(polygon) {
+  const { vertices } = polygon;
+  const v0 = vertices[0];
+  const triangles = [];
+  for (let i = 1;i < vertices.length - 1; i++) {
+    triangles.push([v0, vertices[i], vertices[i + 1]]);
+  }
+  return triangles;
+}
+
+// src/io/triangulate-solid.ts
+function triangulateSolid(solid) {
+  const triangles = [];
+  for (const polygon of solid.polygons) {
+    for (const [a, b, c] of triangulate(polygon)) {
+      const normal = normalize(cross(sub(b.pos, a.pos), sub(c.pos, a.pos)));
+      triangles.push({ normal, vertices: [a.pos, b.pos, c.pos] });
+    }
+  }
+  return triangles;
+}
+
+// src/io/stl-binary.ts
+var HEADER_SIZE = 80;
+var COUNT_SIZE = 4;
+var TRIANGLE_SIZE = 50;
+var HEADER_TEXT = "MoreOpenSCAD binary STL export";
+function toBinarySTL(solid) {
+  const triangles = triangulateSolid(solid);
+  const byteLength = HEADER_SIZE + COUNT_SIZE + TRIANGLE_SIZE * triangles.length;
+  const buffer = new ArrayBuffer(byteLength);
+  const view = new DataView(buffer);
+  const bytes = new Uint8Array(buffer);
+  const headerBytes = new TextEncoder().encode(HEADER_TEXT);
+  bytes.set(headerBytes.subarray(0, HEADER_SIZE), 0);
+  view.setUint32(HEADER_SIZE, triangles.length, true);
+  let offset = HEADER_SIZE + COUNT_SIZE;
+  for (const triangle of triangles) {
+    view.setFloat32(offset, triangle.normal.x, true);
+    view.setFloat32(offset + 4, triangle.normal.y, true);
+    view.setFloat32(offset + 8, triangle.normal.z, true);
+    const [v1, v2, v3] = triangle.vertices;
+    view.setFloat32(offset + 12, v1.x, true);
+    view.setFloat32(offset + 16, v1.y, true);
+    view.setFloat32(offset + 20, v1.z, true);
+    view.setFloat32(offset + 24, v2.x, true);
+    view.setFloat32(offset + 28, v2.y, true);
+    view.setFloat32(offset + 32, v2.z, true);
+    view.setFloat32(offset + 36, v3.x, true);
+    view.setFloat32(offset + 40, v3.y, true);
+    view.setFloat32(offset + 44, v3.z, true);
+    view.setUint16(offset + 48, 0, true);
+    offset += TRIANGLE_SIZE;
+  }
+  return bytes;
+}
+// src/io/stl-ascii.ts
+var DECIMAL_PLACES = 6;
+var ZERO_STRING = 0 .toFixed(DECIMAL_PLACES);
+function formatNumber(value) {
+  const fixed = value.toFixed(DECIMAL_PLACES);
+  return fixed === `-${ZERO_STRING}` ? ZERO_STRING : fixed;
+}
+function formatVec3(v) {
+  return `${formatNumber(v.x)} ${formatNumber(v.y)} ${formatNumber(v.z)}`;
+}
+function toASCIISTL(solid, name = "") {
+  const header = name === "" ? "solid" : `solid ${name}`;
+  const footer = name === "" ? "endsolid" : `endsolid ${name}`;
+  const lines = [header];
+  for (const triangle of triangulateSolid(solid)) {
+    lines.push(`  facet normal ${formatVec3(triangle.normal)}`);
+    lines.push("    outer loop");
+    for (const vertex of triangle.vertices) {
+      lines.push(`      vertex ${formatVec3(vertex)}`);
+    }
+    lines.push("    endloop");
+    lines.push("  endfacet");
+  }
+  lines.push(footer);
+  return `${lines.join(`
+`)}
+`;
+}
+// src/io/manifold-check.ts
+var EDGE_KEY_DECIMALS = 9;
+function quantize(n) {
+  return n.toFixed(EDGE_KEY_DECIMALS);
+}
+function pointKey(p) {
+  return `${quantize(p.x)},${quantize(p.y)},${quantize(p.z)}`;
+}
+function directedEdgeKey(from, to) {
+  return `${pointKey(from)}->${pointKey(to)}`;
+}
+function reverseEdgeKey(from, to) {
+  return `${pointKey(to)}->${pointKey(from)}`;
+}
+function isManifold(solid) {
+  const triangles = triangulateSolid(solid);
+  if (triangles.length === 0) {
+    return true;
+  }
+  const edgeCounts = new Map;
+  for (const { vertices } of triangles) {
+    const [a, b, c] = vertices;
+    for (const [from, to] of [
+      [a, b],
+      [b, c],
+      [c, a]
+    ]) {
+      const key = directedEdgeKey(from, to);
+      edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
+    }
+  }
+  for (const { vertices } of triangles) {
+    const [a, b, c] = vertices;
+    for (const [from, to] of [
+      [a, b],
+      [b, c],
+      [c, a]
+    ]) {
+      const count = edgeCounts.get(directedEdgeKey(from, to));
+      if (count !== 1) {
+        return false;
+      }
+      const reverseCount = edgeCounts.get(reverseEdgeKey(from, to)) ?? 0;
+      if (reverseCount !== 1) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+export {
+  exports_mat4 as Mat4,
+  exports_plane as Plane,
+  exports_polygon as Polygon,
+  Solid,
+  exports_vec3 as Vec3,
+  exports_vertex as Vertex,
+  cube,
+  cylinder,
+  difference,
+  intersect,
+  isManifold,
+  polyhedron,
+  sphere,
+  toASCIISTL,
+  toBinarySTL,
+  triangulateSolid,
+  union
+};