@jwc/jscad-utils 5.2.0 → 5.5.0

package/dist/examples/bisect2.jscad

@@ -0,0 +1,2614 @@
+function main() {
+  // var jscadUtils = initJscadutils();
+  util.init(CSG, { debug: 'jscadUtils:*' });
+
+  const sideThickness = 3;
+  const bottomThickness = 5;
+  const bbox = Parts.Cube([88.5, 57.39, 18.21]).center();
+
+  const exteriorSize = bbox.size();
+
+
+  console.log('bbox size', bbox.size());
+  const exterior = Parts.RoundedCube(
+    exteriorSize.x,
+    exteriorSize.y,
+    exteriorSize.z,
+    sideThickness
+  )
+    .align(bbox, 'xyz')
+    .enlarge([sideThickness * 2, sideThickness * 2, 0])
+    .stretch('z', bottomThickness + sideThickness, 0)
+    // .translate([0, 0, -bottomThickness])
+    // .translate([0, 0, -(bottomThickness - 0.5)])
+    .snap(bbox, 'z', 'inside+', sideThickness)
+    .subtract(bbox);
+  console.log('exterior size', exterior.size());
+
+  var p = util.bisect(exterior, 'z', -5, { color: true });
+
+  var q = util.bisect(p.parts.negative, 'z', -7, { color: true });
+
+  return q.combine();
+}
+
+// include:js
+// ../dist/compat.js
+var Parts, Boxes, Group, Debug, array, triUtils;
+
+function initJscadutils(_CSG, options = {}) {
+    options = Object.assign({
+        debug: ""
+    }, options);
+    var jsCadCSG = {
+        CSG,
+        CAG
+    };
+    var scadApi = {
+        vector_text,
+        rectangular_extrude,
+        vector_char,
+        primitives3d: {
+            cube,
+            sphere,
+            cylinder
+        },
+        extrusions: {
+            rectangular_extrude
+        },
+        text: {
+            vector_text,
+            vector_char
+        },
+        booleanOps: {
+            union
+        }
+    };
+    var jscadUtilsDebug = (options.debug.split(",") || []).reduce((checks, check) => {
+        if (check.startsWith("-")) {
+            checks.disabled.push(new RegExp(`^${check.slice(1).replace(/\*/g, ".*?")}$`));
+        } else {
+            checks.enabled.push(new RegExp(`^${check.replace(/\*/g, ".*?")}$`));
+        }
+        return checks;
+    }, {
+        enabled: [],
+        disabled: []
+    });
+    var jscadUtilsAssertValidCSGWarnings = options.assertValidCSGWarnings || false;
+    var jscadUtilsAssertValidCSG = options.assertValidCSG || false;
+    var jscadUtils = function(exports, jsCadCSG, scadApi) {
+        "use strict";
+        function _interopDefaultLegacy(e) {
+            return e && typeof e === "object" && "default" in e ? e : {
+                default: e
+            };
+        }
+        var jsCadCSG__default = _interopDefaultLegacy(jsCadCSG);
+        var scadApi__default = _interopDefaultLegacy(scadApi);
+        var util = Object.freeze({
+            __proto__: null,
+            get NOZZEL_SIZE() {
+                return NOZZEL_SIZE;
+            },
+            get nearest() {
+                return nearest;
+            },
+            get identity() {
+                return identity;
+            },
+            get result() {
+                return result;
+            },
+            get defaults() {
+                return defaults;
+            },
+            get isEmpty() {
+                return isEmpty;
+            },
+            get isNegative() {
+                return isNegative;
+            },
+            get print() {
+                return print;
+            },
+            get jscadToString() {
+                return jscadToString;
+            },
+            get error() {
+                return error;
+            },
+            get depreciated() {
+                return depreciated;
+            },
+            get inch() {
+                return inch;
+            },
+            get cm() {
+                return cm;
+            },
+            get label() {
+                return label;
+            },
+            get text() {
+                return text;
+            },
+            get unitCube() {
+                return unitCube;
+            },
+            get unitAxis() {
+                return unitAxis;
+            },
+            get toArray() {
+                return toArray;
+            },
+            get ifArray() {
+                return ifArray;
+            },
+            get segment() {
+                return segment;
+            },
+            get zipObject() {
+                return zipObject;
+            },
+            get map() {
+                return map;
+            },
+            get mapValues() {
+                return mapValues;
+            },
+            get pick() {
+                return pick;
+            },
+            get mapPick() {
+                return mapPick;
+            },
+            get divA() {
+                return divA;
+            },
+            get divxyz() {
+                return divxyz;
+            },
+            get div() {
+                return div;
+            },
+            get mulxyz() {
+                return mulxyz;
+            },
+            get mul() {
+                return mul;
+            },
+            get xyz2array() {
+                return xyz2array;
+            },
+            get rotationAxes() {
+                return rotationAxes;
+            },
+            get size() {
+                return size;
+            },
+            get scale() {
+                return scale;
+            },
+            get center() {
+                return center;
+            },
+            get centerY() {
+                return centerY;
+            },
+            get centerX() {
+                return centerX;
+            },
+            get enlarge() {
+                return enlarge;
+            },
+            get fit() {
+                return fit;
+            },
+            get shift() {
+                return shift;
+            },
+            get zero() {
+                return zero;
+            },
+            get mirrored4() {
+                return mirrored4;
+            },
+            get flushSide() {
+                return flushSide;
+            },
+            get calcFlush() {
+                return calcFlush;
+            },
+            get calcSnap() {
+                return calcSnap;
+            },
+            get snap() {
+                return snap;
+            },
+            get flush() {
+                return flush;
+            },
+            get axisApply() {
+                return axisApply;
+            },
+            get axis2array() {
+                return axis2array;
+            },
+            get centroid() {
+                return centroid;
+            },
+            get calcmidlineTo() {
+                return calcmidlineTo;
+            },
+            get midlineTo() {
+                return midlineTo;
+            },
+            get translator() {
+                return translator;
+            },
+            get calcCenterWith() {
+                return calcCenterWith;
+            },
+            get centerWith() {
+                return centerWith;
+            },
+            get getDelta() {
+                return getDelta;
+            },
+            get bisect() {
+                return bisect;
+            },
+            get slice() {
+                return slice;
+            },
+            get wedge() {
+                return wedge;
+            },
+            get stretch() {
+                return stretch;
+            },
+            get poly2solid() {
+                return poly2solid;
+            },
+            get slices2poly() {
+                return slices2poly;
+            },
+            get normalVector() {
+                return normalVector;
+            },
+            get sliceParams() {
+                return sliceParams;
+            },
+            get reShape() {
+                return reShape;
+            },
+            get chamfer() {
+                return chamfer;
+            },
+            get fillet() {
+                return fillet;
+            },
+            get calcRotate() {
+                return calcRotate;
+            },
+            get rotateAround() {
+                return rotateAround;
+            },
+            get clone() {
+                return clone;
+            },
+            get addConnector() {
+                return addConnector;
+            }
+        });
+        function _arrayLikeToArray(r, a) {
+            (null == a || a > r.length) && (a = r.length);
+            for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+            return n;
+        }
+        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,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : e[r] = t, e;
+        }
+        function _iterableToArrayLimit(r, l) {
+            var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+            if (null != t) {
+                var e, n, i, u, a = [], f = !0, o = !1;
+                try {
+                    if (i = (t = t.call(r)).next, 0 === l) {
+                        if (Object(t) !== t) return;
+                        f = !1;
+                    } else for (;!(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) ;
+                } catch (r) {
+                    o = !0, n = r;
+                } finally {
+                    try {
+                        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+                    } finally {
+                        if (o) throw n;
+                    }
+                }
+                return a;
+            }
+        }
+        function _nonIterableRest() {
+            throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function ownKeys(e, r) {
+            var t = Object.keys(e);
+            if (Object.getOwnPropertySymbols) {
+                var o = Object.getOwnPropertySymbols(e);
+                r && (o = o.filter(function(r) {
+                    return Object.getOwnPropertyDescriptor(e, r).enumerable;
+                })), t.push.apply(t, o);
+            }
+            return t;
+        }
+        function _objectSpread2(e) {
+            for (var r = 1; r < arguments.length; r++) {
+                var t = null != arguments[r] ? arguments[r] : {};
+                r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+                    _defineProperty(e, r, t[r]);
+                }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+                    Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+                });
+            }
+            return e;
+        }
+        function _slicedToArray(r, e) {
+            return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+        }
+        function _toPrimitive(t, r) {
+            if ("object" != typeof t || !t) return t;
+            var e = t[Symbol.toPrimitive];
+            if (void 0 !== e) {
+                var i = e.call(t, r || "default");
+                if ("object" != typeof i) return i;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+            }
+            return ("string" === r ? String : Number)(t);
+        }
+        function _toPropertyKey(t) {
+            var i = _toPrimitive(t, "string");
+            return "symbol" == typeof i ? i : i + "";
+        }
+        function _typeof(o) {
+            "@babel/helpers - typeof";
+            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+                return typeof o;
+            } : function(o) {
+                return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+            }, _typeof(o);
+        }
+        function _unsupportedIterableToArray(r, a) {
+            if (r) {
+                if ("string" == typeof r) return _arrayLikeToArray(r, a);
+                var t = {}.toString.call(r).slice(8, -1);
+                return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+            }
+        }
+        var toRadians = function toRadians(deg) {
+            return deg / 180 * Math.PI;
+        };
+        var toDegrees = function toDegrees(rad) {
+            return rad * (180 / Math.PI);
+        };
+        var solve = function solve(p1, p2) {
+            var r = {
+                c: 90,
+                A: Math.abs(p2.x - p1.x),
+                B: Math.abs(p2.y - p1.y)
+            };
+            var brad = Math.atan2(r.B, r.A);
+            r.b = this.toDegrees(brad);
+            r.C = r.B / Math.sin(brad);
+            r.a = 90 - r.b;
+            return r;
+        };
+        var solve90SA = function solve90SA(r) {
+            r = Object.assign(r, {
+                C: 90
+            });
+            r.A = r.A || 90 - r.B;
+            r.B = r.B || 90 - r.A;
+            var arad = toRadians(r.A);
+            r.a = r.a || (r.c ? r.c * Math.sin(arad) : r.b * Math.tan(arad));
+            r.c = r.c || r.a / Math.sin(arad);
+            r.b = r.b || r.a / Math.tan(arad);
+            return r;
+        };
+        var solve90ac = function solve90ac(r) {
+            r = Object.assign(r, {
+                C: 90
+            });
+            var arad = Math.asin(r.a / r.c);
+            r.A = toDegrees(arad);
+            r.B = 90 - r.A;
+            r.b = Math.sqrt(Math.pow(r.c, 2) - Math.pow(r.a, 2));
+            return r;
+        };
+        function solveab(r) {
+            r = Object.assign(r, {
+                C: 90
+            });
+            r.c = Math.sqrt(Math.pow(r.a, 2) + Math.pow(r.b, 2));
+            r.A = toDegrees(Math.asin(r.a / r.c));
+            r.B = toDegrees(Math.asin(r.b / r.c));
+            return r;
+        }
+        var triUtils = Object.freeze({
+            __proto__: null,
+            toRadians,
+            toDegrees,
+            solve,
+            solve90SA,
+            solve90ac,
+            solveab
+        });
+        var div$1 = function div(a, f) {
+            return a.map(function(e) {
+                return e / f;
+            });
+        };
+        var addValue = function addValue(a, f) {
+            return a.map(function(e) {
+                return e + f;
+            });
+        };
+        var addArray = function addArray(a, f) {
+            return a.map(function(e, i) {
+                return e + f[i];
+            });
+        };
+        var add = function add(a) {
+            return Array.prototype.slice.call(arguments, 1).reduce(function(result, arg) {
+                if (Array.isArray(arg)) {
+                    result = addArray(result, arg);
+                } else {
+                    result = addValue(result, arg);
+                }
+                return result;
+            }, a);
+        };
+        var fromxyz = function fromxyz(object) {
+            return Array.isArray(object) ? object : [ object.x, object.y, object.z ];
+        };
+        var toxyz = function toxyz(a) {
+            return {
+                x: a[0],
+                y: a[1],
+                z: a[2]
+            };
+        };
+        var first = function first(a) {
+            return a ? a[0] : undefined;
+        };
+        var last = function last(a) {
+            return a && a.length > 0 ? a[a.length - 1] : undefined;
+        };
+        var min = function min(a) {
+            return a.reduce(function(result, value) {
+                return value < result ? value : result;
+            }, Number.MAX_VALUE);
+        };
+        var range = function range(a, b) {
+            var result = [];
+            for (var i = a; i < b; i++) {
+                result.push(i);
+            }
+            return result;
+        };
+        var array = Object.freeze({
+            __proto__: null,
+            div: div$1,
+            addValue,
+            addArray,
+            add,
+            fromxyz,
+            toxyz,
+            first,
+            last,
+            min,
+            range
+        });
+        var debugColors = [ "#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00", "#ffff33", "#a65628", "#f781bf", "#999999" ];
+        var termColors = [ "\\033[0;34m", "\\033[0;32m", "\\033[0;36m", "\\033[0;31m", "\\033[0;35m", "\\033[0;33m", "\\033[1;33m", "\\033[0;30m", "\\033[1;34m" ];
+        var debugCount = 0;
+        var Debug = function Debug(name) {
+            var checks = Object.assign({
+                enabled: [],
+                disabled: [],
+                options: {
+                    browser: true
+                }
+            }, jscadUtilsDebug || {});
+            var style = checks.options.browser ? "color:".concat(debugColors[debugCount++ % debugColors.length]) : "".concat(termColors[debugCount++ % termColors.length]);
+            var enabled = checks.enabled.some(function checkEnabled(check) {
+                return check.test(name);
+            }) && !checks.disabled.some(function checkEnabled(check) {
+                return check.test(name);
+            });
+            var logger = enabled ? checks.options.browser ? function() {
+                var _console;
+                for (var _len = arguments.length, msg = new Array(_len), _key = 0; _key < _len; _key++) {
+                    msg[_key] = arguments[_key];
+                }
+                (_console = console).log.apply(_console, [ "%c%s", style, name ].concat(msg));
+            } : function() {
+                var _console2;
+                for (var _len2 = arguments.length, msg = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                    msg[_key2] = arguments[_key2];
+                }
+                (_console2 = console).log.apply(_console2, [ "".concat(name) ].concat(msg));
+            } : function() {
+                return undefined;
+            };
+            logger.enabled = enabled;
+            return logger;
+        };
+        var nameArray = {
+            aliceblue: "#f0f8ff",
+            antiquewhite: "#faebd7",
+            aqua: "#00ffff",
+            aquamarine: "#7fffd4",
+            azure: "#f0ffff",
+            beige: "#f5f5dc",
+            bisque: "#ffe4c4",
+            black: "#000000",
+            blanchedalmond: "#ffebcd",
+            blue: "#0000ff",
+            blueviolet: "#8a2be2",
+            brown: "#a52a2a",
+            burlywood: "#deb887",
+            cadetblue: "#5f9ea0",
+            chartreuse: "#7fff00",
+            chocolate: "#d2691e",
+            coral: "#ff7f50",
+            cornflowerblue: "#6495ed",
+            cornsilk: "#fff8dc",
+            crimson: "#dc143c",
+            cyan: "#00ffff",
+            darkblue: "#00008b",
+            darkcyan: "#008b8b",
+            darkgoldenrod: "#b8860b",
+            darkgray: "#a9a9a9",
+            darkgrey: "#a9a9a9",
+            darkgreen: "#006400",
+            darkkhaki: "#bdb76b",
+            darkmagenta: "#8b008b",
+            darkolivegreen: "#556b2f",
+            darkorange: "#ff8c00",
+            darkorchid: "#9932cc",
+            darkred: "#8b0000",
+            darksalmon: "#e9967a",
+            darkseagreen: "#8fbc8f",
+            darkslateblue: "#483d8b",
+            darkslategray: "#2f4f4f",
+            darkslategrey: "#2f4f4f",
+            darkturquoise: "#00ced1",
+            darkviolet: "#9400d3",
+            deeppink: "#ff1493",
+            deepskyblue: "#00bfff",
+            dimgray: "#696969",
+            dimgrey: "#696969",
+            dodgerblue: "#1e90ff",
+            firebrick: "#b22222",
+            floralwhite: "#fffaf0",
+            forestgreen: "#228b22",
+            fuchsia: "#ff00ff",
+            gainsboro: "#dcdcdc",
+            ghostwhite: "#f8f8ff",
+            gold: "#ffd700",
+            goldenrod: "#daa520",
+            gray: "#808080",
+            grey: "#808080",
+            green: "#008000",
+            greenyellow: "#adff2f",
+            honeydew: "#f0fff0",
+            hotpink: "#ff69b4",
+            indianred: "#cd5c5c",
+            indigo: "#4b0082",
+            ivory: "#fffff0",
+            khaki: "#f0e68c",
+            lavender: "#e6e6fa",
+            lavenderblush: "#fff0f5",
+            lawngreen: "#7cfc00",
+            lemonchiffon: "#fffacd",
+            lightblue: "#add8e6",
+            lightcoral: "#f08080",
+            lightcyan: "#e0ffff",
+            lightgoldenrodyellow: "#fafad2",
+            lightgray: "#d3d3d3",
+            lightgrey: "#d3d3d3",
+            lightgreen: "#90ee90",
+            lightpink: "#ffb6c1",
+            lightsalmon: "#ffa07a",
+            lightseagreen: "#20b2aa",
+            lightskyblue: "#87cefa",
+            lightslategray: "#778899",
+            lightslategrey: "#778899",
+            lightsteelblue: "#b0c4de",
+            lightyellow: "#ffffe0",
+            lime: "#00ff00",
+            limegreen: "#32cd32",
+            linen: "#faf0e6",
+            magenta: "#ff00ff",
+            maroon: "#800000",
+            mediumaquamarine: "#66cdaa",
+            mediumblue: "#0000cd",
+            mediumorchid: "#ba55d3",
+            mediumpurple: "#9370d8",
+            mediumseagreen: "#3cb371",
+            mediumslateblue: "#7b68ee",
+            mediumspringgreen: "#00fa9a",
+            mediumturquoise: "#48d1cc",
+            mediumvioletred: "#c71585",
+            midnightblue: "#191970",
+            mintcream: "#f5fffa",
+            mistyrose: "#ffe4e1",
+            moccasin: "#ffe4b5",
+            navajowhite: "#ffdead",
+            navy: "#000080",
+            oldlace: "#fdf5e6",
+            olive: "#808000",
+            olivedrab: "#6b8e23",
+            orange: "#ffa500",
+            orangered: "#ff4500",
+            orchid: "#da70d6",
+            palegoldenrod: "#eee8aa",
+            palegreen: "#98fb98",
+            paleturquoise: "#afeeee",
+            palevioletred: "#d87093",
+            papayawhip: "#ffefd5",
+            peachpuff: "#ffdab9",
+            peru: "#cd853f",
+            pink: "#ffc0cb",
+            plum: "#dda0dd",
+            powderblue: "#b0e0e6",
+            purple: "#800080",
+            red: "#ff0000",
+            rosybrown: "#bc8f8f",
+            royalblue: "#4169e1",
+            saddlebrown: "#8b4513",
+            salmon: "#fa8072",
+            sandybrown: "#f4a460",
+            seagreen: "#2e8b57",
+            seashell: "#fff5ee",
+            sienna: "#a0522d",
+            silver: "#c0c0c0",
+            skyblue: "#87ceeb",
+            slateblue: "#6a5acd",
+            slategray: "#708090",
+            slategrey: "#708090",
+            snow: "#fffafa",
+            springgreen: "#00ff7f",
+            steelblue: "#4682b4",
+            tan: "#d2b48c",
+            teal: "#008080",
+            thistle: "#d8bfd8",
+            tomato: "#ff6347",
+            turquoise: "#40e0d0",
+            violet: "#ee82ee",
+            wheat: "#f5deb3",
+            white: "#ffffff",
+            whitesmoke: "#f5f5f5",
+            yellow: "#ffff00",
+            yellowgreen: "#9acd32"
+        };
+        function name2hex(n) {
+            n = n.toLowerCase();
+            if (!nameArray[n]) return "Invalid Color Name";
+            return nameArray[n];
+        }
+        function hex2rgb(h) {
+            h = h.replace(/^\#/, "");
+            if (h.length === 6) {
+                return [ parseInt(h.substr(0, 2), 16), parseInt(h.substr(2, 2), 16), parseInt(h.substr(4, 2), 16) ];
+            } else {
+                return [ 0, 0, 0 ];
+            }
+        }
+        var _name2rgb = {};
+        function name2rgb(n) {
+            if (!_name2rgb[n]) _name2rgb[n] = hex2rgb(name2hex(n));
+            return _name2rgb[n];
+        }
+        function color(o, r, g, b, a) {
+            if (typeof r !== "string") return o.setColor(r, g, b, a);
+            if (r === "") return o;
+            var c = name2rgb(r).map(function(x) {
+                return x / 255;
+            });
+            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) {
+                if (!r) return this;
+                return color(this, r, g, b, a);
+            };
+            proto.prototype.flush = function flush$1(to, axis, mside, wside) {
+                return flush(this, to, axis, mside, wside);
+            };
+            proto.prototype.snap = function snap$1(to, axis, orientation, delta) {
+                return snap(this, to, axis, orientation, delta);
+            };
+            proto.prototype.calcSnap = function calcSnap$1(to, axis, orientation, delta) {
+                return calcSnap(this, to, axis, orientation, delta);
+            };
+            proto.prototype.midlineTo = function midlineTo$1(axis, to) {
+                return midlineTo(this, axis, to);
+            };
+            proto.prototype.calcmidlineTo = function midlineTo(axis, to) {
+                return calcmidlineTo(this, axis, to);
+            };
+            proto.prototype.centerWith = function centerWith$1(axis, to) {
+                depreciated("centerWith", true, "Use align instead.");
+                return centerWith(this, axis, to);
+            };
+            if (proto.center) echo("proto already has .center");
+            proto.prototype.center = function center(axis) {
+                return centerWith(this, axis || "xyz", unitCube());
+            };
+            proto.prototype.calcCenter = function centerWith(axis) {
+                return calcCenterWith(this, axis || "xyz", unitCube(), 0);
+            };
+            proto.prototype.align = function align(to, axis) {
+                return centerWith(this, axis, to);
+            };
+            proto.prototype.calcAlign = function calcAlign(to, axis, delta) {
+                return calcCenterWith(this, axis, to, delta);
+            };
+            proto.prototype.enlarge = function enlarge$1(x, y, z) {
+                return enlarge(this, x, y, z);
+            };
+            proto.prototype.fit = function fit$1(x, y, z, a) {
+                return fit(this, x, y, z, a);
+            };
+            if (proto.size) echo("proto already has .size");
+            proto.prototype.size = function() {
+                return size(this.getBounds());
+            };
+            proto.prototype.centroid = function() {
+                return centroid(this);
+            };
+            proto.prototype.Zero = function zero$1() {
+                return zero(this);
+            };
+            proto.prototype.Center = function Center(axes) {
+                return this.align(unitCube(), axes || "xy");
+            };
+            proto.Vector2D.prototype.map = function Vector2D_map(cb) {
+                return new proto.Vector2D(cb(this.x), cb(this.y));
+            };
+            proto.prototype.fillet = function fillet$1(radius, orientation, options) {
+                return fillet(this, radius, orientation, options);
+            };
+            proto.prototype.chamfer = function chamfer$1(radius, orientation, options) {
+                return chamfer(this, radius, orientation, options);
+            };
+            proto.prototype.bisect = function bisect$1() {
+                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                    args[_key] = arguments[_key];
+                }
+                return bisect.apply(util, [ this ].concat(args));
+            };
+            proto.prototype.slice = function slice$1() {
+                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                    args[_key2] = arguments[_key2];
+                }
+                return slice.apply(util, [ this ].concat(args));
+            };
+            proto.prototype.wedge = function wedge$1() {
+                for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                    args[_key3] = arguments[_key3];
+                }
+                return wedge.apply(util, [ this ].concat(args));
+            };
+            proto.prototype.stretch = function stretch$1(axis, distance, offset) {
+                return stretch(this, axis, distance, offset);
+            };
+            proto.prototype.unionIf = function unionIf(object, condition) {
+                return condition ? this.union(result(this, object)) : this;
+            };
+            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) {
+                    return this._translate(arguments[0]);
+                } else {
+                    var t = Array.prototype.slice.call(arguments, 0).reduce(function(result, arg) {
+                        result = undefined(result, arg);
+                        return result;
+                    }, [ 0, 0, 0 ]);
+                    return this._translate(t);
+                }
+            };
+            proto.prototype.addConnector = function addConnector$1(name, point, axis, normal) {
+                return addConnector(this, name, point, axis, normal);
+            };
+            proto.prototype.connect = function connectTo(myConnectorName, otherConnector) {
+                var mirror = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+                var normalrotation = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+                var myConnector = myConnectorName.split(".").reduce(function(a, v) {
+                    return a[v];
+                }, this.properties);
+                if (!myConnector) {
+                    error("The connector '".concat(myConnectorName, "' does not exist on the object [").concat(Object.keys(this.properties).join(","), "]"), "Missing connector property");
+                }
+                return this.connectTo(myConnector, otherConnector, mirror, normalrotation);
+            };
+            proto.prototype._jscadutilsinit = true;
+        }
+        var init$1 = Object.freeze({
+            __proto__: null,
+            default: init
+        });
+        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$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] : {};
+            var holes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+            this.name = "";
+            this.names = names;
+            this.parts = parts;
+            this.holes = holes;
+        }
+        JsCadUtilsGroup.prototype.add = function(object, name, hidden, subparts, parts) {
+            debug$3("add", object, name, hidden, subparts, parts);
+            var self = this;
+            if (object.parts) {
+                if (name) {
+                    if (!hidden) self.names.push(name);
+                    self.parts[name] = object.combine(parts);
+                    if (subparts) {
+                        Object.keys(object.parts).forEach(function(key) {
+                            self.parts[subparts + key] = object.parts[key];
+                        });
+                    }
+                } else {
+                    Object.assign(self.parts, object.parts);
+                    if (!hidden) self.names = self.names.concat(object.names);
+                }
+            } else {
+                if (!hidden) self.names.push(name);
+                self.parts[name] = object;
+            }
+            return self;
+        };
+        JsCadUtilsGroup.prototype.combine = function(pieces) {
+            var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+            var map = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function(x) {
+                return x;
+            };
+            try {
+                var self = this;
+                options = Object.assign({
+                    noholes: false
+                }, options);
+                pieces = pieces ? pieces.split(",") : self.names;
+                if (pieces.length === 0) {
+                    throw new Error("no pieces found in ".concat(self.name, " pieces: ").concat(pieces, " parts: ").concat(Object.keys(self.parts), " names: ").concat(self.names));
+                }
+                debug$3("combine", self.names, self.parts);
+                var g = union(mapPick(self.parts, pieces, function(value, key, index, object) {
+                    debug$3("combine mapPick", value, key, object);
+                    return map ? map(value, key, index, object) : identity(value);
+                }, self.name));
+                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");
+            }
+        };
+        JsCadUtilsGroup.prototype.map = function(cb) {
+            var self = this;
+            self.parts = Object.keys(self.parts).filter(function(k) {
+                return k !== "holes";
+            }).reduce(function(result, key) {
+                result[key] = cb(self.parts[key], key);
+                return result;
+            }, {});
+            if (self.holes) {
+                if (Array.isArray(self.holes)) {
+                    self.holes = self.holes.map(function(hole, idx) {
+                        return cb(hole, idx);
+                    });
+                } else {
+                    self.holes = cb(self.holes, "holes");
+                }
+            }
+            return self;
+        };
+        JsCadUtilsGroup.prototype.clone = function(name, map) {
+            debug$3("clone", name, _typeof(name), map);
+            var self = this;
+            if (typeof name == "function") {
+                map = name;
+                name = undefined;
+            }
+            if (!map) map = identity;
+            var group = Group(name);
+            Object.keys(self.parts).forEach(function(key) {
+                var part = self.parts[key];
+                var hidden = self.names.indexOf(key) == -1;
+                group.add(map(clone(part)), key, hidden);
+            });
+            if (self.holes) {
+                group.holes = toArray(self.holes).map(function(part) {
+                    return assertValidCSG$2(map(CSG$1.fromPolygons(part.toPolygons()), "holes"), "clone");
+                });
+            }
+            return group;
+        };
+        JsCadUtilsGroup.prototype.rotate = function(solid, axis, angle) {
+            var self = this;
+            var axes = {
+                x: [ 1, 0, 0 ],
+                y: [ 0, 1, 0 ],
+                z: [ 0, 0, 1 ]
+            };
+            if (typeof solid === "string") {
+                var _names = solid;
+                solid = self.combine(_names);
+            }
+            var rotationCenter = solid.centroid();
+            var rotationAxis = axes[axis];
+            self.map(function(part) {
+                return assertValidCSG$2(part.rotate(rotationCenter, rotationAxis, angle), "rotate");
+            });
+            return self;
+        };
+        JsCadUtilsGroup.prototype.combineAll = function(options, map) {
+            var self = this;
+            return self.combine(Object.keys(self.parts).join(","), options, map);
+        };
+        JsCadUtilsGroup.prototype.snap = function snap(part, to, axis, orientation, delta) {
+            try {
+                var self = this;
+                var t = calcSnap(self.combine(part), to, axis, orientation, delta);
+                self.map(function(part) {
+                    return assertValidCSG$2(part.translate(t), "snap");
+                });
+                return self;
+            } catch (err) {
+                debug$3("snap error", this, part, to, axis, delta, err);
+                throw error('group::snap error "'.concat(err.message || err.toString(), '"\nthis: ').concat(this, '\npart: "').concat(part, '"\nto: ').concat(to, '\naxis: "').concat(axis, '"\norientation: "').concat(orientation, '"\ndelta: "').concat(delta, '"\nstack: ').concat(err.stack, "\n"), "JSCAD_UTILS_GROUP_ERROR");
+            }
+        };
+        JsCadUtilsGroup.prototype.align = function align(part, to, axis, delta) {
+            try {
+                var self = this;
+                var t = calcCenterWith(self.combine(part, {
+                    noholes: true
+                }), axis, to, delta);
+                self.map(function(part) {
+                    return assertValidCSG$2(part.translate(t), "align");
+                });
+                return self;
+            } catch (err) {
+                debug$3("align error", this, part, to, axis, delta, err);
+                throw error('group::align error "'.concat(err.message || err.toString(), '"\nthis: ').concat(this, '\npart: "').concat(part, '"\nto: ').concat(to, '\naxis: "').concat(axis, '"\ndelta: "').concat(delta, '"\nstack: ').concat(err.stack, "\n"), "JSCAD_UTILS_GROUP_ERROR");
+            }
+        };
+        JsCadUtilsGroup.prototype.center = function center(part) {
+            var self = this;
+            return self.align(part, unitCube(), "xyz");
+        };
+        JsCadUtilsGroup.prototype.zero = function zero(part) {
+            var self = this;
+            var bounds = self.parts[part].getBounds();
+            return self.translate([ 0, 0, -bounds[0].z ]);
+        };
+        JsCadUtilsGroup.prototype.connectTo = function connectTo(partName, connectorName, to, toConnectorName) {
+            var mirror = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+            var normalrotation = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
+            debug$3("connectTo", {
+                partName,
+                connectorName,
+                to,
+                toConnectorName,
+                mirror,
+                normalrotation
+            });
+            var self = this;
+            var myConnector = connectorName.split(".").reduce(function(a, v) {
+                return a[v];
+            }, self.parts[partName].properties);
+            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 assertValidCSG$2(part.transform(matrix), "connectTo");
+            });
+            return self;
+        };
+        JsCadUtilsGroup.prototype.midlineTo = function midlineTo(part, axis, to) {
+            var self = this;
+            var size = self.combine(part).size();
+            var t = axisApply(axis, function(i, a) {
+                return to - size[a] / 2;
+            });
+            self.map(function(part) {
+                return assertValidCSG$2(part.translate(t), "midlineTo");
+            });
+            return self;
+        };
+        JsCadUtilsGroup.prototype.translate = function translate(x, y, z) {
+            var self = this;
+            var t = Array.isArray(x) ? x : [ x, y, z ];
+            debug$3("translate", t);
+            self.map(function(part) {
+                return assertValidCSG$2(part.translate(t), "translate");
+            });
+            return self;
+        };
+        JsCadUtilsGroup.prototype.pick = function(parts, map) {
+            var self = this;
+            var p = parts && parts.length > 0 && parts.split(",") || self.names;
+            if (!map) map = identity;
+            var g = Group();
+            p.forEach(function(name) {
+                g.add(assertValidCSG$2(map(CSG$1.fromPolygons(self.parts[name].toPolygons()), name), "pick"), name);
+            });
+            return g;
+        };
+        JsCadUtilsGroup.prototype.array = function(parts, map) {
+            var _this = this;
+            var self = this;
+            var p = parts && parts.length > 0 && parts.split(",") || self.names;
+            if (!map) map = identity;
+            var a = [];
+            p.forEach(function(name) {
+                if (!self.parts[name]) {
+                    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(assertValidCSG$2(map(CSG$1.fromPolygons(self.parts[name].toPolygons()), name), "array"));
+            });
+            return a;
+        };
+        JsCadUtilsGroup.prototype.toArray = function(pieces) {
+            var self = this;
+            var piecesArray = pieces ? pieces.split(",") : self.names;
+            return piecesArray.map(function(piece) {
+                if (!self.parts[piece]) console.error("Cannot find ".concat(piece, " in ").concat(self.names));
+                return self.parts[piece];
+            });
+        };
+        JsCadUtilsGroup.prototype.toString = function() {
+            return '{\n  name: "'.concat(this.name, '",\n  names: "').concat(this.names.join(","), '", \n  parts: "').concat(Object.keys(this.parts), '",\n  holes: ').concat(Array.isArray(this.holes) ? this.holes.length : this.holes ? 1 : 0, "\n}");
+        };
+        JsCadUtilsGroup.prototype.setName = function(name) {
+            this.name = name;
+            return this;
+        };
+        function Group(objectNames, addObjects) {
+            debug$3("Group", objectNames, addObjects);
+            var self = {
+                name: "",
+                names: [],
+                parts: {}
+            };
+            if (objectNames) {
+                if (addObjects) {
+                    var names = objectNames;
+                    var objects = addObjects;
+                    self.names = names && names.length > 0 && names.split(",") || [];
+                    if (Array.isArray(objects)) {
+                        self.parts = zipObject(self.names, objects);
+                    } else if (objects instanceof CSG$1) {
+                        self.parts = zipObject(self.names, [ objects ]);
+                    } else {
+                        self.parts = objects || {};
+                    }
+                } else {
+                    if (typeof objectNames == "string") {
+                        self.name = objectNames;
+                    } else {
+                        var objects = objectNames;
+                        self.names = Object.keys(objects).filter(function(k) {
+                            return k !== "holes";
+                        });
+                        self.parts = Object.assign({}, objects);
+                        self.holes = objects.holes;
+                    }
+                }
+            }
+            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) {
+                var nozzel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NOZZEL_SIZE;
+                var nozzie = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+                return (Math.floor(desired / nozzel) + nozzie) * nozzel;
+            },
+            over: function over(desired) {
+                var nozzel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NOZZEL_SIZE;
+                var nozzie = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+                return (Math.ceil(desired / nozzel) + nozzie) * nozzel;
+            }
+        };
+        function identity(solid) {
+            return solid;
+        }
+        function result(object, f) {
+            if (typeof f === "function") {
+                return f.call(object);
+            } else {
+                return f;
+            }
+        }
+        function defaults(target, defaults) {
+            depreciated("defaults", true, "use Object.assign instead");
+            return Object.assign(defaults, target);
+        }
+        function isEmpty(variable) {
+            return typeof variable === "undefined" || variable === null;
+        }
+        function isNegative(n) {
+            return ((n = +n) || 1 / n) < 0;
+        }
+        function print(msg, o) {
+            debug$2(msg, JSON.stringify(o.getBounds()), JSON.stringify(this.size(o.getBounds())));
+        }
+        function jscadToString(o) {
+            if (_typeof(o) == "object") {
+                if (o.polygons) {
+                    return "{\npolygons: ".concat(o.polygons.length, ',\nproperties: "').concat(Object.keys(o.properties), '"\n}\n');
+                }
+            } else {
+                return o.toString();
+            }
+        }
+        function error(msg, name, error) {
+            if (console && console.error) console.error(msg, error);
+            var err = new Error(msg);
+            err.name = name || "JSCAD_UTILS_ERROR";
+            err._error = error;
+            throw err;
+        }
+        function depreciated(method, error, message) {
+            var msg = method + " is depreciated." + (" " + message || "");
+            if (!error && console && console.error) console[error ? "error" : "warn"](msg);
+            if (error) {
+                var err = new Error(msg);
+                err.name = "JSCAD_UTILS_DEPRECATED";
+                throw err;
+            }
+        }
+        function inch(x) {
+            return x * 25.4;
+        }
+        function cm(x) {
+            return x / 25.4;
+        }
+        function label(text, x, y, width, height) {
+            var l = vector_text(x || 0, y || 0, text);
+            var o = [];
+            l.forEach(function(pl) {
+                o.push(rectangular_extrude(pl, {
+                    w: width || 2,
+                    h: height || 2
+                }));
+            });
+            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$1.Path2D(segment);
+                var cag = path.expandToCAG(2);
+                return result ? result.union(cag) : cag;
+            }, undefined);
+            return _char;
+        }
+        function unitCube(length, radius) {
+            radius = radius || .5;
+            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$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 ];
+        }
+        function ifArray(a, cb) {
+            return Array.isArray(a) ? a.map(cb) : cb(a);
+        }
+        function segment(object, segments, axis) {
+            var size = object.size()[axis];
+            var width = size / segments;
+            var result = [];
+            for (var i = width; i < size; i += width) {
+                result.push(i);
+            }
+            return result;
+        }
+        function zipObject(names, values) {
+            return names.reduce(function(result, value, idx) {
+                result[value] = values[idx];
+                return result;
+            }, {});
+        }
+        function map(o, f) {
+            return Object.keys(o).map(function(key) {
+                return f(o[key], key, o);
+            });
+        }
+        function mapValues(o, f) {
+            return Object.keys(o).map(function(key) {
+                return f(o[key], key);
+            });
+        }
+        function pick(o, names) {
+            return names.reduce(function(result, name) {
+                result[name] = o[name];
+                return result;
+            }, {});
+        }
+        function mapPick(o, names, f, options) {
+            return names.reduce(function(result, name, index) {
+                if (!o[name]) {
+                    throw new Error("".concat(name, " not found in ").concat(options.name, ": ").concat(Object.keys(o).join(",")));
+                }
+                result.push(f ? f(o[name], name, index, o) : o[name]);
+                return result;
+            }, []);
+        }
+        function divA(a, f) {
+            return div$1(a, f);
+        }
+        function divxyz(size, x, y, z) {
+            return {
+                x: size.x / x,
+                y: size.y / y,
+                z: size.z / z
+            };
+        }
+        function div(size, d) {
+            return this.divxyz(size, d, d, d);
+        }
+        function mulxyz(size, x, y, z) {
+            return {
+                x: size.x * x,
+                y: size.y * y,
+                z: size.z * z
+            };
+        }
+        function mul(size, d) {
+            return this.divxyz(size, d, d, d);
+        }
+        function xyz2array(size) {
+            return [ size.x, size.y, size.z ];
+        }
+        var rotationAxes = {
+            x: [ 1, 0, 0 ],
+            y: [ 0, 1, 0 ],
+            z: [ 0, 0, 1 ]
+        };
+        function size(o) {
+            var bbox = o.getBounds ? o.getBounds() : o;
+            var foo = bbox[1].minus(bbox[0]);
+            return foo;
+        }
+        function scale(size, value) {
+            if (value == 0) return 1;
+            return 1 + 100 / (size / value) / 100;
+        }
+        function center(object, objectSize) {
+            objectSize = objectSize || size(object.getBounds());
+            return assertValidCSG$1(centerY(centerX(object, objectSize), objectSize), "center");
+        }
+        function centerY(object, objectSize) {
+            objectSize = objectSize || size(object.getBounds());
+            return assertValidCSG$1(object.translate([ 0, -objectSize.y / 2, 0 ]), "centerY");
+        }
+        function centerX(object, objectSize) {
+            objectSize = objectSize || size(object.getBounds());
+            return assertValidCSG$1(object.translate([ -objectSize.x / 2, 0, 0 ]), "centerX");
+        }
+        function enlarge(object, x, y, z) {
+            var a;
+            if (Array.isArray(x)) {
+                a = x;
+            } else {
+                a = [ x, y || x, z || x ];
+            }
+            var objectSize = size(object);
+            var objectCentroid = centroid(object, objectSize);
+            var idx = 0;
+            var t = map(objectSize, function(i) {
+                return scale(i, a[idx++]);
+            });
+            var new_object = object.scale(t);
+            var new_centroid = centroid(new_object);
+            var delta = new_centroid.minus(objectCentroid).times(-1);
+            return assertValidCSG$1(new_object.translate(delta), "enlarge");
+        }
+        function fit(object, x, y, z, keep_aspect_ratio) {
+            var a;
+            if (Array.isArray(x)) {
+                a = x;
+                keep_aspect_ratio = y;
+                x = a[0];
+                y = a[1];
+                z = a[2];
+            } else {
+                a = [ x, y, z ];
+            }
+            var objectSize = size(object.getBounds());
+            function scale(size, value) {
+                if (value == 0) return 1;
+                return value / size;
+            }
+            var s = [ scale(objectSize.x, x), scale(objectSize.y, y), scale(objectSize.z, z) ];
+            var min$1 = min(s);
+            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), "fit");
+        }
+        function shift(object, x, y, z) {
+            var hsize = this.div(this.size(object.getBounds()), 2);
+            return object.translate(this.xyz2array(this.mulxyz(hsize, x, y, z)));
+        }
+        function zero(object) {
+            var bounds = object.getBounds();
+            return assertValidCSG$1(object.translate([ 0, 0, -bounds[0].z ]), "zero");
+        }
+        function mirrored4(x) {
+            return assertValidCSG$1(x.union([ x.mirroredY(90), x.mirroredX(90), x.mirroredY(90).mirroredX(90) ]), "mirrored4");
+        }
+        var flushSide = {
+            "above-outside": [ 1, 0 ],
+            "above-inside": [ 1, 1 ],
+            "below-outside": [ 0, 1 ],
+            "below-inside": [ 0, 0 ],
+            "outside+": [ 0, 1 ],
+            "outside-": [ 1, 0 ],
+            "inside+": [ 1, 1 ],
+            "inside-": [ 0, 0 ],
+            "center+": [ -1, 1 ],
+            "center-": [ -1, 0 ]
+        };
+        function calcFlush(moveobj, withobj, axes, mside, wside) {
+            depreciated("calcFlush", false, "Use calcSnap instead.");
+            var side;
+            if (mside === 0 || mside === 1) {
+                side = [ wside !== undefined ? wside : mside, mside ];
+            } else {
+                side = flushSide[mside];
+                if (!side) error("invalid side: " + mside);
+            }
+            var m = moveobj.getBounds();
+            var w = withobj.getBounds();
+            if (side[0] === -1) {
+                w[-1] = toxyz(withobj.centroid());
+            }
+            return this.axisApply(axes, function(i, axis) {
+                return w[side[0]][axis] - m[side[1]][axis];
+            });
+        }
+        function calcSnap(moveobj, withobj, axes, orientation) {
+            var delta = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+            var side = flushSide[orientation];
+            if (!side) {
+                var fix = {
+                    "01": "outside+",
+                    10: "outside-",
+                    11: "inside+",
+                    "00": "inside-",
+                    "-11": "center+",
+                    "-10": "center-"
+                };
+                error("calcSnap: invalid side: " + orientation + " should be " + fix["" + orientation + delta]);
+            }
+            var m = moveobj.getBounds();
+            var w = withobj.getBounds();
+            if (side[0] === -1) {
+                w[-1] = withobj.centroid();
+            }
+            var t = axisApply(axes, function(i, axis) {
+                return w[side[0]][axis] - m[side[1]][axis];
+            });
+            return delta ? axisApply(axes, function(i) {
+                return t[i] + delta;
+            }) : t;
+        }
+        function snap(moveobj, withobj, axis, orientation, delta) {
+            debug$2("snap", moveobj, withobj, axis, orientation, delta);
+            var t = calcSnap(moveobj, withobj, axis, orientation, delta);
+            return assertValidCSG$1(moveobj.translate(t), "snap");
+        }
+        function flush(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);
+            var retval = a || [ 0, 0, 0 ];
+            var lookup = {
+                x: 0,
+                y: 1,
+                z: 2
+            };
+            axes.split("").forEach(function(axis) {
+                retval[lookup[axis]] = valfun(lookup[axis], axis);
+            });
+            return retval;
+        }
+        function axis2array(axes, valfun) {
+            depreciated("axis2array", false, "Use axisApply instead.");
+            var a = [ 0, 0, 0 ];
+            var lookup = {
+                x: 0,
+                y: 1,
+                z: 2
+            };
+            axes.split("").forEach(function(axis) {
+                var i = lookup[axis];
+                a[i] = valfun(i, axis);
+            });
+            return a;
+        }
+        function centroid(o, objectSize) {
+            try {
+                var bounds = o.getBounds();
+                objectSize = objectSize || size(bounds);
+                return bounds[0].plus(objectSize.dividedBy(2));
+            } catch (err) {
+                error("centroid error o:".concat(jscadToString(o), " objectSize: ").concat(objectSize), undefined, err);
+            }
+        }
+        function calcmidlineTo(o, axis, to) {
+            var bounds = o.getBounds();
+            var objectSize = size(bounds);
+            return axisApply(axis, function(i, a) {
+                return to - objectSize[a] / 2;
+            });
+        }
+        function midlineTo(o, axis, to) {
+            return assertValidCSG$1(o.translate(calcmidlineTo(o, axis, to)), "midlineTo");
+        }
+        function translator(o, axis, withObj) {
+            var objectCentroid = centroid(o);
+            var withCentroid = centroid(withObj);
+            var t = axisApply(axis, function(i) {
+                return withCentroid[i] - objectCentroid[i];
+            });
+            return t;
+        }
+        function calcCenterWith(o, axes, withObj) {
+            var delta = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+            var objectCentroid = centroid(o);
+            var withCentroid = centroid(withObj);
+            var t = axisApply(axes, function(i, axis) {
+                return withCentroid[axis] - objectCentroid[axis];
+            });
+            return delta ? add(t, delta) : t;
+        }
+        function centerWith(o, axis, withObj) {
+            return assertValidCSG$1(o.translate(calcCenterWith(o, axis, withObj)), "centerWith");
+        }
+        function getDelta(size, bounds, axis, offset, nonzero) {
+            if (!isEmpty(offset) && nonzero) {
+                if (Math.abs(offset) < 1e-4) {
+                    offset = 1e-4 * (isNegative(offset) ? -1 : 1);
+                }
+            }
+            var dist = isNegative(offset) ? offset = size[axis] + offset : offset;
+            return axisApply(axis, function(i, a) {
+                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];
+            }
+            if (args.length < 2) {
+                error("bisect requires an object and an axis", "JSCAD_UTILS_INVALID_ARGS");
+            }
+            var object = args[0];
+            var axis = args[1];
+            var offset, angle = 0, rotateaxis, rotateoffset, options = {};
+            for (var i = 2; i < args.length; i++) {
+                if (args[i] instanceof Object) {
+                    options = args[i];
+                    if (options.offset) offset = options.offset;
+                    if (options.angle) angle = options.angle;
+                    if (options.rotateaxis) rotateaxis = options.rotateaxis;
+                    if (options.rotateoffset) rotateoffset = options.rotateoffset;
+                } else {
+                    switch (i) {
+                      case 2:
+                        offset = args[i];
+                        break;
+
+                      case 3:
+                        angle = args[i];
+                        break;
+
+                      case 4:
+                        rotateaxis = args[i];
+                        break;
+
+                      case 5:
+                        rotateoffset = args[i];
+                        break;
+
+                      case 6:
+                        options = args[i];
+                        break;
+                    }
+                }
+            }
+            options = Object.assign({
+                addRotationCenter: false
+            }, options);
+            angle = angle || 0;
+            var info = normalVector(axis);
+            var bounds = object.getBounds();
+            var objectSize = size(object);
+            rotateaxis = rotateaxis || {
+                x: "y",
+                y: "x",
+                z: "x"
+            }[axis];
+            var cutDelta = options.cutDelta || getDelta(objectSize, bounds, axis, offset);
+            var rotateOffsetAxis = {
+                xy: "z",
+                yz: "x",
+                xz: "y"
+            }[[ axis, rotateaxis ].sort().join("")];
+            var centroid = object.centroid();
+            var rotateDelta = getDelta(objectSize, bounds, rotateOffsetAxis, rotateoffset);
+            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$1.OrthoNormalBasis.GetCartesian(info.orthoNormalCartesian[0], info.orthoNormalCartesian[1]).translate(cutDelta).rotate(rotationCenter, theRotationAxis, angle);
+            debug$2("bisect", debug$2.enabled && {
+                axis,
+                offset,
+                angle,
+                rotateaxis,
+                cutDelta,
+                rotateOffsetAxis,
+                rotationCenter,
+                theRotationAxis,
+                cutplane,
+                options
+            });
+            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;
+        }
+        function slice(object) {
+            var angle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 15;
+            var axis = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "x";
+            var rotateaxis = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "z";
+            var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
+                color: true,
+                addRotationCenter: true
+            };
+            var info = normalVector(axis);
+            var rotationCenter = options.rotationCenter || new CSG$1.Vector3D(0, 0, 0);
+            var theRotationAxis = rotationAxes[rotateaxis];
+            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);
+                g.add(unitAxis(objectSize.length() + 10, .1, rotationCenter), "rotationCenter");
+            }
+            return g;
+        }
+        function wedge(object, start, end, axis) {
+            var a = slice(object, start, axis);
+            var b = slice(a.parts.positive, end, axis);
+            return Group({
+                body: b.parts.positive.union(a.parts.negative).color("blue"),
+                wedge: b.parts.negative.color("red")
+            });
+        }
+        function stretch(object, axis, distance, offset) {
+            var normal = {
+                x: [ 1, 0, 0 ],
+                y: [ 0, 1, 0 ],
+                z: [ 0, 0, 1 ]
+            };
+            var bounds = object.getBounds();
+            var objectSize = size(object);
+            var cutDelta = getDelta(objectSize, bounds, axis, offset, true);
+            return assertValidCSG$1(object.stretchAtPlane(normal[axis], cutDelta, distance), "stretch");
+        }
+        function poly2solid(top, bottom, height) {
+            if (top.sides.length == 0) {
+                return new CSG$1;
+            }
+            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 ],
+                normalVector,
+                flipped: !(offsetVector.z < 0)
+            }));
+            polygons = polygons.concat(top._toPlanePolygons({
+                translation: offsetVector,
+                normalVector,
+                flipped: offsetVector.z < 0
+            }));
+            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 assertValidCSG$1(CSG$1.fromPolygons(polygons), "poly2solid");
+        }
+        function slices2poly(slices, options, axis) {
+            debug$2("slices2poly", slices, options, axis);
+            options = Object.assign({
+                twistangle: 0,
+                twiststeps: 0
+            }, options);
+            var twistangle = options && parseFloat(options.twistangle) || 0;
+            options && parseInt(options.twiststeps) || CSG$1.defaultResolution3D;
+            var normalVector = options.si.normalVector;
+            var polygons = [];
+            var first$1 = first(slices);
+            var last$1 = last(slices);
+            debug$2("slices2poly first", first$1, first$1.offset, "last", last$1);
+            var up = first$1.offset[axis] > last$1.offset[axis];
+            polygons = polygons.concat(first$1.poly._toPlanePolygons({
+                translation: first$1.offset,
+                normalVector,
+                flipped: !up
+            }));
+            var rotateAxis = "rotate" + axis.toUpperCase();
+            polygons = polygons.concat(last$1.poly._toPlanePolygons({
+                translation: last$1.offset,
+                normalVector: normalVector[rotateAxis](twistangle),
+                flipped: up
+            }));
+            var rotate = twistangle === 0 ? function rotateZero(v) {
+                return v;
+            } : function rotate(v, angle, percent) {
+                return v[rotateAxis](angle * percent);
+            };
+            var connectorAxis = last$1.offset.minus(first$1.offset).abs();
+            slices.forEach(function(slice, idx) {
+                if (idx < slices.length - 1) {
+                    var nextidx = idx + 1;
+                    var top = !up ? slices[nextidx] : slice;
+                    var bottom = up ? slices[nextidx] : slice;
+                    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,
+                        toConnector2: c2
+                    }));
+                }
+            });
+            return assertValidCSG$1(CSG$1.fromPolygons(polygons), "slices2poly");
+        }
+        function normalVector(axis) {
+            var axisInfo = {
+                z: {
+                    orthoNormalCartesian: [ "X", "Y" ],
+                    normalVector: CSG$1.Vector3D.Create(0, 1, 0)
+                },
+                x: {
+                    orthoNormalCartesian: [ "Y", "Z" ],
+                    normalVector: CSG$1.Vector3D.Create(0, 0, 1)
+                },
+                y: {
+                    orthoNormalCartesian: [ "Z", "X" ],
+                    normalVector: CSG$1.Vector3D.Create(0, 0, 1)
+                }
+            };
+            if (!axisInfo[axis]) error("normalVector: invalid axis " + axis);
+            return axisInfo[axis];
+        }
+        function sliceParams(orientation, radius, bounds) {
+            var axis = orientation[0];
+            var direction = orientation[1];
+            var dirInfo = {
+                "dir+": {
+                    sizeIdx: 1,
+                    sizeDir: -1,
+                    moveDir: -1,
+                    positive: true
+                },
+                "dir-": {
+                    sizeIdx: 0,
+                    sizeDir: 1,
+                    moveDir: 0,
+                    positive: false
+                }
+            };
+            var info = dirInfo["dir" + direction];
+            return Object.assign({
+                axis,
+                cutDelta: axisApply(axis, function(i, a) {
+                    return bounds[info.sizeIdx][a] + Math.abs(radius) * info.sizeDir;
+                }),
+                moveDelta: axisApply(axis, function(i, a) {
+                    return bounds[info.sizeIdx][a] + Math.abs(radius) * info.moveDir;
+                })
+            }, info, normalVector(axis));
+        }
+        function reShape(object, radius, orientation, options, slicer) {
+            options = options || {};
+            var b = object.getBounds();
+            var absoluteRadius = Math.abs(radius);
+            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$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;
+            });
+            var last = axisApply(si.axis, function() {
+                return si.positive ? absoluteRadius : 0;
+            });
+            var plane = si.positive ? cutplane.plane : cutplane.plane.flipped();
+            debug$2("reShape first/last", first, last);
+            var slices = slicer(first, last, slice, radius);
+            var delta = slices2poly(slices, Object.assign(options, {
+                si
+            }), si.axis).color(options.color);
+            var remainder = object.cutByPlane(plane);
+            return assertValidCSG$1(union([ options.unionOriginal ? object : remainder, delta.translate(si.moveDelta) ]), "reShape");
+        }
+        function chamfer(object, radius, orientation, options) {
+            return assertValidCSG$1(reShape(object, radius, orientation, options, function(first, last, slice) {
+                return [ {
+                    poly: slice,
+                    offset: new CSG$1.Vector3D(first)
+                }, {
+                    poly: enlarge(slice, [ -radius * 2, -radius * 2 ]),
+                    offset: new CSG$1.Vector3D(last)
+                } ];
+            }), "chamfer");
+        }
+        function fillet(object, radius, orientation, options) {
+            options = options || {};
+            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);
+                    var size = -radius * 2 - Math.cos(Math.asin(p)) * (-radius * 2);
+                    return {
+                        poly: enlarge(slice, [ size, size ]),
+                        offset: v
+                    };
+                });
+                return slices;
+            }), "fillet");
+        }
+        function calcRotate(part, solid, axis) {
+            var axes = {
+                x: [ 1, 0, 0 ],
+                y: [ 0, 1, 0 ],
+                z: [ 0, 0, 1 ]
+            };
+            var rotationCenter = solid.centroid();
+            var rotationAxis = axes[axis];
+            return {
+                rotationCenter,
+                rotationAxis
+            };
+        }
+        function rotateAround(part, solid, axis, angle) {
+            var _calcRotate = calcRotate(part, solid, axis), rotationCenter = _calcRotate.rotationCenter, rotationAxis = _calcRotate.rotationAxis;
+            return assertValidCSG$1("rotateAround")(part.rotate(rotationCenter, rotationAxis, angle));
+        }
+        function cloneProperties(from, to) {
+            return Object.entries(from).reduce(function(props, _ref) {
+                var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1];
+                props[key] = value;
+                return props;
+            }, to);
+        }
+        function clone(o) {
+            var c = CSG$1.fromPolygons(o.toPolygons());
+            cloneProperties(o, 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$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,
+            RoundedCube,
+            Cylinder,
+            Cone
+        };
+        function BBox$1() {
+            function box(object) {
+                return CSG$1.cube({
+                    center: object.centroid(),
+                    radius: object.size().dividedBy(2)
+                });
+            }
+            for (var _len = arguments.length, objects = new Array(_len), _key = 0; _key < _len; _key++) {
+                objects[_key] = arguments[_key];
+            }
+            return assertValidCSG(objects.reduce(function(bbox, part) {
+                var object = bbox ? union([ bbox, box(part) ]) : part;
+                return box(object);
+            }, undefined), "BBox");
+        }
+        function Cube(width) {
+            var r = div$1(fromxyz(width), 2);
+            return assertValidCSG(CSG$1.cube({
+                center: r,
+                radius: r
+            }), "Cube");
+        }
+        function RoundedCube(x, y, thickness, corner_radius) {
+            if (x.getBounds) {
+                var size$1 = size(x.getBounds());
+                var r = [ size$1.x / 2, size$1.y / 2 ];
+                thickness = size$1.z;
+                corner_radius = y;
+            } else {
+                var r = [ x / 2, y / 2 ];
+            }
+            debug$1("RoundedCube", size$1, r, thickness, corner_radius);
+            var roundedcube = CAG.roundedRectangle({
+                center: [ r[0], r[1], 0 ],
+                radius: r,
+                roundradius: corner_radius,
+                resolution: CSG$1.defaultResolution2D
+            }).extrude({
+                offset: [ 0, 0, thickness || 1.62 ]
+            });
+            return assertValidCSG(roundedcube, "RoundedCube");
+        }
+        function Cylinder(diameter, height) {
+            var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+            debug$1("parts.Cylinder", diameter, height, options);
+            options = Object.assign({
+                start: [ 0, 0, 0 ],
+                end: [ 0, 0, height ],
+                radius: diameter / 2,
+                resolution: CSG$1.defaultResolution2D
+            }, 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 assertValidCSG(CSG$1.cylinder(Object.assign({
+                start: [ 0, 0, 0 ],
+                end: [ 0, 0, height ],
+                radiusStart: diameter1 / 2,
+                radiusEnd: diameter2 / 2,
+                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 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 assertValidCSG(tri.extrude({
+                offset: [ 0, 0, height ]
+            }), "Triangle");
+        }
+        function Tube(outsideDiameter, insideDiameter, height, outsideOptions, insideOptions) {
+            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;
+            var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+            var hole = Cylinder(width, height).Center().color("red");
+            var post = Cylinder(height / 2, width * .66).rotateX(90).align(hole, "xz").snap(hole, "y", "inside-").translate([ 0, 0, -height / 6 ]).color("purple");
+            return Group({
+                post,
+                hole
+            });
+        }
+        function Board(width, height, corner_radius, thickness) {
+            var r = divA([ width, height ], 2);
+            var board = CAG.roundedRectangle({
+                center: [ r[0], r[1], 0 ],
+                radius: r,
+                roundradius: corner_radius,
+                resolution: CSG$1.defaultResolution2D
+            }).extrude({
+                offset: [ 0, 0, thickness || 1.62 ]
+            });
+            return assertValidCSG(board, "Board");
+        }
+        var Hardware = {
+            Orientation: {
+                up: {
+                    head: "outside-",
+                    clear: "inside+"
+                },
+                down: {
+                    head: "outside+",
+                    clear: "inside-"
+                }
+            },
+            Screw: function Screw(head, thread, headClearSpace, options) {
+                depreciated("Screw", false, "Use the jscad-hardware screw methods instead");
+                options = Object.assign(options, {
+                    orientation: "up",
+                    clearance: [ 0, 0, 0 ]
+                });
+                var orientation = Hardware.Orientation[options.orientation];
+                var group = Group("head,thread", {
+                    head: head.color("gray"),
+                    thread: thread.snap(head, "z", orientation.head).color("silver")
+                });
+                if (headClearSpace) {
+                    group.add(headClearSpace.enlarge(options.clearance).snap(head, "z", orientation.clear).color("red"), "headClearSpace", true);
+                }
+                return group;
+            },
+            PanHeadScrew: function PanHeadScrew(headDiameter, headLength, diameter, length, clearLength, options) {
+                depreciated("PanHeadScrew", false, "Use the jscad-hardware screw methods instead");
+                var head = Cylinder(headDiameter, headLength);
+                var thread = Cylinder(diameter, length);
+                if (clearLength) {
+                    var headClearSpace = Cylinder(headDiameter, clearLength);
+                }
+                return Hardware.Screw(head, thread, headClearSpace, options);
+            },
+            HexHeadScrew: function HexHeadScrew(headDiameter, headLength, diameter, length, clearLength, options) {
+                depreciated("HexHeadScrew", false, "Use the jscad-hardware screw methods instead");
+                var head = Hexagon(headDiameter, headLength);
+                var thread = Cylinder(diameter, length);
+                if (clearLength) {
+                    var headClearSpace = Hexagon(headDiameter, clearLength);
+                }
+                return Hardware.Screw(head, thread, headClearSpace, options);
+            },
+            FlatHeadScrew: function FlatHeadScrew(headDiameter, headLength, diameter, length, clearLength, options) {
+                depreciated("FlatHeadScrew", false, "Use the jscad-hardware screw methods instead");
+                var head = Cone(headDiameter, diameter, headLength);
+                var thread = Cylinder(diameter, length);
+                if (clearLength) {
+                    var headClearSpace = Cylinder(headDiameter, clearLength);
+                }
+                return Hardware.Screw(head, thread, headClearSpace, options);
+            }
+        };
+        var parts$1 = Object.freeze({
+            __proto__: null,
+            default: parts,
+            BBox: BBox$1,
+            Cube,
+            RoundedCube,
+            Cylinder,
+            Cone,
+            Hexagon,
+            Triangle,
+            Tube,
+            Anchor,
+            Board,
+            Hardware
+        });
+        var debug = Debug("jscadUtils:boxes");
+        function RabbetJoin(box, thickness, cutHeight) {
+            depreciated("RabbetJoin", true, "Use 'Rabbet' instead");
+            return rabbetJoin(box, thickness, cutHeight);
+        }
+        function topMiddleBottom(box, thickness) {
+            debug("TopMiddleBottom", box, thickness);
+            var bottom = box.bisect("z", thickness, {
+                color: true
+            });
+            var top = bottom.parts.positive.bisect("z", -thickness);
+            return Group("top,middle,bottom", [ top.parts.positive, top.parts.negative.color("green"), bottom.parts.negative ]);
+        }
+        function Rabett(box, thickness, gap, height, face) {
+            var options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+            debug("Rabett", "thickness", thickness, "gap", gap, "height", height, "face", face);
+            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;
+            var lowerBisectHeight = Math.sign(height) < 0 ? face * Math.sign(height) : height - face;
+            var _lower2_3rd$bisect$pa = lower2_3rd.bisect("z", lowerBisectHeight, options).parts, middle = _lower2_3rd$bisect$pa.positive, bottom = _lower2_3rd$bisect$pa.negative;
+            var middleTop = middle.color("yellow").subtract(middle.color("darkred").enlarge([ outside, outside, 0 ]));
+            group.add(top.union(middleTop), "top");
+            var bottomOutline = middle.color("yellow").subtract(middle.color("orange").enlarge([ outside, outside, 0 ])).enlarge([ outside, outside, 0 ]);
+            group.add(bottomOutline, "middle-top", true);
+            group.add(middle.color("green").subtract(middle.color("pink").enlarge([ inside, inside, 0 ])), "middle-bottom", true);
+            group.add(bottom.color("orange").union(middle.color("green").subtract(middle.color("red").enlarge([ inside, inside, 0 ])).subtract(middleTop)), "bottom");
+            return group;
+        }
+        var RabettTopBottom = function rabbetTMB(box, thickness) {
+            var gap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : .25;
+            var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+            options = Object.assign({
+                removableTop: true,
+                removableBottom: true,
+                topWidth: -thickness,
+                bottomWidth: thickness
+            }, options);
+            debug("RabettTopBottom", box, thickness, gap, options);
+            var group = Group("", {
+                box
+            });
+            var inside = -thickness - gap;
+            var outside = -thickness + gap;
+            if (options.removableTop) {
+                var top = box.bisect("z", options.topWidth, {
+                    color: true
+                });
+                group.add(top.parts.positive.enlarge([ inside, inside, 0 ]), "top");
+                if (!options.removableBottom) group.add(box.subtract(top.parts.positive.enlarge([ outside, outside, 0 ])), "bottom");
+            }
+            if (options.removableBottom) {
+                var bottom = box.bisect("z", options.bottomWidth, {
+                    color: true
+                });
+                group.add(bottom.parts.negative.enlarge([ outside, outside, 0 ]), "bottomCutout", true);
+                group.add(bottom.parts.negative.enlarge([ inside, inside, 0 ]), "bottom");
+                if (!options.removableTop) group.add(box.subtract(group.parts.bottomCutout), "top");
+            }
+            if (options.removableBottom && options.removableTop) {
+                group.add(box.subtract(union([ bottom.parts.negative.enlarge([ outside, outside, 0 ]), top.parts.positive.enlarge([ outside, outside, 0 ]) ])), "middle");
+            }
+            return group;
+        };
+        var CutOut = function cutOut(o, h, box, plug, gap) {
+            gap = gap || .25;
+            var s = o.size();
+            var cutout = o.intersect(box);
+            var cs = o.size();
+            var clear = Parts.Cube([ s.x, s.y, h ]).align(o, "xy").color("yellow");
+            var top = clear.snap(o, "z", "center+").union(o);
+            var back = Parts.Cube([ cs.x + 6, 2, cs.z + 2.5 ]).align(cutout, "x").snap(cutout, "z", "center+").snap(cutout, "y", "outside-");
+            var clip = Parts.Cube([ cs.x + 2 - gap, 1 - gap, cs.z + 2.5 ]).align(cutout, "x").snap(cutout, "z", "center+").snap(cutout, "y", "outside-");
+            return Group("insert", {
+                top,
+                bottom: clear.snap(o, "z", "center-").union(o),
+                cutout: union([ o, top ]),
+                back: back.subtract(plug).subtract(clip.enlarge(gap, gap, gap)).subtract(clear.translate([ 0, 5, 0 ])),
+                clip: clip.subtract(plug).color("red"),
+                insert: union([ o, top ]).intersect(box).subtract(o).enlarge([ -gap, 0, 0 ]).union(clip.subtract(plug).enlarge(-gap, -gap, 0)).color("blue")
+            });
+        };
+        var Rectangle = function Rectangle(size, thickness, cb) {
+            thickness = thickness || 2;
+            var s = div$1(xyz2array(size), 2);
+            var r = add(s, thickness);
+            var box = CSG$1.cube({
+                center: r,
+                radius: r
+            }).subtract(CSG$1.cube({
+                center: r,
+                radius: s
+            }));
+            if (cb) box = cb(box);
+            return box;
+        };
+        var Hollow = function Hollow(object, thickness, interiorcb, exteriorcb) {
+            thickness = thickness || 2;
+            var size = -thickness * 2;
+            interiorcb = interiorcb || identity;
+            var box = object.subtract(interiorcb(object.enlarge([ size, size, size ])));
+            if (exteriorcb) box = exteriorcb(box);
+            return box;
+        };
+        var BBox = function BBox(o) {
+            depreciated("BBox", true, "Use 'parts.BBox' instead");
+            var s = div$1(xyz2array(o.size()), 2);
+            return CSG$1.cube({
+                center: s,
+                radius: s
+            }).align(o, "xyz");
+        };
+        function getRadius(o) {
+            return div$1(xyz2array(o.size()), 2);
+        }
+        function rabbetJoin(box, thickness) {
+            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$1.cube({
+                center: r,
+                radius: r
+            }).align(box, "xy").color("green");
+            var topCutter = cutter.snap(box, "z", "inside+");
+            var group = Group("", {
+                topCutter,
+                bottomCutter: cutter
+            });
+            group.add(box.subtract(cutter.enlarge([ gap, gap, 0 ])).color("blue"), "top");
+            group.add(box.subtract(topCutter.enlarge([ gap, gap, 0 ])).color("red"), "bottom");
+            return group;
+        }
+        var Boxes = Object.freeze({
+            __proto__: null,
+            RabbetJoin,
+            topMiddleBottom,
+            Rabett,
+            RabettTopBottom,
+            CutOut,
+            Rectangle,
+            Hollow,
+            BBox
+        });
+        var compatV1 = _objectSpread2(_objectSpread2({}, util), {}, {
+            group: Group,
+            init: init$1,
+            triangle: triUtils,
+            array,
+            parts: parts$1,
+            Boxes,
+            Debug
+        });
+        exports.Boxes = Boxes;
+        exports.Debug = Debug;
+        exports.Group = Group;
+        exports.array = array;
+        exports.compatV1 = compatV1;
+        exports.init = init$1;
+        exports.parts = parts$1;
+        exports.triUtils = triUtils;
+        exports.util = util;
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        return exports;
+    }({}, jsCadCSG, scadApi);
+    const debug = jscadUtils.Debug("jscadUtils:initJscadutils");
+    util = jscadUtils.compatV1;
+    util.init.default(CSG);
+    debug("initJscadutils:jscadUtils", jscadUtils);
+    Parts = jscadUtils.parts;
+    Boxes = jscadUtils.Boxes;
+    Group = jscadUtils.Group;
+    Debug = jscadUtils.Debug;
+    array = jscadUtils.array;
+    triUtils = jscadUtils.triUtils;
+    return jscadUtils;
+}
+
+var jscadUtilsPluginInit = [];
+
+var util = {
+    init: (...a) => {
+        initJscadutils(...a);
+        jscadUtilsPluginInit.forEach(p => {
+            p(...a);
+        });
+    }
+};
+// endinject