@jwc/jscad-utils 5.1.0 → 5.5.0

package/dist/examples/parts-hexagon.jscad

@@ -48,6 +48,8 @@ function initJscadutils(_CSG, options = {}) {
         enabled: [],
         disabled: []
     });
+    var jscadUtilsAssertValidCSGWarnings = options.assertValidCSGWarnings || false;
+    var jscadUtilsAssertValidCSG = options.assertValidCSG || false;
     var jscadUtils = function(exports, jsCadCSG, scadApi) {
         "use strict";
         function _interopDefaultLegacy(e) {
@@ -281,6 +283,51 @@ function initJscadutils(_CSG, options = {}) {
         function _arrayWithHoles(r) {
             if (Array.isArray(r)) return r;
         }
+        function _createForOfIteratorHelper(r, e) {
+            var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+            if (!t) {
+                if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+                    t && (r = t);
+                    var n = 0, F = function() {};
+                    return {
+                        s: F,
+                        n: function() {
+                            return n >= r.length ? {
+                                done: !0
+                            } : {
+                                done: !1,
+                                value: r[n++]
+                            };
+                        },
+                        e: function(r) {
+                            throw r;
+                        },
+                        f: F
+                    };
+                }
+                throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+            }
+            var o, a = !0, u = !1;
+            return {
+                s: function() {
+                    t = t.call(r);
+                },
+                n: function() {
+                    var r = t.next();
+                    return a = r.done, r;
+                },
+                e: function(r) {
+                    u = !0, o = r;
+                },
+                f: function() {
+                    try {
+                        a || null == t.return || t.return();
+                    } finally {
+                        if (u) throw o;
+                    }
+                }
+            };
+        }
         function _defineProperty(e, r, t) {
             return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
                 value: t,
@@ -701,6 +748,219 @@ function initJscadutils(_CSG, options = {}) {
             c[3] = g || 1;
             return o.setColor(c);
         }
+        function validateCSG(csg, options) {
+            var errors = [];
+            var warnings = [];
+            if (!csg || !csg.polygons || csg.polygons.length === 0) {
+                errors.push("Empty mesh: no polygons");
+                return {
+                    ok: false,
+                    errors,
+                    warnings
+                };
+            }
+            var opts = _objectSpread2({
+                fixTJunctions: true
+            }, options);
+            if (opts.fixTJunctions && typeof csg.canonicalized === "function") {
+                csg = csg.canonicalized();
+                if (typeof csg.reTesselated === "function") {
+                    csg = csg.reTesselated();
+                }
+                if (typeof csg.fixTJunctions === "function") {
+                    csg = csg.fixTJunctions();
+                }
+            }
+            var AREA_EPS = 1e-10;
+            var KEY_EPS = 1e-5;
+            var degenerateCount = 0;
+            var invalidVertexCount = 0;
+            var _iterator = _createForOfIteratorHelper(csg.polygons), _step;
+            try {
+                for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+                    var npoly = _step.value;
+                    var _iterator4 = _createForOfIteratorHelper(npoly.vertices), _step4;
+                    try {
+                        for (_iterator4.s(); !(_step4 = _iterator4.n()).done; ) {
+                            var nvert = _step4.value;
+                            var np = nvert.pos;
+                            if (!Number.isFinite(np.x) || !Number.isFinite(np.y) || !Number.isFinite(np.z) || Number.isNaN(np.x) || Number.isNaN(np.y) || Number.isNaN(np.z)) {
+                                invalidVertexCount++;
+                                break;
+                            }
+                        }
+                    } catch (err) {
+                        _iterator4.e(err);
+                    } finally {
+                        _iterator4.f();
+                    }
+                }
+            } catch (err) {
+                _iterator.e(err);
+            } finally {
+                _iterator.f();
+            }
+            if (invalidVertexCount > 0) {
+                errors.push(invalidVertexCount + " polygon(s) with invalid vertex coordinates (NaN or Infinity)");
+            }
+            function vtxKey(v) {
+                var p = v.pos;
+                return Math.round(p.x / KEY_EPS) + "," + Math.round(p.y / KEY_EPS) + "," + Math.round(p.z / KEY_EPS);
+            }
+            var validPolygons = [];
+            var _iterator2 = _createForOfIteratorHelper(csg.polygons), _step2;
+            try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
+                    var poly = _step2.value;
+                    var verts = poly.vertices;
+                    var nv = verts.length;
+                    if (nv < 3) {
+                        degenerateCount++;
+                        continue;
+                    }
+                    var hasInvalid = false;
+                    var _iterator5 = _createForOfIteratorHelper(verts), _step5;
+                    try {
+                        for (_iterator5.s(); !(_step5 = _iterator5.n()).done; ) {
+                            var vert = _step5.value;
+                            var ip = vert.pos;
+                            if (!Number.isFinite(ip.x) || !Number.isFinite(ip.y) || !Number.isFinite(ip.z)) {
+                                hasInvalid = true;
+                                break;
+                            }
+                        }
+                    } catch (err) {
+                        _iterator5.e(err);
+                    } finally {
+                        _iterator5.f();
+                    }
+                    if (hasInvalid) continue;
+                    var area = 0;
+                    for (var ai = 0; ai < nv - 2; ai++) {
+                        area += verts[ai + 1].pos.minus(verts[0].pos).cross(verts[ai + 2].pos.minus(verts[ai + 1].pos)).length();
+                    }
+                    area *= .5;
+                    if (area < AREA_EPS) {
+                        degenerateCount++;
+                        continue;
+                    }
+                    validPolygons.push(poly);
+                }
+            } catch (err) {
+                _iterator2.e(err);
+            } finally {
+                _iterator2.f();
+            }
+            if (degenerateCount > 0) {
+                warnings.push(degenerateCount + " degenerate polygon(s) (fewer than 3 vertices or near-zero area)");
+                if (opts.fixTJunctions && typeof CSG !== "undefined") {
+                    var cleaned = CSG.fromPolygons(validPolygons);
+                    cleaned = cleaned.canonicalized();
+                    if (typeof cleaned.reTesselated === "function") {
+                        cleaned = cleaned.reTesselated();
+                    }
+                    if (typeof cleaned.fixTJunctions === "function") {
+                        cleaned = cleaned.fixTJunctions();
+                    }
+                    validPolygons = [];
+                    var _iterator3 = _createForOfIteratorHelper(cleaned.polygons), _step3;
+                    try {
+                        for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
+                            var cpoly = _step3.value;
+                            var cverts = cpoly.vertices;
+                            var cnv = cverts.length;
+                            if (cnv < 3) continue;
+                            var carea = 0;
+                            for (var cai = 0; cai < cnv - 2; cai++) {
+                                carea += cverts[cai + 1].pos.minus(cverts[0].pos).cross(cverts[cai + 2].pos.minus(cverts[cai + 1].pos)).length();
+                            }
+                            carea *= .5;
+                            if (carea < AREA_EPS) continue;
+                            validPolygons.push(cpoly);
+                        }
+                    } catch (err) {
+                        _iterator3.e(err);
+                    } finally {
+                        _iterator3.f();
+                    }
+                }
+            }
+            var edgeCounts = {};
+            for (var _i = 0, _validPolygons = validPolygons; _i < _validPolygons.length; _i++) {
+                var vpoly = _validPolygons[_i];
+                var vverts = vpoly.vertices;
+                var vnv = vverts.length;
+                for (var ei = 0; ei < vnv; ei++) {
+                    var v0 = vverts[ei];
+                    var v1 = vverts[(ei + 1) % vnv];
+                    var edgeKey = vtxKey(v0) + "/" + vtxKey(v1);
+                    edgeCounts[edgeKey] = (edgeCounts[edgeKey] || 0) + 1;
+                }
+            }
+            var unmatchedEdges = 0;
+            var nonManifoldEdges = 0;
+            var checked = {};
+            for (var _i2 = 0, _Object$keys = Object.keys(edgeCounts); _i2 < _Object$keys.length; _i2++) {
+                var _edgeKey = _Object$keys[_i2];
+                if (checked[_edgeKey]) continue;
+                var parts = _edgeKey.split("/");
+                var reverseKey = parts[1] + "/" + parts[0];
+                var forwardCount = edgeCounts[_edgeKey] || 0;
+                var reverseCount = edgeCounts[reverseKey] || 0;
+                checked[_edgeKey] = true;
+                checked[reverseKey] = true;
+                if (forwardCount !== reverseCount) {
+                    unmatchedEdges += Math.abs(forwardCount - reverseCount);
+                }
+                if (forwardCount > 1 || reverseCount > 1) {
+                    nonManifoldEdges++;
+                }
+            }
+            if (unmatchedEdges > 0) {
+                errors.push(unmatchedEdges + " unmatched edge(s): mesh is not watertight");
+            }
+            if (nonManifoldEdges > 0) {
+                errors.push(nonManifoldEdges + " non-manifold edge(s): edge shared by more than 2 polygons");
+            }
+            return {
+                ok: errors.length === 0,
+                errors,
+                warnings
+            };
+        }
+        function _noOp(csg) {
+            return csg;
+        }
+        function _makeAssertFn(warnEnabled) {
+            return function _assert(csg) {
+                var functionName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "unknown";
+                var moduleName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "unknown";
+                if (!csg || csg.polygons === undefined) return csg;
+                var result = validateCSG(csg);
+                if (!result.ok) {
+                    throw new Error(moduleName + ":" + functionName + ": " + "invalid CSG: " + result.errors.join(", "));
+                }
+                if (warnEnabled && result.warnings.length > 0) {
+                    throw new Error(moduleName + ":" + functionName + ": " + "CSG warnings: " + result.warnings.join(", "));
+                }
+                return csg;
+            };
+        }
+        var _assertFn = _noOp;
+        function _resolveFromGlobals() {
+            var enabled = typeof jscadUtilsAssertValidCSG !== "undefined" && !!jscadUtilsAssertValidCSG;
+            var warnEnabled = typeof jscadUtilsAssertValidCSGWarnings !== "undefined" && !!jscadUtilsAssertValidCSGWarnings;
+            return enabled ? _makeAssertFn(warnEnabled) : _noOp;
+        }
+        function AssertValidCSG() {
+            var moduleName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "unknown";
+            {
+                _assertFn = _resolveFromGlobals();
+            }
+            return function(csg, name) {
+                return _assertFn(csg, name, moduleName);
+            };
+        }
         function init(proto) {
             if (proto.prototype._jscadutilsinit) return;
             proto.prototype.color = function(r, g, b, a) {
@@ -794,6 +1054,9 @@ function initJscadutils(_CSG, options = {}) {
             proto.prototype.subtractIf = function subtractIf(object, condition) {
                 return condition ? this.subtract(result(this, object)) : this;
             };
+            proto.prototype.validate = function validate(options) {
+                return validateCSG(this, options);
+            };
             proto.prototype._translate = proto.prototype.translate;
             proto.prototype.translate = function translate() {
                 if (arguments.length === 1) {
@@ -826,12 +1089,13 @@ function initJscadutils(_CSG, options = {}) {
             __proto__: null,
             default: init
         });
-        var CSG = jsCadCSG__default["default"].CSG, CAG = jsCadCSG__default["default"].CAG;
+        var CSG$1 = jsCadCSG__default["default"].CSG, CAG = jsCadCSG__default["default"].CAG;
         var rectangular_extrude = scadApi__default["default"].extrusions.rectangular_extrude;
         var _scadApi$text = scadApi__default["default"].text, vector_text = _scadApi$text.vector_text, vector_char = _scadApi$text.vector_char;
         var union = scadApi__default["default"].booleanOps.union;
-        init(CSG);
+        init(CSG$1);
         var debug$3 = Debug("jscadUtils:group");
+        var assertValidCSG$2 = AssertValidCSG("group");
         function JsCadUtilsGroup() {
             var names = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
             var parts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -882,7 +1146,7 @@ function initJscadutils(_CSG, options = {}) {
                     debug$3("combine mapPick", value, key, object);
                     return map ? map(value, key, index, object) : identity(value);
                 }, self.name));
-                return g.subtractIf(self.holes && Array.isArray(self.holes) ? union(self.holes) : self.holes, self.holes && !options.noholes);
+                return assertValidCSG$2(g.subtractIf(self.holes && Array.isArray(self.holes) ? union(self.holes) : self.holes, self.holes && !options.noholes), "combine");
             } catch (err) {
                 debug$3("combine error", this, pieces, options, err);
                 throw error('group::combine error "'.concat(err.message || err.toString(), '"\nthis: ').concat(this, '\npieces: "').concat(pieces, '"\noptions: ').concat(JSON.stringify(options, null, 2), "\nstack: ").concat(err.stack, "\n"), "JSCAD_UTILS_GROUP_ERROR");
@@ -923,7 +1187,7 @@ function initJscadutils(_CSG, options = {}) {
             });
             if (self.holes) {
                 group.holes = toArray(self.holes).map(function(part) {
-                    return map(CSG.fromPolygons(part.toPolygons()), "holes");
+                    return assertValidCSG$2(map(CSG$1.fromPolygons(part.toPolygons()), "holes"), "clone");
                 });
             }
             return group;
@@ -942,7 +1206,7 @@ function initJscadutils(_CSG, options = {}) {
             var rotationCenter = solid.centroid();
             var rotationAxis = axes[axis];
             self.map(function(part) {
-                return part.rotate(rotationCenter, rotationAxis, angle);
+                return assertValidCSG$2(part.rotate(rotationCenter, rotationAxis, angle), "rotate");
             });
             return self;
         };
@@ -955,7 +1219,7 @@ function initJscadutils(_CSG, options = {}) {
                 var self = this;
                 var t = calcSnap(self.combine(part), to, axis, orientation, delta);
                 self.map(function(part) {
-                    return part.translate(t);
+                    return assertValidCSG$2(part.translate(t), "snap");
                 });
                 return self;
             } catch (err) {
@@ -970,7 +1234,7 @@ function initJscadutils(_CSG, options = {}) {
                     noholes: true
                 }), axis, to, delta);
                 self.map(function(part) {
-                    return part.translate(t);
+                    return assertValidCSG$2(part.translate(t), "align");
                 });
                 return self;
             } catch (err) {
@@ -1002,14 +1266,14 @@ function initJscadutils(_CSG, options = {}) {
             var myConnector = connectorName.split(".").reduce(function(a, v) {
                 return a[v];
             }, self.parts[partName].properties);
-            debug$3("toConnector", to instanceof CSG.Connector);
+            debug$3("toConnector", to instanceof CSG$1.Connector);
             var toConnector = toConnectorName.split(".").reduce(function(a, v) {
                 return a[v];
             }, to.properties);
             var matrix = myConnector.getTransformationTo(toConnector, mirror, normalrotation);
             debug$3("connectTo", matrix);
             self.map(function(part) {
-                return part.transform(matrix);
+                return assertValidCSG$2(part.transform(matrix), "connectTo");
             });
             return self;
         };
@@ -1020,7 +1284,7 @@ function initJscadutils(_CSG, options = {}) {
                 return to - size[a] / 2;
             });
             self.map(function(part) {
-                return part.translate(t);
+                return assertValidCSG$2(part.translate(t), "midlineTo");
             });
             return self;
         };
