@jwc/jscad-utils 4.8.4 → 5.0.0

package/dist/examples/text.jscad

@@ -54,335 +54,13 @@ function initJscadutils(_CSG, options = {}) {
     });
     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$1;
-            },
-            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 _typeof(obj) {
-            "@babel/helpers - typeof";
-            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-                _typeof = function(obj) {
-                    return typeof obj;
-                };
-            } else {
-                _typeof = function(obj) {
-                    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-                };
-            }
-            return _typeof(obj);
-        }
-        function _defineProperty(obj, key, value) {
-            if (key in obj) {
-                Object.defineProperty(obj, key, {
-                    value,
-                    enumerable: true,
-                    configurable: true,
-                    writable: true
-                });
-            } else {
-                obj[key] = value;
-            }
-            return obj;
-        }
-        function ownKeys(object, enumerableOnly) {
-            var keys = Object.keys(object);
-            if (Object.getOwnPropertySymbols) {
-                var symbols = Object.getOwnPropertySymbols(object);
-                if (enumerableOnly) symbols = symbols.filter((function(sym) {
-                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-                }));
-                keys.push.apply(keys, symbols);
-            }
-            return keys;
-        }
-        function _objectSpread2(target) {
-            for (var i = 1; i < arguments.length; i++) {
-                var source = arguments[i] != null ? arguments[i] : {};
-                if (i % 2) {
-                    ownKeys(Object(source), true).forEach((function(key) {
-                        _defineProperty(target, key, source[key]);
-                    }));
-                } else if (Object.getOwnPropertyDescriptors) {
-                    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-                } else {
-                    ownKeys(Object(source)).forEach((function(key) {
-                        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-                    }));
-                }
-            }
-            return target;
-        }
-        function _slicedToArray(arr, i) {
-            return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-        }
-        function _arrayWithHoles(arr) {
-            if (Array.isArray(arr)) return arr;
-        }
-        function _iterableToArrayLimit(arr, i) {
-            if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-            var _arr = [];
-            var _n = true;
-            var _d = false;
-            var _e = undefined;
-            try {
-                for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-                    _arr.push(_s.value);
-                    if (i && _arr.length === i) break;
-                }
-            } catch (err) {
-                _d = true;
-                _e = err;
-            } finally {
-                try {
-                    if (!_n && _i["return"] != null) _i["return"]();
-                } finally {
-                    if (_d) throw _e;
-                }
-            }
-            return _arr;
-        }
-        function _unsupportedIterableToArray(o, minLen) {
-            if (!o) return;
-            if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-            var n = Object.prototype.toString.call(o).slice(8, -1);
-            if (n === "Object" && o.constructor) n = o.constructor.name;
-            if (n === "Map" || n === "Set") return Array.from(o);
-            if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-        }
-        function _arrayLikeToArray(arr, len) {
-            if (len == null || len > arr.length) len = arr.length;
-            for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-            return arr2;
-        }
-        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.");
-        }
-        var toRadians = function toRadians(deg) {
+        const toRadians = function toRadians(deg) {
             return deg / 180 * Math.PI;
         };
-        var toDegrees = function toDegrees(rad) {
+        const toDegrees = function toDegrees(rad) {
             return rad * (180 / Math.PI);
         };
-        var solve = function solve(p1, p2) {
+        const solve = function(p1, p2) {
             var r = {
                 c: 90,
                 A: Math.abs(p2.x - p1.x),
@@ -394,7 +72,7 @@ function initJscadutils(_CSG, options = {}) {
             r.a = 90 - r.b;
             return r;
         };
-        var solve90SA = function solve90SA(r) {
+        const solve90SA = function(r) {
             r = Object.assign(r, {
                 C: 90
             });
@@ -406,7 +84,7 @@ function initJscadutils(_CSG, options = {}) {
             r.b = r.b || r.a / Math.tan(arad);
             return r;
         };
-        var solve90ac = function solve90ac(r) {
+        const solve90ac = function(r) {
             r = Object.assign(r, {
                 C: 90
             });
@@ -427,60 +105,60 @@ function initJscadutils(_CSG, options = {}) {
         }
         var triUtils = Object.freeze({
             __proto__: null,
-            toRadians,
-            toDegrees,
             solve,
             solve90SA,
             solve90ac,
-            solveab
+            solveab,
+            toDegrees,
+            toRadians
         });
-        var div = function div(a, f) {
-            return a.map((function(e) {
+        const div$1 = function(a, f) {
+            return a.map(function(e) {
                 return e / f;
-            }));
+            });
         };
-        var addValue = function addValue(a, f) {
-            return a.map((function(e) {
+        const addValue = function(a, f) {
+            return a.map(function(e) {
                 return e + f;
-            }));
+            });
         };
-        var addArray = function addArray(a, f) {
-            return a.map((function(e, i) {
+        const addArray = function(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) {
+        const add = function(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);
+            }, a);
         };
-        var fromxyz = function fromxyz(object) {
+        const fromxyz = function(object) {
             return Array.isArray(object) ? object : [ object.x, object.y, object.z ];
         };
-        var toxyz = function toxyz(a) {
+        const toxyz = function(a) {
             return {
                 x: a[0],
                 y: a[1],
                 z: a[2]
             };
         };
-        var first = function first(a) {
+        const first = function(a) {
             return a ? a[0] : undefined;
         };
-        var last = function last(a) {
+        const last = function(a) {
             return a && a.length > 0 ? a[a.length - 1] : undefined;
         };
-        var min = function min(a) {
-            return a.reduce((function(result, value) {
+        const min = function(a) {
+            return a.reduce(function(result, value) {
                 return value < result ? value : result;
-            }), Number.MAX_VALUE);
+            }, Number.MAX_VALUE);
         };
-        var range = function range(a, b) {
+        const range = function(a, b) {
             var result = [];
             for (var i = a; i < b; i++) {
                 result.push(i);
@@ -489,21 +167,21 @@ function initJscadutils(_CSG, options = {}) {
         };
         var array = Object.freeze({
             __proto__: null,
-            div,
-            addValue,
-            addArray,
             add,
-            fromxyz,
-            toxyz,
+            addArray,
+            addValue,
+            div: div$1,
             first,
+            fromxyz,
             last,
             min,
-            range
+            range,
+            toxyz
         });
-        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" ];
+        const debugColors = [ "#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00", "#ffff33", "#a65628", "#f781bf", "#999999" ];
+        const 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) {
+        const Debug = function(name) {
             var checks = Object.assign({
                 enabled: [],
                 disabled: [],
@@ -511,31 +189,21 @@ function initJscadutils(_CSG, 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) {
+            var style = checks.options.browser ? `color:${debugColors[debugCount++ % debugColors.length]}` : `${termColors[debugCount++ % termColors.length]}`;
+            var enabled = checks.enabled.some(function checkEnabled(check) {
                 return check.test(name);
-            })) && !checks.disabled.some((function checkEnabled(check) {
+            }) && !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;
-            };
+            });
+            var logger = enabled ? checks.options.browser ? (...msg) => {
+                console.log("%c%s", style, name, ...msg);
+            } : (...msg) => {
+                console.log(`${name}`, ...msg);
+            } : () => undefined;
             logger.enabled = enabled;
             return logger;
         };
-        var nameArray = {
+        const nameArray = {
             aliceblue: "#f0f8ff",
             antiquewhite: "#faebd7",
             aqua: "#00ffff",
@@ -693,9 +361,11 @@ function initJscadutils(_CSG, options = {}) {
             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 = {};
+        const _name2rgb = {};
         function name2rgb(n) {
             if (!_name2rgb[n]) _name2rgb[n] = hex2rgb(name2hex(n));
             return _name2rgb[n];
@@ -703,9 +373,9 @@ function initJscadutils(_CSG, options = {}) {
         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) {
+            var c = name2rgb(r).map(function(x) {
                 return x / 255;
-            }));
+            });
             c[3] = g || 1;
             return o.setColor(c);
         }
@@ -775,23 +445,14 @@ function initJscadutils(_CSG, 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.bisect = function bisect$1(...args) {
+                return bisect(this, ...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.slice = function slice$1(...args) {
+                return slice(this, ...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.wedge = function wedge$1(...args) {
+                return wedge(this, ...args);
             };
             proto.prototype.stretch = function stretch$1(axis, distance, offset) {
                 return stretch(this, axis, distance, offset);
@@ -807,24 +468,20 @@ function initJscadutils(_CSG, options = {}) {
                 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);
+                    var t = Array.prototype.slice.call(arguments, 0).reduce(function(result, arg) {
+                        result = undefined.addArray(result, arg);
                         return result;
-                    }), [ 0, 0, 0 ]);
+                    }, [ 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);
+            proto.prototype.connect = function connectTo(myConnectorName, otherConnector, mirror = false, normalrotation = 0) {
+                var myConnector = myConnectorName.split(".").reduce((a, v) => 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");
+                    error(`The connector '${myConnectorName}' does not exist on the object [${Object.keys(this.properties).join(",")}]`, "Missing connector property");
                 }
                 return this.connectTo(myConnector, otherConnector, mirror, normalrotation);
             };
@@ -834,32 +491,29 @@ function initJscadutils(_CSG, options = {}) {
             __proto__: null,
             default: init
         });
-        var CSG = 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;
+        const {CSG, CAG} = jsCadCSG;
+        const {rectangular_extrude} = scadApi.extrusions;
+        const {vector_text, vector_char} = scadApi.text;
+        const {union} = scadApi.booleanOps;
         init(CSG);
-        var debug = Debug("jscadUtils: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] : [];
+        const debug$3 = Debug("jscadUtils:group");
+        function JsCadUtilsGroup(names = [], parts = {}, holes = []) {
             this.name = "";
             this.names = names;
             this.parts = parts;
             this.holes = holes;
         }
         JsCadUtilsGroup.prototype.add = function(object, name, hidden, subparts, parts) {
-            debug("add", 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) {
+                        Object.keys(object.parts).forEach(function(key) {
                             self.parts[subparts + key] = object.parts[key];
-                        }));
+                        });
                     }
                 } else {
                     Object.assign(self.parts, object.parts);
@@ -871,11 +525,7 @@ function initJscadutils(_CSG, options = {}) {
             }
             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;
-            };
+        JsCadUtilsGroup.prototype.combine = function(pieces, options = {}, map = x => x) {
             try {
                 var self = this;
                 options = Object.assign({
@@ -883,31 +533,30 @@ function initJscadutils(_CSG, options = {}) {
                 }, 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));
+                    throw new Error(`no pieces found in ${self.name} pieces: ${pieces} parts: ${Object.keys(self.parts)} names: ${self.names}`);
                 }
-                debug("combine", self.names, self.parts);
-                var g = union(mapPick(self.parts, pieces, (function(value, key, index, object) {
+                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));
+                }, self.name));
                 return g.subtractIf(self.holes && Array.isArray(self.holes) ? union(self.holes) : self.holes, self.holes && !options.noholes);
             } catch (err) {
-                debug("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");
+                debug$3("combine error", this, pieces, options, err);
+                throw error(`group::combine error "${err.message || err.toString()}"\nthis: ${this}\npieces: "${pieces}"\noptions: ${JSON.stringify(options, null, 2)}\nstack: ${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) {
+            self.parts = Object.keys(self.parts).filter(k => 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) {
+                    self.holes = self.holes.map(function(hole, idx) {
                         return cb(hole, idx);
-                    }));
+                    });
                 } else {
                     self.holes = cb(self.holes, "holes");
                 }
@@ -915,7 +564,7 @@ function initJscadutils(_CSG, options = {}) {
             return self;
         };
         JsCadUtilsGroup.prototype.clone = function(name, map) {
-            debug("clone", name, _typeof(name), map);
+            debug$3("clone", name, typeof name, map);
             var self = this;
             if (typeof name == "function") {
                 map = name;
@@ -923,15 +572,15 @@ function initJscadutils(_CSG, options = {}) {
             }
             if (!map) map = identity;
             var group = Group(name);
-            Object.keys(self.parts).forEach((function(key) {
+            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) {
+                group.holes = toArray(self.holes).map(function(part) {
                     return map(CSG.fromPolygons(part.toPolygons()), "holes");
-                }));
+                });
             }
             return group;
         };
@@ -948,9 +597,9 @@ function initJscadutils(_CSG, options = {}) {
             }
             var rotationCenter = solid.centroid();
             var rotationAxis = axes[axis];
-            self.map((function(part) {
+            self.map(function(part) {
                 return part.rotate(rotationCenter, rotationAxis, angle);
-            }));
+            });
             return self;
         };
         JsCadUtilsGroup.prototype.combineAll = function(options, map) {
@@ -961,13 +610,13 @@ function initJscadutils(_CSG, options = {}) {
             try {
                 var self = this;
                 var t = calcSnap(self.combine(part), to, axis, orientation, delta);
-                self.map((function(part) {
+                self.map(function(part) {
                     return part.translate(t);
-                }));
+                });
                 return self;
             } catch (err) {
-                debug("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");
+                debug$3("snap error", this, part, to, axis, delta, err);
+                throw error(`group::snap error "${err.message || err.toString()}"\nthis: ${this}\npart: "${part}"\nto: ${to}\naxis: "${axis}"\norientation: "${orientation}"\ndelta: "${delta}"\nstack: ${err.stack}\n`, "JSCAD_UTILS_GROUP_ERROR");
             }
         };
         JsCadUtilsGroup.prototype.align = function align(part, to, axis, delta) {
@@ -976,13 +625,13 @@ function initJscadutils(_CSG, options = {}) {
                 var t = calcCenterWith(self.combine(part, {
                     noholes: true
                 }), axis, to, delta);
-                self.map((function(part) {
+                self.map(function(part) {
                     return part.translate(t);
-                }));
+                });
                 return self;
             } catch (err) {
-                debug("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");
+                debug$3("align error", this, part, to, axis, delta, err);
+                throw error(`group::align error "${err.message || err.toString()}"\nthis: ${this}\npart: "${part}"\nto: ${to}\naxis: "${axis}"\ndelta: "${delta}"\nstack: ${err.stack}\n`, "JSCAD_UTILS_GROUP_ERROR");
             }
         };
         JsCadUtilsGroup.prototype.center = function center(part) {
@@ -994,10 +643,8 @@ function initJscadutils(_CSG, options = {}) {
             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("connectTo", {
+        JsCadUtilsGroup.prototype.connectTo = function connectTo(partName, connectorName, to, toConnectorName, mirror = true, normalrotation = 0) {
+            debug$3("connectTo", {
                 partName,
                 connectorName,
                 to,
@@ -1006,38 +653,34 @@ function initJscadutils(_CSG, options = {}) {
                 normalrotation
             });
             var self = this;
-            var myConnector = connectorName.split(".").reduce((function(a, v) {
-                return a[v];
-            }), self.parts[partName].properties);
-            debug("toConnector", to instanceof CSG.Connector);
-            var toConnector = toConnectorName.split(".").reduce((function(a, v) {
-                return a[v];
-            }), to.properties);
+            var myConnector = connectorName.split(".").reduce((a, v) => a[v], self.parts[partName].properties);
+            debug$3("toConnector", to instanceof CSG.Connector);
+            var toConnector = toConnectorName.split(".").reduce((a, v) => a[v], to.properties);
             var matrix = myConnector.getTransformationTo(toConnector, mirror, normalrotation);
-            debug("connectTo", matrix);
-            self.map((function(part) {
+            debug$3("connectTo", matrix);
+            self.map(function(part) {
                 return part.transform(matrix);
-            }));
+            });
             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) {
+            var t = axisApply(axis, function(i, a) {
                 return to - size[a] / 2;
-            }));
-            self.map((function(part) {
+            });
+            self.map(function(part) {
                 return part.translate(t);
-            }));
+            });
             return self;
         };
         JsCadUtilsGroup.prototype.translate = function translate(x, y, z) {
             var self = this;
             var t = Array.isArray(x) ? x : [ x, y, z ];
-            debug("translate", t);
-            self.map((function(part) {
+            debug$3("translate", t);
+            self.map(function(part) {
                 return part.translate(t);
-            }));
+            });
             return self;
         };
         JsCadUtilsGroup.prototype.pick = function(parts, map) {
@@ -1045,43 +688,42 @@ function initJscadutils(_CSG, options = {}) {
             var p = parts && parts.length > 0 && parts.split(",") || self.names;
             if (!map) map = identity;
             var g = Group();
-            p.forEach((function(name) {
+            p.forEach(function(name) {
                 g.add(map(CSG.fromPolygons(self.parts[name].toPolygons()), name), 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) {
+            p.forEach(name => {
                 if (!self.parts[name]) {
-                    debug("array error", _this, parts);
-                    throw error('group::array error "'.concat(name, '" not found.\nthis: ').concat(_this, '\nparts: "').concat(parts, '"\n'), "JSCAD_UTILS_GROUP_ERROR");
+                    debug$3("array error", this, parts);
+                    throw error(`group::array error "${name}" not found.\nthis: ${this}\nparts: "${parts}"\n`, "JSCAD_UTILS_GROUP_ERROR");
                 }
                 a.push(map(CSG.fromPolygons(self.parts[name].toPolygons()), name));
-            }));
+            });
             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 piecesArray.map(function(piece) {
+                if (!self.parts[piece]) console.error(`Cannot find ${piece} in ${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(this.holes, '"\n}');
+            return `{\n  name: "${this.name}",\n  names: "${this.names.join(",")}", \n  parts: "${Object.keys(this.parts)}",\n  holes: ${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("Group", objectNames, addObjects);
+            debug$3("Group", objectNames, addObjects);
             var self = {
                 name: "",
                 names: [],
@@ -1104,9 +746,7 @@ function initJscadutils(_CSG, options = {}) {
                         self.name = objectNames;
                     } else {
                         var objects = objectNames;
-                        self.names = Object.keys(objects).filter((function(k) {
-                            return k !== "holes";
-                        }));
+                        self.names = Object.keys(objects).filter(k => k !== "holes");
                         self.parts = Object.assign({}, objects);
                         self.holes = objects.holes;
                     }
@@ -1114,17 +754,13 @@ function initJscadutils(_CSG, options = {}) {
             }
             return new JsCadUtilsGroup(self.names, self.parts, self.holes);
         }
-        var debug$1 = Debug("jscadUtils:util");
+        const debug$2 = Debug("jscadUtils: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;
+        const nearest = {
+            under: function(desired, nozzel = NOZZEL_SIZE, nozzie = 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;
+            over: function(desired, nozzel = NOZZEL_SIZE, nozzie = 0) {
                 return (Math.ceil(desired / nozzel) + nozzie) * nozzel;
             }
         };
@@ -1149,12 +785,12 @@ function initJscadutils(_CSG, options = {}) {
             return ((n = +n) || 1 / n) < 0;
         }
         function print(msg, o) {
-            debug$1(msg, JSON.stringify(o.getBounds()), JSON.stringify(this.size(o.getBounds())));
+            debug$2(msg, JSON.stringify(o.getBounds()), JSON.stringify(this.size(o.getBounds())));
         }
         function jscadToString(o) {
-            if (_typeof(o) == "object") {
+            if (typeof o == "object") {
                 if (o.polygons) {
-                    return "{\npolygons: ".concat(o.polygons.length, ',\nproperties: "').concat(Object.keys(o.properties), '"\n}\n');
+                    return `{\npolygons: ${o.polygons.length},\nproperties: "${Object.keys(o.properties)}"\n}\n`;
                 }
             } else {
                 return o.toString();
@@ -1185,22 +821,22 @@ function initJscadutils(_CSG, options = {}) {
         function label(text, x, y, width, height) {
             var l = vector_text(x || 0, y || 0, text);
             var o = [];
-            l.forEach((function(pl) {
+            l.forEach(function(pl) {
                 o.push(rectangular_extrude(pl, {
                     w: width || 2,
                     h: height || 2
                 }));
-            }));
+            });
             return center(union(o));
         }
         function text(text) {
             var l = vector_char(0, 0, text);
-            var _char = l.segments.reduce((function(result, segment) {
+            var char = l.segments.reduce(function(result, segment) {
                 var path = new CSG.Path2D(segment);
                 var cag = path.expandToCAG(2);
                 return result ? result.union(cag) : cag;
-            }), undefined);
-            return _char;
+            }, undefined);
+            return char;
         }
         function unitCube(length, radius) {
             radius = radius || .5;
@@ -1210,7 +846,7 @@ function initJscadutils(_CSG, options = {}) {
             });
         }
         function unitAxis(length, radius, centroid) {
-            debug$1("unitAxis", length, radius, centroid);
+            debug$2("unitAxis", length, radius, centroid);
             centroid = centroid || [ 0, 0, 0 ];
             var unitaxis = unitCube(length, radius).setColor(1, 0, 0).union([ unitCube(length, radius).rotateY(90).setColor(0, 1, 0), unitCube(length, radius).rotateX(90).setColor(0, 0, 1) ]);
             unitaxis.properties.origin = new CSG.Connector([ 0, 0, 0 ], [ 1, 0, 0 ], [ 0, 1, 0 ]);
@@ -1232,38 +868,38 @@ function initJscadutils(_CSG, options = {}) {
             return result;
         }
         function zipObject(names, values) {
-            return names.reduce((function(result, value, idx) {
+            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 Object.keys(o).map(function(key) {
                 return f(o[key], key, o);
-            }));
+            });
         }
         function mapValues(o, f) {
-            return Object.keys(o).map((function(key) {
+            return Object.keys(o).map(function(key) {
                 return f(o[key], key);
-            }));
+            });
         }
         function pick(o, names) {
-            return names.reduce((function(result, name) {
+            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) {
+            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(",")));
+                    throw new Error(`${name} not found in ${options.name}: ${Object.keys(o).join(",")}`);
                 }
                 result.push(f ? f(o[name], name, index, o) : o[name]);
                 return result;
-            }), []);
+            }, []);
         }
         function divA(a, f) {
-            return div(a, f);
+            return div$1(a, f);
         }
         function divxyz(size, x, y, z) {
             return {
@@ -1272,7 +908,7 @@ function initJscadutils(_CSG, options = {}) {
                 z: size.z / z
             };
         }
-        function div$1(size, d) {
+        function div(size, d) {
             return this.divxyz(size, d, d, d);
         }
         function mulxyz(size, x, y, z) {
@@ -1288,7 +924,7 @@ function initJscadutils(_CSG, options = {}) {
         function xyz2array(size) {
             return [ size.x, size.y, size.z ];
         }
-        var rotationAxes = {
+        const rotationAxes = {
             x: [ 1, 0, 0 ],
             y: [ 0, 1, 0 ],
             z: [ 0, 0, 1 ]
@@ -1324,9 +960,9 @@ function initJscadutils(_CSG, options = {}) {
             var objectSize = size(object);
             var objectCentroid = centroid(object, objectSize);
             var idx = 0;
-            var t = map(objectSize, (function(i) {
+            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);
@@ -1350,10 +986,10 @@ function initJscadutils(_CSG, options = {}) {
             }
             var s = [ scale(objectSize.x, x), scale(objectSize.y, y), scale(objectSize.z, z) ];
             var min$1 = min(s);
-            return centerWith(object.scale(s.map((function(d, i) {
+            return centerWith(object.scale(s.map(function(d, i) {
                 if (a[i] === 0) return 1;
                 return keep_aspect_ratio ? min$1 : d;
-            }))), "xyz", object);
+            })), "xyz", object);
         }
         function shift(object, x, y, z) {
             var hsize = this.div(this.size(object.getBounds()), 2);
@@ -1366,7 +1002,7 @@ function initJscadutils(_CSG, options = {}) {
         function mirrored4(x) {
             return x.union([ x.mirroredY(90), x.mirroredX(90), x.mirroredY(90).mirroredX(90) ]);
         }
-        var flushSide = {
+        const flushSide = {
             "above-outside": [ 1, 0 ],
             "above-inside": [ 1, 1 ],
             "below-outside": [ 0, 1 ],
@@ -1392,12 +1028,11 @@ function initJscadutils(_CSG, options = {}) {
             if (side[0] === -1) {
                 w[-1] = toxyz(withobj.centroid());
             }
-            return this.axisApply(axes, (function(i, axis) {
+            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;
+        function calcSnap(moveobj, withobj, axes, orientation, delta = 0) {
             var side = flushSide[orientation];
             if (!side) {
                 var fix = {
@@ -1415,15 +1050,15 @@ function initJscadutils(_CSG, options = {}) {
             if (side[0] === -1) {
                 w[-1] = withobj.centroid();
             }
-            var t = axisApply(axes, (function(i, axis) {
+            var t = axisApply(axes, function(i, axis) {
                 return w[side[0]][axis] - m[side[1]][axis];
-            }));
-            return delta ? axisApply(axes, (function(i) {
+            });
+            return delta ? axisApply(axes, function(i) {
                 return t[i] + delta;
-            })) : t;
+            }) : t;
         }
         function snap(moveobj, withobj, axis, orientation, delta) {
-            debug$1("snap", moveobj, withobj, axis, orientation, delta);
+            debug$2("snap", moveobj, withobj, axis, orientation, delta);
             var t = calcSnap(moveobj, withobj, axis, orientation, delta);
             return moveobj.translate(t);
         }
@@ -1431,16 +1066,16 @@ function initJscadutils(_CSG, options = {}) {
             return moveobj.translate(calcFlush(moveobj, withobj, axis, mside, wside));
         }
         function axisApply(axes, valfun, a) {
-            debug$1("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) {
+            axes.split("").forEach(function(axis) {
                 retval[lookup[axis]] = valfun(lookup[axis], axis);
-            }));
+            });
             return retval;
         }
         function axis2array(axes, valfun) {
@@ -1451,10 +1086,10 @@ function initJscadutils(_CSG, options = {}) {
                 y: 1,
                 z: 2
             };
-            axes.split("").forEach((function(axis) {
+            axes.split("").forEach(function(axis) {
                 var i = lookup[axis];
                 a[i] = valfun(i, axis);
-            }));
+            });
             return a;
         }
         function centroid(o, objectSize) {
@@ -1463,15 +1098,15 @@ function initJscadutils(_CSG, options = {}) {
                 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);
+                error(`centroid error o:${jscadToString(o)} objectSize: ${objectSize}`, undefined, err);
             }
         }
         function calcmidlineTo(o, axis, to) {
             var bounds = o.getBounds();
             var objectSize = size(bounds);
-            return axisApply(axis, (function(i, a) {
+            return axisApply(axis, function(i, a) {
                 return to - objectSize[a] / 2;
-            }));
+            });
         }
         function midlineTo(o, axis, to) {
             return o.translate(calcmidlineTo(o, axis, to));
@@ -1479,18 +1114,17 @@ function initJscadutils(_CSG, options = {}) {
         function translator(o, axis, withObj) {
             var objectCentroid = centroid(o);
             var withCentroid = centroid(withObj);
-            var t = axisApply(axis, (function(i) {
+            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;
+        function calcCenterWith(o, axes, withObj, delta = 0) {
             var objectCentroid = centroid(o);
             var withCentroid = centroid(withObj);
-            var t = axisApply(axes, (function(i, axis) {
+            var t = axisApply(axes, function(i, axis) {
                 return withCentroid[axis] - objectCentroid[axis];
-            }));
+            });
             return delta ? add(t, delta) : t;
         }
         function centerWith(o, axis, withObj) {
@@ -1503,16 +1137,13 @@ function initJscadutils(_CSG, options = {}) {
                 }
             }
             var dist = isNegative(offset) ? offset = size[axis] + offset : offset;
-            return axisApply(axis, (function(i, a) {
+            return axisApply(axis, function(i, a) {
                 return bounds[0][a] + (isEmpty(dist) ? size[axis] / 2 : dist);
-            }));
+            });
         }
-        function bisect() {
-            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-                args[_key] = arguments[_key];
-            }
+        function bisect(...args) {
             if (args.length < 2) {
-                error("bisect requries an object and an axis", "JSCAD_UTILS_INVALID_ARGS");
+                error("bisect requires an object and an axis", "JSCAD_UTILS_INVALID_ARGS");
             }
             var object = args[0];
             var axis = args[1];
@@ -1568,14 +1199,14 @@ function initJscadutils(_CSG, options = {}) {
             }[[ axis, rotateaxis ].sort().join("")];
             var centroid = object.centroid();
             var rotateDelta = getDelta(objectSize, bounds, rotateOffsetAxis, rotateoffset);
-            var rotationCenter = options.rotationCenter || new CSG.Vector3D(axisApply("xyz", (function(i, a) {
+            var rotationCenter = options.rotationCenter || new CSG.Vector3D(axisApply("xyz", function(i, a) {
                 if (a == axis) return cutDelta[i];
                 if (a == rotateOffsetAxis) return rotateDelta[i];
                 return centroid[a];
-            })));
+            }));
             var theRotationAxis = rotationAxes[rotateaxis];
             var cutplane = CSG.OrthoNormalBasis.GetCartesian(info.orthoNormalCartesian[0], info.orthoNormalCartesian[1]).translate(cutDelta).rotate(rotationCenter, theRotationAxis, angle);
-            debug$1("bisect", debug$1.enabled && {
+            debug$2("bisect", debug$2.enabled && {
                 axis,
                 offset,
                 angle,
@@ -1591,14 +1222,10 @@ function initJscadutils(_CSG, options = {}) {
             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
-            };
+        function slice(object, angle = 15, axis = "x", rotateaxis = "z", options = {
+            color: true,
+            addRotationCenter: true
+        }) {
             var info = normalVector(axis);
             var rotationCenter = options.rotationCenter || new CSG.Vector3D(0, 0, 0);
             var theRotationAxis = rotationAxes[rotateaxis];
@@ -1656,21 +1283,18 @@ function initJscadutils(_CSG, options = {}) {
             return CSG.fromPolygons(polygons);
         }
         function slices2poly(slices, options, axis) {
-            debug$1("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;
-            var twiststeps = options && parseInt(options.twiststeps) || CSG.defaultResolution3D;
-            if (twistangle == 0 || twiststeps < 1) {
-                twiststeps = 1;
-            }
+            options && parseInt(options.twiststeps) || CSG.defaultResolution3D;
             var normalVector = options.si.normalVector;
             var polygons = [];
             var first$1 = first(slices);
             var last$1 = last(slices);
-            debug$1("slices2poly first", first$1, first$1.offset, "last", last$1);
+            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,
@@ -1689,7 +1313,7 @@ function initJscadutils(_CSG, options = {}) {
                 return v[rotateAxis](angle * percent);
             };
             var connectorAxis = last$1.offset.minus(first$1.offset).abs();
-            slices.forEach((function(slice, idx) {
+            slices.forEach(function(slice, idx) {
                 if (idx < slices.length - 1) {
                     var nextidx = idx + 1;
                     var top = !up ? slices[nextidx] : slice;
@@ -1702,7 +1326,7 @@ function initJscadutils(_CSG, options = {}) {
                         toConnector2: c2
                     }));
                 }
-            }));
+            });
             return CSG.fromPolygons(polygons);
         }
         function normalVector(axis) {
@@ -1743,12 +1367,12 @@ function initJscadutils(_CSG, options = {}) {
             var info = dirInfo["dir" + direction];
             return Object.assign({
                 axis,
-                cutDelta: axisApply(axis, (function(i, a) {
+                cutDelta: axisApply(axis, function(i, a) {
                     return bounds[info.sizeIdx][a] + Math.abs(radius) * info.sizeDir;
-                })),
-                moveDelta: axisApply(axis, (function(i, a) {
+                }),
+                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) {
@@ -1756,18 +1380,18 @@ function initJscadutils(_CSG, options = {}) {
             var b = object.getBounds();
             var absoluteRadius = Math.abs(radius);
             var si = sliceParams(orientation, radius, b);
-            debug$1("reShape", absoluteRadius, si);
-            if (si.axis !== "z") throw new Error('reShape error: CAG._toPlanePolytons only uses the "z" axis.  You must use the "z" axis for now.');
+            debug$2("reShape", absoluteRadius, si);
+            if (si.axis !== "z") throw new Error('reShape error: CAG._toPlanePolygons only uses the "z" axis.  You must use the "z" axis for now.');
             var cutplane = CSG.OrthoNormalBasis.GetCartesian(si.orthoNormalCartesian[0], si.orthoNormalCartesian[1]).translate(si.cutDelta);
             var slice = object.sectionCut(cutplane);
-            var first = axisApply(si.axis, (function() {
+            var first = axisApply(si.axis, function() {
                 return si.positive ? 0 : absoluteRadius;
-            }));
-            var last = axisApply(si.axis, (function() {
+            });
+            var last = axisApply(si.axis, function() {
                 return si.positive ? absoluteRadius : 0;
-            }));
+            });
             var plane = si.positive ? cutplane.plane : cutplane.plane.flipped();
-            debug$1("reShape first/last", first, last);
+            debug$2("reShape first/last", first, last);
             var slices = slicer(first, last, slice, radius);
             var delta = slices2poly(slices, Object.assign(options, {
                 si
@@ -1776,7 +1400,7 @@ function initJscadutils(_CSG, options = {}) {
             return union([ options.unionOriginal ? object : remainder, delta.translate(si.moveDelta) ]);
         }
         function chamfer(object, radius, orientation, options) {
-            return reShape(object, radius, orientation, options, (function(first, last, slice) {
+            return reShape(object, radius, orientation, options, function(first, last, slice) {
                 return [ {
                     poly: slice,
                     offset: new CSG.Vector3D(first)
@@ -1784,15 +1408,15 @@ function initJscadutils(_CSG, options = {}) {
                     poly: enlarge(slice, [ -radius * 2, -radius * 2 ]),
                     offset: new CSG.Vector3D(last)
                 } ];
-            }));
+            });
         }
         function fillet(object, radius, orientation, options) {
             options = options || {};
-            return reShape(object, radius, orientation, options, (function(first, last, slice) {
+            return reShape(object, radius, orientation, options, function(first, last, slice) {
                 var v1 = new CSG.Vector3D(first);
                 var v2 = new CSG.Vector3D(last);
                 var res = options.resolution || CSG.defaultResolution3D;
-                var slices = range(0, res).map((function(i) {
+                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);
@@ -1800,9 +1424,9 @@ function initJscadutils(_CSG, options = {}) {
                         poly: enlarge(slice, [ size, size ]),
                         offset: v
                     };
-                }));
+                });
                 return slices;
-            }));
+            });
         }
         function calcRotate(part, solid, axis) {
             var axes = {
@@ -1818,54 +1442,121 @@ function initJscadutils(_CSG, options = {}) {
             };
         }
         function rotateAround(part, solid, axis, angle) {
-            var _calcRotate = calcRotate(part, solid, axis), rotationCenter = _calcRotate.rotationCenter, rotationAxis = _calcRotate.rotationAxis;
+            var {rotationCenter, rotationAxis} = calcRotate(part, solid, axis);
             return 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];
+        function cloneProperties(from, to, depth = 0) {
+            return Object.entries(from).reduce((props, [key, value]) => {
                 props[key] = value;
                 return props;
-            }), to);
+            }, to);
         }
         function clone(o) {
             var c = CSG.fromPolygons(o.toPolygons());
             cloneProperties(o, c);
-            debug$1("clone", o, c, CSG);
+            debug$2("clone", o, c, CSG);
             return c;
         }
-        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 ];
+        function addConnector(object, name, point = [ 0, 0, 0 ], axis = [ 1, 0, 0 ], normal = [ 0, 0, 1 ]) {
             object.properties[name] = new CSG.Connector(point, axis, normal);
             return object;
         }
-        var debug$2 = Debug("jscadUtils:parts");
+        var util = Object.freeze({
+            __proto__: null,
+            NOZZEL_SIZE,
+            addConnector,
+            axis2array,
+            axisApply,
+            bisect,
+            calcCenterWith,
+            calcFlush,
+            calcRotate,
+            calcSnap,
+            calcmidlineTo,
+            center,
+            centerWith,
+            centerX,
+            centerY,
+            centroid,
+            chamfer,
+            clone,
+            cm,
+            defaults,
+            depreciated,
+            div,
+            divA,
+            divxyz,
+            enlarge,
+            error,
+            fillet,
+            fit,
+            flush,
+            flushSide,
+            getDelta,
+            identity,
+            ifArray,
+            inch,
+            isEmpty,
+            isNegative,
+            jscadToString,
+            label,
+            map,
+            mapPick,
+            mapValues,
+            midlineTo,
+            mirrored4,
+            mul,
+            mulxyz,
+            nearest,
+            normalVector,
+            pick,
+            poly2solid,
+            print,
+            reShape,
+            result,
+            rotateAround,
+            rotationAxes,
+            scale,
+            segment,
+            shift,
+            size,
+            slice,
+            sliceParams,
+            slices2poly,
+            snap,
+            stretch,
+            text,
+            toArray,
+            translator,
+            unitAxis,
+            unitCube,
+            wedge,
+            xyz2array,
+            zero,
+            zipObject
+        });
+        const debug$1 = Debug("jscadUtils:parts");
         var parts = {
-            BBox,
+            BBox: BBox$1,
             Cube,
             RoundedCube,
             Cylinder,
             Cone
         };
-        function BBox() {
+        function BBox$1(...objects) {
             function box(object) {
                 return CSG.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 objects.reduce((function(bbox, part) {
+            return objects.reduce(function(bbox, part) {
                 var object = bbox ? union([ bbox, box(part) ]) : part;
                 return box(object);
-            }), undefined);
+            }, undefined);
         }
         function Cube(width) {
-            var r = div(fromxyz(width), 2);
+            var r = div$1(fromxyz(width), 2);
             return CSG.cube({
                 center: r,
                 radius: r
@@ -1880,7 +1571,7 @@ function initJscadutils(_CSG, options = {}) {
             } else {
                 var r = [ x / 2, y / 2 ];
             }
-            debug$2("RoundedCube", size$1, r, thickness, corner_radius);
+            debug$1("RoundedCube", size$1, r, thickness, corner_radius);
             var roundedcube = CAG.roundedRectangle({
                 center: [ r[0], r[1], 0 ],
                 radius: r,
@@ -1891,9 +1582,8 @@ function initJscadutils(_CSG, options = {}) {
             });
             return roundedcube;
         }
-        function Cylinder(diameter, height) {
-            var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-            debug$2("parts.Cylinder", diameter, height, options);
+        function Cylinder(diameter, height, options = {}) {
+            debug$1("parts.Cylinder", diameter, height, options);
             options = Object.assign({
                 start: [ 0, 0, 0 ],
                 end: [ 0, 0, height ],
@@ -1902,9 +1592,8 @@ function initJscadutils(_CSG, options = {}) {
             }, options);
             return CSG.cylinder(options);
         }
-        function Cone(diameter1, diameter2, height) {
-            var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-            debug$2("parts.Cone", diameter1, diameter2, height, options);
+        function Cone(diameter1, diameter2, height, options = {}) {
+            debug$1("parts.Cone", diameter1, diameter2, height, options);
             return CSG.cylinder(Object.assign({
                 start: [ 0, 0, 0 ],
                 end: [ 0, 0, height ],
@@ -1914,7 +1603,7 @@ function initJscadutils(_CSG, options = {}) {
             }, options));
         }
         function Hexagon(diameter, height) {
-            debug$2("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 ] ]);
@@ -1932,9 +1621,7 @@ function initJscadutils(_CSG, options = {}) {
         function Tube(outsideDiameter, insideDiameter, height, outsideOptions, insideOptions) {
             return Cylinder(outsideDiameter, height, outsideOptions).subtract(Cylinder(insideDiameter, height, insideOptions || outsideOptions));
         }
-        function Anchor() {
-            var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
-            var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+        function Anchor(width = 10, height = 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({
@@ -1954,7 +1641,7 @@ function initJscadutils(_CSG, options = {}) {
             });
             return board;
         }
-        var Hardware = {
+        const Hardware = {
             Orientation: {
                 up: {
                     head: "outside-",
@@ -1965,7 +1652,7 @@ function initJscadutils(_CSG, options = {}) {
                     clear: "inside-"
                 }
             },
-            Screw: function Screw(head, thread, headClearSpace, options) {
+            Screw: function(head, thread, headClearSpace, options) {
                 depreciated("Screw", false, "Use the jscad-hardware screw methods instead");
                 options = Object.assign(options, {
                     orientation: "up",
@@ -1981,7 +1668,7 @@ function initJscadutils(_CSG, options = {}) {
                 }
                 return group;
             },
-            PanHeadScrew: function PanHeadScrew(headDiameter, headLength, diameter, length, clearLength, options) {
+            PanHeadScrew: function(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);
@@ -1990,7 +1677,7 @@ function initJscadutils(_CSG, options = {}) {
                 }
                 return Hardware.Screw(head, thread, headClearSpace, options);
             },
-            HexHeadScrew: function HexHeadScrew(headDiameter, headLength, diameter, length, clearLength, options) {
+            HexHeadScrew: function(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);
@@ -1999,7 +1686,7 @@ function initJscadutils(_CSG, options = {}) {
                 }
                 return Hardware.Screw(head, thread, headClearSpace, options);
             },
-            FlatHeadScrew: function FlatHeadScrew(headDiameter, headLength, diameter, length, clearLength, options) {
+            FlatHeadScrew: function(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);
@@ -2011,43 +1698,42 @@ function initJscadutils(_CSG, options = {}) {
         };
         var parts$1 = Object.freeze({
             __proto__: null,
-            default: parts,
-            BBox,
+            Anchor,
+            BBox: BBox$1,
+            Board,
+            Cone,
             Cube,
-            RoundedCube,
             Cylinder,
-            Cone,
+            Hardware,
             Hexagon,
+            RoundedCube,
             Triangle,
             Tube,
-            Anchor,
-            Board,
-            Hardware
+            default: parts
         });
-        var debug$3 = Debug("jscadUtils:boxes");
+        const 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$3("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$3("Rabett", "thickness", thickness, "gap", gap, "height", height, "face", face);
+        function Rabett(box, thickness, gap, height, face, options = {}) {
+            debug("Rabett", "thickness", thickness, "gap", gap, "height", height, "face", face);
             gap = gap || .25;
             var inside = thickness - gap;
             var outside = -thickness + gap;
-            debug$3("inside", inside, "outside", outside);
+            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 {positive: top, negative: lower2_3rd} = box.bisect("z", height, options).parts;
             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 {positive: middle, negative: bottom} = lower2_3rd.bisect("z", lowerBisectHeight, options).parts;
             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 ]);
@@ -2056,16 +1742,14 @@ function initJscadutils(_CSG, options = {}) {
             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] : {};
+        const RabettTopBottom = function rabbetTMB(box, thickness, gap = .25, options = {}) {
             options = Object.assign({
                 removableTop: true,
                 removableBottom: true,
                 topWidth: -thickness,
                 bottomWidth: thickness
             }, options);
-            debug$3("RabettTopBottom", box, thickness, gap, options);
+            debug("RabettTopBottom", box, thickness, gap, options);
             var group = Group("", {
                 box
             });
@@ -2091,7 +1775,7 @@ function initJscadutils(_CSG, options = {}) {
             }
             return group;
         };
-        var CutOut = function cutOut(o, h, box, plug, gap) {
+        const CutOut = function cutOut(o, h, box, plug, gap) {
             gap = gap || .25;
             var s = o.size();
             var cutout = o.intersect(box);
@@ -2109,9 +1793,9 @@ function initJscadutils(_CSG, options = {}) {
                 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) {
+        const Rectangle = function(size, thickness, cb) {
             thickness = thickness || 2;
-            var s = div(xyz2array(size), 2);
+            var s = div$1(xyz2array(size), 2);
             var r = add(s, thickness);
             var box = CSG.cube({
                 center: r,
@@ -2123,7 +1807,7 @@ function initJscadutils(_CSG, options = {}) {
             if (cb) box = cb(box);
             return box;
         };
-        var Hollow = function Hollow(object, thickness, interiorcb, exteriorcb) {
+        const Hollow = function(object, thickness, interiorcb, exteriorcb) {
             thickness = thickness || 2;
             var size = -thickness * 2;
             interiorcb = interiorcb || identity;
@@ -2131,19 +1815,18 @@ function initJscadutils(_CSG, options = {}) {
             if (exteriorcb) box = exteriorcb(box);
             return box;
         };
-        var BBox$1 = function BBox(o) {
+        const BBox = function(o) {
             depreciated("BBox", true, "Use 'parts.BBox' instead");
-            var s = div(xyz2array(o.size()), 2);
+            var s = div$1(xyz2array(o.size()), 2);
             return CSG.cube({
                 center: s,
                 radius: s
             }).align(o, "xyz");
         };
         function getRadius(o) {
-            return div(xyz2array(o.size()), 2);
+            return div$1(xyz2array(o.size()), 2);
         }
-        function rabbetJoin(box, thickness) {
-            var gap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : .25;
+        function rabbetJoin(box, thickness, gap = .25) {
             var r = add(getRadius(box), -thickness / 2);
             r[2] = thickness / 2;
             var cutter = CSG.cube({
@@ -2161,16 +1844,17 @@ function initJscadutils(_CSG, options = {}) {
         }
         var Boxes = Object.freeze({
             __proto__: null,
+            BBox,
+            CutOut,
+            Hollow,
             RabbetJoin,
-            topMiddleBottom,
             Rabett,
             RabettTopBottom,
-            CutOut,
             Rectangle,
-            Hollow,
-            BBox: BBox$1
+            topMiddleBottom
         });
-        var compatV1 = _objectSpread2(_objectSpread2({}, util), {}, {
+        const compatV1 = {
+            ...util,
             group: Group,
             init: init$1,
             triangle: triUtils,
@@ -2178,7 +1862,7 @@ function initJscadutils(_CSG, options = {}) {
             parts: parts$1,
             Boxes,
             Debug
-        });
+        };
         exports.Boxes = Boxes;
         exports.Debug = Debug;
         exports.Group = Group;