@jwc/jscad-utils 5.0.1 → 5.1.0

package/dist/examples/fillet.jscad

@@ -59,13 +59,329 @@ function initJscadutils(_CSG, options = {}) {
     });
     var jscadUtils = function(exports, jsCadCSG, scadApi) {
         "use strict";
-        const toRadians = function toRadians(deg) {
+        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 _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;
         };
-        const toDegrees = function toDegrees(rad) {
+        var toDegrees = function toDegrees(rad) {
             return rad * (180 / Math.PI);
         };
-        const solve = function(p1, p2) {
+        var solve = function solve(p1, p2) {
             var r = {
                 c: 90,
                 A: Math.abs(p2.x - p1.x),
@@ -77,7 +393,7 @@ function initJscadutils(_CSG, options = {}) {
             r.a = 90 - r.b;
             return r;
         };
-        const solve90SA = function(r) {
+        var solve90SA = function solve90SA(r) {
             r = Object.assign(r, {
                 C: 90
             });
@@ -89,7 +405,7 @@ function initJscadutils(_CSG, options = {}) {
             r.b = r.b || r.a / Math.tan(arad);
             return r;
         };
-        const solve90ac = function(r) {
+        var solve90ac = function solve90ac(r) {
             r = Object.assign(r, {
                 C: 90
             });
@@ -110,29 +426,29 @@ function initJscadutils(_CSG, options = {}) {
         }
         var triUtils = Object.freeze({
             __proto__: null,
+            toRadians,
+            toDegrees,
             solve,
             solve90SA,
             solve90ac,
-            solveab,
-            toDegrees,
-            toRadians
+            solveab
         });
-        const div$1 = function(a, f) {
+        var div$1 = function div(a, f) {
             return a.map(function(e) {
                 return e / f;
             });
         };
-        const addValue = function(a, f) {
+        var addValue = function addValue(a, f) {
             return a.map(function(e) {
                 return e + f;
             });
         };
-        const addArray = function(a, f) {
+        var addArray = function addArray(a, f) {
             return a.map(function(e, i) {
                 return e + f[i];
             });
         };
-        const add = function(a) {
+        var add = function add(a) {
             return Array.prototype.slice.call(arguments, 1).reduce(function(result, arg) {
                 if (Array.isArray(arg)) {
                     result = addArray(result, arg);
@@ -142,28 +458,28 @@ function initJscadutils(_CSG, options = {}) {
                 return result;
             }, a);
         };
-        const fromxyz = function(object) {
+        var fromxyz = function fromxyz(object) {
             return Array.isArray(object) ? object : [ object.x, object.y, object.z ];
         };
-        const toxyz = function(a) {
+        var toxyz = function toxyz(a) {
             return {
                 x: a[0],
                 y: a[1],
                 z: a[2]
             };
         };
-        const first = function(a) {
+        var first = function first(a) {
             return a ? a[0] : undefined;
         };
-        const last = function(a) {
+        var last = function last(a) {
             return a && a.length > 0 ? a[a.length - 1] : undefined;
         };
-        const min = function(a) {
+        var min = function min(a) {
             return a.reduce(function(result, value) {
                 return value < result ? value : result;
             }, Number.MAX_VALUE);
         };
-        const range = function(a, b) {
+        var range = function range(a, b) {
             var result = [];
             for (var i = a; i < b; i++) {
                 result.push(i);
@@ -172,21 +488,21 @@ function initJscadutils(_CSG, options = {}) {
         };
         var array = Object.freeze({
             __proto__: null,
-            add,
-            addArray,
-            addValue,
             div: div$1,
-            first,
+            addValue,
+            addArray,
+            add,
             fromxyz,
+            toxyz,
+            first,
             last,
             min,
-            range,
-            toxyz
+            range
         });
-        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 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;
-        const Debug = function(name) {
+        var Debug = function Debug(name) {
             var checks = Object.assign({
                 enabled: [],
                 disabled: [],
@@ -194,21 +510,31 @@ function initJscadutils(_CSG, options = {}) {
                     browser: true
                 }
             }, jscadUtilsDebug || {});
-            var style = checks.options.browser ? `color:${debugColors[debugCount++ % debugColors.length]}` : `${termColors[debugCount++ % termColors.length]}`;
+            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 ? (...msg) => {
-                console.log("%c%s", style, name, ...msg);
-            } : (...msg) => {
-                console.log(`${name}`, ...msg);
-            } : () => undefined;
+            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;
         };
-        const nameArray = {
+        var nameArray = {
             aliceblue: "#f0f8ff",
             antiquewhite: "#faebd7",
             aqua: "#00ffff",
@@ -370,7 +696,7 @@ function initJscadutils(_CSG, options = {}) {
                 return [ 0, 0, 0 ];
             }
         }
-        const _name2rgb = {};
+        var _name2rgb = {};
         function name2rgb(n) {
             if (!_name2rgb[n]) _name2rgb[n] = hex2rgb(name2hex(n));
             return _name2rgb[n];
@@ -450,14 +776,23 @@ 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(...args) {
-                return bisect(this, ...args);
+            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(...args) {
-                return slice(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.wedge = function wedge$1(...args) {
-                return wedge(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.stretch = function stretch$1(axis, distance, offset) {
                 return stretch(this, axis, distance, offset);
@@ -474,7 +809,7 @@ function initJscadutils(_CSG, options = {}) {
                     return this._translate(arguments[0]);
                 } else {
                     var t = Array.prototype.slice.call(arguments, 0).reduce(function(result, arg) {
-                        result = undefined.addArray(result, arg);
+                        result = undefined(result, arg);
                         return result;
                     }, [ 0, 0, 0 ]);
                     return this._translate(t);
@@ -483,10 +818,14 @@ function initJscadutils(_CSG, options = {}) {
             proto.prototype.addConnector = function addConnector$1(name, point, axis, normal) {
                 return addConnector(this, name, point, axis, normal);
             };
-            proto.prototype.connect = function connectTo(myConnectorName, otherConnector, mirror = false, normalrotation = 0) {
-                var myConnector = myConnectorName.split(".").reduce((a, v) => a[v], this.properties);
+            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 '${myConnectorName}' does not exist on the object [${Object.keys(this.properties).join(",")}]`, "Missing connector property");
+                    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);
             };
@@ -496,13 +835,16 @@ function initJscadutils(_CSG, options = {}) {
             __proto__: null,
             default: init
         });
-        const {CSG, CAG} = jsCadCSG;
-        const {rectangular_extrude} = scadApi.extrusions;
-        const {vector_text, vector_char} = scadApi.text;
-        const {union} = scadApi.booleanOps;
+        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;
         init(CSG);
-        const debug$3 = Debug("jscadUtils:group");
-        function JsCadUtilsGroup(names = [], parts = {}, holes = []) {
+        var debug$3 = 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] : [];
             this.name = "";
             this.names = names;
             this.parts = parts;
@@ -530,7 +872,11 @@ function initJscadutils(_CSG, options = {}) {
             }
             return self;
         };
-        JsCadUtilsGroup.prototype.combine = function(pieces, options = {}, map = x => x) {
+        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({
@@ -538,7 +884,7 @@ function initJscadutils(_CSG, options = {}) {
                 }, options);
                 pieces = pieces ? pieces.split(",") : self.names;
                 if (pieces.length === 0) {
-                    throw new Error(`no pieces found in ${self.name} pieces: ${pieces} parts: ${Object.keys(self.parts)} names: ${self.names}`);
+                    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) {
@@ -548,12 +894,14 @@ function initJscadutils(_CSG, options = {}) {
                 return g.subtractIf(self.holes && Array.isArray(self.holes) ? union(self.holes) : self.holes, self.holes && !options.noholes);
             } catch (err) {
                 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");
+                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(k => k !== "holes").reduce(function(result, key) {
+            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;
             }, {});
@@ -569,7 +917,7 @@ function initJscadutils(_CSG, options = {}) {
             return self;
         };
         JsCadUtilsGroup.prototype.clone = function(name, map) {
-            debug$3("clone", name, typeof name, map);
+            debug$3("clone", name, _typeof(name), map);
             var self = this;
             if (typeof name == "function") {
                 map = name;
@@ -621,7 +969,7 @@ function initJscadutils(_CSG, options = {}) {
                 return self;
             } catch (err) {
                 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");
+                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) {
@@ -636,7 +984,7 @@ function initJscadutils(_CSG, options = {}) {
                 return self;
             } catch (err) {
                 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");
+                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) {
@@ -648,7 +996,9 @@ 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, mirror = true, normalrotation = 0) {
+        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,
@@ -658,9 +1008,13 @@ function initJscadutils(_CSG, options = {}) {
                 normalrotation
             });
             var self = this;
-            var myConnector = connectorName.split(".").reduce((a, v) => a[v], self.parts[partName].properties);
+            var myConnector = connectorName.split(".").reduce(function(a, v) {
+                return 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 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) {
@@ -699,14 +1053,15 @@ function initJscadutils(_CSG, options = {}) {
             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(name => {
+            p.forEach(function(name) {
                 if (!self.parts[name]) {
-                    debug$3("array error", this, parts);
-                    throw error(`group::array error "${name}" not found.\nthis: ${this}\nparts: "${parts}"\n`, "JSCAD_UTILS_GROUP_ERROR");
+                    debug$3("array error", _this, parts);
+                    throw error('group::array error "'.concat(name, '" not found.\nthis: ').concat(_this, '\nparts: "').concat(parts, '"\n'), "JSCAD_UTILS_GROUP_ERROR");
                 }
                 a.push(map(CSG.fromPolygons(self.parts[name].toPolygons()), name));
             });
@@ -716,12 +1071,12 @@ function initJscadutils(_CSG, options = {}) {
             var self = this;
             var piecesArray = pieces ? pieces.split(",") : self.names;
             return piecesArray.map(function(piece) {
-                if (!self.parts[piece]) console.error(`Cannot find ${piece} in ${self.names}`);
+                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: "${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}`;
+            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;
@@ -751,7 +1106,9 @@ function initJscadutils(_CSG, options = {}) {
                         self.name = objectNames;
                     } else {
                         var objects = objectNames;
-                        self.names = Object.keys(objects).filter(k => k !== "holes");
+                        self.names = Object.keys(objects).filter(function(k) {
+                            return k !== "holes";
+                        });
                         self.parts = Object.assign({}, objects);
                         self.holes = objects.holes;
                     }
@@ -759,13 +1116,17 @@ function initJscadutils(_CSG, options = {}) {
             }
             return new JsCadUtilsGroup(self.names, self.parts, self.holes);
         }
-        const debug$2 = Debug("jscadUtils:util");
+        var debug$2 = Debug("jscadUtils:util");
         var NOZZEL_SIZE = .4;
-        const nearest = {
-            under: function(desired, nozzel = NOZZEL_SIZE, nozzie = 0) {
+        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(desired, nozzel = NOZZEL_SIZE, nozzie = 0) {
+            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;
             }
         };
@@ -793,9 +1154,9 @@ function initJscadutils(_CSG, options = {}) {
             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: ${o.polygons.length},\nproperties: "${Object.keys(o.properties)}"\n}\n`;
+                    return "{\npolygons: ".concat(o.polygons.length, ',\nproperties: "').concat(Object.keys(o.properties), '"\n}\n');
                 }
             } else {
                 return o.toString();
@@ -836,12 +1197,12 @@ function initJscadutils(_CSG, options = {}) {
         }
         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;
+            return _char;
         }
         function unitCube(length, radius) {
             radius = radius || .5;
@@ -897,7 +1258,7 @@ function initJscadutils(_CSG, options = {}) {
         function mapPick(o, names, f, options) {
             return names.reduce(function(result, name, index) {
                 if (!o[name]) {
-                    throw new Error(`${name} not found in ${options.name}: ${Object.keys(o).join(",")}`);
+                    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;
@@ -929,7 +1290,7 @@ function initJscadutils(_CSG, options = {}) {
         function xyz2array(size) {
             return [ size.x, size.y, size.z ];
         }
-        const rotationAxes = {
+        var rotationAxes = {
             x: [ 1, 0, 0 ],
             y: [ 0, 1, 0 ],
             z: [ 0, 0, 1 ]
@@ -1007,7 +1368,7 @@ function initJscadutils(_CSG, options = {}) {
         function mirrored4(x) {
             return x.union([ x.mirroredY(90), x.mirroredX(90), x.mirroredY(90).mirroredX(90) ]);
         }
-        const flushSide = {
+        var flushSide = {
             "above-outside": [ 1, 0 ],
             "above-inside": [ 1, 1 ],
             "below-outside": [ 0, 1 ],
@@ -1037,7 +1398,8 @@ function initJscadutils(_CSG, options = {}) {
                 return w[side[0]][axis] - m[side[1]][axis];
             });
         }
-        function calcSnap(moveobj, withobj, axes, orientation, delta = 0) {
+        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 = {
@@ -1103,7 +1465,7 @@ function initJscadutils(_CSG, options = {}) {
                 objectSize = objectSize || size(bounds);
                 return bounds[0].plus(objectSize.dividedBy(2));
             } catch (err) {
-                error(`centroid error o:${jscadToString(o)} objectSize: ${objectSize}`, undefined, err);
+                error("centroid error o:".concat(jscadToString(o), " objectSize: ").concat(objectSize), undefined, err);
             }
         }
         function calcmidlineTo(o, axis, to) {
@@ -1124,7 +1486,8 @@ function initJscadutils(_CSG, options = {}) {
             });
             return t;
         }
-        function calcCenterWith(o, axes, withObj, delta = 0) {
+        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) {
@@ -1146,7 +1509,10 @@ function initJscadutils(_CSG, options = {}) {
                 return bounds[0][a] + (isEmpty(dist) ? size[axis] / 2 : dist);
             });
         }
-        function bisect(...args) {
+        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");
             }
@@ -1227,10 +1593,14 @@ function initJscadutils(_CSG, options = {}) {
             if (options.addRotationCenter) g.add(unitAxis(objectSize.length() + 10, .1, rotationCenter), "rotationCenter");
             return g;
         }
-        function slice(object, angle = 15, axis = "x", rotateaxis = "z", options = {
-            color: true,
-            addRotationCenter: true
-        }) {
+        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.Vector3D(0, 0, 0);
             var theRotationAxis = rotationAxes[rotateaxis];
@@ -1447,11 +1817,12 @@ function initJscadutils(_CSG, options = {}) {
             };
         }
         function rotateAround(part, solid, axis, angle) {
-            var {rotationCenter, rotationAxis} = calcRotate(part, solid, axis);
+            var _calcRotate = calcRotate(part, solid, axis), rotationCenter = _calcRotate.rotationCenter, rotationAxis = _calcRotate.rotationAxis;
             return part.rotate(rotationCenter, rotationAxis, angle);
         }
-        function cloneProperties(from, to, depth = 0) {
-            return Object.entries(from).reduce((props, [key, value]) => {
+        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);
@@ -1462,85 +1833,14 @@ function initJscadutils(_CSG, options = {}) {
             debug$2("clone", o, c, CSG);
             return c;
         }
-        function addConnector(object, name, point = [ 0, 0, 0 ], axis = [ 1, 0, 0 ], normal = [ 0, 0, 1 ]) {
+        function addConnector(object, name) {
+            var point = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [ 0, 0, 0 ];
+            var axis = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [ 1, 0, 0 ];
+            var normal = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [ 0, 0, 1 ];
             object.properties[name] = new CSG.Connector(point, axis, normal);
             return object;
         }
-        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 debug$1 = Debug("jscadUtils:parts");
         var parts = {
             BBox: BBox$1,
             Cube,
@@ -1548,13 +1848,16 @@ function initJscadutils(_CSG, options = {}) {
             Cylinder,
             Cone
         };
-        function BBox$1(...objects) {
+        function BBox$1() {
             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) {
                 var object = bbox ? union([ bbox, box(part) ]) : part;
                 return box(object);
@@ -1587,7 +1890,8 @@ function initJscadutils(_CSG, options = {}) {
             });
             return roundedcube;
         }
-        function Cylinder(diameter, height, options = {}) {
+        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 ],
@@ -1597,7 +1901,8 @@ function initJscadutils(_CSG, options = {}) {
             }, options);
             return CSG.cylinder(options);
         }
-        function Cone(diameter1, diameter2, height, options = {}) {
+        function Cone(diameter1, diameter2, height) {
+            var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
             debug$1("parts.Cone", diameter1, diameter2, height, options);
             return CSG.cylinder(Object.assign({
                 start: [ 0, 0, 0 ],
@@ -1626,7 +1931,9 @@ function initJscadutils(_CSG, options = {}) {
         function Tube(outsideDiameter, insideDiameter, height, outsideOptions, insideOptions) {
             return Cylinder(outsideDiameter, height, outsideOptions).subtract(Cylinder(insideDiameter, height, insideOptions || outsideOptions));
         }
-        function Anchor(width = 10, height = 10) {
+        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({
@@ -1646,7 +1953,7 @@ function initJscadutils(_CSG, options = {}) {
             });
             return board;
         }
-        const Hardware = {
+        var Hardware = {
             Orientation: {
                 up: {
                     head: "outside-",
@@ -1657,7 +1964,7 @@ function initJscadutils(_CSG, options = {}) {
                     clear: "inside-"
                 }
             },
-            Screw: function(head, thread, headClearSpace, options) {
+            Screw: function Screw(head, thread, headClearSpace, options) {
                 depreciated("Screw", false, "Use the jscad-hardware screw methods instead");
                 options = Object.assign(options, {
                     orientation: "up",
@@ -1673,7 +1980,7 @@ function initJscadutils(_CSG, options = {}) {
                 }
                 return group;
             },
-            PanHeadScrew: function(headDiameter, headLength, diameter, length, clearLength, options) {
+            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);
@@ -1682,7 +1989,7 @@ function initJscadutils(_CSG, options = {}) {
                 }
                 return Hardware.Screw(head, thread, headClearSpace, options);
             },
-            HexHeadScrew: function(headDiameter, headLength, diameter, length, clearLength, 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);
@@ -1691,7 +1998,7 @@ function initJscadutils(_CSG, options = {}) {
                 }
                 return Hardware.Screw(head, thread, headClearSpace, options);
             },
-            FlatHeadScrew: function(headDiameter, headLength, diameter, length, clearLength, 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);
@@ -1703,20 +2010,20 @@ function initJscadutils(_CSG, options = {}) {
         };
         var parts$1 = Object.freeze({
             __proto__: null,
-            Anchor,
+            default: parts,
             BBox: BBox$1,
-            Board,
-            Cone,
             Cube,
+            RoundedCube,
             Cylinder,
-            Hardware,
+            Cone,
             Hexagon,
-            RoundedCube,
             Triangle,
             Tube,
-            default: parts
+            Anchor,
+            Board,
+            Hardware
         });
-        const debug = Debug("jscadUtils:boxes");
+        var debug = Debug("jscadUtils:boxes");
         function RabbetJoin(box, thickness, cutHeight) {
             depreciated("RabbetJoin", true, "Use 'Rabbet' instead");
             return rabbetJoin(box, thickness, cutHeight);
@@ -1729,16 +2036,17 @@ function initJscadutils(_CSG, options = {}) {
             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, options = {}) {
+        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;
             debug("inside", inside, "outside", outside);
             var group = Group();
-            var {positive: top, negative: lower2_3rd} = box.bisect("z", height, options).parts;
+            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 {positive: middle, negative: bottom} = lower2_3rd.bisect("z", lowerBisectHeight, options).parts;
+            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 ]);
@@ -1747,7 +2055,9 @@ 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;
         }
-        const RabettTopBottom = function rabbetTMB(box, thickness, gap = .25, options = {}) {
+        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,
@@ -1780,7 +2090,7 @@ function initJscadutils(_CSG, options = {}) {
             }
             return group;
         };
-        const CutOut = function cutOut(o, h, box, plug, gap) {
+        var CutOut = function cutOut(o, h, box, plug, gap) {
             gap = gap || .25;
             var s = o.size();
             var cutout = o.intersect(box);
@@ -1798,7 +2108,7 @@ 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")
             });
         };
-        const Rectangle = function(size, thickness, cb) {
+        var Rectangle = function Rectangle(size, thickness, cb) {
             thickness = thickness || 2;
             var s = div$1(xyz2array(size), 2);
             var r = add(s, thickness);
@@ -1812,7 +2122,7 @@ function initJscadutils(_CSG, options = {}) {
             if (cb) box = cb(box);
             return box;
         };
-        const Hollow = function(object, thickness, interiorcb, exteriorcb) {
+        var Hollow = function Hollow(object, thickness, interiorcb, exteriorcb) {
             thickness = thickness || 2;
             var size = -thickness * 2;
             interiorcb = interiorcb || identity;
@@ -1820,7 +2130,7 @@ function initJscadutils(_CSG, options = {}) {
             if (exteriorcb) box = exteriorcb(box);
             return box;
         };
-        const BBox = function(o) {
+        var BBox = function BBox(o) {
             depreciated("BBox", true, "Use 'parts.BBox' instead");
             var s = div$1(xyz2array(o.size()), 2);
             return CSG.cube({
@@ -1831,7 +2141,8 @@ function initJscadutils(_CSG, options = {}) {
         function getRadius(o) {
             return div$1(xyz2array(o.size()), 2);
         }
-        function rabbetJoin(box, thickness, gap = .25) {
+        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.cube({
@@ -1849,17 +2160,16 @@ function initJscadutils(_CSG, options = {}) {
         }
         var Boxes = Object.freeze({
             __proto__: null,
-            BBox,
-            CutOut,
-            Hollow,
             RabbetJoin,
+            topMiddleBottom,
             Rabett,
             RabettTopBottom,
+            CutOut,
             Rectangle,
-            topMiddleBottom
+            Hollow,
+            BBox
         });
-        const compatV1 = {
-            ...util,
+        var compatV1 = _objectSpread2(_objectSpread2({}, util), {}, {
             group: Group,
             init: init$1,
             triangle: triUtils,
@@ -1867,7 +2177,7 @@ function initJscadutils(_CSG, options = {}) {
             parts: parts$1,
             Boxes,
             Debug
-        };
+        });
         exports.Boxes = Boxes;
         exports.Debug = Debug;
         exports.Group = Group;
@@ -1877,6 +2187,9 @@ function initJscadutils(_CSG, options = {}) {
         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");
@@ -1894,7 +2207,7 @@ function initJscadutils(_CSG, options = {}) {
 
 var jscadUtilsPluginInit = [];
 
-util = {
+var util = {
     init: (...a) => {
         initJscadutils(...a);
         jscadUtilsPluginInit.forEach(p => {