@@ -1029,7 +1293,7 @@ function initJscadutils(_CSG, options = {}) {
             var t = Array.isArray(x) ? x : [ x, y, z ];
             debug$3("translate", t);
             self.map(function(part) {
-                return part.translate(t);
+                return assertValidCSG$2(part.translate(t), "translate");
             });
             return self;
         };
@@ -1039,7 +1303,7 @@ function initJscadutils(_CSG, options = {}) {
             if (!map) map = identity;
             var g = Group();
             p.forEach(function(name) {
-                g.add(map(CSG.fromPolygons(self.parts[name].toPolygons()), name), name);
+                g.add(assertValidCSG$2(map(CSG$1.fromPolygons(self.parts[name].toPolygons()), name), "pick"), name);
             });
             return g;
         };
@@ -1054,7 +1318,7 @@ function initJscadutils(_CSG, options = {}) {
                     debug$3("array error", _this, parts);
                     throw error('group::array error "'.concat(name, '" not found.\nthis: ').concat(_this, '\nparts: "').concat(parts, '"\n'), "JSCAD_UTILS_GROUP_ERROR");
                 }
-                a.push(map(CSG.fromPolygons(self.parts[name].toPolygons()), name));
+                a.push(assertValidCSG$2(map(CSG$1.fromPolygons(self.parts[name].toPolygons()), name), "array"));
             });
             return a;
         };
@@ -1087,7 +1351,7 @@ function initJscadutils(_CSG, options = {}) {
                     self.names = names && names.length > 0 && names.split(",") || [];
                     if (Array.isArray(objects)) {
                         self.parts = zipObject(self.names, objects);
-                    } else if (objects instanceof CSG) {
+                    } else if (objects instanceof CSG$1) {
                         self.parts = zipObject(self.names, [ objects ]);
                     } else {
                         self.parts = objects || {};
@@ -1108,6 +1372,7 @@ function initJscadutils(_CSG, options = {}) {
             return new JsCadUtilsGroup(self.names, self.parts, self.holes);
         }
         var debug$2 = Debug("jscadUtils:util");
+        var assertValidCSG$1 = AssertValidCSG("util");
         var NOZZEL_SIZE = .4;
         var nearest = {
             under: function under(desired) {
@@ -1184,12 +1449,12 @@ function initJscadutils(_CSG, options = {}) {
                     h: height || 2
                 }));
             });
-            return center(union(o));
+            return assertValidCSG$1(center(union(o)), "label");
         }
         function text(text) {
             var l = vector_char(0, 0, text);
             var _char = l.segments.reduce(function(result, segment) {
-                var path = new CSG.Path2D(segment);
+                var path = new CSG$1.Path2D(segment);
                 var cag = path.expandToCAG(2);
                 return result ? result.union(cag) : cag;
             }, undefined);
@@ -1197,17 +1462,17 @@ function initJscadutils(_CSG, options = {}) {
         }
         function unitCube(length, radius) {
             radius = radius || .5;
-            return CSG.cube({
+            return assertValidCSG$1(CSG$1.cube({
                 center: [ 0, 0, 0 ],
                 radius: [ radius, radius, length || .5 ]
-            });
+            }), "unitCube");
         }
         function unitAxis(length, radius, centroid) {
             debug$2("unitAxis", length, radius, centroid);
             centroid = centroid || [ 0, 0, 0 ];
             var unitaxis = unitCube(length, radius).setColor(1, 0, 0).union([ unitCube(length, radius).rotateY(90).setColor(0, 1, 0), unitCube(length, radius).rotateX(90).setColor(0, 0, 1) ]);
-            unitaxis.properties.origin = new CSG.Connector([ 0, 0, 0 ], [ 1, 0, 0 ], [ 0, 1, 0 ]);
-            return unitaxis.translate(centroid);
+            unitaxis.properties.origin = new CSG$1.Connector([ 0, 0, 0 ], [ 1, 0, 0 ], [ 0, 1, 0 ]);
+            return assertValidCSG$1(unitaxis.translate(centroid), "unitAxis");
         }
         function toArray(a) {
             return Array.isArray(a) ? a : [ a ];
@@ -1297,15 +1562,15 @@ function initJscadutils(_CSG, options = {}) {
         }
         function center(object, objectSize) {
             objectSize = objectSize || size(object.getBounds());
-            return centerY(centerX(object, objectSize), objectSize);
+            return assertValidCSG$1(centerY(centerX(object, objectSize), objectSize), "center");
         }
         function centerY(object, objectSize) {
             objectSize = objectSize || size(object.getBounds());
-            return object.translate([ 0, -objectSize.y / 2, 0 ]);
+            return assertValidCSG$1(object.translate([ 0, -objectSize.y / 2, 0 ]), "centerY");
         }
         function centerX(object, objectSize) {
             objectSize = objectSize || size(object.getBounds());
-            return object.translate([ -objectSize.x / 2, 0, 0 ]);
+            return assertValidCSG$1(object.translate([ -objectSize.x / 2, 0, 0 ]), "centerX");
         }
         function enlarge(object, x, y, z) {
             var a;
@@ -1323,7 +1588,7 @@ function initJscadutils(_CSG, options = {}) {
             var new_object = object.scale(t);
             var new_centroid = centroid(new_object);
             var delta = new_centroid.minus(objectCentroid).times(-1);
-            return new_object.translate(delta);
+            return assertValidCSG$1(new_object.translate(delta), "enlarge");
         }
         function fit(object, x, y, z, keep_aspect_ratio) {
             var a;
@@ -1343,10 +1608,10 @@ function initJscadutils(_CSG, options = {}) {
             }
             var s = [ scale(objectSize.x, x), scale(objectSize.y, y), scale(objectSize.z, z) ];
             var min$1 = min(s);
-            return centerWith(object.scale(s.map(function(d, i) {
+            return assertValidCSG$1(centerWith(object.scale(s.map(function(d, i) {
                 if (a[i] === 0) return 1;
                 return keep_aspect_ratio ? min$1 : d;
-            })), "xyz", object);
+            })), "xyz", object), "fit");
         }
         function shift(object, x, y, z) {
             var hsize = this.div(this.size(object.getBounds()), 2);
@@ -1354,10 +1619,10 @@ function initJscadutils(_CSG, options = {}) {
         }
         function zero(object) {
             var bounds = object.getBounds();
-            return object.translate([ 0, 0, -bounds[0].z ]);
+            return assertValidCSG$1(object.translate([ 0, 0, -bounds[0].z ]), "zero");
         }
         function mirrored4(x) {
-            return x.union([ x.mirroredY(90), x.mirroredX(90), x.mirroredY(90).mirroredX(90) ]);
+            return assertValidCSG$1(x.union([ x.mirroredY(90), x.mirroredX(90), x.mirroredY(90).mirroredX(90) ]), "mirrored4");
         }
         var flushSide = {
             "above-outside": [ 1, 0 ],
@@ -1418,10 +1683,10 @@ function initJscadutils(_CSG, options = {}) {
         function snap(moveobj, withobj, axis, orientation, delta) {
             debug$2("snap", moveobj, withobj, axis, orientation, delta);
             var t = calcSnap(moveobj, withobj, axis, orientation, delta);
-            return moveobj.translate(t);
+            return assertValidCSG$1(moveobj.translate(t), "snap");
         }
         function flush(moveobj, withobj, axis, mside, wside) {
-            return moveobj.translate(calcFlush(moveobj, withobj, axis, mside, wside));
+            return assertValidCSG$1(moveobj.translate(calcFlush(moveobj, withobj, axis, mside, wside)), "flush");
         }
         function axisApply(axes, valfun, a) {
             debug$2("axisApply", axes, valfun, a);
@@ -1437,7 +1702,7 @@ function initJscadutils(_CSG, options = {}) {
             return retval;
         }
         function axis2array(axes, valfun) {
-            depreciated("axis2array");
+            depreciated("axis2array", false, "Use axisApply instead.");
             var a = [ 0, 0, 0 ];
             var lookup = {
                 x: 0,
@@ -1467,7 +1732,7 @@ function initJscadutils(_CSG, options = {}) {
             });
         }
         function midlineTo(o, axis, to) {
-            return o.translate(calcmidlineTo(o, axis, to));
+            return assertValidCSG$1(o.translate(calcmidlineTo(o, axis, to)), "midlineTo");
         }
         function translator(o, axis, withObj) {
             var objectCentroid = centroid(o);
@@ -1487,7 +1752,7 @@ function initJscadutils(_CSG, options = {}) {
             return delta ? add(t, delta) : t;
         }
         function centerWith(o, axis, withObj) {
-            return o.translate(calcCenterWith(o, axis, withObj));
+            return assertValidCSG$1(o.translate(calcCenterWith(o, axis, withObj)), "centerWith");
         }
         function getDelta(size, bounds, axis, offset, nonzero) {
             if (!isEmpty(offset) && nonzero) {
@@ -1500,6 +1765,95 @@ function initJscadutils(_CSG, options = {}) {
                 return bounds[0][a] + (isEmpty(dist) ? size[axis] / 2 : dist);
             });
         }
+        var EPS = 1e-5;
+        function splitCSGByPlane(csg, plane) {
+            var frontPolys = [];
+            var backPolys = [];
+            csg.polygons.forEach(function(poly) {
+                var vertices = poly.vertices;
+                var numVerts = vertices.length;
+                var hasfront = false;
+                var hasback = false;
+                var vertexIsBack = [];
+                for (var i = 0; i < numVerts; i++) {
+                    var t = plane.normal.dot(vertices[i].pos) - plane.w;
+                    vertexIsBack.push(t < 0);
+                    if (t > EPS) hasfront = true;
+                    if (t < -EPS) hasback = true;
+                }
+                if (!hasfront && !hasback) {
+                    var d = plane.normal.dot(poly.plane.normal);
+                    if (d >= 0) {
+                        frontPolys.push(poly);
+                    } else {
+                        backPolys.push(poly);
+                    }
+                } else if (!hasback) {
+                    frontPolys.push(poly);
+                } else if (!hasfront) {
+                    backPolys.push(poly);
+                } else {
+                    var fv = [];
+                    var bv = [];
+                    for (var vi = 0; vi < numVerts; vi++) {
+                        var vertex = vertices[vi];
+                        var nextVi = (vi + 1) % numVerts;
+                        var isback = vertexIsBack[vi];
+                        var nextisback = vertexIsBack[nextVi];
+                        if (isback === nextisback) {
+                            if (isback) {
+                                bv.push(vertex);
+                            } else {
+                                fv.push(vertex);
+                            }
+                        } else {
+                            var point = vertex.pos;
+                            var nextpoint = vertices[nextVi].pos;
+                            var ip = plane.splitLineBetweenPoints(point, nextpoint);
+                            var iv = new CSG$1.Vertex(ip);
+                            if (isback) {
+                                bv.push(vertex);
+                                bv.push(iv);
+                                fv.push(iv);
+                            } else {
+                                fv.push(vertex);
+                                fv.push(iv);
+                                bv.push(iv);
+                            }
+                        }
+                    }
+                    var EPSEPS = EPS * EPS;
+                    if (fv.length >= 3) {
+                        var prev = fv[fv.length - 1];
+                        for (var fi = 0; fi < fv.length; fi++) {
+                            var curr = fv[fi];
+                            if (curr.pos.distanceToSquared(prev.pos) < EPSEPS) {
+                                fv.splice(fi, 1);
+                                fi--;
+                            }
+                            prev = curr;
+                        }
+                    }
+                    if (bv.length >= 3) {
+                        var prev = bv[bv.length - 1];
+                        for (var bi = 0; bi < bv.length; bi++) {
+                            var curr = bv[bi];
+                            if (curr.pos.distanceToSquared(prev.pos) < EPSEPS) {
+                                bv.splice(bi, 1);
+                                bi--;
+                            }
+                            prev = curr;
+                        }
+                    }
+                    if (fv.length >= 3) frontPolys.push(new CSG$1.Polygon(fv, poly.shared, poly.plane));
+                    if (bv.length >= 3) backPolys.push(new CSG$1.Polygon(bv, poly.shared, poly.plane));
+                }
+            });
+            return {
+                front: CSG$1.fromPolygons(frontPolys),
+                back: CSG$1.fromPolygons(backPolys)
+            };
+        }
         function bisect() {
             for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                 args[_key] = arguments[_key];
@@ -1561,13 +1915,13 @@ function initJscadutils(_CSG, options = {}) {
             }[[ axis, rotateaxis ].sort().join("")];
             var centroid = object.centroid();
             var rotateDelta = getDelta(objectSize, bounds, rotateOffsetAxis, rotateoffset);
-            var rotationCenter = options.rotationCenter || new CSG.Vector3D(axisApply("xyz", function(i, a) {
+            var rotationCenter = options.rotationCenter || new CSG$1.Vector3D(axisApply("xyz", function(i, a) {
                 if (a == axis) return cutDelta[i];
                 if (a == rotateOffsetAxis) return rotateDelta[i];
                 return centroid[a];
             }));
             var theRotationAxis = rotationAxes[rotateaxis];
-            var cutplane = CSG.OrthoNormalBasis.GetCartesian(info.orthoNormalCartesian[0], info.orthoNormalCartesian[1]).translate(cutDelta).rotate(rotationCenter, theRotationAxis, angle);
+            var cutplane = CSG$1.OrthoNormalBasis.GetCartesian(info.orthoNormalCartesian[0], info.orthoNormalCartesian[1]).translate(cutDelta).rotate(rotationCenter, theRotationAxis, angle);
             debug$2("bisect", debug$2.enabled && {
                 axis,
                 offset,
@@ -1580,7 +1934,26 @@ function initJscadutils(_CSG, options = {}) {
                 cutplane,
                 options
             });
-            var g = Group("negative,positive", [ object.cutByPlane(cutplane.plane).color(options.color && "red"), object.cutByPlane(cutplane.plane.flipped()).color(options.color && "blue") ]);
+            var negative = object.cutByPlane(cutplane.plane);
+            var positive = object.cutByPlane(cutplane.plane.flipped());
+            var negSize = size(negative);
+            var posSize = size(positive);
+            if (negSize[axis] >= objectSize[axis] - EPS || posSize[axis] >= objectSize[axis] - EPS) {
+                var halves = splitCSGByPlane(object, cutplane.plane);
+                if (negSize[axis] >= objectSize[axis] - EPS) {
+                    negative = halves.back;
+                    try {
+                        negative = negative.cutByPlane(cutplane.plane);
+                    } catch (e) {}
+                }
+                if (posSize[axis] >= objectSize[axis] - EPS) {
+                    positive = halves.front;
+                    try {
+                        positive = positive.cutByPlane(cutplane.plane.flipped());
+                    } catch (e) {}
+                }
+            }
+            var g = Group("negative,positive", [ negative.color(options.color && "red"), positive.color(options.color && "blue") ]);
             if (options.addRotationCenter) g.add(unitAxis(objectSize.length() + 10, .1, rotationCenter), "rotationCenter");
             return g;
         }
@@ -1593,9 +1966,9 @@ function initJscadutils(_CSG, options = {}) {
                 addRotationCenter: true
             };
             var info = normalVector(axis);
-            var rotationCenter = options.rotationCenter || new CSG.Vector3D(0, 0, 0);
+            var rotationCenter = options.rotationCenter || new CSG$1.Vector3D(0, 0, 0);
             var theRotationAxis = rotationAxes[rotateaxis];
-            var cutplane = CSG.OrthoNormalBasis.GetCartesian(info.orthoNormalCartesian[0], info.orthoNormalCartesian[1]).rotate(rotationCenter, theRotationAxis, angle);
+            var cutplane = CSG$1.OrthoNormalBasis.GetCartesian(info.orthoNormalCartesian[0], info.orthoNormalCartesian[1]).rotate(rotationCenter, theRotationAxis, angle);
             var g = Group("negative,positive", [ object.cutByPlane(cutplane.plane).color(options.color && "red"), object.cutByPlane(cutplane.plane.flipped()).color(options.color && "blue") ]);
             if (options.addRotationCenter) {
                 var objectSize = size(object);
@@ -1620,14 +1993,14 @@ function initJscadutils(_CSG, options = {}) {
             var bounds = object.getBounds();
             var objectSize = size(object);
             var cutDelta = getDelta(objectSize, bounds, axis, offset, true);
-            return object.stretchAtPlane(normal[axis], cutDelta, distance);
+            return assertValidCSG$1(object.stretchAtPlane(normal[axis], cutDelta, distance), "stretch");
         }
         function poly2solid(top, bottom, height) {
             if (top.sides.length == 0) {
-                return new CSG;
+                return new CSG$1;
             }
-            var offsetVector = CSG.Vector3D.Create(0, 0, height);
-            var normalVector = CSG.Vector3D.Create(0, 1, 0);
+            var offsetVector = CSG$1.Vector3D.Create(0, 0, height);
+            var normalVector = CSG$1.Vector3D.Create(0, 1, 0);
             var polygons = [];
             polygons = polygons.concat(bottom._toPlanePolygons({
                 translation: [ 0, 0, 0 ],
@@ -1639,14 +2012,14 @@ function initJscadutils(_CSG, options = {}) {
                 normalVector,
                 flipped: offsetVector.z < 0
             }));
-            var c1 = new CSG.Connector(offsetVector.times(0), [ 0, 0, offsetVector.z ], normalVector);
-            var c2 = new CSG.Connector(offsetVector, [ 0, 0, offsetVector.z ], normalVector);
+            var c1 = new CSG$1.Connector(offsetVector.times(0), [ 0, 0, offsetVector.z ], normalVector);
+            var c2 = new CSG$1.Connector(offsetVector, [ 0, 0, offsetVector.z ], normalVector);
             polygons = polygons.concat(bottom._toWallPolygons({
                 cag: top,
                 toConnector1: c1,
                 toConnector2: c2
             }));
-            return CSG.fromPolygons(polygons);
+            return assertValidCSG$1(CSG$1.fromPolygons(polygons), "poly2solid");
         }
         function slices2poly(slices, options, axis) {
             debug$2("slices2poly", slices, options, axis);
@@ -1655,7 +2028,7 @@ function initJscadutils(_CSG, options = {}) {
                 twiststeps: 0
             }, options);
             var twistangle = options && parseFloat(options.twistangle) || 0;
-            options && parseInt(options.twiststeps) || CSG.defaultResolution3D;
+            options && parseInt(options.twiststeps) || CSG$1.defaultResolution3D;
             var normalVector = options.si.normalVector;
             var polygons = [];
             var first$1 = first(slices);
@@ -1684,8 +2057,8 @@ function initJscadutils(_CSG, options = {}) {
                     var nextidx = idx + 1;
                     var top = !up ? slices[nextidx] : slice;
                     var bottom = up ? slices[nextidx] : slice;
-                    var c1 = new CSG.Connector(bottom.offset, connectorAxis, rotate(normalVector, twistangle, idx / slices.length));
-                    var c2 = new CSG.Connector(top.offset, connectorAxis, rotate(normalVector, twistangle, nextidx / slices.length));
+                    var c1 = new CSG$1.Connector(bottom.offset, connectorAxis, rotate(normalVector, twistangle, idx / slices.length));
+                    var c2 = new CSG$1.Connector(top.offset, connectorAxis, rotate(normalVector, twistangle, nextidx / slices.length));
                     polygons = polygons.concat(bottom.poly._toWallPolygons({
                         cag: top.poly,
                         toConnector1: c1,
@@ -1693,21 +2066,21 @@ function initJscadutils(_CSG, options = {}) {
                     }));
                 }
             });
-            return CSG.fromPolygons(polygons);
+            return assertValidCSG$1(CSG$1.fromPolygons(polygons), "slices2poly");
         }
         function normalVector(axis) {
             var axisInfo = {
                 z: {
                     orthoNormalCartesian: [ "X", "Y" ],
-                    normalVector: CSG.Vector3D.Create(0, 1, 0)
+                    normalVector: CSG$1.Vector3D.Create(0, 1, 0)
                 },
                 x: {
                     orthoNormalCartesian: [ "Y", "Z" ],
-                    normalVector: CSG.Vector3D.Create(0, 0, 1)
+                    normalVector: CSG$1.Vector3D.Create(0, 0, 1)
                 },
                 y: {
-                    orthoNormalCartesian: [ "X", "Z" ],
-                    normalVector: CSG.Vector3D.Create(0, 0, 1)
+                    orthoNormalCartesian: [ "Z", "X" ],
+                    normalVector: CSG$1.Vector3D.Create(0, 0, 1)
                 }
             };
             if (!axisInfo[axis]) error("normalVector: invalid axis " + axis);
@@ -1748,7 +2121,7 @@ function initJscadutils(_CSG, options = {}) {
             var si = sliceParams(orientation, radius, b);
             debug$2("reShape", absoluteRadius, si);
             if (si.axis !== "z") throw new Error('reShape error: CAG._toPlanePolygons only uses the "z" axis.  You must use the "z" axis for now.');
-            var cutplane = CSG.OrthoNormalBasis.GetCartesian(si.orthoNormalCartesian[0], si.orthoNormalCartesian[1]).translate(si.cutDelta);
+            var cutplane = CSG$1.OrthoNormalBasis.GetCartesian(si.orthoNormalCartesian[0], si.orthoNormalCartesian[1]).translate(si.cutDelta);
             var slice = object.sectionCut(cutplane);
             var first = axisApply(si.axis, function() {
                 return si.positive ? 0 : absoluteRadius;
@@ -1763,25 +2136,25 @@ function initJscadutils(_CSG, options = {}) {
                 si
             }), si.axis).color(options.color);
             var remainder = object.cutByPlane(plane);
-            return union([ options.unionOriginal ? object : remainder, delta.translate(si.moveDelta) ]);
+            return assertValidCSG$1(union([ options.unionOriginal ? object : remainder, delta.translate(si.moveDelta) ]), "reShape");
         }
         function chamfer(object, radius, orientation, options) {
-            return reShape(object, radius, orientation, options, function(first, last, slice) {
+            return assertValidCSG$1(reShape(object, radius, orientation, options, function(first, last, slice) {
                 return [ {
                     poly: slice,
-                    offset: new CSG.Vector3D(first)
+                    offset: new CSG$1.Vector3D(first)
                 }, {
                     poly: enlarge(slice, [ -radius * 2, -radius * 2 ]),
-                    offset: new CSG.Vector3D(last)
+                    offset: new CSG$1.Vector3D(last)
                 } ];
-            });
+            }), "chamfer");
         }
         function fillet(object, radius, orientation, options) {
             options = options || {};
-            return reShape(object, radius, orientation, options, function(first, last, slice) {
-                var v1 = new CSG.Vector3D(first);
-                var v2 = new CSG.Vector3D(last);
-                var res = options.resolution || CSG.defaultResolution3D;
+            return assertValidCSG$1(reShape(object, radius, orientation, options, function(first, last, slice) {
+                var v1 = new CSG$1.Vector3D(first);
+                var v2 = new CSG$1.Vector3D(last);
+                var res = options.resolution || CSG$1.defaultResolution3D;
                 var slices = range(0, res).map(function(i) {
                     var p = i > 0 ? i / (res - 1) : 0;
                     var v = v1.lerp(v2, p);
@@ -1792,7 +2165,7 @@ function initJscadutils(_CSG, options = {}) {
                     };
                 });
                 return slices;
-            });
+            }), "fillet");
         }
         function calcRotate(part, solid, axis) {
             var axes = {
@@ -1809,7 +2182,7 @@ function initJscadutils(_CSG, options = {}) {
         }
         function rotateAround(part, solid, axis, angle) {
             var _calcRotate = calcRotate(part, solid, axis), rotationCenter = _calcRotate.rotationCenter, rotationAxis = _calcRotate.rotationAxis;
-            return part.rotate(rotationCenter, rotationAxis, angle);
+            return assertValidCSG$1("rotateAround")(part.rotate(rotationCenter, rotationAxis, angle));
         }
         function cloneProperties(from, to) {
             return Object.entries(from).reduce(function(props, _ref) {
@@ -1819,19 +2192,20 @@ function initJscadutils(_CSG, options = {}) {
             }, to);
         }
         function clone(o) {
-            var c = CSG.fromPolygons(o.toPolygons());
+            var c = CSG$1.fromPolygons(o.toPolygons());
             cloneProperties(o, c);
-            debug$2("clone", o, c, CSG);
-            return c;
+            debug$2("clone", o, c, CSG$1);
+            return assertValidCSG$1(c, "clone");
         }
         function addConnector(object, name) {
             var point = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [ 0, 0, 0 ];
             var axis = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [ 1, 0, 0 ];
             var normal = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [ 0, 0, 1 ];
-            object.properties[name] = new CSG.Connector(point, axis, normal);
-            return object;
+            object.properties[name] = new CSG$1.Connector(point, axis, normal);
+            return assertValidCSG$1("addConnector")(object);
         }
         var debug$1 = Debug("jscadUtils:parts");
+        var assertValidCSG = AssertValidCSG("parts");
         var parts = {
             BBox: BBox$1,
             Cube,
@@ -1841,7 +2215,7 @@ function initJscadutils(_CSG, options = {}) {
         };
         function BBox$1() {
             function box(object) {
-                return CSG.cube({
+                return CSG$1.cube({
                     center: object.centroid(),
                     radius: object.size().dividedBy(2)
                 });
@@ -1849,17 +2223,17 @@ function initJscadutils(_CSG, options = {}) {
             for (var _len = arguments.length, objects = new Array(_len), _key = 0; _key < _len; _key++) {
                 objects[_key] = arguments[_key];
             }
-            return objects.reduce(function(bbox, part) {
+            return assertValidCSG(objects.reduce(function(bbox, part) {
                 var object = bbox ? union([ bbox, box(part) ]) : part;
                 return box(object);
-            }, undefined);
+            }, undefined), "BBox");
         }
         function Cube(width) {
             var r = div$1(fromxyz(width), 2);
-            return CSG.cube({
+            return assertValidCSG(CSG$1.cube({
                 center: r,
                 radius: r
-            });
+            }), "Cube");
         }
         function RoundedCube(x, y, thickness, corner_radius) {
             if (x.getBounds) {
@@ -1875,11 +2249,11 @@ function initJscadutils(_CSG, options = {}) {
                 center: [ r[0], r[1], 0 ],
                 radius: r,
                 roundradius: corner_radius,
-                resolution: CSG.defaultResolution2D
+                resolution: CSG$1.defaultResolution2D
             }).extrude({
                 offset: [ 0, 0, thickness || 1.62 ]
             });
-            return roundedcube;
+            return assertValidCSG(roundedcube, "RoundedCube");
         }
         function Cylinder(diameter, height) {
             var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -1888,39 +2262,39 @@ function initJscadutils(_CSG, options = {}) {
                 start: [ 0, 0, 0 ],
                 end: [ 0, 0, height ],
                 radius: diameter / 2,
-                resolution: CSG.defaultResolution2D
+                resolution: CSG$1.defaultResolution2D
             }, options);
-            return CSG.cylinder(options);
+            return assertValidCSG(CSG$1.cylinder(options), "Cylinder");
         }
         function Cone(diameter1, diameter2, height) {
             var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
             debug$1("parts.Cone", diameter1, diameter2, height, options);
-            return CSG.cylinder(Object.assign({
+            return assertValidCSG(CSG$1.cylinder(Object.assign({
                 start: [ 0, 0, 0 ],
                 end: [ 0, 0, height ],
                 radiusStart: diameter1 / 2,
                 radiusEnd: diameter2 / 2,
-                resolution: CSG.defaultResolution2D
-            }, options));
+                resolution: CSG$1.defaultResolution2D
+            }, options)), "Cone");
         }
         function Hexagon(diameter, height) {
             debug$1("hexagon", diameter, height);
             var radius = diameter / 2;
             var sqrt3 = Math.sqrt(3) / 2;
             var hex = CAG.fromPoints([ [ radius, 0 ], [ radius / 2, radius * sqrt3 ], [ -radius / 2, radius * sqrt3 ], [ -radius, 0 ], [ -radius / 2, -radius * sqrt3 ], [ radius / 2, -radius * sqrt3 ] ]);
-            return hex.extrude({
+            return assertValidCSG(hex.extrude({
                 offset: [ 0, 0, height ]
-            });
+            }), "Hexagon");
         }
         function Triangle(base, height) {
             var radius = base / 2;
             var tri = CAG.fromPoints([ [ -radius, 0 ], [ radius, 0 ], [ 0, Math.sin(30) * radius ] ]);
-            return tri.extrude({
+            return assertValidCSG(tri.extrude({
                 offset: [ 0, 0, height ]
-            });
+            }), "Triangle");
         }
         function Tube(outsideDiameter, insideDiameter, height, outsideOptions, insideOptions) {
-            return Cylinder(outsideDiameter, height, outsideOptions).subtract(Cylinder(insideDiameter, height, insideOptions || outsideOptions));
+            return assertValidCSG(Cylinder(outsideDiameter, height, outsideOptions).subtract(Cylinder(insideDiameter, height, insideOptions || outsideOptions)), "Tube");
         }
         function Anchor() {
             var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
@@ -1938,11 +2312,11 @@ function initJscadutils(_CSG, options = {}) {
                 center: [ r[0], r[1], 0 ],
                 radius: r,
                 roundradius: corner_radius,
-                resolution: CSG.defaultResolution2D
+                resolution: CSG$1.defaultResolution2D
             }).extrude({
                 offset: [ 0, 0, thickness || 1.62 ]
             });
-            return board;
+            return assertValidCSG(board, "Board");
         }
         var Hardware = {
             Orientation: {
@@ -2033,6 +2407,10 @@ function initJscadutils(_CSG, options = {}) {
             gap = gap || .25;
             var inside = thickness - gap;
             var outside = -thickness + gap;
+            var boxHeight = box.size().z;
+            if (Math.abs(height) >= boxHeight) {
+                throw new Error("Rabett: height (".concat(height, ") must be less than the object height (").concat(boxHeight, ")"));
+            }
             debug("inside", inside, "outside", outside);
             var group = Group();
             var _box$bisect$parts = box.bisect("z", height, options).parts, top = _box$bisect$parts.positive, lower2_3rd = _box$bisect$parts.negative;
@@ -2103,10 +2481,10 @@ function initJscadutils(_CSG, options = {}) {
             thickness = thickness || 2;
             var s = div$1(xyz2array(size), 2);
             var r = add(s, thickness);
-            var box = CSG.cube({
+            var box = CSG$1.cube({
                 center: r,
                 radius: r
-            }).subtract(CSG.cube({
+            }).subtract(CSG$1.cube({
                 center: r,
                 radius: s
             }));
@@ -2124,7 +2502,7 @@ function initJscadutils(_CSG, options = {}) {
         var BBox = function BBox(o) {
             depreciated("BBox", true, "Use 'parts.BBox' instead");
             var s = div$1(xyz2array(o.size()), 2);
-            return CSG.cube({
+            return CSG$1.cube({
                 center: s,
                 radius: s
             }).align(o, "xyz");
@@ -2136,7 +2514,7 @@ function initJscadutils(_CSG, options = {}) {
             var gap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : .25;
             var r = add(getRadius(box), -thickness / 2);
             r[2] = thickness / 2;
-            var cutter = CSG.cube({
+            var cutter = CSG$1.cube({
                 center: r,
                 radius: r
             }).align(box, "xy").color("green");