diff --git a/CHANGES.md b/CHANGES.md
index 6a04c72c..f764ca97 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,9 @@
 # SVG-Edit CHANGES
 
+# ?
+
+- Enhancement: Add svgcanvas distributions
+
 # 4.0.1
 
 - Fix: Adjust side panel width checking based on device zoom (fixes #298)
diff --git a/dist/svgcanvas-iife.js b/dist/svgcanvas-iife.js
new file mode 100644
index 00000000..72ec4ead
--- /dev/null
+++ b/dist/svgcanvas-iife.js
@@ -0,0 +1,21432 @@
+var SvgCanvas = (function () {
+  'use strict';
+
+  function _typeof(obj) {
+    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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+      var info = gen[key](arg);
+      var value = info.value;
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    if (info.done) {
+      resolve(value);
+    } else {
+      Promise.resolve(value).then(_next, _throw);
+    }
+  }
+
+  function _asyncToGenerator(fn) {
+    return function () {
+      var self = this,
+          args = arguments;
+      return new Promise(function (resolve, reject) {
+        var gen = fn.apply(self, args);
+
+        function _next(value) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+        }
+
+        function _throw(err) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+        }
+
+        _next(undefined);
+      });
+    };
+  }
+
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+      return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+  }
+
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
+
+  function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return self;
+  }
+
+  function _possibleConstructorReturn(self, call) {
+    if (call && (typeof call === "object" || typeof call === "function")) {
+      return call;
+    }
+
+    return _assertThisInitialized(self);
+  }
+
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+  }
+
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+  }
+
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) {
+      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+      return arr2;
+    }
+  }
+
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _iterableToArray(iter) {
+    if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+  }
+
+  function _iterableToArrayLimit(arr, i) {
+    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 _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance");
+  }
+
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+  }
+
+  /* globals SVGPathSeg, SVGPathSegMovetoRel, SVGPathSegMovetoAbs,
+      SVGPathSegMovetoRel, SVGPathSegLinetoRel, SVGPathSegLinetoAbs,
+      SVGPathSegLinetoHorizontalRel, SVGPathSegLinetoHorizontalAbs,
+      SVGPathSegLinetoVerticalRel, SVGPathSegLinetoVerticalAbs,
+      SVGPathSegClosePath, SVGPathSegCurvetoCubicRel,
+      SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicSmoothRel,
+      SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoQuadraticRel,
+      SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticSmoothRel,
+      SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegArcRel, SVGPathSegArcAbs */
+
+  /**
+  * SVGPathSeg API polyfill
+  * https://github.com/progers/pathseg
+  *
+  * This is a drop-in replacement for the `SVGPathSeg` and `SVGPathSegList` APIs
+  * that were removed from SVG2 ({@link https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html}),
+  * including the latest spec changes which were implemented in Firefox 43 and
+  * Chrome 46.
+  */
+
+  /* eslint-disable no-shadow, class-methods-use-this */
+  // Linting: We avoid `no-shadow` as ESLint thinks these are still available globals
+  // Linting: We avoid `class-methods-use-this` as this is a polyfill that must
+  //   follow the conventions
+  (function () {
+    if (!('SVGPathSeg' in window)) {
+      // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg
+      var _SVGPathSeg =
+      /*#__PURE__*/
+      function () {
+        function _SVGPathSeg(type, typeAsLetter, owningPathSegList) {
+          _classCallCheck(this, _SVGPathSeg);
+
+          this.pathSegType = type;
+          this.pathSegTypeAsLetter = typeAsLetter;
+          this._owningPathSegList = owningPathSegList;
+        } // Notify owning PathSegList on any changes so they can be synchronized back to the path element.
+
+
+        _createClass(_SVGPathSeg, [{
+          key: "_segmentChanged",
+          value: function _segmentChanged() {
+            if (this._owningPathSegList) {
+              this._owningPathSegList.segmentChanged(this);
+            }
+          }
+        }]);
+
+        return _SVGPathSeg;
+      }();
+
+      _SVGPathSeg.prototype.classname = 'SVGPathSeg';
+      _SVGPathSeg.PATHSEG_UNKNOWN = 0;
+      _SVGPathSeg.PATHSEG_CLOSEPATH = 1;
+      _SVGPathSeg.PATHSEG_MOVETO_ABS = 2;
+      _SVGPathSeg.PATHSEG_MOVETO_REL = 3;
+      _SVGPathSeg.PATHSEG_LINETO_ABS = 4;
+      _SVGPathSeg.PATHSEG_LINETO_REL = 5;
+      _SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6;
+      _SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7;
+      _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8;
+      _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9;
+      _SVGPathSeg.PATHSEG_ARC_ABS = 10;
+      _SVGPathSeg.PATHSEG_ARC_REL = 11;
+      _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12;
+      _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13;
+      _SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14;
+      _SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15;
+      _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;
+      _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;
+      _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;
+      _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;
+
+      var _SVGPathSegClosePath =
+      /*#__PURE__*/
+      function (_SVGPathSeg2) {
+        _inherits(_SVGPathSegClosePath, _SVGPathSeg2);
+
+        function _SVGPathSegClosePath(owningPathSegList) {
+          _classCallCheck(this, _SVGPathSegClosePath);
+
+          return _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegClosePath).call(this, _SVGPathSeg.PATHSEG_CLOSEPATH, 'z', owningPathSegList));
+        }
+
+        _createClass(_SVGPathSegClosePath, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegClosePath]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegClosePath(undefined);
+          }
+        }]);
+
+        return _SVGPathSegClosePath;
+      }(_SVGPathSeg);
+
+      var _SVGPathSegMovetoAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg3) {
+        _inherits(_SVGPathSegMovetoAbs, _SVGPathSeg3);
+
+        function _SVGPathSegMovetoAbs(owningPathSegList, x, y) {
+          var _this;
+
+          _classCallCheck(this, _SVGPathSegMovetoAbs);
+
+          _this = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegMovetoAbs).call(this, _SVGPathSeg.PATHSEG_MOVETO_ABS, 'M', owningPathSegList));
+          _this._x = x;
+          _this._y = y;
+          return _this;
+        }
+
+        _createClass(_SVGPathSegMovetoAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegMovetoAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegMovetoAbs(undefined, this._x, this._y);
+          }
+        }]);
+
+        return _SVGPathSegMovetoAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegMovetoAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegMovetoRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg4) {
+        _inherits(_SVGPathSegMovetoRel, _SVGPathSeg4);
+
+        function _SVGPathSegMovetoRel(owningPathSegList, x, y) {
+          var _this2;
+
+          _classCallCheck(this, _SVGPathSegMovetoRel);
+
+          _this2 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegMovetoRel).call(this, _SVGPathSeg.PATHSEG_MOVETO_REL, 'm', owningPathSegList));
+          _this2._x = x;
+          _this2._y = y;
+          return _this2;
+        }
+
+        _createClass(_SVGPathSegMovetoRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegMovetoRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegMovetoRel(undefined, this._x, this._y);
+          }
+        }]);
+
+        return _SVGPathSegMovetoRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegMovetoRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegLinetoAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg5) {
+        _inherits(_SVGPathSegLinetoAbs, _SVGPathSeg5);
+
+        function _SVGPathSegLinetoAbs(owningPathSegList, x, y) {
+          var _this3;
+
+          _classCallCheck(this, _SVGPathSegLinetoAbs);
+
+          _this3 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegLinetoAbs).call(this, _SVGPathSeg.PATHSEG_LINETO_ABS, 'L', owningPathSegList));
+          _this3._x = x;
+          _this3._y = y;
+          return _this3;
+        }
+
+        _createClass(_SVGPathSegLinetoAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegLinetoAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegLinetoAbs(undefined, this._x, this._y);
+          }
+        }]);
+
+        return _SVGPathSegLinetoAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegLinetoAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegLinetoRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg6) {
+        _inherits(_SVGPathSegLinetoRel, _SVGPathSeg6);
+
+        function _SVGPathSegLinetoRel(owningPathSegList, x, y) {
+          var _this4;
+
+          _classCallCheck(this, _SVGPathSegLinetoRel);
+
+          _this4 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegLinetoRel).call(this, _SVGPathSeg.PATHSEG_LINETO_REL, 'l', owningPathSegList));
+          _this4._x = x;
+          _this4._y = y;
+          return _this4;
+        }
+
+        _createClass(_SVGPathSegLinetoRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegLinetoRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegLinetoRel(undefined, this._x, this._y);
+          }
+        }]);
+
+        return _SVGPathSegLinetoRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegLinetoRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoCubicAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg7) {
+        _inherits(_SVGPathSegCurvetoCubicAbs, _SVGPathSeg7);
+
+        function _SVGPathSegCurvetoCubicAbs(owningPathSegList, x, y, x1, y1, x2, y2) {
+          var _this5;
+
+          _classCallCheck(this, _SVGPathSegCurvetoCubicAbs);
+
+          _this5 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoCubicAbs).call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, 'C', owningPathSegList));
+          _this5._x = x;
+          _this5._y = y;
+          _this5._x1 = x1;
+          _this5._y1 = y1;
+          _this5._x2 = x2;
+          _this5._y2 = y2;
+          return _this5;
+        }
+
+        _createClass(_SVGPathSegCurvetoCubicAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoCubicAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoCubicAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoCubicAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x1: {
+          get: function get() {
+            return this._x1;
+          },
+          set: function set(x1) {
+            this._x1 = x1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y1: {
+          get: function get() {
+            return this._y1;
+          },
+          set: function set(y1) {
+            this._y1 = y1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x2: {
+          get: function get() {
+            return this._x2;
+          },
+          set: function set(x2) {
+            this._x2 = x2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y2: {
+          get: function get() {
+            return this._y2;
+          },
+          set: function set(y2) {
+            this._y2 = y2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoCubicRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg8) {
+        _inherits(_SVGPathSegCurvetoCubicRel, _SVGPathSeg8);
+
+        function _SVGPathSegCurvetoCubicRel(owningPathSegList, x, y, x1, y1, x2, y2) {
+          var _this6;
+
+          _classCallCheck(this, _SVGPathSegCurvetoCubicRel);
+
+          _this6 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoCubicRel).call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, 'c', owningPathSegList));
+          _this6._x = x;
+          _this6._y = y;
+          _this6._x1 = x1;
+          _this6._y1 = y1;
+          _this6._x2 = x2;
+          _this6._y2 = y2;
+          return _this6;
+        }
+
+        _createClass(_SVGPathSegCurvetoCubicRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoCubicRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoCubicRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoCubicRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x1: {
+          get: function get() {
+            return this._x1;
+          },
+          set: function set(x1) {
+            this._x1 = x1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y1: {
+          get: function get() {
+            return this._y1;
+          },
+          set: function set(y1) {
+            this._y1 = y1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x2: {
+          get: function get() {
+            return this._x2;
+          },
+          set: function set(x2) {
+            this._x2 = x2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y2: {
+          get: function get() {
+            return this._y2;
+          },
+          set: function set(y2) {
+            this._y2 = y2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoQuadraticAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg9) {
+        _inherits(_SVGPathSegCurvetoQuadraticAbs, _SVGPathSeg9);
+
+        function _SVGPathSegCurvetoQuadraticAbs(owningPathSegList, x, y, x1, y1) {
+          var _this7;
+
+          _classCallCheck(this, _SVGPathSegCurvetoQuadraticAbs);
+
+          _this7 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoQuadraticAbs).call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, 'Q', owningPathSegList));
+          _this7._x = x;
+          _this7._y = y;
+          _this7._x1 = x1;
+          _this7._y1 = y1;
+          return _this7;
+        }
+
+        _createClass(_SVGPathSegCurvetoQuadraticAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoQuadraticAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoQuadraticAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoQuadraticAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x1: {
+          get: function get() {
+            return this._x1;
+          },
+          set: function set(x1) {
+            this._x1 = x1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y1: {
+          get: function get() {
+            return this._y1;
+          },
+          set: function set(y1) {
+            this._y1 = y1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoQuadraticRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg10) {
+        _inherits(_SVGPathSegCurvetoQuadraticRel, _SVGPathSeg10);
+
+        function _SVGPathSegCurvetoQuadraticRel(owningPathSegList, x, y, x1, y1) {
+          var _this8;
+
+          _classCallCheck(this, _SVGPathSegCurvetoQuadraticRel);
+
+          _this8 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoQuadraticRel).call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, 'q', owningPathSegList));
+          _this8._x = x;
+          _this8._y = y;
+          _this8._x1 = x1;
+          _this8._y1 = y1;
+          return _this8;
+        }
+
+        _createClass(_SVGPathSegCurvetoQuadraticRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoQuadraticRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoQuadraticRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoQuadraticRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x1: {
+          get: function get() {
+            return this._x1;
+          },
+          set: function set(x1) {
+            this._x1 = x1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y1: {
+          get: function get() {
+            return this._y1;
+          },
+          set: function set(y1) {
+            this._y1 = y1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegArcAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg11) {
+        _inherits(_SVGPathSegArcAbs, _SVGPathSeg11);
+
+        function _SVGPathSegArcAbs(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
+          var _this9;
+
+          _classCallCheck(this, _SVGPathSegArcAbs);
+
+          _this9 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegArcAbs).call(this, _SVGPathSeg.PATHSEG_ARC_ABS, 'A', owningPathSegList));
+          _this9._x = x;
+          _this9._y = y;
+          _this9._r1 = r1;
+          _this9._r2 = r2;
+          _this9._angle = angle;
+          _this9._largeArcFlag = largeArcFlag;
+          _this9._sweepFlag = sweepFlag;
+          return _this9;
+        }
+
+        _createClass(_SVGPathSegArcAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegArcAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag);
+          }
+        }]);
+
+        return _SVGPathSegArcAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegArcAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        r1: {
+          get: function get() {
+            return this._r1;
+          },
+          set: function set(r1) {
+            this._r1 = r1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        r2: {
+          get: function get() {
+            return this._r2;
+          },
+          set: function set(r2) {
+            this._r2 = r2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        angle: {
+          get: function get() {
+            return this._angle;
+          },
+          set: function set(angle) {
+            this._angle = angle;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        largeArcFlag: {
+          get: function get() {
+            return this._largeArcFlag;
+          },
+          set: function set(largeArcFlag) {
+            this._largeArcFlag = largeArcFlag;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        sweepFlag: {
+          get: function get() {
+            return this._sweepFlag;
+          },
+          set: function set(sweepFlag) {
+            this._sweepFlag = sweepFlag;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegArcRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg12) {
+        _inherits(_SVGPathSegArcRel, _SVGPathSeg12);
+
+        function _SVGPathSegArcRel(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
+          var _this10;
+
+          _classCallCheck(this, _SVGPathSegArcRel);
+
+          _this10 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegArcRel).call(this, _SVGPathSeg.PATHSEG_ARC_REL, 'a', owningPathSegList));
+          _this10._x = x;
+          _this10._y = y;
+          _this10._r1 = r1;
+          _this10._r2 = r2;
+          _this10._angle = angle;
+          _this10._largeArcFlag = largeArcFlag;
+          _this10._sweepFlag = sweepFlag;
+          return _this10;
+        }
+
+        _createClass(_SVGPathSegArcRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegArcRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag);
+          }
+        }]);
+
+        return _SVGPathSegArcRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegArcRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        r1: {
+          get: function get() {
+            return this._r1;
+          },
+          set: function set(r1) {
+            this._r1 = r1;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        r2: {
+          get: function get() {
+            return this._r2;
+          },
+          set: function set(r2) {
+            this._r2 = r2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        angle: {
+          get: function get() {
+            return this._angle;
+          },
+          set: function set(angle) {
+            this._angle = angle;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        largeArcFlag: {
+          get: function get() {
+            return this._largeArcFlag;
+          },
+          set: function set(largeArcFlag) {
+            this._largeArcFlag = largeArcFlag;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        sweepFlag: {
+          get: function get() {
+            return this._sweepFlag;
+          },
+          set: function set(sweepFlag) {
+            this._sweepFlag = sweepFlag;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegLinetoHorizontalAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg13) {
+        _inherits(_SVGPathSegLinetoHorizontalAbs, _SVGPathSeg13);
+
+        function _SVGPathSegLinetoHorizontalAbs(owningPathSegList, x) {
+          var _this11;
+
+          _classCallCheck(this, _SVGPathSegLinetoHorizontalAbs);
+
+          _this11 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegLinetoHorizontalAbs).call(this, _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, 'H', owningPathSegList));
+          _this11._x = x;
+          return _this11;
+        }
+
+        _createClass(_SVGPathSegLinetoHorizontalAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegLinetoHorizontalAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegLinetoHorizontalAbs(undefined, this._x);
+          }
+        }]);
+
+        return _SVGPathSegLinetoHorizontalAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperty(_SVGPathSegLinetoHorizontalAbs.prototype, 'x', {
+        get: function get() {
+          return this._x;
+        },
+        set: function set(x) {
+          this._x = x;
+
+          this._segmentChanged();
+        },
+        enumerable: true
+      });
+
+      var _SVGPathSegLinetoHorizontalRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg14) {
+        _inherits(_SVGPathSegLinetoHorizontalRel, _SVGPathSeg14);
+
+        function _SVGPathSegLinetoHorizontalRel(owningPathSegList, x) {
+          var _this12;
+
+          _classCallCheck(this, _SVGPathSegLinetoHorizontalRel);
+
+          _this12 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegLinetoHorizontalRel).call(this, _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, 'h', owningPathSegList));
+          _this12._x = x;
+          return _this12;
+        }
+
+        _createClass(_SVGPathSegLinetoHorizontalRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegLinetoHorizontalRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegLinetoHorizontalRel(undefined, this._x);
+          }
+        }]);
+
+        return _SVGPathSegLinetoHorizontalRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperty(_SVGPathSegLinetoHorizontalRel.prototype, 'x', {
+        get: function get() {
+          return this._x;
+        },
+        set: function set(x) {
+          this._x = x;
+
+          this._segmentChanged();
+        },
+        enumerable: true
+      });
+
+      var _SVGPathSegLinetoVerticalAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg15) {
+        _inherits(_SVGPathSegLinetoVerticalAbs, _SVGPathSeg15);
+
+        function _SVGPathSegLinetoVerticalAbs(owningPathSegList, y) {
+          var _this13;
+
+          _classCallCheck(this, _SVGPathSegLinetoVerticalAbs);
+
+          _this13 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegLinetoVerticalAbs).call(this, _SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, 'V', owningPathSegList));
+          _this13._y = y;
+          return _this13;
+        }
+
+        _createClass(_SVGPathSegLinetoVerticalAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegLinetoVerticalAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegLinetoVerticalAbs(undefined, this._y);
+          }
+        }]);
+
+        return _SVGPathSegLinetoVerticalAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperty(_SVGPathSegLinetoVerticalAbs.prototype, 'y', {
+        get: function get() {
+          return this._y;
+        },
+        set: function set(y) {
+          this._y = y;
+
+          this._segmentChanged();
+        },
+        enumerable: true
+      });
+
+      var _SVGPathSegLinetoVerticalRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg16) {
+        _inherits(_SVGPathSegLinetoVerticalRel, _SVGPathSeg16);
+
+        function _SVGPathSegLinetoVerticalRel(owningPathSegList, y) {
+          var _this14;
+
+          _classCallCheck(this, _SVGPathSegLinetoVerticalRel);
+
+          _this14 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegLinetoVerticalRel).call(this, _SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, 'v', owningPathSegList));
+          _this14._y = y;
+          return _this14;
+        }
+
+        _createClass(_SVGPathSegLinetoVerticalRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegLinetoVerticalRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegLinetoVerticalRel(undefined, this._y);
+          }
+        }]);
+
+        return _SVGPathSegLinetoVerticalRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperty(_SVGPathSegLinetoVerticalRel.prototype, 'y', {
+        get: function get() {
+          return this._y;
+        },
+        set: function set(y) {
+          this._y = y;
+
+          this._segmentChanged();
+        },
+        enumerable: true
+      });
+
+      var _SVGPathSegCurvetoCubicSmoothAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg17) {
+        _inherits(_SVGPathSegCurvetoCubicSmoothAbs, _SVGPathSeg17);
+
+        function _SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, x, y, x2, y2) {
+          var _this15;
+
+          _classCallCheck(this, _SVGPathSegCurvetoCubicSmoothAbs);
+
+          _this15 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoCubicSmoothAbs).call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, 'S', owningPathSegList));
+          _this15._x = x;
+          _this15._y = y;
+          _this15._x2 = x2;
+          _this15._y2 = y2;
+          return _this15;
+        }
+
+        _createClass(_SVGPathSegCurvetoCubicSmoothAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoCubicSmoothAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoCubicSmoothAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoCubicSmoothAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x2: {
+          get: function get() {
+            return this._x2;
+          },
+          set: function set(x2) {
+            this._x2 = x2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y2: {
+          get: function get() {
+            return this._y2;
+          },
+          set: function set(y2) {
+            this._y2 = y2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoCubicSmoothRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg18) {
+        _inherits(_SVGPathSegCurvetoCubicSmoothRel, _SVGPathSeg18);
+
+        function _SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, x, y, x2, y2) {
+          var _this16;
+
+          _classCallCheck(this, _SVGPathSegCurvetoCubicSmoothRel);
+
+          _this16 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoCubicSmoothRel).call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, 's', owningPathSegList));
+          _this16._x = x;
+          _this16._y = y;
+          _this16._x2 = x2;
+          _this16._y2 = y2;
+          return _this16;
+        }
+
+        _createClass(_SVGPathSegCurvetoCubicSmoothRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoCubicSmoothRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoCubicSmoothRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoCubicSmoothRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        x2: {
+          get: function get() {
+            return this._x2;
+          },
+          set: function set(x2) {
+            this._x2 = x2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y2: {
+          get: function get() {
+            return this._y2;
+          },
+          set: function set(y2) {
+            this._y2 = y2;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoQuadraticSmoothAbs =
+      /*#__PURE__*/
+      function (_SVGPathSeg19) {
+        _inherits(_SVGPathSegCurvetoQuadraticSmoothAbs, _SVGPathSeg19);
+
+        function _SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, x, y) {
+          var _this17;
+
+          _classCallCheck(this, _SVGPathSegCurvetoQuadraticSmoothAbs);
+
+          _this17 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoQuadraticSmoothAbs).call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, 'T', owningPathSegList));
+          _this17._x = x;
+          _this17._y = y;
+          return _this17;
+        }
+
+        _createClass(_SVGPathSegCurvetoQuadraticSmoothAbs, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoQuadraticSmoothAbs]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoQuadraticSmoothAbs;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoQuadraticSmoothAbs.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      });
+
+      var _SVGPathSegCurvetoQuadraticSmoothRel =
+      /*#__PURE__*/
+      function (_SVGPathSeg20) {
+        _inherits(_SVGPathSegCurvetoQuadraticSmoothRel, _SVGPathSeg20);
+
+        function _SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, x, y) {
+          var _this18;
+
+          _classCallCheck(this, _SVGPathSegCurvetoQuadraticSmoothRel);
+
+          _this18 = _possibleConstructorReturn(this, _getPrototypeOf(_SVGPathSegCurvetoQuadraticSmoothRel).call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, 't', owningPathSegList));
+          _this18._x = x;
+          _this18._y = y;
+          return _this18;
+        }
+
+        _createClass(_SVGPathSegCurvetoQuadraticSmoothRel, [{
+          key: "toString",
+          value: function toString() {
+            return '[object SVGPathSegCurvetoQuadraticSmoothRel]';
+          }
+        }, {
+          key: "_asPathString",
+          value: function _asPathString() {
+            return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y;
+          }
+        }, {
+          key: "clone",
+          value: function clone() {
+            return new _SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y);
+          }
+        }]);
+
+        return _SVGPathSegCurvetoQuadraticSmoothRel;
+      }(_SVGPathSeg);
+
+      Object.defineProperties(_SVGPathSegCurvetoQuadraticSmoothRel.prototype, {
+        x: {
+          get: function get() {
+            return this._x;
+          },
+          set: function set(x) {
+            this._x = x;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        },
+        y: {
+          get: function get() {
+            return this._y;
+          },
+          set: function set(y) {
+            this._y = y;
+
+            this._segmentChanged();
+          },
+          enumerable: true
+        }
+      }); // Add createSVGPathSeg* functions to SVGPathElement.
+      // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement.
+
+      SVGPathElement.prototype.createSVGPathSegClosePath = function () {
+        return new _SVGPathSegClosePath(undefined);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegMovetoAbs = function (x, y) {
+        return new _SVGPathSegMovetoAbs(undefined, x, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegMovetoRel = function (x, y) {
+        return new _SVGPathSegMovetoRel(undefined, x, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegLinetoAbs = function (x, y) {
+        return new _SVGPathSegLinetoAbs(undefined, x, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegLinetoRel = function (x, y) {
+        return new _SVGPathSegLinetoRel(undefined, x, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function (x, y, x1, y1, x2, y2) {
+        return new _SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function (x, y, x1, y1, x2, y2) {
+        return new _SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function (x, y, x1, y1) {
+        return new _SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function (x, y, x1, y1) {
+        return new _SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegArcAbs = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
+        return new _SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegArcRel = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
+        return new _SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function (x) {
+        return new _SVGPathSegLinetoHorizontalAbs(undefined, x);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function (x) {
+        return new _SVGPathSegLinetoHorizontalRel(undefined, x);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function (y) {
+        return new _SVGPathSegLinetoVerticalAbs(undefined, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function (y) {
+        return new _SVGPathSegLinetoVerticalRel(undefined, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function (x, y, x2, y2) {
+        return new _SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function (x, y, x2, y2) {
+        return new _SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function (x, y) {
+        return new _SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y);
+      };
+
+      SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function (x, y) {
+        return new _SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y);
+      };
+
+      if (!('getPathSegAtLength' in SVGPathElement.prototype)) {
+        // Add getPathSegAtLength to SVGPathElement.
+        // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-__svg__SVGPathElement__getPathSegAtLength
+        // This polyfill requires SVGPathElement.getTotalLength to implement the distance-along-a-path algorithm.
+        SVGPathElement.prototype.getPathSegAtLength = function (distance) {
+          if (distance === undefined || !isFinite(distance)) {
+            throw new Error('Invalid arguments.');
+          }
+
+          var measurementElement = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+          measurementElement.setAttribute('d', this.getAttribute('d'));
+          var lastPathSegment = measurementElement.pathSegList.numberOfItems - 1; // If the path is empty, return 0.
+
+          if (lastPathSegment <= 0) {
+            return 0;
+          }
+
+          do {
+            measurementElement.pathSegList.removeItem(lastPathSegment);
+
+            if (distance > measurementElement.getTotalLength()) {
+              break;
+            }
+
+            lastPathSegment--;
+          } while (lastPathSegment > 0);
+
+          return lastPathSegment;
+        };
+      }
+
+      window.SVGPathSeg = _SVGPathSeg;
+      window.SVGPathSegClosePath = _SVGPathSegClosePath;
+      window.SVGPathSegMovetoAbs = _SVGPathSegMovetoAbs;
+      window.SVGPathSegMovetoRel = _SVGPathSegMovetoRel;
+      window.SVGPathSegLinetoAbs = _SVGPathSegLinetoAbs;
+      window.SVGPathSegLinetoRel = _SVGPathSegLinetoRel;
+      window.SVGPathSegCurvetoCubicAbs = _SVGPathSegCurvetoCubicAbs;
+      window.SVGPathSegCurvetoCubicRel = _SVGPathSegCurvetoCubicRel;
+      window.SVGPathSegCurvetoQuadraticAbs = _SVGPathSegCurvetoQuadraticAbs;
+      window.SVGPathSegCurvetoQuadraticRel = _SVGPathSegCurvetoQuadraticRel;
+      window.SVGPathSegArcAbs = _SVGPathSegArcAbs;
+      window.SVGPathSegArcRel = _SVGPathSegArcRel;
+      window.SVGPathSegLinetoHorizontalAbs = _SVGPathSegLinetoHorizontalAbs;
+      window.SVGPathSegLinetoHorizontalRel = _SVGPathSegLinetoHorizontalRel;
+      window.SVGPathSegLinetoVerticalAbs = _SVGPathSegLinetoVerticalAbs;
+      window.SVGPathSegLinetoVerticalRel = _SVGPathSegLinetoVerticalRel;
+      window.SVGPathSegCurvetoCubicSmoothAbs = _SVGPathSegCurvetoCubicSmoothAbs;
+      window.SVGPathSegCurvetoCubicSmoothRel = _SVGPathSegCurvetoCubicSmoothRel;
+      window.SVGPathSegCurvetoQuadraticSmoothAbs = _SVGPathSegCurvetoQuadraticSmoothAbs;
+      window.SVGPathSegCurvetoQuadraticSmoothRel = _SVGPathSegCurvetoQuadraticSmoothRel;
+    } // Checking for SVGPathSegList in window checks for the case of an implementation without the
+    // SVGPathSegList API.
+    // The second check for appendItem is specific to Firefox 59+ which removed only parts of the
+    // SVGPathSegList API (e.g., appendItem). In this case we need to re-implement the entire API
+    // so the polyfill data (i.e., _list) is used throughout.
+
+
+    if (!('SVGPathSegList' in window) || !('appendItem' in window.SVGPathSegList.prototype)) {
+      // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList
+      var SVGPathSegList =
+      /*#__PURE__*/
+      function () {
+        function SVGPathSegList(pathElement) {
+          _classCallCheck(this, SVGPathSegList);
+
+          this._pathElement = pathElement;
+          this._list = this._parsePath(this._pathElement.getAttribute('d')); // Use a MutationObserver to catch changes to the path's "d" attribute.
+
+          this._mutationObserverConfig = {
+            attributes: true,
+            attributeFilter: ['d']
+          };
+          this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this));
+
+          this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);
+        } // Process any pending mutations to the path element and update the list as needed.
+        // This should be the first call of all public functions and is needed because
+        // MutationObservers are not synchronous so we can have pending asynchronous mutations.
+
+
+        _createClass(SVGPathSegList, [{
+          key: "_checkPathSynchronizedToList",
+          value: function _checkPathSynchronizedToList() {
+            this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords());
+          }
+        }, {
+          key: "_updateListFromPathMutations",
+          value: function _updateListFromPathMutations(mutationRecords) {
+            if (!this._pathElement) {
+              return;
+            }
+
+            var hasPathMutations = false;
+            mutationRecords.forEach(function (record) {
+              if (record.attributeName === 'd') {
+                hasPathMutations = true;
+              }
+            });
+
+            if (hasPathMutations) {
+              this._list = this._parsePath(this._pathElement.getAttribute('d'));
+            }
+          } // Serialize the list and update the path's 'd' attribute.
+
+        }, {
+          key: "_writeListToPath",
+          value: function _writeListToPath() {
+            this._pathElementMutationObserver.disconnect();
+
+            this._pathElement.setAttribute('d', SVGPathSegList._pathSegArrayAsString(this._list));
+
+            this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);
+          } // When a path segment changes the list needs to be synchronized back to the path element.
+
+        }, {
+          key: "segmentChanged",
+          value: function segmentChanged(pathSeg) {
+            this._writeListToPath();
+          }
+        }, {
+          key: "clear",
+          value: function clear() {
+            this._checkPathSynchronizedToList();
+
+            this._list.forEach(function (pathSeg) {
+              pathSeg._owningPathSegList = null;
+            });
+
+            this._list = [];
+
+            this._writeListToPath();
+          }
+        }, {
+          key: "initialize",
+          value: function initialize(newItem) {
+            this._checkPathSynchronizedToList();
+
+            this._list = [newItem];
+            newItem._owningPathSegList = this;
+
+            this._writeListToPath();
+
+            return newItem;
+          }
+        }, {
+          key: "_checkValidIndex",
+          value: function _checkValidIndex(index) {
+            if (isNaN(index) || index < 0 || index >= this.numberOfItems) {
+              throw new Error('INDEX_SIZE_ERR');
+            }
+          }
+        }, {
+          key: "getItem",
+          value: function getItem(index) {
+            this._checkPathSynchronizedToList();
+
+            this._checkValidIndex(index);
+
+            return this._list[index];
+          }
+        }, {
+          key: "insertItemBefore",
+          value: function insertItemBefore(newItem, index) {
+            this._checkPathSynchronizedToList(); // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
+
+
+            if (index > this.numberOfItems) {
+              index = this.numberOfItems;
+            }
+
+            if (newItem._owningPathSegList) {
+              // SVG2 spec says to make a copy.
+              newItem = newItem.clone();
+            }
+
+            this._list.splice(index, 0, newItem);
+
+            newItem._owningPathSegList = this;
+
+            this._writeListToPath();
+
+            return newItem;
+          }
+        }, {
+          key: "replaceItem",
+          value: function replaceItem(newItem, index) {
+            this._checkPathSynchronizedToList();
+
+            if (newItem._owningPathSegList) {
+              // SVG2 spec says to make a copy.
+              newItem = newItem.clone();
+            }
+
+            this._checkValidIndex(index);
+
+            this._list[index] = newItem;
+            newItem._owningPathSegList = this;
+
+            this._writeListToPath();
+
+            return newItem;
+          }
+        }, {
+          key: "removeItem",
+          value: function removeItem(index) {
+            this._checkPathSynchronizedToList();
+
+            this._checkValidIndex(index);
+
+            var item = this._list[index];
+
+            this._list.splice(index, 1);
+
+            this._writeListToPath();
+
+            return item;
+          }
+        }, {
+          key: "appendItem",
+          value: function appendItem(newItem) {
+            this._checkPathSynchronizedToList();
+
+            if (newItem._owningPathSegList) {
+              // SVG2 spec says to make a copy.
+              newItem = newItem.clone();
+            }
+
+            this._list.push(newItem);
+
+            newItem._owningPathSegList = this; // TODO: Optimize this to just append to the existing attribute.
+
+            this._writeListToPath();
+
+            return newItem;
+          } // This closely follows SVGPathParser::parsePath from Source/core/svg/SVGPathParser.cpp.
+
+        }, {
+          key: "_parsePath",
+          value: function _parsePath(string) {
+            if (!string || !string.length) {
+              return [];
+            }
+
+            var owningPathSegList = this; // eslint-disable-line consistent-this
+
+            var Builder =
+            /*#__PURE__*/
+            function () {
+              function Builder() {
+                _classCallCheck(this, Builder);
+
+                this.pathSegList = [];
+              }
+
+              _createClass(Builder, [{
+                key: "appendSegment",
+                value: function appendSegment(pathSeg) {
+                  this.pathSegList.push(pathSeg);
+                }
+              }]);
+
+              return Builder;
+            }();
+
+            var Source =
+            /*#__PURE__*/
+            function () {
+              function Source(string) {
+                _classCallCheck(this, Source);
+
+                this._string = string;
+                this._currentIndex = 0;
+                this._endIndex = this._string.length;
+                this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN;
+
+                this._skipOptionalSpaces();
+              }
+
+              _createClass(Source, [{
+                key: "_isCurrentSpace",
+                value: function _isCurrentSpace() {
+                  var character = this._string[this._currentIndex];
+                  return character <= ' ' && (character === ' ' || character === '\n' || character === '\t' || character === '\r' || character === '\f');
+                }
+              }, {
+                key: "_skipOptionalSpaces",
+                value: function _skipOptionalSpaces() {
+                  while (this._currentIndex < this._endIndex && this._isCurrentSpace()) {
+                    this._currentIndex++;
+                  }
+
+                  return this._currentIndex < this._endIndex;
+                }
+              }, {
+                key: "_skipOptionalSpacesOrDelimiter",
+                value: function _skipOptionalSpacesOrDelimiter() {
+                  if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) !== ',') {
+                    return false;
+                  }
+
+                  if (this._skipOptionalSpaces()) {
+                    if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === ',') {
+                      this._currentIndex++;
+
+                      this._skipOptionalSpaces();
+                    }
+                  }
+
+                  return this._currentIndex < this._endIndex;
+                }
+              }, {
+                key: "hasMoreData",
+                value: function hasMoreData() {
+                  return this._currentIndex < this._endIndex;
+                }
+              }, {
+                key: "peekSegmentType",
+                value: function peekSegmentType() {
+                  var lookahead = this._string[this._currentIndex];
+                  return this._pathSegTypeFromChar(lookahead);
+                }
+              }, {
+                key: "_pathSegTypeFromChar",
+                value: function _pathSegTypeFromChar(lookahead) {
+                  switch (lookahead) {
+                    case 'Z':
+                    case 'z':
+                      return SVGPathSeg.PATHSEG_CLOSEPATH;
+
+                    case 'M':
+                      return SVGPathSeg.PATHSEG_MOVETO_ABS;
+
+                    case 'm':
+                      return SVGPathSeg.PATHSEG_MOVETO_REL;
+
+                    case 'L':
+                      return SVGPathSeg.PATHSEG_LINETO_ABS;
+
+                    case 'l':
+                      return SVGPathSeg.PATHSEG_LINETO_REL;
+
+                    case 'C':
+                      return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;
+
+                    case 'c':
+                      return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;
+
+                    case 'Q':
+                      return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;
+
+                    case 'q':
+                      return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;
+
+                    case 'A':
+                      return SVGPathSeg.PATHSEG_ARC_ABS;
+
+                    case 'a':
+                      return SVGPathSeg.PATHSEG_ARC_REL;
+
+                    case 'H':
+                      return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;
+
+                    case 'h':
+                      return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;
+
+                    case 'V':
+                      return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;
+
+                    case 'v':
+                      return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;
+
+                    case 'S':
+                      return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
+
+                    case 's':
+                      return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
+
+                    case 'T':
+                      return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
+
+                    case 't':
+                      return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
+
+                    default:
+                      return SVGPathSeg.PATHSEG_UNKNOWN;
+                  }
+                }
+              }, {
+                key: "_nextCommandHelper",
+                value: function _nextCommandHelper(lookahead, previousCommand) {
+                  // Check for remaining coordinates in the current command.
+                  if ((lookahead === '+' || lookahead === '-' || lookahead === '.' || lookahead >= '0' && lookahead <= '9') && previousCommand !== SVGPathSeg.PATHSEG_CLOSEPATH) {
+                    if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_ABS) {
+                      return SVGPathSeg.PATHSEG_LINETO_ABS;
+                    }
+
+                    if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_REL) {
+                      return SVGPathSeg.PATHSEG_LINETO_REL;
+                    }
+
+                    return previousCommand;
+                  }
+
+                  return SVGPathSeg.PATHSEG_UNKNOWN;
+                }
+              }, {
+                key: "initialCommandIsMoveTo",
+                value: function initialCommandIsMoveTo() {
+                  // If the path is empty it is still valid, so return true.
+                  if (!this.hasMoreData()) {
+                    return true;
+                  }
+
+                  var command = this.peekSegmentType(); // Path must start with moveTo.
+
+                  return command === SVGPathSeg.PATHSEG_MOVETO_ABS || command === SVGPathSeg.PATHSEG_MOVETO_REL;
+                } // Parse a number from an SVG path. This very closely follows genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp.
+                // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF
+
+              }, {
+                key: "_parseNumber",
+                value: function _parseNumber() {
+                  var exponent = 0;
+                  var integer = 0;
+                  var frac = 1;
+                  var decimal = 0;
+                  var sign = 1;
+                  var expsign = 1;
+                  var startIndex = this._currentIndex;
+
+                  this._skipOptionalSpaces(); // Read the sign.
+
+
+                  if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '+') {
+                    this._currentIndex++;
+                  } else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '-') {
+                    this._currentIndex++;
+                    sign = -1;
+                  }
+
+                  if (this._currentIndex === this._endIndex || (this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') && this._string.charAt(this._currentIndex) !== '.') {
+                    // The first character of a number must be one of [0-9+-.].
+                    return undefined;
+                  } // Read the integer part, build right-to-left.
+
+
+                  var startIntPartIndex = this._currentIndex;
+
+                  while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {
+                    this._currentIndex++; // Advance to first non-digit.
+                  }
+
+                  if (this._currentIndex !== startIntPartIndex) {
+                    var scanIntPartIndex = this._currentIndex - 1;
+                    var multiplier = 1;
+
+                    while (scanIntPartIndex >= startIntPartIndex) {
+                      integer += multiplier * (this._string.charAt(scanIntPartIndex--) - '0');
+                      multiplier *= 10;
+                    }
+                  } // Read the decimals.
+
+
+                  if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '.') {
+                    this._currentIndex++; // There must be a least one digit following the .
+
+                    if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') {
+                      return undefined;
+                    }
+
+                    while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {
+                      frac *= 10;
+                      decimal += (this._string.charAt(this._currentIndex) - '0') / frac;
+                      this._currentIndex += 1;
+                    }
+                  } // Read the exponent part.
+
+
+                  if (this._currentIndex !== startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) === 'e' || this._string.charAt(this._currentIndex) === 'E') && this._string.charAt(this._currentIndex + 1) !== 'x' && this._string.charAt(this._currentIndex + 1) !== 'm') {
+                    this._currentIndex++; // Read the sign of the exponent.
+
+                    if (this._string.charAt(this._currentIndex) === '+') {
+                      this._currentIndex++;
+                    } else if (this._string.charAt(this._currentIndex) === '-') {
+                      this._currentIndex++;
+                      expsign = -1;
+                    } // There must be an exponent.
+
+
+                    if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') {
+                      return undefined;
+                    }
+
+                    while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {
+                      exponent *= 10;
+                      exponent += this._string.charAt(this._currentIndex) - '0';
+                      this._currentIndex++;
+                    }
+                  }
+
+                  var number = integer + decimal;
+                  number *= sign;
+
+                  if (exponent) {
+                    number *= Math.pow(10, expsign * exponent);
+                  }
+
+                  if (startIndex === this._currentIndex) {
+                    return undefined;
+                  }
+
+                  this._skipOptionalSpacesOrDelimiter();
+
+                  return number;
+                }
+              }, {
+                key: "_parseArcFlag",
+                value: function _parseArcFlag() {
+                  if (this._currentIndex >= this._endIndex) {
+                    return undefined;
+                  }
+
+                  var flag = false;
+
+                  var flagChar = this._string.charAt(this._currentIndex++);
+
+                  if (flagChar === '0') {
+                    flag = false;
+                  } else if (flagChar === '1') {
+                    flag = true;
+                  } else {
+                    return undefined;
+                  }
+
+                  this._skipOptionalSpacesOrDelimiter();
+
+                  return flag;
+                }
+              }, {
+                key: "parseSegment",
+                value: function parseSegment() {
+                  var lookahead = this._string[this._currentIndex];
+
+                  var command = this._pathSegTypeFromChar(lookahead);
+
+                  if (command === SVGPathSeg.PATHSEG_UNKNOWN) {
+                    // Possibly an implicit command. Not allowed if this is the first command.
+                    if (this._previousCommand === SVGPathSeg.PATHSEG_UNKNOWN) {
+                      return null;
+                    }
+
+                    command = this._nextCommandHelper(lookahead, this._previousCommand);
+
+                    if (command === SVGPathSeg.PATHSEG_UNKNOWN) {
+                      return null;
+                    }
+                  } else {
+                    this._currentIndex++;
+                  }
+
+                  this._previousCommand = command;
+
+                  switch (command) {
+                    case SVGPathSeg.PATHSEG_MOVETO_REL:
+                      return new SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_MOVETO_ABS:
+                      return new SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_LINETO_REL:
+                      return new SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_LINETO_ABS:
+                      return new SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:
+                      return new SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:
+                      return new SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:
+                      return new SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:
+                      return new SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_CLOSEPATH:
+                      this._skipOptionalSpaces();
+
+                      return new SVGPathSegClosePath(owningPathSegList);
+
+                    case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL:
+                      {
+                        var points = {
+                          x1: this._parseNumber(),
+                          y1: this._parseNumber(),
+                          x2: this._parseNumber(),
+                          y2: this._parseNumber(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);
+                      }
+
+                    case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS:
+                      {
+                        var _points = {
+                          x1: this._parseNumber(),
+                          y1: this._parseNumber(),
+                          x2: this._parseNumber(),
+                          y2: this._parseNumber(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegCurvetoCubicAbs(owningPathSegList, _points.x, _points.y, _points.x1, _points.y1, _points.x2, _points.y2);
+                      }
+
+                    case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL:
+                      {
+                        var _points2 = {
+                          x2: this._parseNumber(),
+                          y2: this._parseNumber(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, _points2.x, _points2.y, _points2.x2, _points2.y2);
+                      }
+
+                    case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:
+                      {
+                        var _points3 = {
+                          x2: this._parseNumber(),
+                          y2: this._parseNumber(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, _points3.x, _points3.y, _points3.x2, _points3.y2);
+                      }
+
+                    case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL:
+                      {
+                        var _points4 = {
+                          x1: this._parseNumber(),
+                          y1: this._parseNumber(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegCurvetoQuadraticRel(owningPathSegList, _points4.x, _points4.y, _points4.x1, _points4.y1);
+                      }
+
+                    case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS:
+                      {
+                        var _points5 = {
+                          x1: this._parseNumber(),
+                          y1: this._parseNumber(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegCurvetoQuadraticAbs(owningPathSegList, _points5.x, _points5.y, _points5.x1, _points5.y1);
+                      }
+
+                    case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:
+                      return new SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:
+                      return new SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
+
+                    case SVGPathSeg.PATHSEG_ARC_REL:
+                      {
+                        var _points6 = {
+                          x1: this._parseNumber(),
+                          y1: this._parseNumber(),
+                          arcAngle: this._parseNumber(),
+                          arcLarge: this._parseArcFlag(),
+                          arcSweep: this._parseArcFlag(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegArcRel(owningPathSegList, _points6.x, _points6.y, _points6.x1, _points6.y1, _points6.arcAngle, _points6.arcLarge, _points6.arcSweep);
+                      }
+
+                    case SVGPathSeg.PATHSEG_ARC_ABS:
+                      {
+                        var _points7 = {
+                          x1: this._parseNumber(),
+                          y1: this._parseNumber(),
+                          arcAngle: this._parseNumber(),
+                          arcLarge: this._parseArcFlag(),
+                          arcSweep: this._parseArcFlag(),
+                          x: this._parseNumber(),
+                          y: this._parseNumber()
+                        };
+                        return new SVGPathSegArcAbs(owningPathSegList, _points7.x, _points7.y, _points7.x1, _points7.y1, _points7.arcAngle, _points7.arcLarge, _points7.arcSweep);
+                      }
+
+                    default:
+                      throw new Error('Unknown path seg type.');
+                  }
+                }
+              }]);
+
+              return Source;
+            }();
+
+            var builder = new Builder();
+            var source = new Source(string);
+
+            if (!source.initialCommandIsMoveTo()) {
+              return [];
+            }
+
+            while (source.hasMoreData()) {
+              var pathSeg = source.parseSegment();
+
+              if (!pathSeg) {
+                return [];
+              }
+
+              builder.appendSegment(pathSeg);
+            }
+
+            return builder.pathSegList;
+          }
+        }]);
+
+        return SVGPathSegList;
+      }();
+
+      SVGPathSegList.prototype.classname = 'SVGPathSegList';
+      Object.defineProperty(SVGPathSegList.prototype, 'numberOfItems', {
+        get: function get() {
+          this._checkPathSynchronizedToList();
+
+          return this._list.length;
+        },
+        enumerable: true
+      });
+
+      SVGPathSegList._pathSegArrayAsString = function (pathSegArray) {
+        var string = '';
+        var first = true;
+        pathSegArray.forEach(function (pathSeg) {
+          if (first) {
+            first = false;
+            string += pathSeg._asPathString();
+          } else {
+            string += ' ' + pathSeg._asPathString();
+          }
+        });
+        return string;
+      }; // Add the pathSegList accessors to SVGPathElement.
+      // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData
+
+
+      Object.defineProperties(SVGPathElement.prototype, {
+        pathSegList: {
+          get: function get() {
+            if (!this._pathSegList) {
+              this._pathSegList = new SVGPathSegList(this);
+            }
+
+            return this._pathSegList;
+          },
+          enumerable: true
+        },
+        // FIXME: The following are not implemented and simply return SVGPathElement.pathSegList.
+        normalizedPathSegList: {
+          get: function get() {
+            return this.pathSegList;
+          },
+          enumerable: true
+        },
+        animatedPathSegList: {
+          get: function get() {
+            return this.pathSegList;
+          },
+          enumerable: true
+        },
+        animatedNormalizedPathSegList: {
+          get: function get() {
+            return this.pathSegList;
+          },
+          enumerable: true
+        }
+      });
+      window.SVGPathSegList = SVGPathSegList;
+    }
+  })();
+
+  /**
+   * jQuery module to work with SVG attributes
+   * @module jQueryAttr
+   * @license MIT
+   */
+
+  /**
+  * This fixes `$(...).attr()` to work as expected with SVG elements.
+  * Does not currently use `*AttributeNS()` since we rarely need that.
+  * Adds {@link external:jQuery.fn.attr}.
+  * See {@link https://api.jquery.com/attr/} for basic documentation of `.attr()`.
+  *
+  * Additional functionality:
+  * - When getting attributes, a string that's a number is returned as type number.
+  * - If an array is supplied as the first parameter, multiple values are returned
+  *    as an object with values for each given attribute.
+  * @function module:jQueryAttr.jQueryAttr
+  * @param {external:jQuery} $ The jQuery object to which to add the plug-in
+  * @returns {external:jQuery}
+  */
+  function jQueryPluginSVG($) {
+    var proxied = $.fn.attr,
+        svgns = 'http://www.w3.org/2000/svg';
+    /**
+    * @typedef {PlainObject.<string, string|Float>} module:jQueryAttr.Attributes
+    */
+
+    /**
+    * @function external:jQuery.fn.attr
+    * @param {string|string[]|PlainObject.<string, string>} key
+    * @param {string} value
+    * @returns {external:jQuery|module:jQueryAttr.Attributes}
+    */
+
+    $.fn.attr = function (key, value) {
+      var len = this.length;
+
+      if (!len) {
+        return proxied.call(this, key, value);
+      }
+
+      for (var i = 0; i < len; ++i) {
+        var elem = this[i]; // set/get SVG attribute
+
+        if (elem.namespaceURI === svgns) {
+          // Setting attribute
+          if (value !== undefined) {
+            elem.setAttribute(key, value);
+          } else if (Array.isArray(key)) {
+            // Getting attributes from array
+            var obj = {};
+            var j = key.length;
+
+            while (j--) {
+              var aname = key[j];
+              var attr = elem.getAttribute(aname); // This returns a number when appropriate
+
+              if (attr || attr === '0') {
+                attr = isNaN(attr) ? attr : attr - 0;
+              }
+
+              obj[aname] = attr;
+            }
+
+            return obj;
+          }
+
+          if (_typeof(key) === 'object') {
+            // Setting attributes from object
+            var _arr = Object.entries(key);
+
+            for (var _i = 0; _i < _arr.length; _i++) {
+              var _arr$_i = _slicedToArray(_arr[_i], 2),
+                  name = _arr$_i[0],
+                  val = _arr$_i[1];
+
+              elem.setAttribute(name, val);
+            } // Getting attribute
+
+          } else {
+            var _attr = elem.getAttribute(key);
+
+            if (_attr || _attr === '0') {
+              _attr = isNaN(_attr) ? _attr : _attr - 0;
+            }
+
+            return _attr;
+          }
+        } else {
+          return proxied.call(this, key, value);
+        }
+      }
+
+      return this;
+    };
+
+    return $;
+  }
+
+  /**
+   * @module jQueryPluginDBox
+   */
+
+  /**
+  * @param {external:jQuery} $
+  * @param {PlainObject} [strings]
+  * @param {PlainObject} [strings.ok]
+  * @param {PlainObject} [strings.cancel]
+  * @returns {external:jQuery}
+  */
+  function jQueryPluginDBox($) {
+    var strings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      ok: 'Ok',
+      cancel: 'Cancel'
+    };
+    // This sets up alternative dialog boxes. They mostly work the same way as
+    // their UI counterparts, expect instead of returning the result, a callback
+    // needs to be included that returns the result as its first parameter.
+    // In the future we may want to add additional types of dialog boxes, since
+    // they should be easy to handle this way.
+    $('#dialog_container').draggable({
+      cancel: '#dialog_content, #dialog_buttons *',
+      containment: 'window'
+    }).css('position', 'absolute');
+    var box = $('#dialog_box'),
+        btnHolder = $('#dialog_buttons'),
+        dialogContent = $('#dialog_content');
+    /**
+    * Resolves to `false` (if cancelled), for prompts and selects
+    * without checkboxes, it resolves to the value of the form control. For other
+    * types without checkboxes, it resolves to `true`. For checkboxes, it resolves
+    * to an object with the `response` key containing the same value as the previous
+    * mentioned (string or `true`) and a `checked` (boolean) property.
+    * @typedef {Promise} module:jQueryPluginDBox.PromiseResult
+    */
+
+    /**
+    * @typedef {PlainObject} module:jQueryPluginDBox.SelectOption
+    * @property {string} text
+    * @property {string} value
+    */
+
+    /**
+    * @typedef {PlainObject} module:jQueryPluginDBox.CheckboxInfo
+    * @property {string} label Label for the checkbox
+    * @property {string} value Value of the checkbox
+    * @property {string} tooltip Tooltip on the checkbox label
+    * @property {boolean} checked Whether the checkbox is checked by default
+    */
+
+    /**
+     * Triggered upon a change of value for the select pull-down.
+     * @callback module:jQueryPluginDBox.SelectChangeListener
+     * @returns {undefined}
+     */
+
+    /**
+    * @param {"alert"|"prompt"|"select"|"process"} type
+    * @param {string} msg
+    * @param {string} [defaultVal]
+    * @param {module:jQueryPluginDBox.SelectOption[]} [opts]
+    * @param {module:jQueryPluginDBox.SelectChangeListener} [changeListener]
+    * @param {module:jQueryPluginDBox.CheckboxInfo} [checkbox]
+    * @returns {jQueryPluginDBox.PromiseResult}
+    */
+
+    function dbox(type, msg, defaultVal, opts, changeListener, checkbox) {
+      dialogContent.html('<p>' + msg.replace(/\n/g, '</p><p>') + '</p>').toggleClass('prompt', type === 'prompt');
+      btnHolder.empty();
+      var ok = $('<input type="button" value="' + strings.ok + '">').appendTo(btnHolder);
+      return new Promise(function (resolve, reject) {
+        // eslint-disable-line promise/avoid-new
+        if (type !== 'alert') {
+          $('<input type="button" value="' + strings.cancel + '">').appendTo(btnHolder).click(function () {
+            box.hide();
+            resolve(false);
+          });
+        }
+
+        var ctrl, chkbx;
+
+        if (type === 'prompt') {
+          ctrl = $('<input type="text">').prependTo(btnHolder);
+          ctrl.val(defaultVal || '');
+          ctrl.bind('keydown', 'return', function () {
+            ok.click();
+          });
+        } else if (type === 'select') {
+          var div = $('<div style="text-align:center;">');
+          ctrl = $('<select>').appendTo(div);
+
+          if (checkbox) {
+            var label = $('<label>').text(checkbox.label);
+            chkbx = $('<input type="checkbox">').appendTo(label);
+            chkbx.val(checkbox.value);
+
+            if (checkbox.tooltip) {
+              label.attr('title', checkbox.tooltip);
+            }
+
+            chkbx.prop('checked', Boolean(checkbox.checked));
+            div.append($('<div>').append(label));
+          }
+
+          $.each(opts || [], function (opt, val) {
+            if (_typeof(val) === 'object') {
+              ctrl.append($('<option>').val(val.value).html(val.text));
+            } else {
+              ctrl.append($('<option>').html(val));
+            }
+          });
+          dialogContent.append(div);
+
+          if (defaultVal) {
+            ctrl.val(defaultVal);
+          }
+
+          if (changeListener) {
+            ctrl.bind('change', 'return', changeListener);
+          }
+
+          ctrl.bind('keydown', 'return', function () {
+            ok.click();
+          });
+        } else if (type === 'process') {
+          ok.hide();
+        }
+
+        box.show();
+        ok.click(function () {
+          box.hide();
+          var response = type === 'prompt' || type === 'select' ? ctrl.val() : true;
+
+          if (chkbx) {
+            resolve({
+              response: response,
+              checked: chkbx.prop('checked')
+            });
+            return;
+          }
+
+          resolve(response);
+        }).focus();
+
+        if (type === 'prompt' || type === 'select') {
+          ctrl.focus();
+        }
+      });
+    }
+    /**
+    * @param {string} msg Message to alert
+    * @returns {jQueryPluginDBox.PromiseResult}
+    */
+
+
+    $.alert = function (msg) {
+      return dbox('alert', msg);
+    };
+    /**
+    * @param {string} msg Message for which to ask confirmation
+    * @returns {jQueryPluginDBox.PromiseResult}
+    */
+
+
+    $.confirm = function (msg) {
+      return dbox('confirm', msg);
+    };
+    /**
+    * @param {string} msg Message to indicate upon cancelable indicator
+    * @returns {jQueryPluginDBox.PromiseResult}
+    */
+
+
+    $.process_cancel = function (msg) {
+      return dbox('process', msg);
+    };
+    /**
+    * @param {string} msg Message to accompany the prompt
+    * @param {string} [defaultText=''] The default text to show for the prompt
+    * @returns {jQueryPluginDBox.PromiseResult}
+    */
+
+
+    $.prompt = function (msg) {
+      var defaultText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      return dbox('prompt', msg, defaultText);
+    };
+
+    $.select = function (msg, opts, changeListener, txt, checkbox) {
+      return dbox('select', msg, txt, opts, changeListener, checkbox);
+    };
+
+    return $;
+  }
+
+  /**
+   * Namespaces or tools therefor
+   * @module namespaces
+   * @license MIT
+  */
+
+  /**
+  * Common namepaces constants in alpha order
+  * @enum {string}
+  * @type {PlainObject}
+  * @memberof module:namespaces
+  */
+  var NS = {
+    HTML: 'http://www.w3.org/1999/xhtml',
+    MATH: 'http://www.w3.org/1998/Math/MathML',
+    SE: 'http://svg-edit.googlecode.com',
+    SVG: 'http://www.w3.org/2000/svg',
+    XLINK: 'http://www.w3.org/1999/xlink',
+    XML: 'http://www.w3.org/XML/1998/namespace',
+    XMLNS: 'http://www.w3.org/2000/xmlns/' // see http://www.w3.org/TR/REC-xml-names/#xmlReserved
+
+  };
+  /**
+  * @function module:namespaces.getReverseNS
+  * @returns {string} The NS with key values switched and lowercase
+  */
+
+  var getReverseNS = function getReverseNS() {
+    var reverseNS = {};
+    Object.entries(NS).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          name = _ref2[0],
+          URI = _ref2[1];
+
+      reverseNS[URI] = name.toLowerCase();
+    });
+    return reverseNS;
+  };
+
+  /* globals jQuery */
+  var $ = jQuery;
+
+  var supportsSVG_ = function () {
+    return Boolean(document.createElementNS && document.createElementNS(NS.SVG, 'svg').createSVGRect);
+  }();
+  var _navigator = navigator,
+      userAgent = _navigator.userAgent;
+  var svg = document.createElementNS(NS.SVG, 'svg'); // Note: Browser sniffing should only be used if no other detection method is possible
+
+  var isOpera_ = Boolean(window.opera);
+  var isWebkit_ = userAgent.includes('AppleWebKit');
+  var isGecko_ = userAgent.includes('Gecko/');
+  var isIE_ = userAgent.includes('MSIE');
+  var isChrome_ = userAgent.includes('Chrome/');
+  var isWindows_ = userAgent.includes('Windows');
+  var isMac_ = userAgent.includes('Macintosh');
+  var isTouch_ = 'ontouchstart' in window;
+
+  var supportsSelectors_ = function () {
+    return Boolean(svg.querySelector);
+  }();
+
+  var supportsXpath_ = function () {
+    return Boolean(document.evaluate);
+  }(); // segList functions (for FF1.5 and 2.0)
+
+
+  var supportsPathReplaceItem_ = function () {
+    var path = document.createElementNS(NS.SVG, 'path');
+    path.setAttribute('d', 'M0,0 10,10');
+    var seglist = path.pathSegList;
+    var seg = path.createSVGPathSegLinetoAbs(5, 5);
+
+    try {
+      seglist.replaceItem(seg, 1);
+      return true;
+    } catch (err) {}
+
+    return false;
+  }();
+
+  var supportsPathInsertItemBefore_ = function () {
+    var path = document.createElementNS(NS.SVG, 'path');
+    path.setAttribute('d', 'M0,0 10,10');
+    var seglist = path.pathSegList;
+    var seg = path.createSVGPathSegLinetoAbs(5, 5);
+
+    try {
+      seglist.insertItemBefore(seg, 1);
+      return true;
+    } catch (err) {}
+
+    return false;
+  }(); // text character positioning (for IE9 and now Chrome)
+
+
+  var supportsGoodTextCharPos_ = function () {
+    var svgroot = document.createElementNS(NS.SVG, 'svg');
+    var svgcontent = document.createElementNS(NS.SVG, 'svg');
+    document.documentElement.append(svgroot);
+    svgcontent.setAttribute('x', 5);
+    svgroot.append(svgcontent);
+    var text = document.createElementNS(NS.SVG, 'text');
+    text.textContent = 'a';
+    svgcontent.append(text);
+
+    try {
+      // Chrome now fails here
+      var pos = text.getStartPositionOfChar(0).x;
+      return pos === 0;
+    } catch (err) {
+      return false;
+    } finally {
+      svgroot.remove();
+    }
+  }();
+
+  var supportsPathBBox_ = function () {
+    var svgcontent = document.createElementNS(NS.SVG, 'svg');
+    document.documentElement.append(svgcontent);
+    var path = document.createElementNS(NS.SVG, 'path');
+    path.setAttribute('d', 'M0,0 C0,0 10,10 10,0');
+    svgcontent.append(path);
+    var bbox = path.getBBox();
+    svgcontent.remove();
+    return bbox.height > 4 && bbox.height < 5;
+  }(); // Support for correct bbox sizing on groups with horizontal/vertical lines
+
+
+  var supportsHVLineContainerBBox_ = function () {
+    var svgcontent = document.createElementNS(NS.SVG, 'svg');
+    document.documentElement.append(svgcontent);
+    var path = document.createElementNS(NS.SVG, 'path');
+    path.setAttribute('d', 'M0,0 10,0');
+    var path2 = document.createElementNS(NS.SVG, 'path');
+    path2.setAttribute('d', 'M5,0 15,0');
+    var g = document.createElementNS(NS.SVG, 'g');
+    g.append(path, path2);
+    svgcontent.append(g);
+    var bbox = g.getBBox();
+    svgcontent.remove(); // Webkit gives 0, FF gives 10, Opera (correctly) gives 15
+
+    return bbox.width === 15;
+  }();
+
+  var supportsGoodDecimals_ = function () {
+    // Correct decimals on clone attributes (Opera < 10.5/win/non-en)
+    var rect = document.createElementNS(NS.SVG, 'rect');
+    rect.setAttribute('x', 0.1);
+    var crect = rect.cloneNode(false);
+    var retValue = !crect.getAttribute('x').includes(',');
+
+    if (!retValue) {
+      // Todo: i18nize or remove
+      $.alert('NOTE: This version of Opera is known to contain bugs in SVG-edit.\n' + 'Please upgrade to the <a href="http://opera.com">latest version</a> in which the problems have been fixed.');
+    }
+
+    return retValue;
+  }();
+
+  var supportsNonScalingStroke_ = function () {
+    var rect = document.createElementNS(NS.SVG, 'rect');
+    rect.setAttribute('style', 'vector-effect:non-scaling-stroke');
+    return rect.style.vectorEffect === 'non-scaling-stroke';
+  }();
+
+  var supportsNativeSVGTransformLists_ = function () {
+    var rect = document.createElementNS(NS.SVG, 'rect');
+    var rxform = rect.transform.baseVal;
+    var t1 = svg.createSVGTransform();
+    rxform.appendItem(t1);
+    var r1 = rxform.getItem(0); // Todo: Do frame-independent instance checking
+
+    return r1 instanceof SVGTransform && t1 instanceof SVGTransform && r1.type === t1.type && r1.angle === t1.angle && r1.matrix.a === t1.matrix.a && r1.matrix.b === t1.matrix.b && r1.matrix.c === t1.matrix.c && r1.matrix.d === t1.matrix.d && r1.matrix.e === t1.matrix.e && r1.matrix.f === t1.matrix.f;
+  }(); // Public API
+
+  /**
+   * @function module:browser.isOpera
+   * @returns {boolean}
+  */
+
+
+  var isOpera = function isOpera() {
+    return isOpera_;
+  };
+  /**
+   * @function module:browser.isWebkit
+   * @returns {boolean}
+  */
+
+  var isWebkit = function isWebkit() {
+    return isWebkit_;
+  };
+  /**
+   * @function module:browser.isGecko
+   * @returns {boolean}
+  */
+
+  var isGecko = function isGecko() {
+    return isGecko_;
+  };
+  /**
+   * @function module:browser.isIE
+   * @returns {boolean}
+  */
+
+  var isIE = function isIE() {
+    return isIE_;
+  };
+  /**
+   * @function module:browser.isChrome
+   * @returns {boolean}
+  */
+
+  var isChrome = function isChrome() {
+    return isChrome_;
+  };
+  /**
+   * @function module:browser.isTouch
+   * @returns {boolean}
+  */
+
+  var isTouch = function isTouch() {
+    return isTouch_;
+  };
+  /**
+   * @function module:browser.supportsSelectors
+   * @returns {boolean}
+  */
+
+  var supportsSelectors = function supportsSelectors() {
+    return supportsSelectors_;
+  };
+  /**
+   * @function module:browser.supportsXpath
+   * @returns {boolean}
+  */
+
+  var supportsXpath = function supportsXpath() {
+    return supportsXpath_;
+  };
+  /**
+   * @function module:browser.supportsPathReplaceItem
+   * @returns {boolean}
+  */
+
+  var supportsPathReplaceItem = function supportsPathReplaceItem() {
+    return supportsPathReplaceItem_;
+  };
+  /**
+   * @function module:browser.supportsPathInsertItemBefore
+   * @returns {boolean}
+  */
+
+  var supportsPathInsertItemBefore = function supportsPathInsertItemBefore() {
+    return supportsPathInsertItemBefore_;
+  };
+  /**
+   * @function module:browser.supportsPathBBox
+   * @returns {boolean}
+  */
+
+  var supportsPathBBox = function supportsPathBBox() {
+    return supportsPathBBox_;
+  };
+  /**
+   * @function module:browser.supportsHVLineContainerBBox
+   * @returns {boolean}
+  */
+
+  var supportsHVLineContainerBBox = function supportsHVLineContainerBBox() {
+    return supportsHVLineContainerBBox_;
+  };
+  /**
+   * @function module:browser.supportsGoodTextCharPos
+   * @returns {boolean}
+  */
+
+  var supportsGoodTextCharPos = function supportsGoodTextCharPos() {
+    return supportsGoodTextCharPos_;
+  };
+  /**
+  * @function module:browser.supportsNonScalingStroke
+  * @returns {boolean}
+  */
+
+  var supportsNonScalingStroke = function supportsNonScalingStroke() {
+    return supportsNonScalingStroke_;
+  };
+  /**
+  * @function module:browser.supportsNativeTransformLists
+  * @returns {boolean}
+  */
+
+  var supportsNativeTransformLists = function supportsNativeTransformLists() {
+    return supportsNativeSVGTransformLists_;
+  };
+
+  var svgroot = document.createElementNS(NS.SVG, 'svg');
+  /**
+   * Helper function to convert `SVGTransform` to a string.
+   * @param {SVGTransform} xform
+   * @returns {string}
+   */
+
+  function transformToString(xform) {
+    var m = xform.matrix;
+    var text = '';
+
+    switch (xform.type) {
+      case 1:
+        // MATRIX
+        text = 'matrix(' + [m.a, m.b, m.c, m.d, m.e, m.f].join(',') + ')';
+        break;
+
+      case 2:
+        // TRANSLATE
+        text = 'translate(' + m.e + ',' + m.f + ')';
+        break;
+
+      case 3:
+        // SCALE
+        if (m.a === m.d) {
+          text = 'scale(' + m.a + ')';
+        } else {
+          text = 'scale(' + m.a + ',' + m.d + ')';
+        }
+
+        break;
+
+      case 4:
+        {
+          // ROTATE
+          var cx = 0;
+          var cy = 0; // this prevents divide by zero
+
+          if (xform.angle !== 0) {
+            var K = 1 - m.a;
+            cy = (K * m.f + m.b * m.e) / (K * K + m.b * m.b);
+            cx = (m.e - m.b * cy) / K;
+          }
+
+          text = 'rotate(' + xform.angle + ' ' + cx + ',' + cy + ')';
+          break;
+        }
+    }
+
+    return text;
+  }
+  /**
+   * Map of SVGTransformList objects.
+   */
+
+
+  var listMap_ = {};
+  /**
+  * @interface module:SVGTransformList.SVGEditTransformList
+  * @property {Integer} numberOfItems unsigned long
+  */
+
+  /**
+  * @function module:SVGTransformList.SVGEditTransformList#clear
+  * @returns {undefined}
+  */
+
+  /**
+  * @function module:SVGTransformList.SVGEditTransformList#initialize
+  * @param {SVGTransform} newItem
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * (DOES NOT THROW DOMException, INDEX_SIZE_ERR)
+  * @function module:SVGTransformList.SVGEditTransformList#getItem
+  * @param {Integer} index unsigned long
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * (DOES NOT THROW DOMException, INDEX_SIZE_ERR)
+  * @function module:SVGTransformList.SVGEditTransformList#insertItemBefore
+  * @param {SVGTransform} newItem
+  * @param {Integer} index unsigned long
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * (DOES NOT THROW DOMException, INDEX_SIZE_ERR)
+  * @function module:SVGTransformList.SVGEditTransformList#replaceItem
+  * @param {SVGTransform} newItem
+  * @param {Integer} index unsigned long
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * (DOES NOT THROW DOMException, INDEX_SIZE_ERR)
+  * @function module:SVGTransformList.SVGEditTransformList#removeItem
+  * @param {Integer} index unsigned long
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * @function module:SVGTransformList.SVGEditTransformList#appendItem
+  * @param {SVGTransform} newItem
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * NOT IMPLEMENTED
+  * @ignore
+  * @function module:SVGTransformList.SVGEditTransformList#createSVGTransformFromMatrix
+  * @param {SVGMatrix} matrix
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * NOT IMPLEMENTED
+  * @ignore
+  * @function module:SVGTransformList.SVGEditTransformList#consolidate
+  * @returns {SVGTransform}
+  */
+
+  /**
+  * SVGTransformList implementation for Webkit.
+  * These methods do not currently raise any exceptions.
+  * These methods also do not check that transforms are being inserted.  This is basically
+  * implementing as much of SVGTransformList that we need to get the job done.
+  * @implements {module:SVGTransformList.SVGEditTransformList}
+  */
+
+  var SVGTransformList =
+  /*#__PURE__*/
+  function () {
+    // eslint-disable-line no-shadow
+
+    /**
+    * @param {Element} elem
+    */
+    function SVGTransformList(elem) {
+      _classCallCheck(this, SVGTransformList);
+
+      this._elem = elem || null;
+      this._xforms = []; // TODO: how do we capture the undo-ability in the changed transform list?
+
+      this._update = function () {
+        var tstr = ''; // /* const concatMatrix = */ svgroot.createSVGMatrix();
+
+        for (var i = 0; i < this.numberOfItems; ++i) {
+          var xform = this._list.getItem(i);
+
+          tstr += transformToString(xform) + ' ';
+        }
+
+        this._elem.setAttribute('transform', tstr);
+      };
+
+      this._list = this;
+
+      this._init = function () {
+        var _this = this;
+
+        // Transform attribute parser
+        var str = this._elem.getAttribute('transform');
+
+        if (!str) {
+          return;
+        } // TODO: Add skew support in future
+
+
+        var re = /\s*((scale|matrix|rotate|translate)\s*\(.*?\))\s*,?\s*/;
+        var m = true;
+
+        while (m) {
+          m = str.match(re);
+          str = str.replace(re, '');
+
+          if (m && m[1]) {
+            (function () {
+              var x = m[1];
+              var bits = x.split(/\s*\(/);
+              var name = bits[0];
+              var valBits = bits[1].match(/\s*(.*?)\s*\)/);
+              valBits[1] = valBits[1].replace(/(\d)-/g, '$1 -');
+              var valArr = valBits[1].split(/[, ]+/);
+              var letters = 'abcdef'.split('');
+              var mtx = svgroot.createSVGMatrix();
+              Object.values(valArr).forEach(function (item, i) {
+                valArr[i] = parseFloat(item);
+
+                if (name === 'matrix') {
+                  mtx[letters[i]] = valArr[i];
+                }
+              });
+              var xform = svgroot.createSVGTransform();
+              var fname = 'set' + name.charAt(0).toUpperCase() + name.slice(1);
+              var values = name === 'matrix' ? [mtx] : valArr;
+
+              if (name === 'scale' && values.length === 1) {
+                values.push(values[0]);
+              } else if (name === 'translate' && values.length === 1) {
+                values.push(0);
+              } else if (name === 'rotate' && values.length === 1) {
+                values.push(0, 0);
+              }
+
+              xform[fname].apply(xform, _toConsumableArray(values));
+
+              _this._list.appendItem(xform);
+            })();
+          }
+        }
+      };
+
+      this._removeFromOtherLists = function (item) {
+        if (item) {
+          // Check if this transform is already in a transformlist, and
+          // remove it if so.
+          Object.values(listMap_).some(function (tl) {
+            for (var i = 0, len = tl._xforms.length; i < len; ++i) {
+              if (tl._xforms[i] === item) {
+                tl.removeItem(i);
+                return true;
+              }
+            }
+
+            return false;
+          });
+        }
+      };
+
+      this.numberOfItems = 0;
+    }
+    /**
+    * @returns {undefined}
+    */
+
+
+    _createClass(SVGTransformList, [{
+      key: "clear",
+      value: function clear() {
+        this.numberOfItems = 0;
+        this._xforms = [];
+      }
+      /**
+      * @param {SVGTransform} newItem
+      * @returns {SVGTransform}
+      */
+
+    }, {
+      key: "initialize",
+      value: function initialize(newItem) {
+        this.numberOfItems = 1;
+
+        this._removeFromOtherLists(newItem);
+
+        this._xforms = [newItem];
+      }
+      /**
+      * @param {Integer} index unsigned long
+      * @throws {Error}
+      * @returns {SVGTransform}
+      */
+
+    }, {
+      key: "getItem",
+      value: function getItem(index) {
+        if (index < this.numberOfItems && index >= 0) {
+          return this._xforms[index];
+        }
+
+        var err = new Error('DOMException with code=INDEX_SIZE_ERR');
+        err.code = 1;
+        throw err;
+      }
+      /**
+      * @param {SVGTransform} newItem
+      * @param {Integer} index unsigned long
+      * @returns {SVGTransform}
+      */
+
+    }, {
+      key: "insertItemBefore",
+      value: function insertItemBefore(newItem, index) {
+        var retValue = null;
+
+        if (index >= 0) {
+          if (index < this.numberOfItems) {
+            this._removeFromOtherLists(newItem);
+
+            var newxforms = new Array(this.numberOfItems + 1); // TODO: use array copying and slicing
+
+            var i;
+
+            for (i = 0; i < index; ++i) {
+              newxforms[i] = this._xforms[i];
+            }
+
+            newxforms[i] = newItem;
+
+            for (var j = i + 1; i < this.numberOfItems; ++j, ++i) {
+              newxforms[j] = this._xforms[i];
+            }
+
+            this.numberOfItems++;
+            this._xforms = newxforms;
+            retValue = newItem;
+
+            this._list._update();
+          } else {
+            retValue = this._list.appendItem(newItem);
+          }
+        }
+
+        return retValue;
+      }
+      /**
+      * @param {SVGTransform} newItem
+      * @param {Integer} index unsigned long
+      * @returns {SVGTransform}
+      */
+
+    }, {
+      key: "replaceItem",
+      value: function replaceItem(newItem, index) {
+        var retValue = null;
+
+        if (index < this.numberOfItems && index >= 0) {
+          this._removeFromOtherLists(newItem);
+
+          this._xforms[index] = newItem;
+          retValue = newItem;
+
+          this._list._update();
+        }
+
+        return retValue;
+      }
+      /**
+      * @param {Integer} index unsigned long
+      * @throws {Error}
+      * @returns {SVGTransform}
+      */
+
+    }, {
+      key: "removeItem",
+      value: function removeItem(index) {
+        if (index < this.numberOfItems && index >= 0) {
+          var retValue = this._xforms[index];
+          var newxforms = new Array(this.numberOfItems - 1);
+          var i;
+
+          for (i = 0; i < index; ++i) {
+            newxforms[i] = this._xforms[i];
+          }
+
+          for (var j = i; j < this.numberOfItems - 1; ++j, ++i) {
+            newxforms[j] = this._xforms[i + 1];
+          }
+
+          this.numberOfItems--;
+          this._xforms = newxforms;
+
+          this._list._update();
+
+          return retValue;
+        }
+
+        var err = new Error('DOMException with code=INDEX_SIZE_ERR');
+        err.code = 1;
+        throw err;
+      }
+      /**
+      * @param {SVGTransform} newItem
+      * @returns {SVGTransform}
+      */
+
+    }, {
+      key: "appendItem",
+      value: function appendItem(newItem) {
+        this._removeFromOtherLists(newItem);
+
+        this._xforms.push(newItem);
+
+        this.numberOfItems++;
+
+        this._list._update();
+
+        return newItem;
+      }
+    }]);
+
+    return SVGTransformList;
+  }();
+  /**
+  * @function module:SVGTransformList.resetListMap
+  * @returns {undefined}
+  */
+
+  var resetListMap = function resetListMap() {
+    listMap_ = {};
+  };
+  /**
+   * Removes transforms of the given element from the map.
+   * @function module:SVGTransformList.removeElementFromListMap
+   * @param {Element} elem - a DOM Element
+   * @returns {undefined}
+   */
+
+  var removeElementFromListMap = function removeElementFromListMap(elem) {
+    // eslint-disable-line import/no-mutable-exports
+    if (elem.id && listMap_[elem.id]) {
+      delete listMap_[elem.id];
+    }
+  };
+  /**
+  * Returns an object that behaves like a `SVGTransformList` for the given DOM element.
+  * @function module:SVGTransformList.getTransformList
+  * @param {Element} elem - DOM element to get a transformlist from
+  * @todo The polyfill should have `SVGAnimatedTransformList` and this should use it
+  * @returns {SVGAnimatedTransformList|SVGTransformList}
+  */
+
+  var getTransformList = function getTransformList(elem) {
+    if (!supportsNativeTransformLists()) {
+      var id = elem.id || 'temp';
+      var t = listMap_[id];
+
+      if (!t || id === 'temp') {
+        listMap_[id] = new SVGTransformList(elem);
+
+        listMap_[id]._init();
+
+        t = listMap_[id];
+      }
+
+      return t;
+    }
+
+    if (elem.transform) {
+      return elem.transform.baseVal;
+    }
+
+    if (elem.gradientTransform) {
+      return elem.gradientTransform.baseVal;
+    }
+
+    if (elem.patternTransform) {
+      return elem.patternTransform.baseVal;
+    }
+
+    return null;
+  };
+
+  /**
+   * Tools for working with units
+   * @module units
+   * @license MIT
+   *
+   * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller
+   */
+  var wAttrs = ['x', 'x1', 'cx', 'rx', 'width'];
+  var hAttrs = ['y', 'y1', 'cy', 'ry', 'height'];
+
+  /*
+  const unitNumMap = {
+    '%': 2,
+    em: 3,
+    ex: 4,
+    px: 5,
+    cm: 6,
+    mm: 7,
+    in: 8,
+    pt: 9,
+    pc: 10
+  };
+  */
+  // Container of elements.
+
+  var elementContainer_; // Stores mapping of unit type to user coordinates.
+
+  var typeMap_ = {};
+  /**
+   * @interface module:units.ElementContainer
+   */
+
+  /**
+   * @function module:units.ElementContainer#getBaseUnit
+   * @returns {string} The base unit type of the container ('em')
+   */
+
+  /**
+   * @function module:units.ElementContainer#getElement
+   * @returns {?Element} An element in the container given an id
+   */
+
+  /**
+   * @function module:units.ElementContainer#getHeight
+   * @returns {Float} The container's height
+   */
+
+  /**
+   * @function module:units.ElementContainer#getWidth
+   * @returns {Float} The container's width
+   */
+
+  /**
+   * @function module:units.ElementContainer#getRoundDigits
+   * @returns {Integer} The number of digits number should be rounded to
+   */
+
+  /**
+   * @typedef {PlainObject} module:units.TypeMap
+   * @property {Float} em
+   * @property {Float} ex
+   * @property {Float} in
+   * @property {Float} cm
+   * @property {Float} mm
+   * @property {Float} pt
+   * @property {Float} pc
+   * @property {Integer} px
+   * @property {0} %
+   */
+
+  /**
+   * Initializes this module.
+   *
+   * @function module:units.init
+   * @param {module:units.ElementContainer} elementContainer - An object implementing the ElementContainer interface.
+   * @returns {undefined}
+   */
+
+  var init = function init(elementContainer) {
+    elementContainer_ = elementContainer; // Get correct em/ex values by creating a temporary SVG.
+
+    var svg = document.createElementNS(NS.SVG, 'svg');
+    document.body.append(svg);
+    var rect = document.createElementNS(NS.SVG, 'rect');
+    rect.setAttribute('width', '1em');
+    rect.setAttribute('height', '1ex');
+    rect.setAttribute('x', '1in');
+    svg.append(rect);
+    var bb = rect.getBBox();
+    svg.remove();
+    var inch = bb.x;
+    typeMap_ = {
+      em: bb.width,
+      ex: bb.height,
+      in: inch,
+      cm: inch / 2.54,
+      mm: inch / 25.4,
+      pt: inch / 72,
+      pc: inch / 6,
+      px: 1,
+      '%': 0
+    };
+  };
+  /**
+  * Group: Unit conversion functions
+  */
+
+  /**
+   * @function module:units.getTypeMap
+   * @returns {module:units.TypeMap} The unit object with values for each unit
+  */
+
+  var getTypeMap = function getTypeMap() {
+    return typeMap_;
+  };
+  /**
+  * @typedef {GenericArray} module:units.CompareNumbers
+  * @property {Integer} length 2
+  * @property {Float} 0
+  * @property {Float} 1
+  */
+
+  /**
+  * Rounds a given value to a float with number of digits defined in
+  * `round_digits` of `saveOptions`
+  *
+  * @function module:units.shortFloat
+  * @param {string|Float|module:units.CompareNumbers} val - The value (or Array of two numbers) to be rounded
+  * @returns {Float|string} If a string/number was given, returns a Float. If an array, return a string
+  * with comma-separated floats
+  */
+
+  var shortFloat = function shortFloat(val) {
+    var digits = elementContainer_.getRoundDigits();
+
+    if (!isNaN(val)) {
+      return Number(Number(val).toFixed(digits));
+    }
+
+    if (Array.isArray(val)) {
+      return shortFloat(val[0]) + ',' + shortFloat(val[1]);
+    }
+
+    return parseFloat(val).toFixed(digits) - 0;
+  };
+  /**
+  * Converts the number to given unit or baseUnit.
+  * @function module:units.convertUnit
+  * @param {string|Float} val
+  * @param {"em"|"ex"|"in"|"cm"|"mm"|"pt"|"pc"|"px"|"%"} [unit]
+  * @returns {Float}
+  */
+
+  var convertUnit = function convertUnit(val, unit) {
+    unit = unit || elementContainer_.getBaseUnit(); // baseVal.convertToSpecifiedUnits(unitNumMap[unit]);
+    // const val = baseVal.valueInSpecifiedUnits;
+    // baseVal.convertToSpecifiedUnits(1);
+
+    return shortFloat(val / typeMap_[unit]);
+  };
+  /**
+  * Sets an element's attribute based on the unit in its current value.
+  *
+  * @function module:units.setUnitAttr
+  * @param {Element} elem - DOM element to be changed
+  * @param {string} attr - Name of the attribute associated with the value
+  * @param {string} val - Attribute value to convert
+  * @returns {undefined}
+  */
+
+  var setUnitAttr = function setUnitAttr(elem, attr, val) {
+    //  if (!isNaN(val)) {
+    // New value is a number, so check currently used unit
+    // const oldVal = elem.getAttribute(attr);
+    // Enable this for alternate mode
+    // if (oldVal !== null && (isNaN(oldVal) || elementContainer_.getBaseUnit() !== 'px')) {
+    //   // Old value was a number, so get unit, then convert
+    //   let unit;
+    //   if (oldVal.substr(-1) === '%') {
+    //     const res = getResolution();
+    //     unit = '%';
+    //     val *= 100;
+    //     if (wAttrs.includes(attr)) {
+    //       val = val / res.w;
+    //     } else if (hAttrs.includes(attr)) {
+    //       val = val / res.h;
+    //     } else {
+    //       return val / Math.sqrt((res.w*res.w) + (res.h*res.h))/Math.sqrt(2);
+    //     }
+    //   } else {
+    //     if (elementContainer_.getBaseUnit() !== 'px') {
+    //       unit = elementContainer_.getBaseUnit();
+    //     } else {
+    //       unit = oldVal.substr(-2);
+    //     }
+    //     val = val / typeMap_[unit];
+    //   }
+    //
+    // val += unit;
+    // }
+    // }
+    elem.setAttribute(attr, val);
+  };
+  /**
+  * Converts given values to numbers. Attributes must be supplied in
+  * case a percentage is given.
+  *
+  * @function module:units.convertToNum
+  * @param {string} attr - Name of the attribute associated with the value
+  * @param {string} val - Attribute value to convert
+  * @returns {Float} The converted number
+  */
+
+  var convertToNum = function convertToNum(attr, val) {
+    // Return a number if that's what it already is
+    if (!isNaN(val)) {
+      return val - 0;
+    }
+
+    if (val.substr(-1) === '%') {
+      // Deal with percentage, depends on attribute
+      var _num = val.substr(0, val.length - 1) / 100;
+
+      var width = elementContainer_.getWidth();
+      var height = elementContainer_.getHeight();
+
+      if (wAttrs.includes(attr)) {
+        return _num * width;
+      }
+
+      if (hAttrs.includes(attr)) {
+        return _num * height;
+      }
+
+      return _num * Math.sqrt(width * width + height * height) / Math.sqrt(2);
+    }
+
+    var unit = val.substr(-2);
+    var num = val.substr(0, val.length - 2); // Note that this multiplication turns the string into a number
+
+    return num * typeMap_[unit];
+  };
+
+  /**
+  * Group: Undo/Redo history management
+  */
+
+  var HistoryEventTypes = {
+    BEFORE_APPLY: 'before_apply',
+    AFTER_APPLY: 'after_apply',
+    BEFORE_UNAPPLY: 'before_unapply',
+    AFTER_UNAPPLY: 'after_unapply'
+  }; // const removedElements = {};
+
+  /**
+  * Base class for commands.
+  */
+
+  var Command =
+  /*#__PURE__*/
+  function () {
+    function Command() {
+      _classCallCheck(this, Command);
+    }
+
+    _createClass(Command, [{
+      key: "getText",
+
+      /**
+      * @returns {string}
+      */
+      value: function getText() {
+        return this.text;
+      }
+    }]);
+
+    return Command;
+  }(); // Todo: Figure out why the interface members aren't showing
+  //   up (with or without modules applied), despite our apparently following
+  //   http://usejsdoc.org/tags-interface.html#virtual-comments
+
+  /**
+   * An interface that all command objects must implement.
+   * @interface module:history.HistoryCommand
+  */
+
+  /**
+   * Applies
+   *
+   * @function module:history.HistoryCommand#apply
+   * @param {module:history.HistoryEventHandler}
+   * @fires module:history~Command#event:history
+   * @returns {undefined|true}
+   */
+
+  /**
+   *
+   * Unapplies
+   * @function module:history.HistoryCommand#unapply
+   * @param {module:history.HistoryEventHandler}
+   * @fires module:history~Command#event:history
+   * @returns {undefined|true}
+   */
+
+  /**
+   * Returns the elements
+   * @function module:history.HistoryCommand#elements
+   * @returns {Element[]}
+   */
+
+  /**
+   * Gets the text
+   * @function module:history.HistoryCommand#getText
+   * @returns {string}
+   */
+
+  /**
+   * Gives the type
+   * @function module:history.HistoryCommand.type
+   * @returns {string}
+   */
+
+  /**
+   * Gives the type
+   * @function module:history.HistoryCommand#type
+   * @returns {string}
+  */
+
+  /**
+   * @event module:history~Command#event:history
+   * @type {module:history.HistoryCommand}
+   */
+
+  /**
+   * An interface for objects that will handle history events.
+   * @interface module:history.HistoryEventHandler
+   */
+
+  /**
+   *
+   * @function module:history.HistoryEventHandler#handleHistoryEvent
+   * @param {string} eventType One of the HistoryEvent types
+   * @param {module:history~Command#event:history} command
+   * @listens module:history~Command#event:history
+   * @returns {undefined}
+   *
+   */
+
+  /**
+   * History command for an element that had its DOM position changed.
+   * @implements {module:history.HistoryCommand}
+   * @param {Element} elem - The DOM element that was moved
+   * @param {Element} oldNextSibling - The element's next sibling before it was moved
+   * @param {Element} oldParent - The element's parent before it was moved
+   * @param {string} [text] - An optional string visible to user related to this change
+  */
+
+
+  var MoveElementCommand =
+  /*#__PURE__*/
+  function (_Command) {
+    _inherits(MoveElementCommand, _Command);
+
+    function MoveElementCommand(elem, oldNextSibling, oldParent, text) {
+      var _this;
+
+      _classCallCheck(this, MoveElementCommand);
+
+      _this = _possibleConstructorReturn(this, _getPrototypeOf(MoveElementCommand).call(this));
+      _this.elem = elem;
+      _this.text = text ? 'Move ' + elem.tagName + ' to ' + text : 'Move ' + elem.tagName;
+      _this.oldNextSibling = oldNextSibling;
+      _this.oldParent = oldParent;
+      _this.newNextSibling = elem.nextSibling;
+      _this.newParent = elem.parentNode;
+      return _this;
+    }
+
+    _createClass(MoveElementCommand, [{
+      key: "type",
+      value: function type() {
+        // eslint-disable-line class-methods-use-this
+        return 'svgedit.history.MoveElementCommand';
+      }
+      /**
+       * Re-positions the element.
+       * @param {module:history.HistoryEventHandler} handler
+       * @fires module:history~Command#event:history
+       * @returns {undefined}
+      */
+
+    }, {
+      key: "apply",
+      value: function apply(handler) {
+        // TODO(codedread): Refactor this common event code into a base HistoryCommand class.
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);
+        }
+
+        this.elem = this.newParent.insertBefore(this.elem, this.newNextSibling);
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);
+        }
+      }
+      /**
+       * Positions the element back to its original location.
+       * @param {module:history.HistoryEventHandler} handler
+       * @fires module:history~Command#event:history
+       * @returns {undefined}
+      */
+
+    }, {
+      key: "unapply",
+      value: function unapply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);
+        }
+
+        this.elem = this.oldParent.insertBefore(this.elem, this.oldNextSibling);
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);
+        }
+      }
+      /**
+      * @returns {Element[]} Array with element associated with this command
+      */
+
+    }, {
+      key: "elements",
+      value: function elements() {
+        return [this.elem];
+      }
+    }]);
+
+    return MoveElementCommand;
+  }(Command);
+  MoveElementCommand.type = MoveElementCommand.prototype.type;
+  /**
+  * History command for an element that was added to the DOM.
+  * @implements {module:history.HistoryCommand}
+  *
+  * @param {Element} elem - The newly added DOM element
+  * @param {string} text - An optional string visible to user related to this change
+  */
+
+  var InsertElementCommand =
+  /*#__PURE__*/
+  function (_Command2) {
+    _inherits(InsertElementCommand, _Command2);
+
+    function InsertElementCommand(elem, text) {
+      var _this2;
+
+      _classCallCheck(this, InsertElementCommand);
+
+      _this2 = _possibleConstructorReturn(this, _getPrototypeOf(InsertElementCommand).call(this));
+      _this2.elem = elem;
+      _this2.text = text || 'Create ' + elem.tagName;
+      _this2.parent = elem.parentNode;
+      _this2.nextSibling = _this2.elem.nextSibling;
+      return _this2;
+    }
+
+    _createClass(InsertElementCommand, [{
+      key: "type",
+      value: function type() {
+        // eslint-disable-line class-methods-use-this
+        return 'svgedit.history.InsertElementCommand';
+      }
+      /**
+      * Re-inserts the new element.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "apply",
+      value: function apply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);
+        }
+
+        this.elem = this.parent.insertBefore(this.elem, this.nextSibling);
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);
+        }
+      }
+      /**
+      * Removes the element.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "unapply",
+      value: function unapply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);
+        }
+
+        this.parent = this.elem.parentNode;
+        this.elem = this.elem.parentNode.removeChild(this.elem);
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);
+        }
+      }
+      /**
+      * @returns {Element[]} Array with element associated with this command
+      */
+
+    }, {
+      key: "elements",
+      value: function elements() {
+        return [this.elem];
+      }
+    }]);
+
+    return InsertElementCommand;
+  }(Command);
+  InsertElementCommand.type = InsertElementCommand.prototype.type;
+  /**
+  * History command for an element removed from the DOM.
+  * @implements {module:history.HistoryCommand}
+  * @param {Element} elem - The removed DOM element
+  * @param {Node} oldNextSibling - The DOM element's nextSibling when it was in the DOM
+  * @param {Element} oldParent - The DOM element's parent
+  * @param {string} [text] - An optional string visible to user related to this change
+  */
+
+  var RemoveElementCommand =
+  /*#__PURE__*/
+  function (_Command3) {
+    _inherits(RemoveElementCommand, _Command3);
+
+    function RemoveElementCommand(elem, oldNextSibling, oldParent, text) {
+      var _this3;
+
+      _classCallCheck(this, RemoveElementCommand);
+
+      _this3 = _possibleConstructorReturn(this, _getPrototypeOf(RemoveElementCommand).call(this));
+      _this3.elem = elem;
+      _this3.text = text || 'Delete ' + elem.tagName;
+      _this3.nextSibling = oldNextSibling;
+      _this3.parent = oldParent; // special hack for webkit: remove this element's entry in the svgTransformLists map
+
+      removeElementFromListMap(elem);
+      return _this3;
+    }
+
+    _createClass(RemoveElementCommand, [{
+      key: "type",
+      value: function type() {
+        // eslint-disable-line class-methods-use-this
+        return 'svgedit.history.RemoveElementCommand';
+      }
+      /**
+      * Re-removes the new element.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "apply",
+      value: function apply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);
+        }
+
+        removeElementFromListMap(this.elem);
+        this.parent = this.elem.parentNode;
+        this.elem = this.parent.removeChild(this.elem);
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);
+        }
+      }
+      /**
+      * Re-adds the new element.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "unapply",
+      value: function unapply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);
+        }
+
+        removeElementFromListMap(this.elem);
+
+        if (isNullish(this.nextSibling)) {
+          if (window.console) {
+            console.log('Error: reference element was lost'); // eslint-disable-line no-console
+          }
+        }
+
+        this.parent.insertBefore(this.elem, this.nextSibling); // Don't use `before` or `prepend` as `this.nextSibling` may be `null`
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);
+        }
+      }
+      /**
+      * @returns {Element[]} Array with element associated with this command
+      */
+
+    }, {
+      key: "elements",
+      value: function elements() {
+        return [this.elem];
+      }
+    }]);
+
+    return RemoveElementCommand;
+  }(Command);
+  RemoveElementCommand.type = RemoveElementCommand.prototype.type;
+  /**
+  * @typedef {"#text"|"#href"|string} module:history.CommandAttributeName
+  */
+
+  /**
+  * @typedef {PlainObject.<module:history.CommandAttributeName, string>} module:history.CommandAttributes
+  */
+
+  /**
+  * History command to make a change to an element.
+  * Usually an attribute change, but can also be textcontent.
+  * @implements {module:history.HistoryCommand}
+  * @param {Element} elem - The DOM element that was changed
+  * @param {module:history.CommandAttributes} attrs - Attributes to be changed with the values they had *before* the change
+  * @param {string} text - An optional string visible to user related to this change
+  */
+
+  var ChangeElementCommand =
+  /*#__PURE__*/
+  function (_Command4) {
+    _inherits(ChangeElementCommand, _Command4);
+
+    function ChangeElementCommand(elem, attrs, text) {
+      var _this4;
+
+      _classCallCheck(this, ChangeElementCommand);
+
+      _this4 = _possibleConstructorReturn(this, _getPrototypeOf(ChangeElementCommand).call(this));
+      _this4.elem = elem;
+      _this4.text = text ? 'Change ' + elem.tagName + ' ' + text : 'Change ' + elem.tagName;
+      _this4.newValues = {};
+      _this4.oldValues = attrs;
+
+      for (var attr in attrs) {
+        if (attr === '#text') {
+          _this4.newValues[attr] = elem.textContent;
+        } else if (attr === '#href') {
+          _this4.newValues[attr] = getHref(elem);
+        } else {
+          _this4.newValues[attr] = elem.getAttribute(attr);
+        }
+      }
+
+      return _this4;
+    }
+
+    _createClass(ChangeElementCommand, [{
+      key: "type",
+      value: function type() {
+        // eslint-disable-line class-methods-use-this
+        return 'svgedit.history.ChangeElementCommand';
+      }
+      /**
+      * Performs the stored change action.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {true}
+      */
+
+    }, {
+      key: "apply",
+      value: function apply(handler) {
+        var _this5 = this;
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);
+        }
+
+        var bChangedTransform = false;
+        Object.entries(this.newValues).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+              attr = _ref2[0],
+              value = _ref2[1];
+
+          if (value) {
+            if (attr === '#text') {
+              _this5.elem.textContent = value;
+            } else if (attr === '#href') {
+              setHref(_this5.elem, value);
+            } else {
+              _this5.elem.setAttribute(attr, value);
+            }
+          } else if (attr === '#text') {
+            _this5.elem.textContent = '';
+          } else {
+            _this5.elem.setAttribute(attr, '');
+
+            _this5.elem.removeAttribute(attr);
+          }
+
+          if (attr === 'transform') {
+            bChangedTransform = true;
+          }
+        }); // relocate rotational transform, if necessary
+
+        if (!bChangedTransform) {
+          var angle = getRotationAngle(this.elem);
+
+          if (angle) {
+            var bbox = this.elem.getBBox();
+            var cx = bbox.x + bbox.width / 2,
+                cy = bbox.y + bbox.height / 2;
+            var rotate = ['rotate(', angle, ' ', cx, ',', cy, ')'].join('');
+
+            if (rotate !== this.elem.getAttribute('transform')) {
+              this.elem.setAttribute('transform', rotate);
+            }
+          }
+        }
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);
+        }
+
+        return true;
+      }
+      /**
+      * Reverses the stored change action.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {true}
+      */
+
+    }, {
+      key: "unapply",
+      value: function unapply(handler) {
+        var _this6 = this;
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);
+        }
+
+        var bChangedTransform = false;
+        Object.entries(this.oldValues).forEach(function (_ref3) {
+          var _ref4 = _slicedToArray(_ref3, 2),
+              attr = _ref4[0],
+              value = _ref4[1];
+
+          if (value) {
+            if (attr === '#text') {
+              _this6.elem.textContent = value;
+            } else if (attr === '#href') {
+              setHref(_this6.elem, value);
+            } else {
+              _this6.elem.setAttribute(attr, value);
+            }
+          } else if (attr === '#text') {
+            _this6.elem.textContent = '';
+          } else {
+            _this6.elem.removeAttribute(attr);
+          }
+
+          if (attr === 'transform') {
+            bChangedTransform = true;
+          }
+        }); // relocate rotational transform, if necessary
+
+        if (!bChangedTransform) {
+          var angle = getRotationAngle(this.elem);
+
+          if (angle) {
+            var bbox = this.elem.getBBox();
+            var cx = bbox.x + bbox.width / 2,
+                cy = bbox.y + bbox.height / 2;
+            var rotate = ['rotate(', angle, ' ', cx, ',', cy, ')'].join('');
+
+            if (rotate !== this.elem.getAttribute('transform')) {
+              this.elem.setAttribute('transform', rotate);
+            }
+          }
+        } // Remove transformlist to prevent confusion that causes bugs like 575.
+
+
+        removeElementFromListMap(this.elem);
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);
+        }
+
+        return true;
+      }
+      /**
+      * @returns {Element[]} Array with element associated with this command
+      */
+
+    }, {
+      key: "elements",
+      value: function elements() {
+        return [this.elem];
+      }
+    }]);
+
+    return ChangeElementCommand;
+  }(Command);
+  ChangeElementCommand.type = ChangeElementCommand.prototype.type; // TODO: create a 'typing' command object that tracks changes in text
+  // if a new Typing command is created and the top command on the stack is also a Typing
+  // and they both affect the same element, then collapse the two commands into one
+
+  /**
+  * History command that can contain/execute multiple other commands.
+  * @implements {module:history.HistoryCommand}
+  */
+
+  var BatchCommand =
+  /*#__PURE__*/
+  function (_Command5) {
+    _inherits(BatchCommand, _Command5);
+
+    /**
+    * @param {string} [text] - An optional string visible to user related to this change
+    */
+    function BatchCommand(text) {
+      var _this7;
+
+      _classCallCheck(this, BatchCommand);
+
+      _this7 = _possibleConstructorReturn(this, _getPrototypeOf(BatchCommand).call(this));
+      _this7.text = text || 'Batch Command';
+      _this7.stack = [];
+      return _this7;
+    }
+
+    _createClass(BatchCommand, [{
+      key: "type",
+      value: function type() {
+        // eslint-disable-line class-methods-use-this
+        return 'svgedit.history.BatchCommand';
+      }
+      /**
+      * Runs "apply" on all subcommands.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "apply",
+      value: function apply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);
+        }
+
+        var len = this.stack.length;
+
+        for (var i = 0; i < len; ++i) {
+          this.stack[i].apply(handler);
+        }
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);
+        }
+      }
+      /**
+      * Runs "unapply" on all subcommands.
+      * @param {module:history.HistoryEventHandler} handler
+      * @fires module:history~Command#event:history
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "unapply",
+      value: function unapply(handler) {
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);
+        }
+
+        for (var i = this.stack.length - 1; i >= 0; i--) {
+          this.stack[i].unapply(handler);
+        }
+
+        if (handler) {
+          handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);
+        }
+      }
+      /**
+      * Iterate through all our subcommands.
+      * @returns {Element[]} All the elements we are changing
+      */
+
+    }, {
+      key: "elements",
+      value: function elements() {
+        var elems = [];
+        var cmd = this.stack.length;
+
+        while (cmd--) {
+          var thisElems = this.stack[cmd].elements();
+          var elem = thisElems.length;
+
+          while (elem--) {
+            if (!elems.includes(thisElems[elem])) {
+              elems.push(thisElems[elem]);
+            }
+          }
+        }
+
+        return elems;
+      }
+      /**
+      * Adds a given command to the history stack.
+      * @param {Command} cmd - The undo command object to add
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "addSubCommand",
+      value: function addSubCommand(cmd) {
+        this.stack.push(cmd);
+      }
+      /**
+      * @returns {boolean} Indicates whether or not the batch command is empty
+      */
+
+    }, {
+      key: "isEmpty",
+      value: function isEmpty() {
+        return !this.stack.length;
+      }
+    }]);
+
+    return BatchCommand;
+  }(Command);
+  BatchCommand.type = BatchCommand.prototype.type;
+  /**
+  *
+  */
+
+  var UndoManager =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {module:history.HistoryEventHandler} historyEventHandler
+    */
+    function UndoManager(historyEventHandler) {
+      _classCallCheck(this, UndoManager);
+
+      this.handler_ = historyEventHandler || null;
+      this.undoStackPointer = 0;
+      this.undoStack = []; // this is the stack that stores the original values, the elements and
+      // the attribute name for begin/finish
+
+      this.undoChangeStackPointer = -1;
+      this.undoableChangeStack = [];
+    }
+    /**
+    * Resets the undo stack, effectively clearing the undo/redo history.
+    * @returns {undefined}
+    */
+
+
+    _createClass(UndoManager, [{
+      key: "resetUndoStack",
+      value: function resetUndoStack() {
+        this.undoStack = [];
+        this.undoStackPointer = 0;
+      }
+      /**
+      * @returns {Integer} Current size of the undo history stack
+      */
+
+    }, {
+      key: "getUndoStackSize",
+      value: function getUndoStackSize() {
+        return this.undoStackPointer;
+      }
+      /**
+      * @returns {Integer} Current size of the redo history stack
+      */
+
+    }, {
+      key: "getRedoStackSize",
+      value: function getRedoStackSize() {
+        return this.undoStack.length - this.undoStackPointer;
+      }
+      /**
+      * @returns {string} String associated with the next undo command
+      */
+
+    }, {
+      key: "getNextUndoCommandText",
+      value: function getNextUndoCommandText() {
+        return this.undoStackPointer > 0 ? this.undoStack[this.undoStackPointer - 1].getText() : '';
+      }
+      /**
+      * @returns {string} String associated with the next redo command
+      */
+
+    }, {
+      key: "getNextRedoCommandText",
+      value: function getNextRedoCommandText() {
+        return this.undoStackPointer < this.undoStack.length ? this.undoStack[this.undoStackPointer].getText() : '';
+      }
+      /**
+      * Performs an undo step.
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "undo",
+      value: function undo() {
+        if (this.undoStackPointer > 0) {
+          var cmd = this.undoStack[--this.undoStackPointer];
+          cmd.unapply(this.handler_);
+        }
+      }
+      /**
+      * Performs a redo step.
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "redo",
+      value: function redo() {
+        if (this.undoStackPointer < this.undoStack.length && this.undoStack.length > 0) {
+          var cmd = this.undoStack[this.undoStackPointer++];
+          cmd.apply(this.handler_);
+        }
+      }
+      /**
+      * Adds a command object to the undo history stack.
+      * @param {Command} cmd - The command object to add
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "addCommandToHistory",
+      value: function addCommandToHistory(cmd) {
+        // FIXME: we MUST compress consecutive text changes to the same element
+        // (right now each keystroke is saved as a separate command that includes the
+        // entire text contents of the text element)
+        // TODO: consider limiting the history that we store here (need to do some slicing)
+        // if our stack pointer is not at the end, then we have to remove
+        // all commands after the pointer and insert the new command
+        if (this.undoStackPointer < this.undoStack.length && this.undoStack.length > 0) {
+          this.undoStack = this.undoStack.splice(0, this.undoStackPointer);
+        }
+
+        this.undoStack.push(cmd);
+        this.undoStackPointer = this.undoStack.length;
+      }
+      /**
+      * This function tells the canvas to remember the old values of the
+      * `attrName` attribute for each element sent in.  The elements and values
+      * are stored on a stack, so the next call to `finishUndoableChange()` will
+      * pop the elements and old values off the stack, gets the current values
+      * from the DOM and uses all of these to construct the undo-able command.
+      * @param {string} attrName - The name of the attribute being changed
+      * @param {Element[]} elems - Array of DOM elements being changed
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "beginUndoableChange",
+      value: function beginUndoableChange(attrName, elems) {
+        var p = ++this.undoChangeStackPointer;
+        var i = elems.length;
+        var oldValues = new Array(i),
+            elements = new Array(i);
+
+        while (i--) {
+          var elem = elems[i];
+
+          if (isNullish(elem)) {
+            continue;
+          }
+
+          elements[i] = elem;
+          oldValues[i] = elem.getAttribute(attrName);
+        }
+
+        this.undoableChangeStack[p] = {
+          attrName: attrName,
+          oldValues: oldValues,
+          elements: elements
+        };
+      }
+      /**
+      * This function returns a `BatchCommand` object which summarizes the
+      * change since `beginUndoableChange` was called.  The command can then
+      * be added to the command history.
+      * @returns {BatchCommand} Batch command object with resulting changes
+      */
+
+    }, {
+      key: "finishUndoableChange",
+      value: function finishUndoableChange() {
+        var p = this.undoChangeStackPointer--;
+        var changeset = this.undoableChangeStack[p];
+        var attrName = changeset.attrName;
+        var batchCmd = new BatchCommand('Change ' + attrName);
+        var i = changeset.elements.length;
+
+        while (i--) {
+          var elem = changeset.elements[i];
+
+          if (isNullish(elem)) {
+            continue;
+          }
+
+          var changes = {};
+          changes[attrName] = changeset.oldValues[i];
+
+          if (changes[attrName] !== elem.getAttribute(attrName)) {
+            batchCmd.addSubCommand(new ChangeElementCommand(elem, changes, attrName));
+          }
+        }
+
+        this.undoableChangeStack[p] = null;
+        return batchCmd;
+      }
+    }]);
+
+    return UndoManager;
+  }();
+
+  var hstry = /*#__PURE__*/Object.freeze({
+    HistoryEventTypes: HistoryEventTypes,
+    MoveElementCommand: MoveElementCommand,
+    InsertElementCommand: InsertElementCommand,
+    RemoveElementCommand: RemoveElementCommand,
+    ChangeElementCommand: ChangeElementCommand,
+    BatchCommand: BatchCommand,
+    UndoManager: UndoManager
+  });
+
+  /**
+   * Mathematical utilities
+   * @module math
+   * @license MIT
+   *
+   * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller
+   */
+
+  var NEAR_ZERO = 1e-14; // Throw away SVGSVGElement used for creating matrices/transforms.
+
+  var svg$1 = document.createElementNS(NS.SVG, 'svg');
+  /**
+   * A (hopefully) quicker function to transform a point by a matrix
+   * (this function avoids any DOM calls and just does the math).
+   * @function module:math.transformPoint
+   * @param {Float} x - Float representing the x coordinate
+   * @param {Float} y - Float representing the y coordinate
+   * @param {SVGMatrix} m - Matrix object to transform the point with
+   * @returns {module:math.XYObject} An x, y object representing the transformed point
+  */
+
+  var transformPoint = function transformPoint(x, y, m) {
+    return {
+      x: m.a * x + m.c * y + m.e,
+      y: m.b * x + m.d * y + m.f
+    };
+  };
+  /**
+   * Helper function to check if the matrix performs no actual transform
+   * (i.e. exists for identity purposes).
+   * @function module:math.isIdentity
+   * @param {SVGMatrix} m - The matrix object to check
+   * @returns {boolean} Indicates whether or not the matrix is 1,0,0,1,0,0
+  */
+
+  var isIdentity = function isIdentity(m) {
+    return m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && m.e === 0 && m.f === 0;
+  };
+  /**
+   * This function tries to return a `SVGMatrix` that is the multiplication `m1 * m2`.
+   * We also round to zero when it's near zero.
+   * @function module:math.matrixMultiply
+   * @param {...SVGMatrix} args - Matrix objects to multiply
+   * @returns {SVGMatrix} The matrix object resulting from the calculation
+  */
+
+  var matrixMultiply = function matrixMultiply() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var m = args.reduceRight(function (prev, m1) {
+      return m1.multiply(prev);
+    });
+
+    if (Math.abs(m.a) < NEAR_ZERO) {
+      m.a = 0;
+    }
+
+    if (Math.abs(m.b) < NEAR_ZERO) {
+      m.b = 0;
+    }
+
+    if (Math.abs(m.c) < NEAR_ZERO) {
+      m.c = 0;
+    }
+
+    if (Math.abs(m.d) < NEAR_ZERO) {
+      m.d = 0;
+    }
+
+    if (Math.abs(m.e) < NEAR_ZERO) {
+      m.e = 0;
+    }
+
+    if (Math.abs(m.f) < NEAR_ZERO) {
+      m.f = 0;
+    }
+
+    return m;
+  };
+  var hasMatrixTransform = function hasMatrixTransform(tlist) {
+    if (!tlist) {
+      return false;
+    }
+
+    var num = tlist.numberOfItems;
+
+    while (num--) {
+      var xform = tlist.getItem(num);
+
+      if (xform.type === 1 && !isIdentity(xform.matrix)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+  /**
+  * @typedef {PlainObject} module:math.TransformedBox An object with the following values
+  * @property {module:math.XYObject} tl - The top left coordinate
+  * @property {module:math.XYObject} tr - The top right coordinate
+  * @property {module:math.XYObject} bl - The bottom left coordinate
+  * @property {module:math.XYObject} br - The bottom right coordinate
+  * @property {PlainObject} aabox - Object with the following values:
+  * @property {Float} aabox.x - Float with the axis-aligned x coordinate
+  * @property {Float} aabox.y - Float with the axis-aligned y coordinate
+  * @property {Float} aabox.width - Float with the axis-aligned width coordinate
+  * @property {Float} aabox.height - Float with the axis-aligned height coordinate
+  */
+
+  /**
+   * Transforms a rectangle based on the given matrix.
+   * @function module:math.transformBox
+   * @param {Float} l - Float with the box's left coordinate
+   * @param {Float} t - Float with the box's top coordinate
+   * @param {Float} w - Float with the box width
+   * @param {Float} h - Float with the box height
+   * @param {SVGMatrix} m - Matrix object to transform the box by
+   * @returns {module:math.TransformedBox}
+  */
+
+  var transformBox = function transformBox(l, t, w, h, m) {
+    var tl = transformPoint(l, t, m),
+        tr = transformPoint(l + w, t, m),
+        bl = transformPoint(l, t + h, m),
+        br = transformPoint(l + w, t + h, m),
+        minx = Math.min(tl.x, tr.x, bl.x, br.x),
+        maxx = Math.max(tl.x, tr.x, bl.x, br.x),
+        miny = Math.min(tl.y, tr.y, bl.y, br.y),
+        maxy = Math.max(tl.y, tr.y, bl.y, br.y);
+    return {
+      tl: tl,
+      tr: tr,
+      bl: bl,
+      br: br,
+      aabox: {
+        x: minx,
+        y: miny,
+        width: maxx - minx,
+        height: maxy - miny
+      }
+    };
+  };
+  /**
+   * This returns a single matrix Transform for a given Transform List
+   * (this is the equivalent of `SVGTransformList.consolidate()` but unlike
+   * that method, this one does not modify the actual `SVGTransformList`).
+   * This function is very liberal with its `min`, `max` arguments.
+   * @function module:math.transformListToTransform
+   * @param {SVGTransformList} tlist - The transformlist object
+   * @param {Integer} [min=0] - Optional integer indicating start transform position
+   * @param {Integer} [max] - Optional integer indicating end transform position;
+   *   defaults to one less than the tlist's `numberOfItems`
+   * @returns {SVGTransform} A single matrix transform object
+  */
+
+  var transformListToTransform = function transformListToTransform(tlist, min, max) {
+    if (isNullish(tlist)) {
+      // Or should tlist = null have been prevented before this?
+      return svg$1.createSVGTransformFromMatrix(svg$1.createSVGMatrix());
+    }
+
+    min = min || 0;
+    max = max || tlist.numberOfItems - 1;
+    min = parseInt(min);
+    max = parseInt(max);
+
+    if (min > max) {
+      var temp = max;
+      max = min;
+      min = temp;
+    }
+
+    var m = svg$1.createSVGMatrix();
+
+    for (var i = min; i <= max; ++i) {
+      // if our indices are out of range, just use a harmless identity matrix
+      var mtom = i >= 0 && i < tlist.numberOfItems ? tlist.getItem(i).matrix : svg$1.createSVGMatrix();
+      m = matrixMultiply(m, mtom);
+    }
+
+    return svg$1.createSVGTransformFromMatrix(m);
+  };
+  /**
+   * Get the matrix object for a given element.
+   * @function module:math.getMatrix
+   * @param {Element} elem - The DOM element to check
+   * @returns {SVGMatrix} The matrix object associated with the element's transformlist
+  */
+
+  var getMatrix = function getMatrix(elem) {
+    var tlist = getTransformList(elem);
+    return transformListToTransform(tlist).matrix;
+  };
+  /**
+   * Returns a 45 degree angle coordinate associated with the two given
+   * coordinates.
+   * @function module:math.snapToAngle
+   * @param {Integer} x1 - First coordinate's x value
+   * @param {Integer} y1 - First coordinate's y value
+   * @param {Integer} x2 - Second coordinate's x value
+   * @param {Integer} y2 - Second coordinate's y value
+   * @returns {module:math.AngleCoord45}
+  */
+
+  var snapToAngle = function snapToAngle(x1, y1, x2, y2) {
+    var snap = Math.PI / 4; // 45 degrees
+
+    var dx = x2 - x1;
+    var dy = y2 - y1;
+    var angle = Math.atan2(dy, dx);
+    var dist = Math.sqrt(dx * dx + dy * dy);
+    var snapangle = Math.round(angle / snap) * snap;
+    return {
+      x: x1 + dist * Math.cos(snapangle),
+      y: y1 + dist * Math.sin(snapangle),
+      a: snapangle
+    };
+  };
+  /**
+   * Check if two rectangles (BBoxes objects) intersect each other.
+   * @function module:math.rectsIntersect
+   * @param {SVGRect} r1 - The first BBox-like object
+   * @param {SVGRect} r2 - The second BBox-like object
+   * @returns {boolean} True if rectangles intersect
+   */
+
+  var rectsIntersect = function rectsIntersect(r1, r2) {
+    return r2.x < r1.x + r1.width && r2.x + r2.width > r1.x && r2.y < r1.y + r1.height && r2.y + r2.height > r1.y;
+  };
+
+  var $$1 = jQuery;
+  var segData = {
+    2: ['x', 'y'],
+    // PATHSEG_MOVETO_ABS
+    4: ['x', 'y'],
+    // PATHSEG_LINETO_ABS
+    6: ['x', 'y', 'x1', 'y1', 'x2', 'y2'],
+    // PATHSEG_CURVETO_CUBIC_ABS
+    8: ['x', 'y', 'x1', 'y1'],
+    // PATHSEG_CURVETO_QUADRATIC_ABS
+    10: ['x', 'y', 'r1', 'r2', 'angle', 'largeArcFlag', 'sweepFlag'],
+    // PATHSEG_ARC_ABS
+    12: ['x'],
+    // PATHSEG_LINETO_HORIZONTAL_ABS
+    14: ['y'],
+    // PATHSEG_LINETO_VERTICAL_ABS
+    16: ['x', 'y', 'x2', 'y2'],
+    // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
+    18: ['x', 'y'] // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
+
+  };
+  /**
+   * @tutorial LocaleDocs
+   * @typedef {module:locale.LocaleStrings|PlainObject} module:path.uiStrings
+   * @property {PlainObject.<string, string>} ui
+  */
+
+  var uiStrings = {};
+  /**
+  * @function module:path.setUiStrings
+  * @param {module:path.uiStrings} strs
+  * @returns {undefined}
+  */
+
+  var setUiStrings = function setUiStrings(strs) {
+    Object.assign(uiStrings, strs.ui);
+  };
+  var pathFuncs = [];
+  var linkControlPts = true; // Stores references to paths via IDs.
+  // TODO: Make this cross-document happy.
+
+  var pathData = {};
+  /**
+  * @function module:path.setLinkControlPoints
+  * @param {boolean} lcp
+  * @returns {undefined}
+  */
+
+  var setLinkControlPoints = function setLinkControlPoints(lcp) {
+    linkControlPts = lcp;
+  };
+  /**
+   * @name module:path.path
+   * @type {null|module:path.Path}
+   * @memberof module:path
+  */
+
+  var path = null; // eslint-disable-line import/no-mutable-exports
+
+  var editorContext_ = null;
+  /**
+  * @external MouseEvent
+  */
+
+  /**
+  * Object with the following keys/values
+  * @typedef {PlainObject} module:path.SVGElementJSON
+  * @property {string} element - Tag name of the SVG element to create
+  * @property {PlainObject.<string, string>} attr - Has key-value attributes to assign to the new element
+  * @property {boolean} [curStyles=false] - Indicates whether current style attributes should be applied first
+  * @property {module:path.SVGElementJSON[]} [children] - Data objects to be added recursively as children
+  * @property {string} [namespace="http://www.w3.org/2000/svg"] - Indicate a (non-SVG) namespace
+  */
+
+  /**
+   * @interface module:path.EditorContext
+   * @property {module:select.SelectorManager} selectorManager
+   * @property {module:svgcanvas.SvgCanvas} canvas
+   */
+
+  /**
+   * @function module:path.EditorContext#call
+   * @param {"selected"|"changed"} ev - String with the event name
+   * @param {module:svgcanvas.SvgCanvas#event:selected|module:svgcanvas.SvgCanvas#event:changed} arg - Argument to pass through to the callback function. If the event is "changed", an array of `Element`s is passed; if "selected", a single-item array of `Element` is passed.
+   * @returns {undefined}
+   */
+
+  /**
+   * @function module:path.EditorContext#resetD
+   * @param {SVGPathElement} p
+   * @returns {undefined}
+  */
+
+  /**
+   * Note: This doesn't round to an integer necessarily
+   * @function module:path.EditorContext#round
+   * @param {Float} val
+   * @returns {Float} Rounded value to nearest value based on `currentZoom`
+   */
+
+  /**
+   * @function module:path.EditorContext#clearSelection
+   * @param {boolean} [noCall] - When `true`, does not call the "selected" handler
+   * @returns {undefined}
+  */
+
+  /**
+   * @function module:path.EditorContext#addToSelection
+   * @param {Element[]} elemsToAdd - An array of DOM elements to add to the selection
+   * @param {boolean} showGrips - Indicates whether the resize grips should be shown
+   * @returns {undefined}
+  */
+
+  /**
+   * @function module:path.EditorContext#addCommandToHistory
+   * @param {Command} cmd
+   * @returns {undefined}
+   */
+
+  /**
+   * @function module:path.EditorContext#remapElement
+   * @param {Element} selected - DOM element to be changed
+   * @param {PlainObject.<string, string>} changes - Object with changes to be remapped
+   * @param {SVGMatrix} m - Matrix object to use for remapping coordinates
+   * @returns {undefined}
+   */
+
+  /**
+   * @function module:path.EditorContext#addSVGElementFromJson
+   * @param {module:path.SVGElementJSON} data
+   * @returns {Element} The new element
+  */
+
+  /**
+   * @function module:path.EditorContext#getGridSnapping
+   * @returns {boolean}
+   */
+
+  /**
+   * @function module:path.EditorContext#getOpacity
+   * @returns {Float}
+   */
+
+  /**
+   * @function module:path.EditorContext#getSelectedElements
+   * @returns {Element[]} the array with selected DOM elements
+  */
+
+  /**
+   * @function module:path.EditorContext#getContainer
+   * @returns {Element}
+   */
+
+  /**
+   * @function module:path.EditorContext#setStarted
+   * @param {boolean} s
+   * @returns {undefined}
+   */
+
+  /**
+   * @function module:path.EditorContext#getRubberBox
+   * @returns {SVGRectElement}
+  */
+
+  /**
+   * @function module:path.EditorContext#setRubberBox
+   * @param {SVGRectElement} rb
+   * @returns {SVGRectElement} Same as parameter passed in
+   */
+
+  /**
+   * @function module:path.EditorContext#addPtsToSelection
+   * @param {PlainObject} cfg
+   * @param {boolean} cfg.closedSubpath
+   * @param {SVGCircleElement[]} cfg.grips
+   * @returns {undefined}
+   */
+
+  /**
+   * @function module:path.EditorContext#endChanges
+   * @param {PlainObject} cfg
+   * @param {string} cfg.cmd
+   * @param {Element} cfg.elem
+   * @returns {undefined}
+  */
+
+  /**
+   * @function module:path.EditorContext#getCurrentZoom
+   * @returns {Float} The current zoom level
+   */
+
+  /**
+   * Returns the last created DOM element ID string
+   * @function module:path.EditorContext#getId
+   * @returns {string}
+   */
+
+  /**
+   * Creates and returns a unique ID string for a DOM element
+   * @function module:path.EditorContext#getNextId
+   * @returns {string}
+  */
+
+  /**
+   * Gets the desired element from a mouse event
+   * @function module:path.EditorContext#getMouseTarget
+   * @param {external:MouseEvent} evt - Event object from the mouse event
+   * @returns {Element} DOM element we want
+   */
+
+  /**
+   * @function module:path.EditorContext#getCurrentMode
+   * @returns {string}
+   */
+
+  /**
+   * @function module:path.EditorContext#setCurrentMode
+   * @param {string} cm The mode
+   * @returns {string} The same mode as passed in
+  */
+
+  /**
+   * @function module:path.EditorContext#getDrawnPath
+   * @returns {SVGPathElement|null}
+   */
+
+  /**
+   * @function module:path.EditorContext#setDrawnPath
+   * @param {SVGPathElement|null} dp
+   * @returns {SVGPathElement|null} The same value as passed in
+   */
+
+  /**
+   * @function module:path.EditorContext#getSVGRoot
+   * @returns {SVGSVGElement}
+  */
+
+  /**
+  * @function module:path.init
+  * @param {module:path.EditorContext} editorContext
+  * @returns {undefined}
+  */
+
+  var init$1 = function init$$1(editorContext) {
+    editorContext_ = editorContext;
+    pathFuncs = [0, 'ClosePath'];
+    var pathFuncsStrs = ['Moveto', 'Lineto', 'CurvetoCubic', 'CurvetoQuadratic', 'Arc', 'LinetoHorizontal', 'LinetoVertical', 'CurvetoCubicSmooth', 'CurvetoQuadraticSmooth'];
+    $$1.each(pathFuncsStrs, function (i, s) {
+      pathFuncs.push(s + 'Abs');
+      pathFuncs.push(s + 'Rel');
+    });
+  };
+  /**
+  * @function module:path.insertItemBefore
+  * @param {Element} elem
+  * @param {Segment} newseg
+  * @param {Integer} index
+  * @returns {undefined}
+  */
+
+  var insertItemBefore = function insertItemBefore(elem, newseg, index) {
+    // Support insertItemBefore on paths for FF2
+    var list = elem.pathSegList;
+
+    if (supportsPathInsertItemBefore()) {
+      list.insertItemBefore(newseg, index);
+      return;
+    }
+
+    var len = list.numberOfItems;
+    var arr = [];
+
+    for (var i = 0; i < len; i++) {
+      var curSeg = list.getItem(i);
+      arr.push(curSeg);
+    }
+
+    list.clear();
+
+    for (var _i = 0; _i < len; _i++) {
+      if (_i === index) {
+        // index + 1
+        list.appendItem(newseg);
+      }
+
+      list.appendItem(arr[_i]);
+    }
+  };
+  /**
+  * @function module:path.ptObjToArr
+  * @todo See if this should just live in `replacePathSeg`
+  * @param {string} type
+  * @param {SVGPathSegMovetoAbs|SVGPathSegLinetoAbs|SVGPathSegCurvetoCubicAbs|SVGPathSegCurvetoQuadraticAbs|SVGPathSegArcAbs|SVGPathSegLinetoHorizontalAbs|SVGPathSegLinetoVerticalAbs|SVGPathSegCurvetoCubicSmoothAbs|SVGPathSegCurvetoQuadraticSmoothAbs} segItem
+  * @returns {ArgumentsArray}
+  */
+
+  var ptObjToArr = function ptObjToArr(type, segItem) {
+    var props = segData[type];
+    return props.map(function (prop) {
+      return segItem[prop];
+    });
+  };
+  /**
+  * @function module:path.getGripPt
+  * @param {Segment} seg
+  * @param {module:math.XYObject} altPt
+  * @returns {module:math.XYObject}
+  */
+
+  var getGripPt = function getGripPt(seg, altPt) {
+    var pth = seg.path;
+    var out = {
+      x: altPt ? altPt.x : seg.item.x,
+      y: altPt ? altPt.y : seg.item.y
+    };
+
+    if (pth.matrix) {
+      var pt = transformPoint(out.x, out.y, pth.matrix);
+      out = pt;
+    }
+
+    var currentZoom = editorContext_.getCurrentZoom();
+    out.x *= currentZoom;
+    out.y *= currentZoom;
+    return out;
+  };
+  /**
+  * @function module:path.getPointFromGrip
+  * @param {module:math.XYObject} pt
+  * @param {module:path.Path} pth
+  * @returns {module:math.XYObject}
+  */
+
+  var getPointFromGrip = function getPointFromGrip(pt, pth) {
+    var out = {
+      x: pt.x,
+      y: pt.y
+    };
+
+    if (pth.matrix) {
+      pt = transformPoint(out.x, out.y, pth.imatrix);
+      out.x = pt.x;
+      out.y = pt.y;
+    }
+
+    var currentZoom = editorContext_.getCurrentZoom();
+    out.x /= currentZoom;
+    out.y /= currentZoom;
+    return out;
+  };
+  /**
+  * Requires prior call to `setUiStrings` if `xlink:title`
+  *    to be set on the grip.
+  * @function module:path.addPointGrip
+  * @param {Integer} index
+  * @param {Integer} x
+  * @param {Integer} y
+  * @returns {SVGCircleElement}
+  */
+
+  var addPointGrip = function addPointGrip(index, x, y) {
+    // create the container of all the point grips
+    var pointGripContainer = getGripContainer();
+    var pointGrip = getElem('pathpointgrip_' + index); // create it
+
+    if (!pointGrip) {
+      pointGrip = document.createElementNS(NS.SVG, 'circle');
+      var atts = {
+        id: 'pathpointgrip_' + index,
+        display: 'none',
+        r: 4,
+        fill: '#0FF',
+        stroke: '#00F',
+        'stroke-width': 2,
+        cursor: 'move',
+        style: 'pointer-events:all'
+      };
+
+      if ('pathNodeTooltip' in uiStrings) {
+        // May be empty if running path.js without svg-editor
+        atts['xlink:title'] = uiStrings.pathNodeTooltip;
+      }
+
+      assignAttributes(pointGrip, atts);
+      pointGrip = pointGripContainer.appendChild(pointGrip);
+      var grip = $$1('#pathpointgrip_' + index);
+      grip.dblclick(function () {
+        if (path) {
+          path.setSegType();
+        }
+      });
+    }
+
+    if (x && y) {
+      // set up the point grip element and display it
+      assignAttributes(pointGrip, {
+        cx: x,
+        cy: y,
+        display: 'inline'
+      });
+    }
+
+    return pointGrip;
+  };
+  /**
+  * @function module:path.getGripContainer
+  * @returns {Element}
+  */
+
+  var getGripContainer = function getGripContainer() {
+    var c = getElem('pathpointgrip_container');
+
+    if (!c) {
+      var parentElement = getElem('selectorParentGroup');
+      c = parentElement.appendChild(document.createElementNS(NS.SVG, 'g'));
+      c.id = 'pathpointgrip_container';
+    }
+
+    return c;
+  };
+  /**
+  * Requires prior call to `setUiStrings` if `xlink:title`
+  *    to be set on the grip.
+  * @function module:path.addCtrlGrip
+  * @param {string} id
+  * @returns {SVGCircleElement}
+  */
+
+  var addCtrlGrip = function addCtrlGrip(id) {
+    var pointGrip = getElem('ctrlpointgrip_' + id);
+
+    if (pointGrip) {
+      return pointGrip;
+    }
+
+    pointGrip = document.createElementNS(NS.SVG, 'circle');
+    var atts = {
+      id: 'ctrlpointgrip_' + id,
+      display: 'none',
+      r: 4,
+      fill: '#0FF',
+      stroke: '#55F',
+      'stroke-width': 1,
+      cursor: 'move',
+      style: 'pointer-events:all'
+    };
+
+    if ('pathCtrlPtTooltip' in uiStrings) {
+      // May be empty if running path.js without svg-editor
+      atts['xlink:title'] = uiStrings.pathCtrlPtTooltip;
+    }
+
+    assignAttributes(pointGrip, atts);
+    getGripContainer().append(pointGrip);
+    return pointGrip;
+  };
+  /**
+  * @function module:path.getCtrlLine
+  * @param {string} id
+  * @returns {SVGLineElement}
+  */
+
+  var getCtrlLine = function getCtrlLine(id) {
+    var ctrlLine = getElem('ctrlLine_' + id);
+
+    if (ctrlLine) {
+      return ctrlLine;
+    }
+
+    ctrlLine = document.createElementNS(NS.SVG, 'line');
+    assignAttributes(ctrlLine, {
+      id: 'ctrlLine_' + id,
+      stroke: '#555',
+      'stroke-width': 1,
+      style: 'pointer-events:none'
+    });
+    getGripContainer().append(ctrlLine);
+    return ctrlLine;
+  };
+  /**
+  * @function module:path.getPointGrip
+  * @param {Segment} seg
+  * @param {boolean} update
+  * @returns {SVGCircleElement}
+  */
+
+  var getPointGrip = function getPointGrip(seg, update) {
+    var index = seg.index;
+    var pointGrip = addPointGrip(index);
+
+    if (update) {
+      var pt = getGripPt(seg);
+      assignAttributes(pointGrip, {
+        cx: pt.x,
+        cy: pt.y,
+        display: 'inline'
+      });
+    }
+
+    return pointGrip;
+  };
+  /**
+  * @function module:path.getControlPoints
+  * @param {Segment} seg
+  * @returns {PlainObject.<string, SVGLineElement|SVGCircleElement>}
+  */
+
+  var getControlPoints = function getControlPoints(seg) {
+    var item = seg.item,
+        index = seg.index;
+
+    if (!('x1' in item) || !('x2' in item)) {
+      return null;
+    }
+
+    var cpt = {};
+    /* const pointGripContainer = */
+
+    getGripContainer(); // Note that this is intentionally not seg.prev.item
+
+    var prev = path.segs[index - 1].item;
+    var segItems = [prev, item];
+
+    for (var i = 1; i < 3; i++) {
+      var id = index + 'c' + i;
+      var ctrlLine = cpt['c' + i + '_line'] = getCtrlLine(id);
+      var pt = getGripPt(seg, {
+        x: item['x' + i],
+        y: item['y' + i]
+      });
+      var gpt = getGripPt(seg, {
+        x: segItems[i - 1].x,
+        y: segItems[i - 1].y
+      });
+      assignAttributes(ctrlLine, {
+        x1: pt.x,
+        y1: pt.y,
+        x2: gpt.x,
+        y2: gpt.y,
+        display: 'inline'
+      });
+      cpt['c' + i + '_line'] = ctrlLine; // create it
+
+      var pointGrip = cpt['c' + i] = addCtrlGrip(id);
+      assignAttributes(pointGrip, {
+        cx: pt.x,
+        cy: pt.y,
+        display: 'inline'
+      });
+      cpt['c' + i] = pointGrip;
+    }
+
+    return cpt;
+  };
+  /**
+  * This replaces the segment at the given index. Type is given as number.
+  * @function module:path.replacePathSeg
+  * @param {Integer} type Possible values set during {@link module:path.init}
+  * @param {Integer} index
+  * @param {ArgumentsArray} pts
+  * @param {SVGPathElement} elem
+  * @returns {undefined}
+  */
+
+  var replacePathSeg = function replacePathSeg(type, index, pts, elem) {
+    var pth = elem || path.elem;
+    var func = 'createSVGPathSeg' + pathFuncs[type];
+    var seg = pth[func].apply(pth, _toConsumableArray(pts));
+
+    if (supportsPathReplaceItem()) {
+      pth.pathSegList.replaceItem(seg, index);
+    } else {
+      var segList = pth.pathSegList;
+      var len = segList.numberOfItems;
+      var arr = [];
+
+      for (var i = 0; i < len; i++) {
+        var curSeg = segList.getItem(i);
+        arr.push(curSeg);
+      }
+
+      segList.clear();
+
+      for (var _i2 = 0; _i2 < len; _i2++) {
+        if (_i2 === index) {
+          segList.appendItem(seg);
+        } else {
+          segList.appendItem(arr[_i2]);
+        }
+      }
+    }
+  };
+  /**
+  * @function module:path.getSegSelector
+  * @param {Segment} seg
+  * @param {boolean} update
+  * @returns {SVGPathElement}
+  */
+
+  var getSegSelector = function getSegSelector(seg, update) {
+    var index = seg.index;
+    var segLine = getElem('segline_' + index);
+
+    if (!segLine) {
+      var pointGripContainer = getGripContainer(); // create segline
+
+      segLine = document.createElementNS(NS.SVG, 'path');
+      assignAttributes(segLine, {
+        id: 'segline_' + index,
+        display: 'none',
+        fill: 'none',
+        stroke: '#0FF',
+        'stroke-width': 2,
+        style: 'pointer-events:none',
+        d: 'M0,0 0,0'
+      });
+      pointGripContainer.append(segLine);
+    }
+
+    if (update) {
+      var prev = seg.prev;
+
+      if (!prev) {
+        segLine.setAttribute('display', 'none');
+        return segLine;
+      }
+
+      var pt = getGripPt(prev); // Set start point
+
+      replacePathSeg(2, 0, [pt.x, pt.y], segLine);
+      var pts = ptObjToArr(seg.type, seg.item); // , true);
+
+      for (var i = 0; i < pts.length; i += 2) {
+        var point = getGripPt(seg, {
+          x: pts[i],
+          y: pts[i + 1]
+        });
+        pts[i] = point.x;
+        pts[i + 1] = point.y;
+      }
+
+      replacePathSeg(seg.type, 1, pts, segLine);
+    }
+
+    return segLine;
+  };
+  /**
+   * @typedef {PlainObject} Point
+   * @property {Integer} x The x value
+   * @property {Integer} y The y value
+   */
+
+  /**
+  * Takes three points and creates a smoother line based on them.
+  * @function module:path.smoothControlPoints
+  * @param {Point} ct1 - Object with x and y values (first control point)
+  * @param {Point} ct2 - Object with x and y values (second control point)
+  * @param {Point} pt - Object with x and y values (third point)
+  * @returns {Point[]} Array of two "smoothed" point objects
+  */
+
+  var smoothControlPoints = function smoothControlPoints(ct1, ct2, pt) {
+    // each point must not be the origin
+    var x1 = ct1.x - pt.x,
+        y1 = ct1.y - pt.y,
+        x2 = ct2.x - pt.x,
+        y2 = ct2.y - pt.y;
+
+    if ((x1 !== 0 || y1 !== 0) && (x2 !== 0 || y2 !== 0)) {
+      var r1 = Math.sqrt(x1 * x1 + y1 * y1),
+          r2 = Math.sqrt(x2 * x2 + y2 * y2),
+          nct1 = editorContext_.getSVGRoot().createSVGPoint(),
+          nct2 = editorContext_.getSVGRoot().createSVGPoint();
+      var anglea = Math.atan2(y1, x1),
+          angleb = Math.atan2(y2, x2);
+
+      if (anglea < 0) {
+        anglea += 2 * Math.PI;
+      }
+
+      if (angleb < 0) {
+        angleb += 2 * Math.PI;
+      }
+
+      var angleBetween = Math.abs(anglea - angleb),
+          angleDiff = Math.abs(Math.PI - angleBetween) / 2;
+      var newAnglea, newAngleb;
+
+      if (anglea - angleb > 0) {
+        newAnglea = angleBetween < Math.PI ? anglea + angleDiff : anglea - angleDiff;
+        newAngleb = angleBetween < Math.PI ? angleb - angleDiff : angleb + angleDiff;
+      } else {
+        newAnglea = angleBetween < Math.PI ? anglea - angleDiff : anglea + angleDiff;
+        newAngleb = angleBetween < Math.PI ? angleb + angleDiff : angleb - angleDiff;
+      } // rotate the points
+
+
+      nct1.x = r1 * Math.cos(newAnglea) + pt.x;
+      nct1.y = r1 * Math.sin(newAnglea) + pt.y;
+      nct2.x = r2 * Math.cos(newAngleb) + pt.x;
+      nct2.y = r2 * Math.sin(newAngleb) + pt.y;
+      return [nct1, nct2];
+    }
+
+    return undefined;
+  };
+  /**
+  *
+  */
+
+  var Segment =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {Integer} index
+    * @param {SVGPathSeg} item
+    * @todo Is `item` be more constrained here?
+    */
+    function Segment(index, item) {
+      _classCallCheck(this, Segment);
+
+      this.selected = false;
+      this.index = index;
+      this.item = item;
+      this.type = item.pathSegType;
+      this.ctrlpts = [];
+      this.ptgrip = null;
+      this.segsel = null;
+    }
+    /**
+     * @param {boolean} y
+     * @returns {undefined}
+     */
+
+
+    _createClass(Segment, [{
+      key: "showCtrlPts",
+      value: function showCtrlPts(y) {
+        for (var i in this.ctrlpts) {
+          if ({}.hasOwnProperty.call(this.ctrlpts, i)) {
+            this.ctrlpts[i].setAttribute('display', y ? 'inline' : 'none');
+          }
+        }
+      }
+      /**
+       * @param {boolean} y
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "selectCtrls",
+      value: function selectCtrls(y) {
+        $$1('#ctrlpointgrip_' + this.index + 'c1, #ctrlpointgrip_' + this.index + 'c2').attr('fill', y ? '#0FF' : '#EEE');
+      }
+      /**
+       * @param {boolean} y
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "show",
+      value: function show(y) {
+        if (this.ptgrip) {
+          this.ptgrip.setAttribute('display', y ? 'inline' : 'none');
+          this.segsel.setAttribute('display', y ? 'inline' : 'none'); // Show/hide all control points if available
+
+          this.showCtrlPts(y);
+        }
+      }
+      /**
+       * @param {boolean} y
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "select",
+      value: function select(y) {
+        if (this.ptgrip) {
+          this.ptgrip.setAttribute('stroke', y ? '#0FF' : '#00F');
+          this.segsel.setAttribute('display', y ? 'inline' : 'none');
+
+          if (this.ctrlpts) {
+            this.selectCtrls(y);
+          }
+
+          this.selected = y;
+        }
+      }
+      /**
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "addGrip",
+      value: function addGrip() {
+        this.ptgrip = getPointGrip(this, true);
+        this.ctrlpts = getControlPoints(this); // , true);
+
+        this.segsel = getSegSelector(this, true);
+      }
+      /**
+       * @param {boolean} full
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "update",
+      value: function update(full) {
+        if (this.ptgrip) {
+          var pt = getGripPt(this);
+          assignAttributes(this.ptgrip, {
+            cx: pt.x,
+            cy: pt.y
+          });
+          getSegSelector(this, true);
+
+          if (this.ctrlpts) {
+            if (full) {
+              this.item = path.elem.pathSegList.getItem(this.index);
+              this.type = this.item.pathSegType;
+            }
+
+            getControlPoints(this);
+          } // this.segsel.setAttribute('display', y ? 'inline' : 'none');
+
+        }
+      }
+      /**
+       * @param {Integer} dx
+       * @param {Integer} dy
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "move",
+      value: function move(dx, dy) {
+        var item = this.item;
+        var curPts = this.ctrlpts ? [item.x += dx, item.y += dy, item.x1, item.y1, item.x2 += dx, item.y2 += dy] : [item.x += dx, item.y += dy];
+        replacePathSeg(this.type, this.index, curPts);
+
+        if (this.next && this.next.ctrlpts) {
+          var next = this.next.item;
+          var nextPts = [next.x, next.y, next.x1 += dx, next.y1 += dy, next.x2, next.y2];
+          replacePathSeg(this.next.type, this.next.index, nextPts);
+        }
+
+        if (this.mate) {
+          // The last point of a closed subpath has a 'mate',
+          // which is the 'M' segment of the subpath
+          var itm = this.mate.item;
+          var pts = [itm.x += dx, itm.y += dy];
+          replacePathSeg(this.mate.type, this.mate.index, pts); // Has no grip, so does not need 'updating'?
+        }
+
+        this.update(true);
+
+        if (this.next) {
+          this.next.update(true);
+        }
+      }
+      /**
+       * @param {Integer} num
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "setLinked",
+      value: function setLinked(num) {
+        var seg, anum, pt;
+
+        if (num === 2) {
+          anum = 1;
+          seg = this.next;
+
+          if (!seg) {
+            return;
+          }
+
+          pt = this.item;
+        } else {
+          anum = 2;
+          seg = this.prev;
+
+          if (!seg) {
+            return;
+          }
+
+          pt = seg.item;
+        }
+
+        var _seg = seg,
+            item = _seg.item;
+        item['x' + anum] = pt.x + (pt.x - this.item['x' + num]);
+        item['y' + anum] = pt.y + (pt.y - this.item['y' + num]);
+        var pts = [item.x, item.y, item.x1, item.y1, item.x2, item.y2];
+        replacePathSeg(seg.type, seg.index, pts);
+        seg.update(true);
+      }
+      /**
+       * @param {Integer} num
+       * @param {Integer} dx
+       * @param {Integer} dy
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "moveCtrl",
+      value: function moveCtrl(num, dx, dy) {
+        var item = this.item;
+        item['x' + num] += dx;
+        item['y' + num] += dy;
+        var pts = [item.x, item.y, item.x1, item.y1, item.x2, item.y2];
+        replacePathSeg(this.type, this.index, pts);
+        this.update(true);
+      }
+      /**
+       * @param {Integer} newType Possible values set during {@link module:path.init}
+       * @param {ArgumentsArray} pts
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "setType",
+      value: function setType(newType, pts) {
+        replacePathSeg(newType, this.index, pts);
+        this.type = newType;
+        this.item = path.elem.pathSegList.getItem(this.index);
+        this.showCtrlPts(newType === 6);
+        this.ctrlpts = getControlPoints(this);
+        this.update(true);
+      }
+    }]);
+
+    return Segment;
+  }();
+  /**
+  *
+  */
+
+  var Path =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {SVGPathElement} elem
+    * @throws {Error} If constructed without a path element
+    */
+    function Path(elem) {
+      _classCallCheck(this, Path);
+
+      if (!elem || elem.tagName !== 'path') {
+        throw new Error('svgedit.path.Path constructed without a <path> element');
+      }
+
+      this.elem = elem;
+      this.segs = [];
+      this.selected_pts = [];
+      path = this; // eslint-disable-line consistent-this
+
+      this.init();
+    }
+    /**
+    * Reset path data.
+    * @returns {module:path.Path}
+    */
+
+
+    _createClass(Path, [{
+      key: "init",
+      value: function init$$1() {
+        // Hide all grips, etc
+        // fixed, needed to work on all found elements, not just first
+        $$1(getGripContainer()).find('*').each(function () {
+          $$1(this).attr('display', 'none');
+        });
+        var segList = this.elem.pathSegList;
+        var len = segList.numberOfItems;
+        this.segs = [];
+        this.selected_pts = [];
+        this.first_seg = null; // Set up segs array
+
+        for (var i = 0; i < len; i++) {
+          var item = segList.getItem(i);
+          var segment = new Segment(i, item);
+          segment.path = this;
+          this.segs.push(segment);
+        }
+
+        var segs = this.segs;
+        var startI = null;
+
+        for (var _i3 = 0; _i3 < len; _i3++) {
+          var seg = segs[_i3];
+          var nextSeg = _i3 + 1 >= len ? null : segs[_i3 + 1];
+          var prevSeg = _i3 - 1 < 0 ? null : segs[_i3 - 1];
+
+          if (seg.type === 2) {
+            if (prevSeg && prevSeg.type !== 1) {
+              // New sub-path, last one is open,
+              // so add a grip to last sub-path's first point
+              var startSeg = segs[startI];
+              startSeg.next = segs[startI + 1];
+              startSeg.next.prev = startSeg;
+              startSeg.addGrip();
+            } // Remember that this is a starter seg
+
+
+            startI = _i3;
+          } else if (nextSeg && nextSeg.type === 1) {
+            // This is the last real segment of a closed sub-path
+            // Next is first seg after "M"
+            seg.next = segs[startI + 1]; // First seg after "M"'s prev is this
+
+            seg.next.prev = seg;
+            seg.mate = segs[startI];
+            seg.addGrip();
+
+            if (isNullish(this.first_seg)) {
+              this.first_seg = seg;
+            }
+          } else if (!nextSeg) {
+            if (seg.type !== 1) {
+              // Last seg, doesn't close so add a grip
+              // to last sub-path's first point
+              var _startSeg = segs[startI];
+              _startSeg.next = segs[startI + 1];
+              _startSeg.next.prev = _startSeg;
+
+              _startSeg.addGrip();
+
+              seg.addGrip();
+
+              if (!this.first_seg) {
+                // Open path, so set first as real first and add grip
+                this.first_seg = segs[startI];
+              }
+            }
+          } else if (seg.type !== 1) {
+            // Regular segment, so add grip and its "next"
+            seg.addGrip(); // Don't set its "next" if it's an "M"
+
+            if (nextSeg && nextSeg.type !== 2) {
+              seg.next = nextSeg;
+              seg.next.prev = seg;
+            }
+          }
+        }
+
+        return this;
+      }
+      /**
+      * @callback module:path.PathEachSegCallback
+      * @this module:path.Segment
+      * @param {Integer} i The index of the seg being iterated
+      * @returns {boolean|undefined} Will stop execution of `eachSeg` if returns `false`
+      */
+
+      /**
+      * @param {module:path.PathEachSegCallback} fn
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "eachSeg",
+      value: function eachSeg(fn) {
+        var len = this.segs.length;
+
+        for (var i = 0; i < len; i++) {
+          var ret = fn.call(this.segs[i], i);
+
+          if (ret === false) {
+            break;
+          }
+        }
+      }
+      /**
+      * @param {Integer} index
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "addSeg",
+      value: function addSeg(index) {
+        // Adds a new segment
+        var seg = this.segs[index];
+
+        if (!seg.prev) {
+          return;
+        }
+
+        var prev = seg.prev;
+        var newseg, newX, newY;
+
+        switch (seg.item.pathSegType) {
+          case 4:
+            {
+              newX = (seg.item.x + prev.item.x) / 2;
+              newY = (seg.item.y + prev.item.y) / 2;
+              newseg = this.elem.createSVGPathSegLinetoAbs(newX, newY);
+              break;
+            }
+
+          case 6:
+            {
+              // make it a curved segment to preserve the shape (WRS)
+              // https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm#Geometric_interpretation
+              var p0x = (prev.item.x + seg.item.x1) / 2;
+              var p1x = (seg.item.x1 + seg.item.x2) / 2;
+              var p2x = (seg.item.x2 + seg.item.x) / 2;
+              var p01x = (p0x + p1x) / 2;
+              var p12x = (p1x + p2x) / 2;
+              newX = (p01x + p12x) / 2;
+              var p0y = (prev.item.y + seg.item.y1) / 2;
+              var p1y = (seg.item.y1 + seg.item.y2) / 2;
+              var p2y = (seg.item.y2 + seg.item.y) / 2;
+              var p01y = (p0y + p1y) / 2;
+              var p12y = (p1y + p2y) / 2;
+              newY = (p01y + p12y) / 2;
+              newseg = this.elem.createSVGPathSegCurvetoCubicAbs(newX, newY, p0x, p0y, p01x, p01y);
+              var pts = [seg.item.x, seg.item.y, p12x, p12y, p2x, p2y];
+              replacePathSeg(seg.type, index, pts);
+              break;
+            }
+        }
+
+        insertItemBefore(this.elem, newseg, index);
+      }
+      /**
+      * @param {Integer} index
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "deleteSeg",
+      value: function deleteSeg(index) {
+        var seg = this.segs[index];
+        var list = this.elem.pathSegList;
+        seg.show(false);
+        var next = seg.next;
+
+        if (seg.mate) {
+          // Make the next point be the "M" point
+          var pt = [next.item.x, next.item.y];
+          replacePathSeg(2, next.index, pt); // Reposition last node
+
+          replacePathSeg(4, seg.index, pt);
+          list.removeItem(seg.mate.index);
+        } else if (!seg.prev) {
+          // First node of open path, make next point the M
+          // const {item} = seg;
+          var _pt = [next.item.x, next.item.y];
+          replacePathSeg(2, seg.next.index, _pt);
+          list.removeItem(index);
+        } else {
+          list.removeItem(index);
+        }
+      }
+      /**
+      * @param {Integer} index
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "removePtFromSelection",
+      value: function removePtFromSelection(index) {
+        var pos = this.selected_pts.indexOf(index);
+
+        if (pos === -1) {
+          return;
+        }
+
+        this.segs[index].select(false);
+        this.selected_pts.splice(pos, 1);
+      }
+      /**
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "clearSelection",
+      value: function clearSelection() {
+        this.eachSeg(function () {
+          // 'this' is the segment here
+          this.select(false);
+        });
+        this.selected_pts = [];
+      }
+      /**
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "storeD",
+      value: function storeD() {
+        this.last_d = this.elem.getAttribute('d');
+      }
+      /**
+      * @param {Integer} y
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "show",
+      value: function show(y) {
+        // Shows this path's segment grips
+        this.eachSeg(function () {
+          // 'this' is the segment here
+          this.show(y);
+        });
+
+        if (y) {
+          this.selectPt(this.first_seg.index);
+        }
+
+        return this;
+      }
+      /**
+      * Move selected points.
+      * @param {Integer} dx
+      * @param {Integer} dy
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "movePts",
+      value: function movePts(dx, dy) {
+        var i = this.selected_pts.length;
+
+        while (i--) {
+          var seg = this.segs[this.selected_pts[i]];
+          seg.move(dx, dy);
+        }
+      }
+      /**
+      * @param {Integer} dx
+      * @param {Integer} dy
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "moveCtrl",
+      value: function moveCtrl(dx, dy) {
+        var seg = this.segs[this.selected_pts[0]];
+        seg.moveCtrl(this.dragctrl, dx, dy);
+
+        if (linkControlPts) {
+          seg.setLinked(this.dragctrl);
+        }
+      }
+      /**
+      * @param {?Integer} newType See {@link https://www.w3.org/TR/SVG/single-page.html#paths-InterfaceSVGPathSeg}
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "setSegType",
+      value: function setSegType(newType) {
+        this.storeD();
+        var i = this.selected_pts.length;
+        var text;
+
+        while (i--) {
+          var selPt = this.selected_pts[i]; // Selected seg
+
+          var cur = this.segs[selPt];
+          var prev = cur.prev;
+
+          if (!prev) {
+            continue;
+          }
+
+          if (!newType) {
+            // double-click, so just toggle
+            text = 'Toggle Path Segment Type'; // Toggle segment to curve/straight line
+
+            var oldType = cur.type;
+            newType = oldType === 6 ? 4 : 6;
+          }
+
+          newType = Number(newType);
+          var curX = cur.item.x;
+          var curY = cur.item.y;
+          var prevX = prev.item.x;
+          var prevY = prev.item.y;
+          var points = void 0;
+
+          switch (newType) {
+            case 6:
+              {
+                if (cur.olditem) {
+                  var old = cur.olditem;
+                  points = [curX, curY, old.x1, old.y1, old.x2, old.y2];
+                } else {
+                  var diffX = curX - prevX;
+                  var diffY = curY - prevY; // get control points from straight line segment
+
+                  /*
+                  const ct1x = (prevX + (diffY/2));
+                  const ct1y = (prevY - (diffX/2));
+                  const ct2x = (curX + (diffY/2));
+                  const ct2y = (curY - (diffX/2));
+                  */
+                  // create control points on the line to preserve the shape (WRS)
+
+                  var ct1x = prevX + diffX / 3;
+                  var ct1y = prevY + diffY / 3;
+                  var ct2x = curX - diffX / 3;
+                  var ct2y = curY - diffY / 3;
+                  points = [curX, curY, ct1x, ct1y, ct2x, ct2y];
+                }
+
+                break;
+              }
+
+            case 4:
+              {
+                points = [curX, curY]; // Store original prevve segment nums
+
+                cur.olditem = cur.item;
+                break;
+              }
+          }
+
+          cur.setType(newType, points);
+        }
+
+        path.endChanges(text);
+      }
+      /**
+      * @param {Integer} pt
+      * @param {Integer} ctrlNum
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "selectPt",
+      value: function selectPt(pt, ctrlNum) {
+        this.clearSelection();
+
+        if (isNullish(pt)) {
+          this.eachSeg(function (i) {
+            // 'this' is the segment here.
+            if (this.prev) {
+              pt = i;
+            }
+          });
+        }
+
+        this.addPtsToSelection(pt);
+
+        if (ctrlNum) {
+          this.dragctrl = ctrlNum;
+
+          if (linkControlPts) {
+            this.segs[pt].setLinked(ctrlNum);
+          }
+        }
+      }
+      /**
+      * Update position of all points.
+      * @returns {Path}
+      */
+
+    }, {
+      key: "update",
+      value: function update() {
+        var elem = this.elem;
+
+        if (getRotationAngle(elem)) {
+          this.matrix = getMatrix(elem);
+          this.imatrix = this.matrix.inverse();
+        } else {
+          this.matrix = null;
+          this.imatrix = null;
+        }
+
+        this.eachSeg(function (i) {
+          this.item = elem.pathSegList.getItem(i);
+          this.update();
+        });
+        return this;
+      }
+      /**
+      * @param {string} text
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "endChanges",
+      value: function endChanges(text) {
+        if (isWebkit()) {
+          editorContext_.resetD(this.elem);
+        }
+
+        var cmd = new ChangeElementCommand(this.elem, {
+          d: this.last_d
+        }, text);
+        editorContext_.endChanges({
+          cmd: cmd,
+          elem: this.elem
+        });
+      }
+      /**
+      * @param {Integer|Integer[]} indexes
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "addPtsToSelection",
+      value: function addPtsToSelection(indexes) {
+        if (!Array.isArray(indexes)) {
+          indexes = [indexes];
+        }
+
+        for (var _i4 = 0; _i4 < indexes.length; _i4++) {
+          var index = indexes[_i4];
+          var seg = this.segs[index];
+
+          if (seg.ptgrip) {
+            if (!this.selected_pts.includes(index) && index >= 0) {
+              this.selected_pts.push(index);
+            }
+          }
+        }
+
+        this.selected_pts.sort();
+        var i = this.selected_pts.length;
+        var grips = [];
+        grips.length = i; // Loop through points to be selected and highlight each
+
+        while (i--) {
+          var pt = this.selected_pts[i];
+          var _seg2 = this.segs[pt];
+
+          _seg2.select(true);
+
+          grips[i] = _seg2.ptgrip;
+        }
+
+        var closedSubpath = Path.subpathIsClosed(this.selected_pts[0]);
+        editorContext_.addPtsToSelection({
+          grips: grips,
+          closedSubpath: closedSubpath
+        });
+      }
+    }]);
+
+    return Path;
+  }();
+  /**
+  * @param {Integer} index
+  * @returns {boolean}
+  */
+
+  Path.subpathIsClosed = function (index) {
+    var clsd = false; // Check if subpath is already open
+
+    path.eachSeg(function (i) {
+      if (i <= index) {
+        return true;
+      }
+
+      if (this.type === 2) {
+        // Found M first, so open
+        return false;
+      }
+
+      if (this.type === 1) {
+        // Found Z first, so closed
+        clsd = true;
+        return false;
+      }
+
+      return true;
+    });
+    return clsd;
+  };
+  /**
+  * @function module:path.getPath_
+  * @param {SVGPathElement} elem
+  * @returns {module:path.Path}
+  */
+
+
+  var getPath_ = function getPath_(elem) {
+    var p = pathData[elem.id];
+
+    if (!p) {
+      p = pathData[elem.id] = new Path(elem);
+    }
+
+    return p;
+  };
+  /**
+  * @function module:path.removePath_
+  * @param {string} id
+  * @returns {undefined}
+  */
+
+  var removePath_ = function removePath_(id) {
+    if (id in pathData) {
+      delete pathData[id];
+    }
+  };
+  var newcx, newcy, oldcx, oldcy, angle;
+
+  var getRotVals = function getRotVals(x, y) {
+    var dx = x - oldcx;
+    var dy = y - oldcy; // rotate the point around the old center
+
+    var r = Math.sqrt(dx * dx + dy * dy);
+    var theta = Math.atan2(dy, dx) + angle;
+    dx = r * Math.cos(theta) + oldcx;
+    dy = r * Math.sin(theta) + oldcy; // dx,dy should now hold the actual coordinates of each
+    // point after being rotated
+    // now we want to rotate them around the new center in the reverse direction
+
+    dx -= newcx;
+    dy -= newcy;
+    r = Math.sqrt(dx * dx + dy * dy);
+    theta = Math.atan2(dy, dx) - angle;
+    return {
+      x: r * Math.cos(theta) + newcx,
+      y: r * Math.sin(theta) + newcy
+    };
+  }; // If the path was rotated, we must now pay the piper:
+  // Every path point must be rotated into the rotated coordinate system of
+  // its old center, then determine the new center, then rotate it back
+  // This is because we want the path to remember its rotation
+
+  /**
+  * @function module:path.recalcRotatedPath
+  * @todo This is still using ye olde transform methods, can probably
+  * be optimized or even taken care of by `recalculateDimensions`
+  * @returns {undefined}
+  */
+
+
+  var recalcRotatedPath = function recalcRotatedPath() {
+    var currentPath = path.elem;
+    angle = getRotationAngle(currentPath, true);
+
+    if (!angle) {
+      return;
+    } // selectedBBoxes[0] = path.oldbbox;
+
+
+    var oldbox = path.oldbbox; // selectedBBoxes[0],
+
+    oldcx = oldbox.x + oldbox.width / 2;
+    oldcy = oldbox.y + oldbox.height / 2;
+    var box = getBBox(currentPath);
+    newcx = box.x + box.width / 2;
+    newcy = box.y + box.height / 2; // un-rotate the new center to the proper position
+
+    var dx = newcx - oldcx,
+        dy = newcy - oldcy,
+        r = Math.sqrt(dx * dx + dy * dy),
+        theta = Math.atan2(dy, dx) + angle;
+    newcx = r * Math.cos(theta) + oldcx;
+    newcy = r * Math.sin(theta) + oldcy;
+    var list = currentPath.pathSegList;
+    var i = list.numberOfItems;
+
+    while (i) {
+      i -= 1;
+      var seg = list.getItem(i),
+          type = seg.pathSegType;
+
+      if (type === 1) {
+        continue;
+      }
+
+      var rvals = getRotVals(seg.x, seg.y),
+          points = [rvals.x, rvals.y];
+
+      if (!isNullish(seg.x1) && !isNullish(seg.x2)) {
+        var cVals1 = getRotVals(seg.x1, seg.y1);
+        var cVals2 = getRotVals(seg.x2, seg.y2);
+        points.splice(points.length, 0, cVals1.x, cVals1.y, cVals2.x, cVals2.y);
+      }
+
+      replacePathSeg(type, i, points);
+    } // loop for each point
+
+    /* box = */
+
+
+    getBBox(currentPath); // selectedBBoxes[0].x = box.x; selectedBBoxes[0].y = box.y;
+    // selectedBBoxes[0].width = box.width; selectedBBoxes[0].height = box.height;
+    // now we must set the new transform to be rotated around the new center
+
+    var Rnc = editorContext_.getSVGRoot().createSVGTransform(),
+        tlist = getTransformList(currentPath);
+    Rnc.setRotate(angle * 180.0 / Math.PI, newcx, newcy);
+    tlist.replaceItem(Rnc, 0);
+  }; // ====================================
+  // Public API starts here
+
+  /**
+  * @function module:path.clearData
+  * @returns {undefined}
+  */
+
+  var clearData = function clearData() {
+    pathData = {};
+  }; // Making public for mocking
+
+  /**
+  * @function module:path.reorientGrads
+  * @param {Element} elem
+  * @param {SVGMatrix} m
+  * @returns {undefined}
+  */
+
+  var reorientGrads = function reorientGrads(elem, m) {
+    var bb = getBBox(elem);
+
+    for (var i = 0; i < 2; i++) {
+      var type = i === 0 ? 'fill' : 'stroke';
+      var attrVal = elem.getAttribute(type);
+
+      if (attrVal && attrVal.startsWith('url(')) {
+        var grad = getRefElem(attrVal);
+
+        if (grad.tagName === 'linearGradient') {
+          var x1 = grad.getAttribute('x1') || 0;
+          var y1 = grad.getAttribute('y1') || 0;
+          var x2 = grad.getAttribute('x2') || 1;
+          var y2 = grad.getAttribute('y2') || 0; // Convert to USOU points
+
+          x1 = bb.width * x1 + bb.x;
+          y1 = bb.height * y1 + bb.y;
+          x2 = bb.width * x2 + bb.x;
+          y2 = bb.height * y2 + bb.y; // Transform those points
+
+          var pt1 = transformPoint(x1, y1, m);
+          var pt2 = transformPoint(x2, y2, m); // Convert back to BB points
+
+          var gCoords = {};
+          gCoords.x1 = (pt1.x - bb.x) / bb.width;
+          gCoords.y1 = (pt1.y - bb.y) / bb.height;
+          gCoords.x2 = (pt2.x - bb.x) / bb.width;
+          gCoords.y2 = (pt2.y - bb.y) / bb.height;
+          var newgrad = grad.cloneNode(true);
+          $$1(newgrad).attr(gCoords);
+          newgrad.id = editorContext_.getNextId();
+          findDefs().append(newgrad);
+          elem.setAttribute(type, 'url(#' + newgrad.id + ')');
+        }
+      }
+    }
+  };
+  /**
+  * This is how we map paths to our preferred relative segment types
+  * @name module:path.pathMap
+  * @type {GenericArray}
+  */
+
+  var pathMap = [0, 'z', 'M', 'm', 'L', 'l', 'C', 'c', 'Q', 'q', 'A', 'a', 'H', 'h', 'V', 'v', 'S', 's', 'T', 't'];
+  /**
+   * Convert a path to one with only absolute or relative values.
+   * @todo move to pathActions.js
+   * @function module:path.convertPath
+   * @param {SVGPathElement} pth - the path to convert
+   * @param {boolean} toRel - true of convert to relative
+   * @returns {string}
+   */
+
+  var convertPath = function convertPath(pth, toRel) {
+    var pathSegList = pth.pathSegList;
+    var len = pathSegList.numberOfItems;
+    var curx = 0,
+        cury = 0;
+    var d = '';
+    var lastM = null;
+
+    for (var i = 0; i < len; ++i) {
+      var seg = pathSegList.getItem(i); // if these properties are not in the segment, set them to zero
+
+      var x = seg.x || 0,
+          y = seg.y || 0,
+          x1 = seg.x1 || 0,
+          y1 = seg.y1 || 0,
+          x2 = seg.x2 || 0,
+          y2 = seg.y2 || 0;
+      var type = seg.pathSegType;
+      var letter = pathMap[type]['to' + (toRel ? 'Lower' : 'Upper') + 'Case']();
+
+      switch (type) {
+        case 1:
+          // z,Z closepath (Z/z)
+          d += 'z';
+
+          if (lastM && !toRel) {
+            curx = lastM[0];
+            cury = lastM[1];
+          }
+
+          break;
+
+        case 12:
+          // absolute horizontal line (H)
+          x -= curx;
+        // Fallthrough
+
+        case 13:
+          // relative horizontal line (h)
+          if (toRel) {
+            curx += x;
+            letter = 'l';
+          } else {
+            x += curx;
+            curx = x;
+            letter = 'L';
+          } // Convert to "line" for easier editing
+
+
+          d += pathDSegment(letter, [[x, cury]]);
+          break;
+
+        case 14:
+          // absolute vertical line (V)
+          y -= cury;
+        // Fallthrough
+
+        case 15:
+          // relative vertical line (v)
+          if (toRel) {
+            cury += y;
+            letter = 'l';
+          } else {
+            y += cury;
+            cury = y;
+            letter = 'L';
+          } // Convert to "line" for easier editing
+
+
+          d += pathDSegment(letter, [[curx, y]]);
+          break;
+
+        case 2: // absolute move (M)
+
+        case 4: // absolute line (L)
+
+        case 18:
+          // absolute smooth quad (T)
+          x -= curx;
+          y -= cury;
+        // Fallthrough
+
+        case 5: // relative line (l)
+
+        case 3: // relative move (m)
+
+        case 19:
+          // relative smooth quad (t)
+          if (toRel) {
+            curx += x;
+            cury += y;
+          } else {
+            x += curx;
+            y += cury;
+            curx = x;
+            cury = y;
+          }
+
+          if (type === 2 || type === 3) {
+            lastM = [curx, cury];
+          }
+
+          d += pathDSegment(letter, [[x, y]]);
+          break;
+
+        case 6:
+          // absolute cubic (C)
+          x -= curx;
+          x1 -= curx;
+          x2 -= curx;
+          y -= cury;
+          y1 -= cury;
+          y2 -= cury;
+        // Fallthrough
+
+        case 7:
+          // relative cubic (c)
+          if (toRel) {
+            curx += x;
+            cury += y;
+          } else {
+            x += curx;
+            x1 += curx;
+            x2 += curx;
+            y += cury;
+            y1 += cury;
+            y2 += cury;
+            curx = x;
+            cury = y;
+          }
+
+          d += pathDSegment(letter, [[x1, y1], [x2, y2], [x, y]]);
+          break;
+
+        case 8:
+          // absolute quad (Q)
+          x -= curx;
+          x1 -= curx;
+          y -= cury;
+          y1 -= cury;
+        // Fallthrough
+
+        case 9:
+          // relative quad (q)
+          if (toRel) {
+            curx += x;
+            cury += y;
+          } else {
+            x += curx;
+            x1 += curx;
+            y += cury;
+            y1 += cury;
+            curx = x;
+            cury = y;
+          }
+
+          d += pathDSegment(letter, [[x1, y1], [x, y]]);
+          break;
+
+        case 10:
+          // absolute elliptical arc (A)
+          x -= curx;
+          y -= cury;
+        // Fallthrough
+
+        case 11:
+          // relative elliptical arc (a)
+          if (toRel) {
+            curx += x;
+            cury += y;
+          } else {
+            x += curx;
+            y += cury;
+            curx = x;
+            cury = y;
+          }
+
+          d += pathDSegment(letter, [[seg.r1, seg.r2]], [seg.angle, seg.largeArcFlag ? 1 : 0, seg.sweepFlag ? 1 : 0], [x, y]);
+          break;
+
+        case 16:
+          // absolute smooth cubic (S)
+          x -= curx;
+          x2 -= curx;
+          y -= cury;
+          y2 -= cury;
+        // Fallthrough
+
+        case 17:
+          // relative smooth cubic (s)
+          if (toRel) {
+            curx += x;
+            cury += y;
+          } else {
+            x += curx;
+            x2 += curx;
+            y += cury;
+            y2 += cury;
+            curx = x;
+            cury = y;
+          }
+
+          d += pathDSegment(letter, [[x2, y2], [x, y]]);
+          break;
+      } // switch on path segment type
+
+    } // for each segment
+
+
+    return d;
+  };
+  /**
+   * TODO: refactor callers in `convertPath` to use `getPathDFromSegments` instead of this function.
+   * Legacy code refactored from `svgcanvas.pathActions.convertPath`.
+   * @param {string} letter - path segment command (letter in potentially either case from {@link module:path.pathMap}; see [SVGPathSeg#pathSegTypeAsLetter]{@link https://www.w3.org/TR/SVG/single-page.html#paths-__svg__SVGPathSeg__pathSegTypeAsLetter})
+   * @param {GenericArray<GenericArray<Integer>>} points - x,y points
+   * @param {GenericArray<GenericArray<Integer>>} [morePoints] - x,y points
+   * @param {Integer[]} [lastPoint] - x,y point
+   * @returns {string}
+   */
+
+  function pathDSegment(letter, points, morePoints, lastPoint) {
+    $$1.each(points, function (i, pnt) {
+      points[i] = shortFloat(pnt);
+    });
+    var segment = letter + points.join(' ');
+
+    if (morePoints) {
+      segment += ' ' + morePoints.join(' ');
+    }
+
+    if (lastPoint) {
+      segment += ' ' + shortFloat(lastPoint);
+    }
+
+    return segment;
+  }
+  /**
+  * Group: Path edit functions
+  * Functions relating to editing path elements
+  * @namespace {PlainObject} pathActions
+  * @memberof module:path
+  */
+
+
+  var pathActions = function () {
+    var subpath = false;
+    var newPoint, firstCtrl;
+    var currentPath = null;
+    var hasMoved = false; // No `editorContext_` yet but should be ok as is `null` by default
+    // editorContext_.setDrawnPath(null);
+
+    /**
+    * This function converts a polyline (created by the fh_path tool) into
+    * a path element and coverts every three line segments into a single bezier
+    * curve in an attempt to smooth out the free-hand.
+    * @function smoothPolylineIntoPath
+    * @param {Element} element
+    * @returns {Element}
+    */
+
+    var smoothPolylineIntoPath = function smoothPolylineIntoPath(element) {
+      var i;
+      var _element = element,
+          points = _element.points;
+      var N = points.numberOfItems;
+
+      if (N >= 4) {
+        // loop through every 3 points and convert to a cubic bezier curve segment
+        //
+        // NOTE: this is cheating, it means that every 3 points has the potential to
+        // be a corner instead of treating each point in an equal manner. In general,
+        // this technique does not look that good.
+        //
+        // I am open to better ideas!
+        //
+        // Reading:
+        // - http://www.efg2.com/Lab/Graphics/Jean-YvesQueinecBezierCurves.htm
+        // - https://www.codeproject.com/KB/graphics/BezierSpline.aspx?msg=2956963
+        // - https://www.ian-ko.com/ET_GeoWizards/UserGuide/smooth.htm
+        // - https://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/Bezier/bezier-der.html
+        var curpos = points.getItem(0),
+            prevCtlPt = null;
+        var d = [];
+        d.push(['M', curpos.x, ',', curpos.y, ' C'].join(''));
+
+        for (i = 1; i <= N - 4; i += 3) {
+          var ct1 = points.getItem(i);
+          var ct2 = points.getItem(i + 1);
+          var end = points.getItem(i + 2); // if the previous segment had a control point, we want to smooth out
+          // the control points on both sides
+
+          if (prevCtlPt) {
+            var newpts = smoothControlPoints(prevCtlPt, ct1, curpos);
+
+            if (newpts && newpts.length === 2) {
+              var prevArr = d[d.length - 1].split(',');
+              prevArr[2] = newpts[0].x;
+              prevArr[3] = newpts[0].y;
+              d[d.length - 1] = prevArr.join(',');
+              ct1 = newpts[1];
+            }
+          }
+
+          d.push([ct1.x, ct1.y, ct2.x, ct2.y, end.x, end.y].join(','));
+          curpos = end;
+          prevCtlPt = ct2;
+        } // handle remaining line segments
+
+
+        d.push('L');
+
+        while (i < N) {
+          var pt = points.getItem(i);
+          d.push([pt.x, pt.y].join(','));
+          i++;
+        }
+
+        d = d.join(' '); // create new path element
+
+        element = editorContext_.addSVGElementFromJson({
+          element: 'path',
+          curStyles: true,
+          attr: {
+            id: editorContext_.getId(),
+            d: d,
+            fill: 'none'
+          }
+        }); // No need to call "changed", as this is already done under mouseUp
+      }
+
+      return element;
+    };
+
+    return (
+      /** @lends module:path.pathActions */
+      {
+        /**
+        * @param {MouseEvent} evt
+        * @param {Element} mouseTarget
+        * @param {Float} startX
+        * @param {Float} startY
+        * @returns {boolean|undefined}
+        */
+        mouseDown: function mouseDown(evt, mouseTarget, startX, startY) {
+          var id;
+
+          if (editorContext_.getCurrentMode() === 'path') {
+            var mouseX = startX; // Was this meant to work with the other `mouseX`? (was defined globally so adding `let` to at least avoid a global)
+
+            var mouseY = startY; // Was this meant to work with the other `mouseY`? (was defined globally so adding `let` to at least avoid a global)
+
+            var currentZoom = editorContext_.getCurrentZoom();
+            var x = mouseX / currentZoom,
+                y = mouseY / currentZoom,
+                stretchy = getElem('path_stretch_line');
+            newPoint = [x, y];
+
+            if (editorContext_.getGridSnapping()) {
+              x = snapToGrid(x);
+              y = snapToGrid(y);
+              mouseX = snapToGrid(mouseX);
+              mouseY = snapToGrid(mouseY);
+            }
+
+            if (!stretchy) {
+              stretchy = document.createElementNS(NS.SVG, 'path');
+              assignAttributes(stretchy, {
+                id: 'path_stretch_line',
+                stroke: '#22C',
+                'stroke-width': '0.5',
+                fill: 'none'
+              });
+              stretchy = getElem('selectorParentGroup').appendChild(stretchy);
+            }
+
+            stretchy.setAttribute('display', 'inline');
+            var keep = null;
+            var index; // if pts array is empty, create path element with M at current point
+
+            var drawnPath = editorContext_.getDrawnPath();
+
+            if (!drawnPath) {
+              var dAttr = 'M' + x + ',' + y + ' '; // Was this meant to work with the other `dAttr`? (was defined globally so adding `var` to at least avoid a global)
+
+              /* drawnPath = */
+
+              editorContext_.setDrawnPath(editorContext_.addSVGElementFromJson({
+                element: 'path',
+                curStyles: true,
+                attr: {
+                  d: dAttr,
+                  id: editorContext_.getNextId(),
+                  opacity: editorContext_.getOpacity() / 2
+                }
+              })); // set stretchy line to first point
+
+              stretchy.setAttribute('d', ['M', mouseX, mouseY, mouseX, mouseY].join(' '));
+              index = subpath ? path.segs.length : 0;
+              addPointGrip(index, mouseX, mouseY);
+            } else {
+              // determine if we clicked on an existing point
+              var seglist = drawnPath.pathSegList;
+              var i = seglist.numberOfItems;
+              var FUZZ = 6 / currentZoom;
+              var clickOnPoint = false;
+
+              while (i) {
+                i--;
+                var item = seglist.getItem(i);
+                var px = item.x,
+                    py = item.y; // found a matching point
+
+                if (x >= px - FUZZ && x <= px + FUZZ && y >= py - FUZZ && y <= py + FUZZ) {
+                  clickOnPoint = true;
+                  break;
+                }
+              } // get path element that we are in the process of creating
+
+
+              id = editorContext_.getId(); // Remove previous path object if previously created
+
+              removePath_(id);
+              var newpath = getElem(id);
+              var newseg;
+              var sSeg;
+              var len = seglist.numberOfItems; // if we clicked on an existing point, then we are done this path, commit it
+              // (i, i+1) are the x,y that were clicked on
+
+              if (clickOnPoint) {
+                // if clicked on any other point but the first OR
+                // the first point was clicked on and there are less than 3 points
+                // then leave the path open
+                // otherwise, close the path
+                if (i <= 1 && len >= 2) {
+                  // Create end segment
+                  var absX = seglist.getItem(0).x;
+                  var absY = seglist.getItem(0).y;
+                  sSeg = stretchy.pathSegList.getItem(1);
+
+                  if (sSeg.pathSegType === 4) {
+                    newseg = drawnPath.createSVGPathSegLinetoAbs(absX, absY);
+                  } else {
+                    newseg = drawnPath.createSVGPathSegCurvetoCubicAbs(absX, absY, sSeg.x1 / currentZoom, sSeg.y1 / currentZoom, absX, absY);
+                  }
+
+                  var endseg = drawnPath.createSVGPathSegClosePath();
+                  seglist.appendItem(newseg);
+                  seglist.appendItem(endseg);
+                } else if (len < 3) {
+                  keep = false;
+                  return keep;
+                }
+
+                $$1(stretchy).remove(); // This will signal to commit the path
+                // const element = newpath; // Other event handlers define own `element`, so this was probably not meant to interact with them or one which shares state (as there were none); I therefore adding a missing `var` to avoid a global
+
+                /* drawnPath = */
+
+                editorContext_.setDrawnPath(null);
+                editorContext_.setStarted(false);
+
+                if (subpath) {
+                  if (path.matrix) {
+                    editorContext_.remapElement(newpath, {}, path.matrix.inverse());
+                  }
+
+                  var newD = newpath.getAttribute('d');
+                  var origD = $$1(path.elem).attr('d');
+                  $$1(path.elem).attr('d', origD + newD);
+                  $$1(newpath).remove();
+
+                  if (path.matrix) {
+                    recalcRotatedPath();
+                  }
+
+                  init$1();
+                  pathActions.toEditMode(path.elem);
+                  path.selectPt();
+                  return false;
+                } // else, create a new point, update path element
+
+              } else {
+                // Checks if current target or parents are #svgcontent
+                if (!$$1.contains(editorContext_.getContainer(), editorContext_.getMouseTarget(evt))) {
+                  // Clicked outside canvas, so don't make point
+                  // console.log('Clicked outside canvas');
+                  return false;
+                }
+
+                var num = drawnPath.pathSegList.numberOfItems;
+                var last = drawnPath.pathSegList.getItem(num - 1);
+                var lastx = last.x,
+                    lasty = last.y;
+
+                if (evt.shiftKey) {
+                  var xya = snapToAngle(lastx, lasty, x, y);
+                  x = xya.x;
+                  y = xya.y;
+                } // Use the segment defined by stretchy
+
+
+                sSeg = stretchy.pathSegList.getItem(1);
+
+                if (sSeg.pathSegType === 4) {
+                  newseg = drawnPath.createSVGPathSegLinetoAbs(editorContext_.round(x), editorContext_.round(y));
+                } else {
+                  newseg = drawnPath.createSVGPathSegCurvetoCubicAbs(editorContext_.round(x), editorContext_.round(y), sSeg.x1 / currentZoom, sSeg.y1 / currentZoom, sSeg.x2 / currentZoom, sSeg.y2 / currentZoom);
+                }
+
+                drawnPath.pathSegList.appendItem(newseg);
+                x *= currentZoom;
+                y *= currentZoom; // set stretchy line to latest point
+
+                stretchy.setAttribute('d', ['M', x, y, x, y].join(' '));
+                index = num;
+
+                if (subpath) {
+                  index += path.segs.length;
+                }
+
+                addPointGrip(index, x, y);
+              } // keep = true;
+
+            }
+
+            return undefined;
+          } // TODO: Make sure currentPath isn't null at this point
+
+
+          if (!path) {
+            return undefined;
+          }
+
+          path.storeD();
+          id = evt.target.id;
+          var curPt;
+
+          if (id.substr(0, 14) === 'pathpointgrip_') {
+            // Select this point
+            curPt = path.cur_pt = parseInt(id.substr(14));
+            path.dragging = [startX, startY];
+            var seg = path.segs[curPt]; // only clear selection if shift is not pressed (otherwise, add
+            // node to selection)
+
+            if (!evt.shiftKey) {
+              if (path.selected_pts.length <= 1 || !seg.selected) {
+                path.clearSelection();
+              }
+
+              path.addPtsToSelection(curPt);
+            } else if (seg.selected) {
+              path.removePtFromSelection(curPt);
+            } else {
+              path.addPtsToSelection(curPt);
+            }
+          } else if (id.startsWith('ctrlpointgrip_')) {
+            path.dragging = [startX, startY];
+            var parts = id.split('_')[1].split('c');
+            curPt = Number(parts[0]);
+            var ctrlNum = Number(parts[1]);
+            path.selectPt(curPt, ctrlNum);
+          } // Start selection box
+
+
+          if (!path.dragging) {
+            var rubberBox = editorContext_.getRubberBox();
+
+            if (isNullish(rubberBox)) {
+              rubberBox = editorContext_.setRubberBox(editorContext_.selectorManager.getRubberBandBox());
+            }
+
+            var _currentZoom = editorContext_.getCurrentZoom();
+
+            assignAttributes(rubberBox, {
+              x: startX * _currentZoom,
+              y: startY * _currentZoom,
+              width: 0,
+              height: 0,
+              display: 'inline'
+            }, 100);
+          }
+
+          return undefined;
+        },
+
+        /**
+        * @param {Float} mouseX
+        * @param {Float} mouseY
+        * @returns {undefined}
+        */
+        mouseMove: function mouseMove(mouseX, mouseY) {
+          var currentZoom = editorContext_.getCurrentZoom();
+          hasMoved = true;
+          var drawnPath = editorContext_.getDrawnPath();
+
+          if (editorContext_.getCurrentMode() === 'path') {
+            if (!drawnPath) {
+              return;
+            }
+
+            var seglist = drawnPath.pathSegList;
+            var index = seglist.numberOfItems - 1;
+
+            if (newPoint) {
+              // First point
+              // if (!index) { return; }
+              // Set control points
+              var pointGrip1 = addCtrlGrip('1c1');
+              var pointGrip2 = addCtrlGrip('0c2'); // dragging pointGrip1
+
+              pointGrip1.setAttribute('cx', mouseX);
+              pointGrip1.setAttribute('cy', mouseY);
+              pointGrip1.setAttribute('display', 'inline');
+              var ptX = newPoint[0];
+              var ptY = newPoint[1]; // set curve
+              // const seg = seglist.getItem(index);
+
+              var curX = mouseX / currentZoom;
+              var curY = mouseY / currentZoom;
+              var altX = ptX + (ptX - curX);
+              var altY = ptY + (ptY - curY);
+              pointGrip2.setAttribute('cx', altX * currentZoom);
+              pointGrip2.setAttribute('cy', altY * currentZoom);
+              pointGrip2.setAttribute('display', 'inline');
+              var ctrlLine = getCtrlLine(1);
+              assignAttributes(ctrlLine, {
+                x1: mouseX,
+                y1: mouseY,
+                x2: altX * currentZoom,
+                y2: altY * currentZoom,
+                display: 'inline'
+              });
+
+              if (index === 0) {
+                firstCtrl = [mouseX, mouseY];
+              } else {
+                var last = seglist.getItem(index - 1);
+                var lastX = last.x;
+                var lastY = last.y;
+
+                if (last.pathSegType === 6) {
+                  lastX += lastX - last.x2;
+                  lastY += lastY - last.y2;
+                } else if (firstCtrl) {
+                  lastX = firstCtrl[0] / currentZoom;
+                  lastY = firstCtrl[1] / currentZoom;
+                }
+
+                replacePathSeg(6, index, [ptX, ptY, lastX, lastY, altX, altY], drawnPath);
+              }
+            } else {
+              var stretchy = getElem('path_stretch_line');
+
+              if (stretchy) {
+                var prev = seglist.getItem(index);
+
+                if (prev.pathSegType === 6) {
+                  var prevX = prev.x + (prev.x - prev.x2);
+                  var prevY = prev.y + (prev.y - prev.y2);
+                  replacePathSeg(6, 1, [mouseX, mouseY, prevX * currentZoom, prevY * currentZoom, mouseX, mouseY], stretchy);
+                } else if (firstCtrl) {
+                  replacePathSeg(6, 1, [mouseX, mouseY, firstCtrl[0], firstCtrl[1], mouseX, mouseY], stretchy);
+                } else {
+                  replacePathSeg(4, 1, [mouseX, mouseY], stretchy);
+                }
+              }
+            }
+
+            return;
+          } // if we are dragging a point, let's move it
+
+
+          if (path.dragging) {
+            var pt = getPointFromGrip({
+              x: path.dragging[0],
+              y: path.dragging[1]
+            }, path);
+            var mpt = getPointFromGrip({
+              x: mouseX,
+              y: mouseY
+            }, path);
+            var diffX = mpt.x - pt.x;
+            var diffY = mpt.y - pt.y;
+            path.dragging = [mouseX, mouseY];
+
+            if (path.dragctrl) {
+              path.moveCtrl(diffX, diffY);
+            } else {
+              path.movePts(diffX, diffY);
+            }
+          } else {
+            path.selected_pts = [];
+            path.eachSeg(function (i) {
+              var seg = this; // eslint-disable-line consistent-this
+
+              if (!seg.next && !seg.prev) {
+                return;
+              } // const {item} = seg;
+
+
+              var rubberBox = editorContext_.getRubberBox();
+              var rbb = rubberBox.getBBox();
+              var pt = getGripPt(seg);
+              var ptBb = {
+                x: pt.x,
+                y: pt.y,
+                width: 0,
+                height: 0
+              };
+              var sel = rectsIntersect(rbb, ptBb);
+              this.select(sel); // Note that addPtsToSelection is not being run
+
+              if (sel) {
+                path.selected_pts.push(seg.index);
+              }
+            });
+          }
+        },
+
+        /**
+         * @typedef module:path.keepElement
+         * @type {PlainObject}
+         * @property {boolean} keep
+         * @property {Element} element
+         */
+
+        /**
+        * @param {Event} evt
+        * @param {Element} element
+        * @param {Float} mouseX
+        * @param {Float} mouseY
+        * @returns {module:path.keepElement|undefined}
+        */
+        mouseUp: function mouseUp(evt, element, mouseX, mouseY) {
+          var drawnPath = editorContext_.getDrawnPath(); // Create mode
+
+          if (editorContext_.getCurrentMode() === 'path') {
+            newPoint = null;
+
+            if (!drawnPath) {
+              element = getElem(editorContext_.getId());
+              editorContext_.setStarted(false);
+              firstCtrl = null;
+            }
+
+            return {
+              keep: true,
+              element: element
+            };
+          } // Edit mode
+
+
+          var rubberBox = editorContext_.getRubberBox();
+
+          if (path.dragging) {
+            var lastPt = path.cur_pt;
+            path.dragging = false;
+            path.dragctrl = false;
+            path.update();
+
+            if (hasMoved) {
+              path.endChanges('Move path point(s)');
+            }
+
+            if (!evt.shiftKey && !hasMoved) {
+              path.selectPt(lastPt);
+            }
+          } else if (rubberBox && rubberBox.getAttribute('display') !== 'none') {
+            // Done with multi-node-select
+            rubberBox.setAttribute('display', 'none');
+
+            if (rubberBox.getAttribute('width') <= 2 && rubberBox.getAttribute('height') <= 2) {
+              pathActions.toSelectMode(evt.target);
+            } // else, move back to select mode
+
+          } else {
+            pathActions.toSelectMode(evt.target);
+          }
+
+          hasMoved = false;
+          return undefined;
+        },
+
+        /**
+        * @param {Element} element
+        * @returns {undefined}
+        */
+        toEditMode: function toEditMode(element) {
+          path = getPath_(element);
+          editorContext_.setCurrentMode('pathedit');
+          editorContext_.clearSelection();
+          path.show(true).update();
+          path.oldbbox = getBBox(path.elem);
+          subpath = false;
+        },
+
+        /**
+        * @param {Element} elem
+        * @fires module:svgcanvas.SvgCanvas#event:selected
+        * @returns {undefined}
+        */
+        toSelectMode: function toSelectMode(elem) {
+          var selPath = elem === path.elem;
+          editorContext_.setCurrentMode('select');
+          path.show(false);
+          currentPath = false;
+          editorContext_.clearSelection();
+
+          if (path.matrix) {
+            // Rotated, so may need to re-calculate the center
+            recalcRotatedPath();
+          }
+
+          if (selPath) {
+            editorContext_.call('selected', [elem]);
+            editorContext_.addToSelection([elem], true);
+          }
+        },
+
+        /**
+        * @param {boolean} on
+        * @returns {undefined}
+        */
+        addSubPath: function addSubPath(on) {
+          if (on) {
+            // Internally we go into "path" mode, but in the UI it will
+            // still appear as if in "pathedit" mode.
+            editorContext_.setCurrentMode('path');
+            subpath = true;
+          } else {
+            pathActions.clear(true);
+            pathActions.toEditMode(path.elem);
+          }
+        },
+
+        /**
+        * @param {Element} target
+        * @returns {undefined}
+        */
+        select: function select(target) {
+          if (currentPath === target) {
+            pathActions.toEditMode(target);
+            editorContext_.setCurrentMode('pathedit'); // going into pathedit mode
+          } else {
+            currentPath = target;
+          }
+        },
+
+        /**
+        * @fires module:svgcanvas.SvgCanvas#event:changed
+        * @returns {undefined}
+        */
+        reorient: function reorient() {
+          var elem = editorContext_.getSelectedElements()[0];
+
+          if (!elem) {
+            return;
+          }
+
+          var angl = getRotationAngle(elem);
+
+          if (angl === 0) {
+            return;
+          }
+
+          var batchCmd = new BatchCommand('Reorient path');
+          var changes = {
+            d: elem.getAttribute('d'),
+            transform: elem.getAttribute('transform')
+          };
+          batchCmd.addSubCommand(new ChangeElementCommand(elem, changes));
+          editorContext_.clearSelection();
+          this.resetOrientation(elem);
+          editorContext_.addCommandToHistory(batchCmd); // Set matrix to null
+
+          getPath_(elem).show(false).matrix = null;
+          this.clear();
+          editorContext_.addToSelection([elem], true);
+          editorContext_.call('changed', editorContext_.getSelectedElements());
+        },
+
+        /**
+        * @param {boolean} remove Not in use
+        * @returns {undefined}
+        */
+        clear: function clear(remove) {
+          var drawnPath = editorContext_.getDrawnPath();
+          currentPath = null;
+
+          if (drawnPath) {
+            var elem = getElem(editorContext_.getId());
+            $$1(getElem('path_stretch_line')).remove();
+            $$1(elem).remove();
+            $$1(getElem('pathpointgrip_container')).find('*').attr('display', 'none');
+            firstCtrl = null;
+            editorContext_.setDrawnPath(null);
+            editorContext_.setStarted(false);
+          } else if (editorContext_.getCurrentMode() === 'pathedit') {
+            this.toSelectMode();
+          }
+
+          if (path) {
+            path.init().show(false);
+          }
+        },
+
+        /**
+        * @param {?(Element|SVGPathElement)} pth
+        * @returns {false|undefined}
+        */
+        resetOrientation: function resetOrientation(pth) {
+          if (isNullish(pth) || pth.nodeName !== 'path') {
+            return false;
+          }
+
+          var tlist = getTransformList(pth);
+          var m = transformListToTransform(tlist).matrix;
+          tlist.clear();
+          pth.removeAttribute('transform');
+          var segList = pth.pathSegList; // Opera/win/non-EN throws an error here.
+          // TODO: Find out why!
+          // Presumed fixed in Opera 10.5, so commented out for now
+          // try {
+
+          var len = segList.numberOfItems; // } catch(err) {
+          //   const fixed_d = pathActions.convertPath(pth);
+          //   pth.setAttribute('d', fixed_d);
+          //   segList = pth.pathSegList;
+          //   const len = segList.numberOfItems;
+          // }
+          // let lastX, lastY;
+
+          var _loop = function _loop(i) {
+            var seg = segList.getItem(i);
+            var type = seg.pathSegType;
+
+            if (type === 1) {
+              return "continue";
+            }
+
+            var pts = [];
+            $$1.each(['', 1, 2], function (j, n) {
+              var x = seg['x' + n],
+                  y = seg['y' + n];
+
+              if (x !== undefined && y !== undefined) {
+                var pt = transformPoint(x, y, m);
+                pts.splice(pts.length, 0, pt.x, pt.y);
+              }
+            });
+            replacePathSeg(type, i, pts, pth);
+          };
+
+          for (var i = 0; i < len; ++i) {
+            var _ret = _loop(i);
+
+            if (_ret === "continue") continue;
+          }
+
+          reorientGrads(pth, m);
+          return undefined;
+        },
+
+        /**
+        * @returns {undefined}
+        */
+        zoomChange: function zoomChange() {
+          if (editorContext_.getCurrentMode() === 'pathedit') {
+            path.update();
+          }
+        },
+
+        /**
+        * @typedef {PlainObject} module:path.NodePoint
+        * @property {Float} x
+        * @property {Float} y
+        * @property {Integer} type
+        */
+
+        /**
+        * @returns {module:path.NodePoint}
+        */
+        getNodePoint: function getNodePoint() {
+          var selPt = path.selected_pts.length ? path.selected_pts[0] : 1;
+          var seg = path.segs[selPt];
+          return {
+            x: seg.item.x,
+            y: seg.item.y,
+            type: seg.type
+          };
+        },
+
+        /**
+        * @param {boolean} linkPoints
+        * @returns {undefined}
+        */
+        linkControlPoints: function linkControlPoints(linkPoints) {
+          setLinkControlPoints(linkPoints);
+        },
+
+        /**
+        * @returns {undefined}
+        */
+        clonePathNode: function clonePathNode() {
+          path.storeD();
+          var selPts = path.selected_pts; // const {segs} = path;
+
+          var i = selPts.length;
+          var nums = [];
+
+          while (i--) {
+            var pt = selPts[i];
+            path.addSeg(pt);
+            nums.push(pt + i);
+            nums.push(pt + i + 1);
+          }
+
+          path.init().addPtsToSelection(nums);
+          path.endChanges('Clone path node(s)');
+        },
+
+        /**
+        * @returns {undefined}
+        */
+        opencloseSubPath: function opencloseSubPath() {
+          var selPts = path.selected_pts; // Only allow one selected node for now
+
+          if (selPts.length !== 1) {
+            return;
+          }
+
+          var _path = path,
+              elem = _path.elem;
+          var list = elem.pathSegList; // const len = list.numberOfItems;
+
+          var index = selPts[0];
+          var openPt = null;
+          var startItem = null; // Check if subpath is already open
+
+          path.eachSeg(function (i) {
+            if (this.type === 2 && i <= index) {
+              startItem = this.item;
+            }
+
+            if (i <= index) {
+              return true;
+            }
+
+            if (this.type === 2) {
+              // Found M first, so open
+              openPt = i;
+              return false;
+            }
+
+            if (this.type === 1) {
+              // Found Z first, so closed
+              openPt = false;
+              return false;
+            }
+
+            return true;
+          });
+
+          if (isNullish(openPt)) {
+            // Single path, so close last seg
+            openPt = path.segs.length - 1;
+          }
+
+          if (openPt !== false) {
+            // Close this path
+            // Create a line going to the previous "M"
+            var newseg = elem.createSVGPathSegLinetoAbs(startItem.x, startItem.y);
+            var closer = elem.createSVGPathSegClosePath();
+
+            if (openPt === path.segs.length - 1) {
+              list.appendItem(newseg);
+              list.appendItem(closer);
+            } else {
+              insertItemBefore(elem, closer, openPt);
+              insertItemBefore(elem, newseg, openPt);
+            }
+
+            path.init().selectPt(openPt + 1);
+            return;
+          } // M 1,1 L 2,2 L 3,3 L 1,1 z // open at 2,2
+          // M 2,2 L 3,3 L 1,1
+          // M 1,1 L 2,2 L 1,1 z M 4,4 L 5,5 L6,6 L 5,5 z
+          // M 1,1 L 2,2 L 1,1 z [M 4,4] L 5,5 L(M)6,6 L 5,5 z
+
+
+          var seg = path.segs[index];
+
+          if (seg.mate) {
+            list.removeItem(index); // Removes last "L"
+
+            list.removeItem(index); // Removes the "Z"
+
+            path.init().selectPt(index - 1);
+            return;
+          }
+
+          var lastM, zSeg; // Find this sub-path's closing point and remove
+
+          for (var i = 0; i < list.numberOfItems; i++) {
+            var item = list.getItem(i);
+
+            if (item.pathSegType === 2) {
+              // Find the preceding M
+              lastM = i;
+            } else if (i === index) {
+              // Remove it
+              list.removeItem(lastM); // index--;
+            } else if (item.pathSegType === 1 && index < i) {
+              // Remove the closing seg of this subpath
+              zSeg = i - 1;
+              list.removeItem(i);
+              break;
+            }
+          }
+
+          var num = index - lastM - 1;
+
+          while (num--) {
+            insertItemBefore(elem, list.getItem(lastM), zSeg);
+          }
+
+          var pt = list.getItem(lastM); // Make this point the new "M"
+
+          replacePathSeg(2, lastM, [pt.x, pt.y]); // i = index; // i is local here, so has no effect; what was the intent for this?
+
+          path.init().selectPt(0);
+        },
+
+        /**
+        * @returns {undefined}
+        */
+        deletePathNode: function deletePathNode() {
+          if (!pathActions.canDeleteNodes) {
+            return;
+          }
+
+          path.storeD();
+          var selPts = path.selected_pts;
+          var i = selPts.length;
+
+          while (i--) {
+            var pt = selPts[i];
+            path.deleteSeg(pt);
+          } // Cleanup
+
+
+          var cleanup = function cleanup() {
+            var segList = path.elem.pathSegList;
+            var len = segList.numberOfItems;
+
+            var remItems = function remItems(pos, count) {
+              while (count--) {
+                segList.removeItem(pos);
+              }
+            };
+
+            if (len <= 1) {
+              return true;
+            }
+
+            while (len--) {
+              var item = segList.getItem(len);
+
+              if (item.pathSegType === 1) {
+                var prev = segList.getItem(len - 1);
+                var nprev = segList.getItem(len - 2);
+
+                if (prev.pathSegType === 2) {
+                  remItems(len - 1, 2);
+                  cleanup();
+                  break;
+                } else if (nprev.pathSegType === 2) {
+                  remItems(len - 2, 3);
+                  cleanup();
+                  break;
+                }
+              } else if (item.pathSegType === 2) {
+                if (len > 0) {
+                  var prevType = segList.getItem(len - 1).pathSegType; // Path has M M
+
+                  if (prevType === 2) {
+                    remItems(len - 1, 1);
+                    cleanup();
+                    break; // Entire path ends with Z M
+                  } else if (prevType === 1 && segList.numberOfItems - 1 === len) {
+                    remItems(len, 1);
+                    cleanup();
+                    break;
+                  }
+                }
+              }
+            }
+
+            return false;
+          };
+
+          cleanup(); // Completely delete a path with 1 or 0 segments
+
+          if (path.elem.pathSegList.numberOfItems <= 1) {
+            pathActions.toSelectMode(path.elem);
+            editorContext_.canvas.deleteSelectedElements();
+            return;
+          }
+
+          path.init();
+          path.clearSelection(); // TODO: Find right way to select point now
+          // path.selectPt(selPt);
+
+          if (window.opera) {
+            // Opera repaints incorrectly
+            var cp = $$1(path.elem);
+            cp.attr('d', cp.attr('d'));
+          }
+
+          path.endChanges('Delete path node(s)');
+        },
+        // Can't seem to use `@borrows` here, so using `@see`
+
+        /**
+        * Smooth polyline into path
+        * @function module:path.pathActions.smoothPolylineIntoPath
+        * @see module:path~smoothPolylineIntoPath
+        */
+        smoothPolylineIntoPath: smoothPolylineIntoPath,
+
+        /**
+        * @param {?Integer} v See {@link https://www.w3.org/TR/SVG/single-page.html#paths-InterfaceSVGPathSeg}
+        * @returns {undefined}
+        */
+        setSegType: function setSegType(v) {
+          path.setSegType(v);
+        },
+
+        /**
+        * @param {string} attr
+        * @param {Float} newValue
+        * @returns {undefined}
+        */
+        moveNode: function moveNode(attr, newValue) {
+          var selPts = path.selected_pts;
+
+          if (!selPts.length) {
+            return;
+          }
+
+          path.storeD(); // Get first selected point
+
+          var seg = path.segs[selPts[0]];
+          var diff = {
+            x: 0,
+            y: 0
+          };
+          diff[attr] = newValue - seg.item[attr];
+          seg.move(diff.x, diff.y);
+          path.endChanges('Move path point');
+        },
+
+        /**
+        * @param {Element} elem
+        * @returns {undefined}
+        */
+        fixEnd: function fixEnd(elem) {
+          // Adds an extra segment if the last seg before a Z doesn't end
+          // at its M point
+          // M0,0 L0,100 L100,100 z
+          var segList = elem.pathSegList;
+          var len = segList.numberOfItems;
+          var lastM;
+
+          for (var i = 0; i < len; ++i) {
+            var item = segList.getItem(i);
+
+            if (item.pathSegType === 2) {
+              lastM = item;
+            }
+
+            if (item.pathSegType === 1) {
+              var prev = segList.getItem(i - 1);
+
+              if (prev.x !== lastM.x || prev.y !== lastM.y) {
+                // Add an L segment here
+                var newseg = elem.createSVGPathSegLinetoAbs(lastM.x, lastM.y);
+                insertItemBefore(elem, newseg, i); // Can this be done better?
+
+                pathActions.fixEnd(elem);
+                break;
+              }
+            }
+          }
+
+          if (isWebkit()) {
+            editorContext_.resetD(elem);
+          }
+        },
+        // Can't seem to use `@borrows` here, so using `@see`
+
+        /**
+        * Convert a path to one with only absolute or relative values
+        * @function module:path.pathActions.convertPath
+        * @see module:path.convertPath
+        */
+        convertPath: convertPath
+      }
+    );
+  }(); // end pathActions
+
+  var $$2 = jQueryPluginSVG(jQuery); // String used to encode base64.
+
+  var KEYSTR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; // Much faster than running getBBox() every time
+
+  var visElems = 'a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use';
+  var visElemsArr = visElems.split(','); // const hidElems = 'clipPath,defs,desc,feGaussianBlur,filter,linearGradient,marker,mask,metadata,pattern,radialGradient,stop,switch,symbol,title,textPath';
+
+  var editorContext_$1 = null;
+  var domdoc_ = null;
+  var domcontainer_ = null;
+  var svgroot_ = null;
+  /**
+  * Object with the following keys/values
+  * @typedef {PlainObject} module:utilities.SVGElementJSON
+  * @property {string} element - Tag name of the SVG element to create
+  * @property {PlainObject.<string, string>} attr - Has key-value attributes to assign to the new element
+  * @property {boolean} [curStyles=false] - Indicates whether current style attributes should be applied first
+  * @property {module:utilities.SVGElementJSON[]} [children] - Data objects to be added recursively as children
+  * @property {string} [namespace="http://www.w3.org/2000/svg"] - Indicate a (non-SVG) namespace
+  */
+
+  /**
+   * An object that creates SVG elements for the canvas.
+   *
+   * @interface module:utilities.EditorContext
+   * @property {module:path.pathActions} pathActions
+   */
+
+  /**
+   * @function module:utilities.EditorContext#getSVGContent
+   * @returns {SVGSVGElement}
+   */
+
+  /**
+   * Create a new SVG element based on the given object keys/values and add it
+   * to the current layer.
+   * The element will be run through `cleanupElement` before being returned
+   * @function module:utilities.EditorContext#addSVGElementFromJson
+   * @param {module:utilities.SVGElementJSON} data
+   * @returns {Element} The new element
+  */
+
+  /**
+   * @function module:utilities.EditorContext#getSelectedElements
+   * @returns {Element[]} the array with selected DOM elements
+  */
+
+  /**
+   * @function module:utilities.EditorContext#getDOMDocument
+   * @returns {HTMLDocument}
+  */
+
+  /**
+   * @function module:utilities.EditorContext#getDOMContainer
+   * @returns {HTMLElement}
+  */
+
+  /**
+   * @function module:utilities.EditorContext#getSVGRoot
+   * @returns {SVGSVGElement}
+  */
+
+  /**
+   * @function module:utilities.EditorContext#getBaseUnit
+   * @returns {string}
+  */
+
+  /**
+   * @function module:utilities.EditorContext#getSnappingStep
+   * @returns {Float|string}
+  */
+
+  /**
+  * @function module:utilities.init
+  * @param {module:utilities.EditorContext} editorContext
+  * @returns {undefined}
+  */
+
+  var init$2 = function init$$1(editorContext) {
+    editorContext_$1 = editorContext;
+    domdoc_ = editorContext.getDOMDocument();
+    domcontainer_ = editorContext.getDOMContainer();
+    svgroot_ = editorContext.getSVGRoot();
+  };
+  /**
+   * Used to prevent the [Billion laughs attack]{@link https://en.wikipedia.org/wiki/Billion_laughs_attack}.
+   * @function module:utilities.dropXMLInteralSubset
+   * @param {string} str String to be processed
+   * @returns {string} The string with entity declarations in the internal subset removed
+   * @todo This might be needed in other places `parseFromString` is used even without LGTM flagging
+   */
+
+  var dropXMLInteralSubset = function dropXMLInteralSubset(str) {
+    return str.replace(/(<!DOCTYPE\s+\w*\s*\[).*(\?\]>)/, '$1$2');
+  };
+  /**
+  * Converts characters in a string to XML-friendly entities.
+  * @function module:utilities.toXml
+  * @example `&` becomes `&amp;`
+  * @param {string} str - The string to be converted
+  * @returns {string} The converted string
+  */
+
+  var toXml = function toXml(str) {
+    // &apos; is ok in XML, but not HTML
+    // &gt; does not normally need escaping, though it can if within a CDATA expression (and preceded by "]]")
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;'); // Note: `&apos;` is XML only
+  };
+  // public domain.  It would be nice if you left this header intact.
+  // Base64 code from Tyler Akins -- http://rumkin.com
+  // schiller: Removed string concatenation in favour of Array.join() optimization,
+  //        also precalculate the size of the array needed.
+
+  /**
+  * Converts a string to base64.
+  * @function module:utilities.encode64
+  * @param {string} input
+  * @returns {string} Base64 output
+  */
+
+  function encode64(input) {
+    // base64 strings are 4/3 larger than the original string
+    input = encodeUTF8(input); // convert non-ASCII characters
+    // input = convertToXMLReferences(input);
+
+    if (window.btoa) {
+      return window.btoa(input); // Use native if available
+    }
+
+    var output = new Array(Math.floor((input.length + 2) / 3) * 4);
+    var i = 0,
+        p = 0;
+
+    do {
+      var chr1 = input.charCodeAt(i++);
+      var chr2 = input.charCodeAt(i++);
+      var chr3 = input.charCodeAt(i++);
+      /* eslint-disable no-bitwise */
+
+      var enc1 = chr1 >> 2;
+      var enc2 = (chr1 & 3) << 4 | chr2 >> 4;
+      var enc3 = (chr2 & 15) << 2 | chr3 >> 6;
+      var enc4 = chr3 & 63;
+      /* eslint-enable no-bitwise */
+
+      if (isNaN(chr2)) {
+        enc3 = 64;
+        enc4 = 64;
+      } else if (isNaN(chr3)) {
+        enc4 = 64;
+      }
+
+      output[p++] = KEYSTR.charAt(enc1);
+      output[p++] = KEYSTR.charAt(enc2);
+      output[p++] = KEYSTR.charAt(enc3);
+      output[p++] = KEYSTR.charAt(enc4);
+    } while (i < input.length);
+
+    return output.join('');
+  }
+  /**
+  * Converts a string from base64.
+  * @function module:utilities.decode64
+  * @param {string} input Base64-encoded input
+  * @returns {string} Decoded output
+  */
+
+  function decode64(input) {
+    if (window.atob) {
+      return decodeUTF8(window.atob(input));
+    } // remove all characters that are not A-Z, a-z, 0-9, +, /, or =
+
+
+    input = input.replace(/[^A-Za-z0-9+/=]/g, '');
+    var output = '';
+    var i = 0;
+
+    do {
+      var enc1 = KEYSTR.indexOf(input.charAt(i++));
+      var enc2 = KEYSTR.indexOf(input.charAt(i++));
+      var enc3 = KEYSTR.indexOf(input.charAt(i++));
+      var enc4 = KEYSTR.indexOf(input.charAt(i++));
+      /* eslint-disable no-bitwise */
+
+      var chr1 = enc1 << 2 | enc2 >> 4;
+      var chr2 = (enc2 & 15) << 4 | enc3 >> 2;
+      var chr3 = (enc3 & 3) << 6 | enc4;
+      /* eslint-enable no-bitwise */
+
+      output += String.fromCharCode(chr1);
+
+      if (enc3 !== 64) {
+        output += String.fromCharCode(chr2);
+      }
+
+      if (enc4 !== 64) {
+        output += String.fromCharCode(chr3);
+      }
+    } while (i < input.length);
+
+    return decodeUTF8(output);
+  }
+  /**
+  * @function module:utilities.decodeUTF8
+  * @param {string} argString
+  * @returns {string}
+  */
+
+  function decodeUTF8(argString) {
+    return decodeURIComponent(escape(argString));
+  } // codedread:does not seem to work with webkit-based browsers on OSX // Brettz9: please test again as function upgraded
+
+  /**
+  * @function module:utilities.encodeUTF8
+  * @param {string} argString
+  * @returns {string}
+  */
+
+  var encodeUTF8 = function encodeUTF8(argString) {
+    return unescape(encodeURIComponent(argString));
+  };
+  /**
+   * Convert dataURL to object URL.
+   * @function module:utilities.dataURLToObjectURL
+   * @param {string} dataurl
+   * @returns {string} object URL or empty string
+   */
+
+  var dataURLToObjectURL = function dataURLToObjectURL(dataurl) {
+    if (typeof Uint8Array === 'undefined' || typeof Blob === 'undefined' || typeof URL === 'undefined' || !URL.createObjectURL) {
+      return '';
+    }
+
+    var arr = dataurl.split(','),
+        mime = arr[0].match(/:(.*?);/)[1],
+        bstr = atob(arr[1]);
+    var n = bstr.length;
+    var u8arr = new Uint8Array(n);
+
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+
+    var blob = new Blob([u8arr], {
+      type: mime
+    });
+    return URL.createObjectURL(blob);
+  };
+  /**
+   * Get object URL for a blob object.
+   * @function module:utilities.createObjectURL
+   * @param {Blob} blob A Blob object or File object
+   * @returns {string} object URL or empty string
+   */
+
+  var createObjectURL = function createObjectURL(blob) {
+    if (!blob || typeof URL === 'undefined' || !URL.createObjectURL) {
+      return '';
+    }
+
+    return URL.createObjectURL(blob);
+  };
+  /**
+   * @property {string} blankPageObjectURL
+   */
+
+  var blankPageObjectURL = function () {
+    if (typeof Blob === 'undefined') {
+      return '';
+    }
+
+    var blob = new Blob(['<html><head><title>SVG-edit</title></head><body>&nbsp;</body></html>'], {
+      type: 'text/html'
+    });
+    return createObjectURL(blob);
+  }();
+  /**
+  * Cross-browser compatible method of converting a string to an XML tree.
+  * Found this function [here]{@link http://groups.google.com/group/jquery-dev/browse_thread/thread/c6d11387c580a77f}.
+  * @function module:utilities.text2xml
+  * @param {string} sXML
+  * @throws {Error}
+  * @returns {XMLDocument}
+  */
+
+  var text2xml = function text2xml(sXML) {
+    if (sXML.includes('<svg:svg')) {
+      sXML = sXML.replace(/<(\/?)svg:/g, '<$1').replace('xmlns:svg', 'xmlns');
+    }
+
+    var out, dXML;
+
+    try {
+      dXML = window.DOMParser ? new DOMParser() : new window.ActiveXObject('Microsoft.XMLDOM');
+      dXML.async = false;
+    } catch (e) {
+      throw new Error('XML Parser could not be instantiated');
+    }
+
+    try {
+      if (dXML.loadXML) {
+        out = dXML.loadXML(sXML) ? dXML : false;
+      } else {
+        out = dXML.parseFromString(sXML, 'text/xml');
+      }
+    } catch (e2) {
+      throw new Error('Error parsing XML string');
+    }
+
+    return out;
+  };
+  /**
+  * @typedef {PlainObject} module:utilities.BBoxObject (like `DOMRect`)
+  * @property {Float} x
+  * @property {Float} y
+  * @property {Float} width
+  * @property {Float} height
+  */
+
+  /**
+  * Converts a `SVGRect` into an object.
+  * @function module:utilities.bboxToObj
+  * @param {SVGRect} bbox - a SVGRect
+  * @returns {module:utilities.BBoxObject} An object with properties names x, y, width, height.
+  */
+
+  var bboxToObj = function bboxToObj(_ref) {
+    var x = _ref.x,
+        y = _ref.y,
+        width = _ref.width,
+        height = _ref.height;
+    return {
+      x: x,
+      y: y,
+      width: width,
+      height: height
+    };
+  };
+  /**
+  * @callback module:utilities.TreeWalker
+  * @param {Element} elem - DOM element being traversed
+  * @returns {undefined}
+  */
+
+  /**
+  * Walks the tree and executes the callback on each element in a top-down fashion.
+  * @function module:utilities.walkTree
+  * @param {Element} elem - DOM element to traverse
+  * @param {module:utilities.TreeWalker} cbFn - Callback function to run on each element
+  * @returns {undefined}
+  */
+
+  var walkTree = function walkTree(elem, cbFn) {
+    if (elem && elem.nodeType === 1) {
+      cbFn(elem);
+      var i = elem.childNodes.length;
+
+      while (i--) {
+        walkTree(elem.childNodes.item(i), cbFn);
+      }
+    }
+  };
+  /**
+  * Walks the tree and executes the callback on each element in a depth-first fashion.
+  * @function module:utilities.walkTreePost
+  * @todo FIXME: Shouldn't this be calling walkTreePost?
+  * @param {Element} elem - DOM element to traverse
+  * @param {module:utilities.TreeWalker} cbFn - Callback function to run on each element
+  * @returns {undefined}
+  */
+
+  var walkTreePost = function walkTreePost(elem, cbFn) {
+    if (elem && elem.nodeType === 1) {
+      var i = elem.childNodes.length;
+
+      while (i--) {
+        walkTree(elem.childNodes.item(i), cbFn);
+      }
+
+      cbFn(elem);
+    }
+  };
+  /**
+  * Extracts the URL from the `url(...)` syntax of some attributes.
+  * Three variants:
+  *  - `<circle fill="url(someFile.svg#foo)" />`
+  *  - `<circle fill="url('someFile.svg#foo')" />`
+  *  - `<circle fill='url("someFile.svg#foo")' />`
+  * @function module:utilities.getUrlFromAttr
+  * @param {string} attrVal The attribute value as a string
+  * @returns {string} String with just the URL, like "someFile.svg#foo"
+  */
+
+  var getUrlFromAttr = function getUrlFromAttr(attrVal) {
+    if (attrVal) {
+      // url('#somegrad')
+      if (attrVal.startsWith('url("')) {
+        return attrVal.substring(5, attrVal.indexOf('"', 6));
+      } // url('#somegrad')
+
+
+      if (attrVal.startsWith("url('")) {
+        return attrVal.substring(5, attrVal.indexOf("'", 6));
+      }
+
+      if (attrVal.startsWith('url(')) {
+        return attrVal.substring(4, attrVal.indexOf(')'));
+      }
+    }
+
+    return null;
+  };
+  /**
+  * @function module:utilities.getHref
+  * @param {Element} elem
+  * @returns {string} The given element's `xlink:href` value
+  */
+
+  var getHref = function getHref(elem) {
+    // eslint-disable-line import/no-mutable-exports
+    return elem.getAttributeNS(NS.XLINK, 'href');
+  };
+  /**
+  * Sets the given element's `xlink:href` value.
+  * @function module:utilities.setHref
+  * @param {Element} elem
+  * @param {string} val
+  * @returns {undefined}
+  */
+
+  var setHref = function setHref(elem, val) {
+    // eslint-disable-line import/no-mutable-exports
+    elem.setAttributeNS(NS.XLINK, 'xlink:href', val);
+  };
+  /**
+  * @function module:utilities.findDefs
+  * @returns {SVGDefsElement} The document's `<defs>` element, creating it first if necessary
+  */
+
+  var findDefs = function findDefs() {
+    var svgElement = editorContext_$1.getSVGContent();
+    var defs = svgElement.getElementsByTagNameNS(NS.SVG, 'defs');
+
+    if (defs.length > 0) {
+      defs = defs[0];
+    } else {
+      defs = svgElement.ownerDocument.createElementNS(NS.SVG, 'defs');
+
+      if (svgElement.firstChild) {
+        // first child is a comment, so call nextSibling
+        svgElement.insertBefore(defs, svgElement.firstChild.nextSibling); // svgElement.firstChild.nextSibling.before(defs); // Not safe
+      } else {
+        svgElement.append(defs);
+      }
+    }
+
+    return defs;
+  }; // TODO(codedread): Consider moving the next to functions to bbox.js
+
+  /**
+  * Get correct BBox for a path in Webkit.
+  * Converted from code found [here]{@link http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html}.
+  * @function module:utilities.getPathBBox
+  * @param {SVGPathElement} path - The path DOM element to get the BBox for
+  * @returns {module:utilities.BBoxObject} A BBox-like object
+  */
+
+  var getPathBBox = function getPathBBox(path$$1) {
+    var seglist = path$$1.pathSegList;
+    var tot = seglist.numberOfItems;
+    var bounds = [[], []];
+    var start = seglist.getItem(0);
+    var P0 = [start.x, start.y];
+
+    var getCalc = function getCalc(j, P1, P2, P3) {
+      return function (t) {
+        return 1 - Math.pow(t, 3) * P0[j] + 3 * 1 - Math.pow(t, 2) * t * P1[j] + 3 * (1 - t) * Math.pow(t, 2) * P2[j] + Math.pow(t, 3) * P3[j];
+      };
+    };
+
+    for (var i = 0; i < tot; i++) {
+      var seg = seglist.getItem(i);
+
+      if (seg.x === undefined) {
+        continue;
+      } // Add actual points to limits
+
+
+      bounds[0].push(P0[0]);
+      bounds[1].push(P0[1]);
+
+      if (seg.x1) {
+        var P1 = [seg.x1, seg.y1],
+            P2 = [seg.x2, seg.y2],
+            P3 = [seg.x, seg.y];
+
+        for (var j = 0; j < 2; j++) {
+          var calc = getCalc(j, P1, P2, P3);
+          var b = 6 * P0[j] - 12 * P1[j] + 6 * P2[j];
+          var a = -3 * P0[j] + 9 * P1[j] - 9 * P2[j] + 3 * P3[j];
+          var c = 3 * P1[j] - 3 * P0[j];
+
+          if (a === 0) {
+            if (b === 0) {
+              continue;
+            }
+
+            var t = -c / b;
+
+            if (t > 0 && t < 1) {
+              bounds[j].push(calc(t));
+            }
+
+            continue;
+          }
+
+          var b2ac = Math.pow(b, 2) - 4 * c * a;
+
+          if (b2ac < 0) {
+            continue;
+          }
+
+          var t1 = (-b + Math.sqrt(b2ac)) / (2 * a);
+
+          if (t1 > 0 && t1 < 1) {
+            bounds[j].push(calc(t1));
+          }
+
+          var t2 = (-b - Math.sqrt(b2ac)) / (2 * a);
+
+          if (t2 > 0 && t2 < 1) {
+            bounds[j].push(calc(t2));
+          }
+        }
+
+        P0 = P3;
+      } else {
+        bounds[0].push(seg.x);
+        bounds[1].push(seg.y);
+      }
+    }
+
+    var x = Math.min.apply(null, bounds[0]);
+    var w = Math.max.apply(null, bounds[0]) - x;
+    var y = Math.min.apply(null, bounds[1]);
+    var h = Math.max.apply(null, bounds[1]) - y;
+    return {
+      x: x,
+      y: y,
+      width: w,
+      height: h
+    };
+  };
+  /**
+  * Get the given/selected element's bounding box object, checking for
+  * horizontal/vertical lines (see issue 717)
+  * Note that performance is currently terrible, so some way to improve would
+  * be great.
+  * @param {Element} selected - Container or `<use>` DOM element
+  * @returns {DOMRect} Bounding box object
+  */
+
+  function groupBBFix(selected) {
+    if (supportsHVLineContainerBBox()) {
+      try {
+        return selected.getBBox();
+      } catch (e) {}
+    }
+
+    var ref = $$2.data(selected, 'ref');
+    var matched = null;
+    var ret, copy;
+
+    if (ref) {
+      copy = $$2(ref).children().clone().attr('visibility', 'hidden');
+      $$2(svgroot_).append(copy);
+      matched = copy.filter('line, path');
+    } else {
+      matched = $$2(selected).find('line, path');
+    }
+
+    var issue = false;
+
+    if (matched.length) {
+      matched.each(function () {
+        var bb = this.getBBox();
+
+        if (!bb.width || !bb.height) {
+          issue = true;
+        }
+      });
+
+      if (issue) {
+        var elems = ref ? copy : $$2(selected).children();
+        ret = getStrokedBBox(elems);
+      } else {
+        ret = selected.getBBox();
+      }
+    } else {
+      ret = selected.getBBox();
+    }
+
+    if (ref) {
+      copy.remove();
+    }
+
+    return ret;
+  }
+  /**
+  * Get the given/selected element's bounding box object, convert it to be more
+  * usable when necessary.
+  * @function module:utilities.getBBox
+  * @param {Element} elem - Optional DOM element to get the BBox for
+  * @returns {module:utilities.BBoxObject} Bounding box object
+  */
+
+
+  var getBBox = function getBBox(elem) {
+    var selected = elem || editorContext_$1.geSelectedElements()[0];
+
+    if (elem.nodeType !== 1) {
+      return null;
+    }
+
+    var elname = selected.nodeName;
+    var ret = null;
+
+    switch (elname) {
+      case 'text':
+        if (selected.textContent === '') {
+          selected.textContent = 'a'; // Some character needed for the selector to use.
+
+          ret = selected.getBBox();
+          selected.textContent = '';
+        } else if (selected.getBBox) {
+          ret = selected.getBBox();
+        }
+
+        break;
+
+      case 'path':
+        if (!supportsPathBBox()) {
+          ret = getPathBBox(selected);
+        } else if (selected.getBBox) {
+          ret = selected.getBBox();
+        }
+
+        break;
+
+      case 'g':
+      case 'a':
+        ret = groupBBFix(selected);
+        break;
+
+      default:
+        if (elname === 'use') {
+          ret = groupBBFix(selected); // , true);
+        }
+
+        if (elname === 'use' || elname === 'foreignObject' && isWebkit()) {
+          if (!ret) {
+            ret = selected.getBBox();
+          } // This is resolved in later versions of webkit, perhaps we should
+          // have a featured detection for correct 'use' behavior?
+          // ——————————
+
+
+          if (!isWebkit()) {
+            var bb = {};
+            bb.width = ret.width;
+            bb.height = ret.height;
+            bb.x = ret.x + parseFloat(selected.getAttribute('x') || 0);
+            bb.y = ret.y + parseFloat(selected.getAttribute('y') || 0);
+            ret = bb;
+          }
+        } else if (visElemsArr.includes(elname)) {
+          if (selected) {
+            try {
+              ret = selected.getBBox();
+            } catch (err) {
+              // tspan (and textPath apparently) have no `getBBox` in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=937268
+              // Re: Chrome returning bbox for containing text element, see: https://bugs.chromium.org/p/chromium/issues/detail?id=349835
+              var extent = selected.getExtentOfChar(0); // pos+dimensions of the first glyph
+
+              var width = selected.getComputedTextLength(); // width of the tspan
+
+              ret = {
+                x: extent.x,
+                y: extent.y,
+                width: width,
+                height: extent.height
+              };
+            }
+          } else {
+            // Check if element is child of a foreignObject
+            var fo = $$2(selected).closest('foreignObject');
+
+            if (fo.length) {
+              if (fo[0].getBBox) {
+                ret = fo[0].getBBox();
+              }
+            }
+          }
+        }
+
+    }
+
+    if (ret) {
+      ret = bboxToObj(ret);
+    } // get the bounding box from the DOM (which is in that element's coordinate system)
+
+
+    return ret;
+  };
+  /**
+  * @typedef {GenericArray} module:utilities.PathSegmentArray
+  * @property {Integer} length 2
+  * @property {"M"|"L"|"C"|"Z"} 0
+  * @property {Float[]} 1
+  */
+
+  /**
+  * Create a path 'd' attribute from path segments.
+  * Each segment is an array of the form: `[singleChar, [x,y, x,y, ...]]`
+  * @function module:utilities.getPathDFromSegments
+  * @param {module:utilities.PathSegmentArray[]} pathSegments - An array of path segments to be converted
+  * @returns {string} The converted path d attribute.
+  */
+
+  var getPathDFromSegments = function getPathDFromSegments(pathSegments) {
+    var d = '';
+    $$2.each(pathSegments, function (j, _ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2),
+          singleChar = _ref3[0],
+          pts = _ref3[1];
+
+      d += singleChar;
+
+      for (var i = 0; i < pts.length; i += 2) {
+        d += pts[i] + ',' + pts[i + 1] + ' ';
+      }
+    });
+    return d;
+  };
+  /**
+  * Make a path 'd' attribute from a simple SVG element shape.
+  * @function module:utilities.getPathDFromElement
+  * @param {Element} elem - The element to be converted
+  * @returns {string} The path d attribute or `undefined` if the element type is unknown.
+  */
+
+  var getPathDFromElement = function getPathDFromElement(elem) {
+    // Possibly the cubed root of 6, but 1.81 works best
+    var num = 1.81;
+    var d, a, rx, ry;
+
+    switch (elem.tagName) {
+      case 'ellipse':
+      case 'circle':
+        {
+          a = $$2(elem).attr(['rx', 'ry', 'cx', 'cy']);
+          var _a = a,
+              cx = _a.cx,
+              cy = _a.cy;
+          var _a2 = a;
+          rx = _a2.rx;
+          ry = _a2.ry;
+
+          if (elem.tagName === 'circle') {
+            ry = $$2(elem).attr('r');
+            rx = ry;
+          }
+
+          d = getPathDFromSegments([['M', [cx - rx, cy]], ['C', [cx - rx, cy - ry / num, cx - rx / num, cy - ry, cx, cy - ry]], ['C', [cx + rx / num, cy - ry, cx + rx, cy - ry / num, cx + rx, cy]], ['C', [cx + rx, cy + ry / num, cx + rx / num, cy + ry, cx, cy + ry]], ['C', [cx - rx / num, cy + ry, cx - rx, cy + ry / num, cx - rx, cy]], ['Z', []]]);
+          break;
+        }
+
+      case 'path':
+        d = elem.getAttribute('d');
+        break;
+
+      case 'line':
+        a = $$2(elem).attr(['x1', 'y1', 'x2', 'y2']);
+        d = 'M' + a.x1 + ',' + a.y1 + 'L' + a.x2 + ',' + a.y2;
+        break;
+
+      case 'polyline':
+        d = 'M' + elem.getAttribute('points');
+        break;
+
+      case 'polygon':
+        d = 'M' + elem.getAttribute('points') + ' Z';
+        break;
+
+      case 'rect':
+        {
+          var r = $$2(elem).attr(['rx', 'ry']);
+          rx = r.rx;
+          ry = r.ry;
+          var b = elem.getBBox();
+          var x = b.x,
+              y = b.y,
+              w = b.width,
+              h = b.height;
+          num = 4 - num; // Why? Because!
+
+          if (!rx && !ry) {
+            // Regular rect
+            d = getPathDFromSegments([['M', [x, y]], ['L', [x + w, y]], ['L', [x + w, y + h]], ['L', [x, y + h]], ['L', [x, y]], ['Z', []]]);
+          } else {
+            d = getPathDFromSegments([['M', [x, y + ry]], ['C', [x, y + ry / num, x + rx / num, y, x + rx, y]], ['L', [x + w - rx, y]], ['C', [x + w - rx / num, y, x + w, y + ry / num, x + w, y + ry]], ['L', [x + w, y + h - ry]], ['C', [x + w, y + h - ry / num, x + w - rx / num, y + h, x + w - rx, y + h]], ['L', [x + rx, y + h]], ['C', [x + rx / num, y + h, x, y + h - ry / num, x, y + h - ry]], ['L', [x, y + ry]], ['Z', []]]);
+          }
+
+          break;
+        }
+
+      default:
+        break;
+    }
+
+    return d;
+  };
+  /**
+  * Get a set of attributes from an element that is useful for convertToPath.
+  * @function module:utilities.getExtraAttributesForConvertToPath
+  * @param {Element} elem - The element to be probed
+  * @returns {PlainObject.<"marker-start"|"marker-end"|"marker-mid"|"filter"|"clip-path", string>} An object with attributes.
+  */
+
+  var getExtraAttributesForConvertToPath = function getExtraAttributesForConvertToPath(elem) {
+    var attrs = {}; // TODO: make this list global so that we can properly maintain it
+    // TODO: what about @transform, @clip-rule, @fill-rule, etc?
+
+    $$2.each(['marker-start', 'marker-end', 'marker-mid', 'filter', 'clip-path'], function () {
+      var a = elem.getAttribute(this);
+
+      if (a) {
+        attrs[this] = a;
+      }
+    });
+    return attrs;
+  };
+  /**
+  * Get the BBox of an element-as-path.
+  * @function module:utilities.getBBoxOfElementAsPath
+  * @param {Element} elem - The DOM element to be probed
+  * @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson
+  * @param {module:path.pathActions} pathActions - If a transform exists, `pathActions.resetOrientation()` is used. See: canvas.pathActions.
+  * @returns {DOMRect|false} The resulting path's bounding box object.
+  */
+
+  var getBBoxOfElementAsPath = function getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions$$1) {
+    var path$$1 = addSVGElementFromJson({
+      element: 'path',
+      attr: getExtraAttributesForConvertToPath(elem)
+    });
+    var eltrans = elem.getAttribute('transform');
+
+    if (eltrans) {
+      path$$1.setAttribute('transform', eltrans);
+    }
+
+    var parentNode = elem.parentNode;
+
+    if (elem.nextSibling) {
+      elem.before(path$$1);
+    } else {
+      parentNode.append(path$$1);
+    }
+
+    var d = getPathDFromElement(elem);
+
+    if (d) {
+      path$$1.setAttribute('d', d);
+    } else {
+      path$$1.remove();
+    } // Get the correct BBox of the new path, then discard it
+
+
+    pathActions$$1.resetOrientation(path$$1);
+    var bb = false;
+
+    try {
+      bb = path$$1.getBBox();
+    } catch (e) {// Firefox fails
+    }
+
+    path$$1.remove();
+    return bb;
+  };
+  /**
+  * Convert selected element to a path.
+  * @function module:utilities.convertToPath
+  * @param {Element} elem - The DOM element to be converted
+  * @param {module:utilities.SVGElementJSON} attrs - Apply attributes to new path. see canvas.convertToPath
+  * @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson
+  * @param {module:path.pathActions} pathActions - If a transform exists, pathActions.resetOrientation() is used. See: canvas.pathActions.
+  * @param {module:draw.DrawCanvasInit#clearSelection|module:path.EditorContext#clearSelection} clearSelection - see [canvas.clearSelection]{@link module:svgcanvas.SvgCanvas#clearSelection}
+  * @param {module:path.EditorContext#addToSelection} addToSelection - see [canvas.addToSelection]{@link module:svgcanvas.SvgCanvas#addToSelection}
+  * @param {module:history} hstry - see history module
+  * @param {module:path.EditorContext#addCommandToHistory|module:draw.DrawCanvasInit#addCommandToHistory} addCommandToHistory - see [canvas.addCommandToHistory]{@link module:svgcanvas~addCommandToHistory}
+  * @returns {SVGPathElement|null} The converted path element or null if the DOM element was not recognized.
+  */
+
+  var convertToPath = function convertToPath(elem, attrs, addSVGElementFromJson, pathActions$$1, clearSelection, addToSelection, hstry, addCommandToHistory) {
+    var batchCmd = new hstry.BatchCommand('Convert element to Path'); // Any attribute on the element not covered by the passed-in attributes
+
+    attrs = $$2.extend({}, attrs, getExtraAttributesForConvertToPath(elem));
+    var path$$1 = addSVGElementFromJson({
+      element: 'path',
+      attr: attrs
+    });
+    var eltrans = elem.getAttribute('transform');
+
+    if (eltrans) {
+      path$$1.setAttribute('transform', eltrans);
+    }
+
+    var id = elem.id;
+    var parentNode = elem.parentNode;
+
+    if (elem.nextSibling) {
+      elem.before(path$$1);
+    } else {
+      parentNode.append(path$$1);
+    }
+
+    var d = getPathDFromElement(elem);
+
+    if (d) {
+      path$$1.setAttribute('d', d); // Replace the current element with the converted one
+      // Reorient if it has a matrix
+
+      if (eltrans) {
+        var tlist = getTransformList(path$$1);
+
+        if (hasMatrixTransform(tlist)) {
+          pathActions$$1.resetOrientation(path$$1);
+        }
+      }
+
+      var nextSibling = elem.nextSibling;
+      batchCmd.addSubCommand(new hstry.RemoveElementCommand(elem, nextSibling, parent));
+      batchCmd.addSubCommand(new hstry.InsertElementCommand(path$$1));
+      clearSelection();
+      elem.remove();
+      path$$1.setAttribute('id', id);
+      path$$1.removeAttribute('visibility');
+      addToSelection([path$$1], true);
+      addCommandToHistory(batchCmd);
+      return path$$1;
+    } // the elem.tagName was not recognized, so no "d" attribute. Remove it, so we've haven't changed anything.
+
+
+    path$$1.remove();
+    return null;
+  };
+  /**
+  * Can the bbox be optimized over the native getBBox? The optimized bbox is the same as the native getBBox when
+  * the rotation angle is a multiple of 90 degrees and there are no complex transforms.
+  * Getting an optimized bbox can be dramatically slower, so we want to make sure it's worth it.
+  *
+  * The best example for this is a circle rotate 45 degrees. The circle doesn't get wider or taller when rotated
+  * about it's center.
+  *
+  * The standard, unoptimized technique gets the native bbox of the circle, rotates the box 45 degrees, uses
+  * that width and height, and applies any transforms to get the final bbox. This means the calculated bbox
+  * is much wider than the original circle. If the angle had been 0, 90, 180, etc. both techniques render the
+  * same bbox.
+  *
+  * The optimization is not needed if the rotation is a multiple 90 degrees. The default technique is to call
+  * getBBox then apply the angle and any transforms.
+  *
+  * @param {Float} angle - The rotation angle in degrees
+  * @param {boolean} hasAMatrixTransform - True if there is a matrix transform
+  * @returns {boolean} True if the bbox can be optimized.
+  */
+
+  function bBoxCanBeOptimizedOverNativeGetBBox(angle, hasAMatrixTransform) {
+    var angleModulo90 = angle % 90;
+    var closeTo90 = angleModulo90 < -89.99 || angleModulo90 > 89.99;
+    var closeTo0 = angleModulo90 > -0.001 && angleModulo90 < 0.001;
+    return hasAMatrixTransform || !(closeTo0 || closeTo90);
+  }
+  /**
+  * Get bounding box that includes any transforms.
+  * @function module:utilities.getBBoxWithTransform
+  * @param {Element} elem - The DOM element to be converted
+  * @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson
+  * @param {module:path.pathActions} pathActions - If a transform exists, pathActions.resetOrientation() is used. See: canvas.pathActions.
+  * @returns {module:utilities.BBoxObject|module:math.TransformedBox|DOMRect} A single bounding box object
+  */
+
+
+  var getBBoxWithTransform = function getBBoxWithTransform(elem, addSVGElementFromJson, pathActions$$1) {
+    // TODO: Fix issue with rotated groups. Currently they work
+    // fine in FF, but not in other browsers (same problem mentioned
+    // in Issue 339 comment #2).
+    var bb = getBBox(elem);
+
+    if (!bb) {
+      return null;
+    }
+
+    var tlist = getTransformList(elem);
+    var angle = getRotationAngleFromTransformList(tlist);
+    var hasMatrixXForm = hasMatrixTransform(tlist);
+
+    if (angle || hasMatrixXForm) {
+      var goodBb = false;
+
+      if (bBoxCanBeOptimizedOverNativeGetBBox(angle, hasMatrixXForm)) {
+        // Get the BBox from the raw path for these elements
+        // TODO: why ellipse and not circle
+        var elemNames = ['ellipse', 'path', 'line', 'polyline', 'polygon'];
+
+        if (elemNames.includes(elem.tagName)) {
+          goodBb = getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions$$1);
+          bb = goodBb;
+        } else if (elem.tagName === 'rect') {
+          // Look for radius
+          var rx = elem.getAttribute('rx');
+          var ry = elem.getAttribute('ry');
+
+          if (rx || ry) {
+            goodBb = getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions$$1);
+            bb = goodBb;
+          }
+        }
+      }
+
+      if (!goodBb) {
+        var _transformListToTrans = transformListToTransform(tlist),
+            matrix = _transformListToTrans.matrix;
+
+        bb = transformBox(bb.x, bb.y, bb.width, bb.height, matrix).aabox; // Old technique that was exceedingly slow with large documents.
+        //
+        // Accurate way to get BBox of rotated element in Firefox:
+        // Put element in group and get its BBox
+        //
+        // Must use clone else FF freaks out
+        // const clone = elem.cloneNode(true);
+        // const g = document.createElementNS(NS.SVG, 'g');
+        // const parent = elem.parentNode;
+        // parent.append(g);
+        // g.append(clone);
+        // const bb2 = bboxToObj(g.getBBox());
+        // g.remove();
+      }
+    }
+
+    return bb;
+  };
+  /**
+   * @param {Element} elem
+   * @returns {Float}
+   * @todo This is problematic with large stroke-width and, for example, a single
+   * horizontal line. The calculated BBox extends way beyond left and right sides.
+   */
+
+  function getStrokeOffsetForBBox(elem) {
+    var sw = elem.getAttribute('stroke-width');
+    return !isNaN(sw) && elem.getAttribute('stroke') !== 'none' ? sw / 2 : 0;
+  }
+  /**
+   * @typedef {PlainObject} BBox
+   * @property {Integer} x The x value
+   * @property {Integer} y The y value
+   * @property {Float} width
+   * @property {Float} height
+   */
+
+  /**
+  * Get the bounding box for one or more stroked and/or transformed elements.
+  * @function module:utilities.getStrokedBBox
+  * @param {Element[]} elems - Array with DOM elements to check
+  * @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson
+  * @param {module:path.pathActions} pathActions - If a transform exists, pathActions.resetOrientation() is used. See: canvas.pathActions.
+  * @returns {module:utilities.BBoxObject|module:math.TransformedBox|DOMRect} A single bounding box object
+  */
+
+
+  var getStrokedBBox = function getStrokedBBox(elems, addSVGElementFromJson, pathActions$$1) {
+    if (!elems || !elems.length) {
+      return false;
+    }
+
+    var fullBb;
+    $$2.each(elems, function () {
+      if (fullBb) {
+        return;
+      }
+
+      if (!this.parentNode) {
+        return;
+      }
+
+      fullBb = getBBoxWithTransform(this, addSVGElementFromJson, pathActions$$1);
+    }); // This shouldn't ever happen...
+
+    if (fullBb === undefined) {
+      return null;
+    } // fullBb doesn't include the stoke, so this does no good!
+    // if (elems.length == 1) return fullBb;
+
+
+    var maxX = fullBb.x + fullBb.width;
+    var maxY = fullBb.y + fullBb.height;
+    var minX = fullBb.x;
+    var minY = fullBb.y; // If only one elem, don't call the potentially slow getBBoxWithTransform method again.
+
+    if (elems.length === 1) {
+      var offset = getStrokeOffsetForBBox(elems[0]);
+      minX -= offset;
+      minY -= offset;
+      maxX += offset;
+      maxY += offset;
+    } else {
+      $$2.each(elems, function (i, elem) {
+        var curBb = getBBoxWithTransform(elem, addSVGElementFromJson, pathActions$$1);
+
+        if (curBb) {
+          var _offset = getStrokeOffsetForBBox(elem);
+
+          minX = Math.min(minX, curBb.x - _offset);
+          minY = Math.min(minY, curBb.y - _offset); // TODO: The old code had this test for max, but not min. I suspect this test should be for both min and max
+
+          if (elem.nodeType === 1) {
+            maxX = Math.max(maxX, curBb.x + curBb.width + _offset);
+            maxY = Math.max(maxY, curBb.y + curBb.height + _offset);
+          }
+        }
+      });
+    }
+
+    fullBb.x = minX;
+    fullBb.y = minY;
+    fullBb.width = maxX - minX;
+    fullBb.height = maxY - minY;
+    return fullBb;
+  };
+  /**
+  * Get all elements that have a BBox (excludes `<defs>`, `<title>`, etc).
+  * Note that 0-opacity, off-screen etc elements are still considered "visible"
+  * for this function.
+  * @function module:utilities.getVisibleElements
+  * @param {Element} parentElement - The parent DOM element to search within
+  * @returns {Element[]} All "visible" elements.
+  */
+
+  var getVisibleElements = function getVisibleElements(parentElement) {
+    if (!parentElement) {
+      parentElement = $$2(editorContext_$1.getSVGContent()).children(); // Prevent layers from being included
+    }
+
+    var contentElems = [];
+    $$2(parentElement).children().each(function (i, elem) {
+      if (elem.getBBox) {
+        contentElems.push(elem);
+      }
+    });
+    return contentElems.reverse();
+  };
+  /**
+  * Get the bounding box for one or more stroked and/or transformed elements.
+  * @function module:utilities.getStrokedBBoxDefaultVisible
+  * @param {Element[]} elems - Array with DOM elements to check
+  * @returns {module:utilities.BBoxObject} A single bounding box object
+  */
+
+  var getStrokedBBoxDefaultVisible = function getStrokedBBoxDefaultVisible(elems) {
+    if (!elems) {
+      elems = getVisibleElements();
+    }
+
+    return getStrokedBBox(elems, editorContext_$1.addSVGElementFromJson, editorContext_$1.pathActions);
+  };
+  /**
+  * Get the rotation angle of the given transform list.
+  * @function module:utilities.getRotationAngleFromTransformList
+  * @param {SVGTransformList} tlist - List of transforms
+  * @param {boolean} toRad - When true returns the value in radians rather than degrees
+  * @returns {Float} The angle in degrees or radians
+  */
+
+  var getRotationAngleFromTransformList = function getRotationAngleFromTransformList(tlist, toRad) {
+    if (!tlist) {
+      return 0;
+    } // <svg> elements have no tlist
+
+
+    var N = tlist.numberOfItems;
+
+    for (var i = 0; i < N; ++i) {
+      var xform = tlist.getItem(i);
+
+      if (xform.type === 4) {
+        return toRad ? xform.angle * Math.PI / 180.0 : xform.angle;
+      }
+    }
+
+    return 0.0;
+  };
+  /**
+  * Get the rotation angle of the given/selected DOM element.
+  * @function module:utilities.getRotationAngle
+  * @param {Element} [elem] - DOM element to get the angle for. Default to first of selected elements.
+  * @param {boolean} [toRad=false] - When true returns the value in radians rather than degrees
+  * @returns {Float} The angle in degrees or radians
+  */
+
+  var getRotationAngle = function getRotationAngle(elem, toRad) {
+    // eslint-disable-line import/no-mutable-exports
+    var selected = elem || editorContext_$1.getSelectedElements()[0]; // find the rotation transform (if any) and set it
+
+    var tlist = getTransformList(selected);
+    return getRotationAngleFromTransformList(tlist, toRad);
+  };
+  /**
+  * Get the reference element associated with the given attribute value.
+  * @function module:utilities.getRefElem
+  * @param {string} attrVal - The attribute value as a string
+  * @returns {Element} Reference element
+  */
+
+  var getRefElem = function getRefElem(attrVal) {
+    return getElem(getUrlFromAttr(attrVal).substr(1));
+  };
+  /**
+  * Get a DOM element by ID within the SVG root element.
+  * @function module:utilities.getElem
+  * @param {string} id - String with the element's new ID
+  * @returns {?Element}
+  */
+
+  var getElem = supportsSelectors() ? function (id) {
+    // querySelector lookup
+    return svgroot_.querySelector('#' + id);
+  } : supportsXpath() ? function (id) {
+    // xpath lookup
+    return domdoc_.evaluate('svg:svg[@id="svgroot"]//svg:*[@id="' + id + '"]', domcontainer_, function () {
+      return NS.SVG;
+    }, 9, null).singleNodeValue;
+  } : function (id) {
+    // jQuery lookup: twice as slow as xpath in FF
+    return $$2(svgroot_).find('[id=' + id + ']')[0];
+  };
+  /**
+  * Assigns multiple attributes to an element.
+  * @function module:utilities.assignAttributes
+  * @param {Element} elem - DOM element to apply new attribute values to
+  * @param {PlainObject.<string, string>} attrs - Object with attribute keys/values
+  * @param {Integer} [suspendLength] - Milliseconds to suspend redraw
+  * @param {boolean} [unitCheck=false] - Boolean to indicate the need to use units.setUnitAttr
+  * @returns {undefined}
+  */
+
+  var assignAttributes = function assignAttributes(elem, attrs, suspendLength, unitCheck) {
+    var _arr = Object.entries(attrs);
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      var _arr$_i = _slicedToArray(_arr[_i], 2),
+          key = _arr$_i[0],
+          value = _arr$_i[1];
+
+      var ns = key.substr(0, 4) === 'xml:' ? NS.XML : key.substr(0, 6) === 'xlink:' ? NS.XLINK : null;
+
+      if (ns) {
+        elem.setAttributeNS(ns, key, value);
+      } else if (!unitCheck) {
+        elem.setAttribute(key, value);
+      } else {
+        setUnitAttr(elem, key, value);
+      }
+    }
+  };
+  /**
+  * Remove unneeded (default) attributes, making resulting SVG smaller.
+  * @function module:utilities.cleanupElement
+  * @param {Element} element - DOM element to clean up
+  * @returns {undefined}
+  */
+
+  var cleanupElement = function cleanupElement(element) {
+    var defaults = {
+      'fill-opacity': 1,
+      'stop-opacity': 1,
+      opacity: 1,
+      stroke: 'none',
+      'stroke-dasharray': 'none',
+      'stroke-linejoin': 'miter',
+      'stroke-linecap': 'butt',
+      'stroke-opacity': 1,
+      'stroke-width': 1,
+      rx: 0,
+      ry: 0
+    };
+
+    if (element.nodeName === 'ellipse') {
+      // Ellipse elements require rx and ry attributes
+      delete defaults.rx;
+      delete defaults.ry;
+    }
+
+    Object.entries(defaults).forEach(function (_ref4) {
+      var _ref5 = _slicedToArray(_ref4, 2),
+          attr = _ref5[0],
+          val = _ref5[1];
+
+      if (element.getAttribute(attr) === String(val)) {
+        element.removeAttribute(attr);
+      }
+    });
+  };
+  /**
+  * Round value to for snapping.
+  * @function module:utilities.snapToGrid
+  * @param {Float} value
+  * @returns {Integer}
+  */
+
+  var snapToGrid = function snapToGrid(value) {
+    var unit = editorContext_$1.getBaseUnit();
+    var stepSize = editorContext_$1.getSnappingStep();
+
+    if (unit !== 'px') {
+      stepSize *= getTypeMap()[unit];
+    }
+
+    value = Math.round(value / stepSize) * stepSize;
+    return value;
+  };
+  /**
+   * Prevents default browser click behaviour on the given element.
+   * @function module:utilities.preventClickDefault
+   * @param {Element} img - The DOM element to prevent the click on
+   * @returns {undefined}
+   */
+
+  var preventClickDefault = function preventClickDefault(img) {
+    $$2(img).click(function (e) {
+      e.preventDefault();
+    });
+  };
+  /**
+   * @callback module:utilities.GetNextID
+   * @returns {string} The ID
+   */
+
+  /**
+   * Create a clone of an element, updating its ID and its children's IDs when needed.
+   * @function module:utilities.copyElem
+   * @param {Element} el - DOM element to clone
+   * @param {module:utilities.GetNextID} getNextId - The getter of the next unique ID.
+   * @returns {Element} The cloned element
+   */
+
+  var copyElem = function copyElem(el, getNextId) {
+    // manually create a copy of the element
+    var newEl = document.createElementNS(el.namespaceURI, el.nodeName);
+    $$2.each(el.attributes, function (i, attr) {
+      if (attr.localName !== '-moz-math-font-style') {
+        newEl.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value);
+      }
+    }); // set the copied element's new id
+
+    newEl.removeAttribute('id');
+    newEl.id = getNextId(); // Opera's "d" value needs to be reset for Opera/Win/non-EN
+    // Also needed for webkit (else does not keep curved segments on clone)
+
+    if (isWebkit() && el.nodeName === 'path') {
+      var fixedD = convertPath(el);
+      newEl.setAttribute('d', fixedD);
+    } // now create copies of all children
+
+
+    $$2.each(el.childNodes, function (i, child) {
+      switch (child.nodeType) {
+        case 1:
+          // element node
+          newEl.append(copyElem(child, getNextId));
+          break;
+
+        case 3:
+          // text node
+          newEl.textContent = child.nodeValue;
+          break;
+
+        default:
+          break;
+      }
+    });
+
+    if ($$2(el).data('gsvg')) {
+      $$2(newEl).data('gsvg', newEl.firstChild);
+    } else if ($$2(el).data('symbol')) {
+      var ref = $$2(el).data('symbol');
+      $$2(newEl).data('ref', ref).data('symbol', ref);
+    } else if (newEl.tagName === 'image') {
+      preventClickDefault(newEl);
+    }
+
+    return newEl;
+  };
+  /**
+   * Whether a value is `null` or `undefined`.
+   * @param {Any} val
+   * @returns {boolean}
+   */
+
+  var isNullish = function isNullish(val) {
+    return val === null || val === undefined;
+  };
+
+  var $$3 = jQuery;
+  /**
+   * This class encapsulates the concept of a layer in the drawing. It can be constructed with
+   * an existing group element or, with three parameters, will create a new layer group element.
+   *
+   * @example
+   * new Layer('name', group);          // Use the existing group for this layer.
+   * new Layer('name', group, svgElem); // Create a new group and add it to the DOM after group.
+   * new Layer('name', null, svgElem);  // Create a new group and add it to the DOM as the last layer.
+   * @memberof module:layer
+   */
+
+  var Layer =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {string} name - Layer name
+    * @param {SVGGElement|null} group - An existing SVG group element or null.
+    *     If group and no svgElem, use group for this layer.
+    *     If group and svgElem, create a new group element and insert it in the DOM after group.
+    *     If no group and svgElem, create a new group element and insert it in the DOM as the last layer.
+    * @param {SVGGElement=} svgElem - The SVG DOM element. If defined, use this to add
+    *     a new layer to the document.
+    */
+    function Layer(name, group, svgElem) {
+      _classCallCheck(this, Layer);
+
+      this.name_ = name;
+      this.group_ = svgElem ? null : group;
+
+      if (svgElem) {
+        // Create a group element with title and add it to the DOM.
+        var svgdoc = svgElem.ownerDocument;
+        this.group_ = svgdoc.createElementNS(NS.SVG, 'g');
+        var layerTitle = svgdoc.createElementNS(NS.SVG, 'title');
+        layerTitle.textContent = name;
+        this.group_.append(layerTitle);
+
+        if (group) {
+          $$3(group).after(this.group_);
+        } else {
+          svgElem.append(this.group_);
+        }
+      }
+
+      addLayerClass(this.group_);
+      walkTree(this.group_, function (e) {
+        e.setAttribute('style', 'pointer-events:inherit');
+      });
+      this.group_.setAttribute('style', svgElem ? 'pointer-events:all' : 'pointer-events:none');
+    }
+    /**
+     * Get the layer's name.
+     * @returns {string} The layer name
+     */
+
+
+    _createClass(Layer, [{
+      key: "getName",
+      value: function getName() {
+        return this.name_;
+      }
+      /**
+       * Get the group element for this layer.
+       * @returns {SVGGElement} The layer SVG group
+       */
+
+    }, {
+      key: "getGroup",
+      value: function getGroup() {
+        return this.group_;
+      }
+      /**
+       * Active this layer so it takes pointer events.
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "activate",
+      value: function activate() {
+        this.group_.setAttribute('style', 'pointer-events:all');
+      }
+      /**
+       * Deactive this layer so it does NOT take pointer events.
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "deactivate",
+      value: function deactivate() {
+        this.group_.setAttribute('style', 'pointer-events:none');
+      }
+      /**
+       * Set this layer visible or hidden based on 'visible' parameter.
+       * @param {boolean} visible - If true, make visible; otherwise, hide it.
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "setVisible",
+      value: function setVisible(visible) {
+        var expected = visible === undefined || visible ? 'inline' : 'none';
+        var oldDisplay = this.group_.getAttribute('display');
+
+        if (oldDisplay !== expected) {
+          this.group_.setAttribute('display', expected);
+        }
+      }
+      /**
+       * Is this layer visible?
+       * @returns {boolean} True if visible.
+       */
+
+    }, {
+      key: "isVisible",
+      value: function isVisible() {
+        return this.group_.getAttribute('display') !== 'none';
+      }
+      /**
+       * Get layer opacity.
+       * @returns {Float} Opacity value.
+       */
+
+    }, {
+      key: "getOpacity",
+      value: function getOpacity() {
+        var opacity = this.group_.getAttribute('opacity');
+
+        if (isNullish(opacity)) {
+          return 1;
+        }
+
+        return parseFloat(opacity);
+      }
+      /**
+       * Sets the opacity of this layer. If opacity is not a value between 0.0 and 1.0,
+       * nothing happens.
+       * @param {Float} opacity - A float value in the range 0.0-1.0
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "setOpacity",
+      value: function setOpacity(opacity) {
+        if (typeof opacity === 'number' && opacity >= 0.0 && opacity <= 1.0) {
+          this.group_.setAttribute('opacity', opacity);
+        }
+      }
+      /**
+       * Append children to this layer.
+       * @param {SVGGElement} children - The children to append to this layer.
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "appendChildren",
+      value: function appendChildren(children) {
+        for (var i = 0; i < children.length; ++i) {
+          this.group_.append(children[i]);
+        }
+      }
+      /**
+      * @returns {SVGTitleElement|null}
+      */
+
+    }, {
+      key: "getTitleElement",
+      value: function getTitleElement() {
+        var len = this.group_.childNodes.length;
+
+        for (var i = 0; i < len; ++i) {
+          var child = this.group_.childNodes.item(i);
+
+          if (child && child.tagName === 'title') {
+            return child;
+          }
+        }
+
+        return null;
+      }
+      /**
+       * Set the name of this layer.
+       * @param {string} name - The new name.
+       * @param {module:history.HistoryRecordingService} hrService - History recording service
+       * @returns {string|null} The new name if changed; otherwise, null.
+       */
+
+    }, {
+      key: "setName",
+      value: function setName(name, hrService) {
+        var previousName = this.name_;
+        name = toXml(name); // now change the underlying title element contents
+
+        var title = this.getTitleElement();
+
+        if (title) {
+          $$3(title).empty();
+          title.textContent = name;
+          this.name_ = name;
+
+          if (hrService) {
+            hrService.changeElement(title, {
+              '#text': previousName
+            });
+          }
+
+          return this.name_;
+        }
+
+        return null;
+      }
+      /**
+       * Remove this layer's group from the DOM. No more functions on group can be called after this.
+       * @returns {SVGGElement} The layer SVG group that was just removed.
+       */
+
+    }, {
+      key: "removeGroup",
+      value: function removeGroup() {
+        var parent = this.group_.parentNode;
+        var group = parent.removeChild(this.group_);
+        this.group_ = undefined;
+        return group;
+      }
+    }]);
+
+    return Layer;
+  }();
+  /**
+   * @property {string} CLASS_NAME - class attribute assigned to all layer groups.
+   */
+
+
+  Layer.CLASS_NAME = 'layer';
+  /**
+   * @property {RegExp} CLASS_REGEX - Used to test presence of class Layer.CLASS_NAME
+   */
+
+  Layer.CLASS_REGEX = new RegExp('(\\s|^)' + Layer.CLASS_NAME + '(\\s|$)');
+  /**
+   * Add class `Layer.CLASS_NAME` to the element (usually `class='layer'`).
+   *
+   * @param {SVGGElement} elem - The SVG element to update
+   * @returns {undefined}
+   */
+
+  function addLayerClass(elem) {
+    var classes = elem.getAttribute('class');
+
+    if (isNullish(classes) || !classes.length) {
+      elem.setAttribute('class', Layer.CLASS_NAME);
+    } else if (!Layer.CLASS_REGEX.test(classes)) {
+      elem.setAttribute('class', classes + ' ' + Layer.CLASS_NAME);
+    }
+  }
+
+  /**
+   * History recording service.
+   *
+   * A self-contained service interface for recording history. Once injected, no other dependencies
+   * or globals are required (example: UndoManager, command types, etc.). Easy to mock for unit tests.
+   * Built on top of history classes in history.js.
+   *
+   * There is a simple start/end interface for batch commands.
+   *
+   * HistoryRecordingService.NO_HISTORY is a singleton that can be passed in to functions
+   * that record history. This helps when the caller requires that no history be recorded.
+   *
+   * The following will record history: insert, batch, insert.
+   * @example
+   * hrService = new history.HistoryRecordingService(this.undoMgr);
+   * hrService.insertElement(elem, text);         // add simple command to history.
+   * hrService.startBatchCommand('create two elements');
+   * hrService.changeElement(elem, attrs, text);  // add to batchCommand
+   * hrService.changeElement(elem, attrs2, text); // add to batchCommand
+   * hrService.endBatchCommand();                  // add batch command with two change commands to history.
+   * hrService.insertElement(elem, text);         // add simple command to history.
+   *
+   * @example
+   * // Note that all functions return this, so commands can be chained, like so:
+   * hrService
+   *   .startBatchCommand('create two elements')
+   *   .insertElement(elem, text)
+   *   .changeElement(elem, attrs, text)
+   *   .endBatchCommand();
+   *
+   * @memberof module:history
+   */
+
+  var HistoryRecordingService =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {history.UndoManager|null} undoManager - The undo manager.
+    *     A value of `null` is valid for cases where no history recording is required.
+    *     See singleton: {@link module:history.HistoryRecordingService.HistoryRecordingService.NO_HISTORY}
+    */
+    function HistoryRecordingService(undoManager) {
+      _classCallCheck(this, HistoryRecordingService);
+
+      this.undoManager_ = undoManager;
+      this.currentBatchCommand_ = null;
+      this.batchCommandStack_ = [];
+    }
+    /**
+     * Start a batch command so multiple commands can recorded as a single history command.
+     * Requires a corresponding call to endBatchCommand. Start and end commands can be nested.
+     *
+     * @param {string} text - Optional string describing the batch command.
+     * @returns {module:history.HistoryRecordingService}
+     */
+
+
+    _createClass(HistoryRecordingService, [{
+      key: "startBatchCommand",
+      value: function startBatchCommand(text) {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        this.currentBatchCommand_ = new BatchCommand(text);
+        this.batchCommandStack_.push(this.currentBatchCommand_);
+        return this;
+      }
+      /**
+       * End a batch command and add it to the history or a parent batch command.
+       * @returns {module:history.HistoryRecordingService}
+       */
+
+    }, {
+      key: "endBatchCommand",
+      value: function endBatchCommand() {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        if (this.currentBatchCommand_) {
+          var batchCommand = this.currentBatchCommand_;
+          this.batchCommandStack_.pop();
+          var len = this.batchCommandStack_.length;
+          this.currentBatchCommand_ = len ? this.batchCommandStack_[len - 1] : null;
+          this.addCommand_(batchCommand);
+        }
+
+        return this;
+      }
+      /**
+       * Add a `MoveElementCommand` to the history or current batch command.
+       * @param {Element} elem - The DOM element that was moved
+       * @param {Element} oldNextSibling - The element's next sibling before it was moved
+       * @param {Element} oldParent - The element's parent before it was moved
+       * @param {string} [text] - An optional string visible to user related to this change
+       * @returns {module:history.HistoryRecordingService}
+       */
+
+    }, {
+      key: "moveElement",
+      value: function moveElement(elem, oldNextSibling, oldParent, text) {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        this.addCommand_(new MoveElementCommand(elem, oldNextSibling, oldParent, text));
+        return this;
+      }
+      /**
+       * Add an `InsertElementCommand` to the history or current batch command.
+       * @param {Element} elem - The DOM element that was added
+       * @param {string} [text] - An optional string visible to user related to this change
+       * @returns {module:history.HistoryRecordingService}
+       */
+
+    }, {
+      key: "insertElement",
+      value: function insertElement(elem, text) {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        this.addCommand_(new InsertElementCommand(elem, text));
+        return this;
+      }
+      /**
+       * Add a `RemoveElementCommand` to the history or current batch command.
+       * @param {Element} elem - The DOM element that was removed
+       * @param {Element} oldNextSibling - The element's next sibling before it was removed
+       * @param {Element} oldParent - The element's parent before it was removed
+       * @param {string} [text] - An optional string visible to user related to this change
+       * @returns {module:history.HistoryRecordingService}
+       */
+
+    }, {
+      key: "removeElement",
+      value: function removeElement(elem, oldNextSibling, oldParent, text) {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        this.addCommand_(new RemoveElementCommand(elem, oldNextSibling, oldParent, text));
+        return this;
+      }
+      /**
+       * Add a `ChangeElementCommand` to the history or current batch command.
+       * @param {Element} elem - The DOM element that was changed
+       * @param {module:history.CommandAttributes} attrs - An object with the attributes to be changed and the values they had *before* the change
+       * @param {string} [text] - An optional string visible to user related to this change
+       * @returns {module:history.HistoryRecordingService}
+       */
+
+    }, {
+      key: "changeElement",
+      value: function changeElement(elem, attrs, text) {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        this.addCommand_(new ChangeElementCommand(elem, attrs, text));
+        return this;
+      }
+      /**
+       * Private function to add a command to the history or current batch command.
+       * @private
+       * @param {Command} cmd
+       * @returns {module:history.HistoryRecordingService|undefined}
+       */
+
+    }, {
+      key: "addCommand_",
+      value: function addCommand_(cmd) {
+        if (!this.undoManager_) {
+          return this;
+        }
+
+        if (this.currentBatchCommand_) {
+          this.currentBatchCommand_.addSubCommand(cmd);
+        } else {
+          this.undoManager_.addCommandToHistory(cmd);
+        }
+
+        return undefined;
+      }
+    }]);
+
+    return HistoryRecordingService;
+  }();
+  /**
+   * @memberof module:history.HistoryRecordingService
+   * @property {module:history.HistoryRecordingService} NO_HISTORY - Singleton that can be passed to functions that record history, but the caller requires that no history be recorded.
+   */
+
+
+  HistoryRecordingService.NO_HISTORY = new HistoryRecordingService();
+
+  var $$4 = jQuery;
+  var visElems$1 = 'a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use'.split(',');
+  var RandomizeModes = {
+    LET_DOCUMENT_DECIDE: 0,
+    ALWAYS_RANDOMIZE: 1,
+    NEVER_RANDOMIZE: 2
+  };
+  var randIds = RandomizeModes.LET_DOCUMENT_DECIDE; // Array with current disabled elements (for in-group editing)
+
+  var disabledElems = [];
+  /**
+   * Get a HistoryRecordingService.
+   * @param {module:history.HistoryRecordingService} [hrService] - if exists, return it instead of creating a new service.
+   * @returns {module:history.HistoryRecordingService}
+   */
+
+  function historyRecordingService(hrService) {
+    return hrService || new HistoryRecordingService(canvas_.undoMgr);
+  }
+  /**
+   * Find the layer name in a group element.
+   * @param {Element} group The group element to search in.
+   * @returns {string} The layer name or empty string.
+   */
+
+
+  function findLayerNameInGroup(group) {
+    return $$4('title', group).text() || (isOpera() && group.querySelectorAll // Hack for Opera 10.60
+    ? $$4(group.querySelectorAll('title')).text() : '');
+  }
+  /**
+   * Given a set of names, return a new unique name.
+   * @param {string[]} existingLayerNames - Existing layer names.
+   * @returns {string} - The new name.
+   */
+
+
+  function getNewLayerName(existingLayerNames) {
+    var i = 1; // TODO(codedread): What about internationalization of "Layer"?
+
+    while (existingLayerNames.includes('Layer ' + i)) {
+      i++;
+    }
+
+    return 'Layer ' + i;
+  }
+  /**
+   * This class encapsulates the concept of a SVG-edit drawing.
+   */
+
+
+  var Drawing =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {SVGSVGElement} svgElem - The SVG DOM Element that this JS object
+    *     encapsulates.  If the svgElem has a se:nonce attribute on it, then
+    *     IDs will use the nonce as they are generated.
+    * @param {string} [optIdPrefix=svg_] - The ID prefix to use.
+    * @throws {Error} If not initialized with an SVG element
+    */
+    function Drawing(svgElem, optIdPrefix) {
+      _classCallCheck(this, Drawing);
+
+      if (!svgElem || !svgElem.tagName || !svgElem.namespaceURI || svgElem.tagName !== 'svg' || svgElem.namespaceURI !== NS.SVG) {
+        throw new Error('Error: svgedit.draw.Drawing instance initialized without a <svg> element');
+      }
+      /**
+      * The SVG DOM Element that represents this drawing.
+      * @type {SVGSVGElement}
+      */
+
+
+      this.svgElem_ = svgElem;
+      /**
+      * The latest object number used in this drawing.
+      * @type {Integer}
+      */
+
+      this.obj_num = 0;
+      /**
+      * The prefix to prepend to each element id in the drawing.
+      * @type {string}
+      */
+
+      this.idPrefix = optIdPrefix || 'svg_';
+      /**
+      * An array of released element ids to immediately reuse.
+      * @type {Integer[]}
+      */
+
+      this.releasedNums = [];
+      /**
+      * The z-ordered array of Layer objects. Each layer has a name
+      * and group element.
+      * The first layer is the one at the bottom of the rendering.
+      * @type {Layer[]}
+      */
+
+      this.all_layers = [];
+      /**
+      * Map of all_layers by name.
+      *
+      * Note: Layers are ordered, but referenced externally by name; so, we need both container
+      * types depending on which function is called (i.e. all_layers and layer_map).
+      *
+      * @type {PlainObject.<string, Layer>}
+      */
+
+      this.layer_map = {};
+      /**
+      * The current layer being used.
+      * @type {Layer}
+      */
+
+      this.current_layer = null;
+      /**
+      * The nonce to use to uniquely identify elements across drawings.
+      * @type {!String}
+      */
+
+      this.nonce_ = '';
+      var n = this.svgElem_.getAttributeNS(NS.SE, 'nonce'); // If already set in the DOM, use the nonce throughout the document
+      // else, if randomizeIds(true) has been called, create and set the nonce.
+
+      if (n && randIds !== RandomizeModes.NEVER_RANDOMIZE) {
+        this.nonce_ = n;
+      } else if (randIds === RandomizeModes.ALWAYS_RANDOMIZE) {
+        this.setNonce(Math.floor(Math.random() * 100001));
+      }
+    }
+    /**
+     * @param {string} id Element ID to retrieve
+     * @returns {Element} SVG element within the root SVGSVGElement
+    */
+
+
+    _createClass(Drawing, [{
+      key: "getElem_",
+      value: function getElem_(id) {
+        if (this.svgElem_.querySelector) {
+          // querySelector lookup
+          return this.svgElem_.querySelector('#' + id);
+        } // jQuery lookup: twice as slow as xpath in FF
+
+
+        return $$4(this.svgElem_).find('[id=' + id + ']')[0];
+      }
+      /**
+       * @returns {SVGSVGElement}
+       */
+
+    }, {
+      key: "getSvgElem",
+      value: function getSvgElem() {
+        return this.svgElem_;
+      }
+      /**
+       * @returns {!(string|Integer)} The previously set nonce
+       */
+
+    }, {
+      key: "getNonce",
+      value: function getNonce() {
+        return this.nonce_;
+      }
+      /**
+       * @param {!(string|Integer)} n The nonce to set
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "setNonce",
+      value: function setNonce(n) {
+        this.svgElem_.setAttributeNS(NS.XMLNS, 'xmlns:se', NS.SE);
+        this.svgElem_.setAttributeNS(NS.SE, 'se:nonce', n);
+        this.nonce_ = n;
+      }
+      /**
+       * Clears any previously set nonce.
+       * @returns {undefined}
+       */
+
+    }, {
+      key: "clearNonce",
+      value: function clearNonce() {
+        // We deliberately leave any se:nonce attributes alone,
+        // we just don't use it to randomize ids.
+        this.nonce_ = '';
+      }
+      /**
+       * Returns the latest object id as a string.
+       * @returns {string} The latest object Id.
+       */
+
+    }, {
+      key: "getId",
+      value: function getId() {
+        return this.nonce_ ? this.idPrefix + this.nonce_ + '_' + this.obj_num : this.idPrefix + this.obj_num;
+      }
+      /**
+       * Returns the next object Id as a string.
+       * @returns {string} The next object Id to use.
+       */
+
+    }, {
+      key: "getNextId",
+      value: function getNextId() {
+        var oldObjNum = this.obj_num;
+        var restoreOldObjNum = false; // If there are any released numbers in the release stack,
+        // use the last one instead of the next obj_num.
+        // We need to temporarily use obj_num as that is what getId() depends on.
+
+        if (this.releasedNums.length > 0) {
+          this.obj_num = this.releasedNums.pop();
+          restoreOldObjNum = true;
+        } else {
+          // If we are not using a released id, then increment the obj_num.
+          this.obj_num++;
+        } // Ensure the ID does not exist.
+
+
+        var id = this.getId();
+
+        while (this.getElem_(id)) {
+          if (restoreOldObjNum) {
+            this.obj_num = oldObjNum;
+            restoreOldObjNum = false;
+          }
+
+          this.obj_num++;
+          id = this.getId();
+        } // Restore the old object number if required.
+
+
+        if (restoreOldObjNum) {
+          this.obj_num = oldObjNum;
+        }
+
+        return id;
+      }
+      /**
+       * Releases the object Id, letting it be used as the next id in getNextId().
+       * This method DOES NOT remove any elements from the DOM, it is expected
+       * that client code will do this.
+       * @param {string} id - The id to release.
+       * @returns {boolean} True if the id was valid to be released, false otherwise.
+      */
+
+    }, {
+      key: "releaseId",
+      value: function releaseId(id) {
+        // confirm if this is a valid id for this Document, else return false
+        var front = this.idPrefix + (this.nonce_ ? this.nonce_ + '_' : '');
+
+        if (typeof id !== 'string' || !id.startsWith(front)) {
+          return false;
+        } // extract the obj_num of this id
+
+
+        var num = parseInt(id.substr(front.length)); // if we didn't get a positive number or we already released this number
+        // then return false.
+
+        if (typeof num !== 'number' || num <= 0 || this.releasedNums.includes(num)) {
+          return false;
+        } // push the released number into the released queue
+
+
+        this.releasedNums.push(num);
+        return true;
+      }
+      /**
+       * Returns the number of layers in the current drawing.
+       * @returns {Integer} The number of layers in the current drawing.
+      */
+
+    }, {
+      key: "getNumLayers",
+      value: function getNumLayers() {
+        return this.all_layers.length;
+      }
+      /**
+       * Check if layer with given name already exists.
+       * @param {string} name - The layer name to check
+       * @returns {boolean}
+      */
+
+    }, {
+      key: "hasLayer",
+      value: function hasLayer(name) {
+        return this.layer_map[name] !== undefined;
+      }
+      /**
+       * Returns the name of the ith layer. If the index is out of range, an empty string is returned.
+       * @param {Integer} i - The zero-based index of the layer you are querying.
+       * @returns {string} The name of the ith layer (or the empty string if none found)
+      */
+
+    }, {
+      key: "getLayerName",
+      value: function getLayerName(i) {
+        return i >= 0 && i < this.getNumLayers() ? this.all_layers[i].getName() : '';
+      }
+      /**
+       * @returns {SVGGElement|null} The SVGGElement representing the current layer.
+       */
+
+    }, {
+      key: "getCurrentLayer",
+      value: function getCurrentLayer() {
+        return this.current_layer ? this.current_layer.getGroup() : null;
+      }
+      /**
+       * Get a layer by name.
+       * @param {string} name
+       * @returns {SVGGElement} The SVGGElement representing the named layer or null.
+       */
+
+    }, {
+      key: "getLayerByName",
+      value: function getLayerByName(name) {
+        var layer = this.layer_map[name];
+        return layer ? layer.getGroup() : null;
+      }
+      /**
+       * Returns the name of the currently selected layer. If an error occurs, an empty string
+       * is returned.
+       * @returns {string} The name of the currently active layer (or the empty string if none found).
+      */
+
+    }, {
+      key: "getCurrentLayerName",
+      value: function getCurrentLayerName() {
+        return this.current_layer ? this.current_layer.getName() : '';
+      }
+      /**
+       * Set the current layer's name.
+       * @param {string} name - The new name.
+       * @param {module:history.HistoryRecordingService} hrService - History recording service
+       * @returns {string|null} The new name if changed; otherwise, null.
+       */
+
+    }, {
+      key: "setCurrentLayerName",
+      value: function setCurrentLayerName(name, hrService) {
+        var finalName = null;
+
+        if (this.current_layer) {
+          var oldName = this.current_layer.getName();
+          finalName = this.current_layer.setName(name, hrService);
+
+          if (finalName) {
+            delete this.layer_map[oldName];
+            this.layer_map[finalName] = this.current_layer;
+          }
+        }
+
+        return finalName;
+      }
+      /**
+       * Set the current layer's position.
+       * @param {Integer} newpos - The zero-based index of the new position of the layer. Range should be 0 to layers-1
+       * @returns {{title: SVGGElement, previousName: string}|null} If the name was changed, returns {title:SVGGElement, previousName:string}; otherwise null.
+       */
+
+    }, {
+      key: "setCurrentLayerPosition",
+      value: function setCurrentLayerPosition(newpos) {
+        var layerCount = this.getNumLayers();
+
+        if (!this.current_layer || newpos < 0 || newpos >= layerCount) {
+          return null;
+        }
+
+        var oldpos;
+
+        for (oldpos = 0; oldpos < layerCount; ++oldpos) {
+          if (this.all_layers[oldpos] === this.current_layer) {
+            break;
+          }
+        } // some unknown error condition (current_layer not in all_layers)
+
+
+        if (oldpos === layerCount) {
+          return null;
+        }
+
+        if (oldpos !== newpos) {
+          // if our new position is below us, we need to insert before the node after newpos
+          var currentGroup = this.current_layer.getGroup();
+          var oldNextSibling = currentGroup.nextSibling;
+          var refGroup = null;
+
+          if (newpos > oldpos) {
+            if (newpos < layerCount - 1) {
+              refGroup = this.all_layers[newpos + 1].getGroup();
+            } // if our new position is above us, we need to insert before the node at newpos
+
+          } else {
+            refGroup = this.all_layers[newpos].getGroup();
+          }
+
+          this.svgElem_.insertBefore(currentGroup, refGroup); // Ok to replace with `refGroup.before(currentGroup);`?
+
+          this.identifyLayers();
+          this.setCurrentLayer(this.getLayerName(newpos));
+          return {
+            currentGroup: currentGroup,
+            oldNextSibling: oldNextSibling
+          };
+        }
+
+        return null;
+      }
+      /**
+      * @param {module:history.HistoryRecordingService} hrService
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "mergeLayer",
+      value: function mergeLayer(hrService) {
+        var currentGroup = this.current_layer.getGroup();
+        var prevGroup = $$4(currentGroup).prev()[0];
+
+        if (!prevGroup) {
+          return;
+        }
+
+        hrService.startBatchCommand('Merge Layer');
+        var layerNextSibling = currentGroup.nextSibling;
+        hrService.removeElement(currentGroup, layerNextSibling, this.svgElem_);
+
+        while (currentGroup.firstChild) {
+          var child = currentGroup.firstChild;
+
+          if (child.localName === 'title') {
+            hrService.removeElement(child, child.nextSibling, currentGroup);
+            child.remove();
+            continue;
+          }
+
+          var oldNextSibling = child.nextSibling;
+          prevGroup.append(child);
+          hrService.moveElement(child, oldNextSibling, currentGroup);
+        } // Remove current layer's group
+
+
+        this.current_layer.removeGroup(); // Remove the current layer and set the previous layer as the new current layer
+
+        var index = this.all_layers.indexOf(this.current_layer);
+
+        if (index > 0) {
+          var _name = this.current_layer.getName();
+
+          this.current_layer = this.all_layers[index - 1];
+          this.all_layers.splice(index, 1);
+          delete this.layer_map[_name];
+        }
+
+        hrService.endBatchCommand();
+      }
+      /**
+      * @param {module:history.HistoryRecordingService} hrService
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "mergeAllLayers",
+      value: function mergeAllLayers(hrService) {
+        // Set the current layer to the last layer.
+        this.current_layer = this.all_layers[this.all_layers.length - 1];
+        hrService.startBatchCommand('Merge all Layers');
+
+        while (this.all_layers.length > 1) {
+          this.mergeLayer(hrService);
+        }
+
+        hrService.endBatchCommand();
+      }
+      /**
+       * Sets the current layer. If the name is not a valid layer name, then this
+       * function returns `false`. Otherwise it returns `true`. This is not an
+       * undo-able action.
+       * @param {string} name - The name of the layer you want to switch to.
+       * @returns {boolean} `true` if the current layer was switched, otherwise `false`
+       */
+
+    }, {
+      key: "setCurrentLayer",
+      value: function setCurrentLayer(name) {
+        var layer = this.layer_map[name];
+
+        if (layer) {
+          if (this.current_layer) {
+            this.current_layer.deactivate();
+          }
+
+          this.current_layer = layer;
+          this.current_layer.activate();
+          return true;
+        }
+
+        return false;
+      }
+      /**
+       * Deletes the current layer from the drawing and then clears the selection.
+       * This function then calls the 'changed' handler.  This is an undoable action.
+       * @todo Does this actually call the 'changed' handler?
+       * @returns {SVGGElement} The SVGGElement of the layer removed or null.
+       */
+
+    }, {
+      key: "deleteCurrentLayer",
+      value: function deleteCurrentLayer() {
+        if (this.current_layer && this.getNumLayers() > 1) {
+          var oldLayerGroup = this.current_layer.removeGroup();
+          this.identifyLayers();
+          return oldLayerGroup;
+        }
+
+        return null;
+      }
+      /**
+       * Updates layer system and sets the current layer to the
+       * top-most layer (last `<g>` child of this drawing).
+       * @returns {undefined}
+      */
+
+    }, {
+      key: "identifyLayers",
+      value: function identifyLayers() {
+        this.all_layers = [];
+        this.layer_map = {};
+        var numchildren = this.svgElem_.childNodes.length; // loop through all children of SVG element
+
+        var orphans = [],
+            layernames = [];
+        var layer = null;
+        var childgroups = false;
+
+        for (var i = 0; i < numchildren; ++i) {
+          var child = this.svgElem_.childNodes.item(i); // for each g, find its layer name
+
+          if (child && child.nodeType === 1) {
+            if (child.tagName === 'g') {
+              childgroups = true;
+
+              var _name2 = findLayerNameInGroup(child);
+
+              if (_name2) {
+                layernames.push(_name2);
+                layer = new Layer(_name2, child);
+                this.all_layers.push(layer);
+                this.layer_map[_name2] = layer;
+              } else {
+                // if group did not have a name, it is an orphan
+                orphans.push(child);
+              }
+            } else if (visElems$1.includes(child.nodeName)) {
+              // Child is "visible" (i.e. not a <title> or <defs> element), so it is an orphan
+              orphans.push(child);
+            }
+          }
+        } // If orphans or no layers found, create a new layer and add all the orphans to it
+
+
+        if (orphans.length > 0 || !childgroups) {
+          layer = new Layer(getNewLayerName(layernames), null, this.svgElem_);
+          layer.appendChildren(orphans);
+          this.all_layers.push(layer);
+          this.layer_map[name] = layer;
+        } else {
+          layer.activate();
+        }
+
+        this.current_layer = layer;
+      }
+      /**
+       * Creates a new top-level layer in the drawing with the given name and
+       * makes it the current layer.
+       * @param {string} name - The given name. If the layer name exists, a new name will be generated.
+       * @param {module:history.HistoryRecordingService} hrService - History recording service
+       * @returns {SVGGElement} The SVGGElement of the new layer, which is
+       *     also the current layer of this drawing.
+      */
+
+    }, {
+      key: "createLayer",
+      value: function createLayer(name, hrService) {
+        if (this.current_layer) {
+          this.current_layer.deactivate();
+        } // Check for duplicate name.
+
+
+        if (name === undefined || name === null || name === '' || this.layer_map[name]) {
+          name = getNewLayerName(Object.keys(this.layer_map));
+        } // Crate new layer and add to DOM as last layer
+
+
+        var layer = new Layer(name, null, this.svgElem_); // Like to assume hrService exists, but this is backwards compatible with old version of createLayer.
+
+        if (hrService) {
+          hrService.startBatchCommand('Create Layer');
+          hrService.insertElement(layer.getGroup());
+          hrService.endBatchCommand();
+        }
+
+        this.all_layers.push(layer);
+        this.layer_map[name] = layer;
+        this.current_layer = layer;
+        return layer.getGroup();
+      }
+      /**
+       * Creates a copy of the current layer with the given name and makes it the current layer.
+       * @param {string} name - The given name. If the layer name exists, a new name will be generated.
+       * @param {module:history.HistoryRecordingService} hrService - History recording service
+       * @returns {SVGGElement} The SVGGElement of the new layer, which is
+       *     also the current layer of this drawing.
+      */
+
+    }, {
+      key: "cloneLayer",
+      value: function cloneLayer(name, hrService) {
+        if (!this.current_layer) {
+          return null;
+        }
+
+        this.current_layer.deactivate(); // Check for duplicate name.
+
+        if (name === undefined || name === null || name === '' || this.layer_map[name]) {
+          name = getNewLayerName(Object.keys(this.layer_map));
+        } // Create new group and add to DOM just after current_layer
+
+
+        var currentGroup = this.current_layer.getGroup();
+        var layer = new Layer(name, currentGroup, this.svgElem_);
+        var group = layer.getGroup(); // Clone children
+
+        var children = currentGroup.childNodes;
+
+        for (var _index = 0; _index < children.length; _index++) {
+          var ch = children[_index];
+
+          if (ch.localName === 'title') {
+            continue;
+          }
+
+          group.append(this.copyElem(ch));
+        }
+
+        if (hrService) {
+          hrService.startBatchCommand('Duplicate Layer');
+          hrService.insertElement(group);
+          hrService.endBatchCommand();
+        } // Update layer containers and current_layer.
+
+
+        var index = this.all_layers.indexOf(this.current_layer);
+
+        if (index >= 0) {
+          this.all_layers.splice(index + 1, 0, layer);
+        } else {
+          this.all_layers.push(layer);
+        }
+
+        this.layer_map[name] = layer;
+        this.current_layer = layer;
+        return group;
+      }
+      /**
+       * Returns whether the layer is visible.  If the layer name is not valid,
+       * then this function returns `false`.
+       * @param {string} layerName - The name of the layer which you want to query.
+       * @returns {boolean} The visibility state of the layer, or `false` if the layer name was invalid.
+      */
+
+    }, {
+      key: "getLayerVisibility",
+      value: function getLayerVisibility(layerName) {
+        var layer = this.layer_map[layerName];
+        return layer ? layer.isVisible() : false;
+      }
+      /**
+       * Sets the visibility of the layer. If the layer name is not valid, this
+       * function returns `null`, otherwise it returns the `SVGElement` representing
+       * the layer. This is an undo-able action.
+       * @param {string} layerName - The name of the layer to change the visibility
+       * @param {boolean} bVisible - Whether the layer should be visible
+       * @returns {?SVGGElement} The SVGGElement representing the layer if the
+       *   `layerName` was valid, otherwise `null`.
+      */
+
+    }, {
+      key: "setLayerVisibility",
+      value: function setLayerVisibility(layerName, bVisible) {
+        if (typeof bVisible !== 'boolean') {
+          return null;
+        }
+
+        var layer = this.layer_map[layerName];
+
+        if (!layer) {
+          return null;
+        }
+
+        layer.setVisible(bVisible);
+        return layer.getGroup();
+      }
+      /**
+       * Returns the opacity of the given layer.  If the input name is not a layer, `null` is returned.
+       * @param {string} layerName - name of the layer on which to get the opacity
+       * @returns {?Float} The opacity value of the given layer.  This will be a value between 0.0 and 1.0, or `null`
+       * if `layerName` is not a valid layer
+      */
+
+    }, {
+      key: "getLayerOpacity",
+      value: function getLayerOpacity(layerName) {
+        var layer = this.layer_map[layerName];
+
+        if (!layer) {
+          return null;
+        }
+
+        return layer.getOpacity();
+      }
+      /**
+       * Sets the opacity of the given layer.  If the input name is not a layer,
+       * nothing happens. If opacity is not a value between 0.0 and 1.0, then
+       * nothing happens.
+       * NOTE: this function exists solely to apply a highlighting/de-emphasis
+       * effect to a layer. When it is possible for a user to affect the opacity
+       * of a layer, we will need to allow this function to produce an undo-able
+       * action.
+       * @param {string} layerName - Name of the layer on which to set the opacity
+       * @param {Float} opacity - A float value in the range 0.0-1.0
+       * @returns {undefined}
+      */
+
+    }, {
+      key: "setLayerOpacity",
+      value: function setLayerOpacity(layerName, opacity) {
+        if (typeof opacity !== 'number' || opacity < 0.0 || opacity > 1.0) {
+          return;
+        }
+
+        var layer = this.layer_map[layerName];
+
+        if (layer) {
+          layer.setOpacity(opacity);
+        }
+      }
+      /**
+       * Create a clone of an element, updating its ID and its children's IDs when needed.
+       * @param {Element} el - DOM element to clone
+       * @returns {Element}
+       */
+
+    }, {
+      key: "copyElem",
+      value: function copyElem$$1(el) {
+        var that = this;
+
+        var getNextIdClosure = function getNextIdClosure() {
+          return that.getNextId();
+        };
+
+        return copyElem(el, getNextIdClosure);
+      }
+    }]);
+
+    return Drawing;
+  }();
+  /**
+   * Called to ensure that drawings will or will not have randomized ids.
+   * The currentDrawing will have its nonce set if it doesn't already.
+   * @function module:draw.randomizeIds
+   * @param {boolean} enableRandomization - flag indicating if documents should have randomized ids
+   * @param {draw.Drawing} currentDrawing
+   * @returns {undefined}
+   */
+
+  var randomizeIds = function randomizeIds(enableRandomization, currentDrawing) {
+    randIds = enableRandomization === false ? RandomizeModes.NEVER_RANDOMIZE : RandomizeModes.ALWAYS_RANDOMIZE;
+
+    if (randIds === RandomizeModes.ALWAYS_RANDOMIZE && !currentDrawing.getNonce()) {
+      currentDrawing.setNonce(Math.floor(Math.random() * 100001));
+    } else if (randIds === RandomizeModes.NEVER_RANDOMIZE && currentDrawing.getNonce()) {
+      currentDrawing.clearNonce();
+    }
+  }; // Layer API Functions
+
+  /**
+  * Group: Layers
+  */
+
+  /**
+   * @see {@link https://api.jquery.com/jQuery.data/}
+   * @name external:jQuery.data
+   */
+
+  /**
+   * @interface module:draw.DrawCanvasInit
+   * @property {module:path.pathActions} pathActions
+   * @property {external:jQuery.data} elData
+   * @property {module:history.UndoManager} undoMgr
+   */
+
+  /**
+   * @function module:draw.DrawCanvasInit#getCurrentGroup
+   * @returns {Element}
+   */
+
+  /**
+   * @function module:draw.DrawCanvasInit#setCurrentGroup
+   * @param {Element} cg
+   * @returns {undefined}
+  */
+
+  /**
+   * @function module:draw.DrawCanvasInit#getSelectedElements
+   * @returns {Element[]} the array with selected DOM elements
+  */
+
+  /**
+   * @function module:draw.DrawCanvasInit#getSVGContent
+   * @returns {SVGSVGElement}
+   */
+
+  /**
+   * @function module:draw.DrawCanvasInit#getCurrentDrawing
+   * @returns {module:draw.Drawing}
+   */
+
+  /**
+   * @function module:draw.DrawCanvasInit#clearSelection
+   * @param {boolean} [noCall] - When `true`, does not call the "selected" handler
+   * @returns {undefined}
+  */
+
+  /**
+   * Run the callback function associated with the given event
+   * @function module:draw.DrawCanvasInit#call
+   * @param {"changed"|"contextset"} ev - String with the event name
+   * @param {module:svgcanvas.SvgCanvas#event:changed|module:svgcanvas.SvgCanvas#event:contextset} arg - Argument to pass through to the callback
+   * function. If the event is "changed", a (single-item) array of `Element`s is
+   * passed. If the event is "contextset", the arg is `null` or `Element`.
+   * @returns {undefined}
+   */
+
+  /**
+   * @function module:draw.DrawCanvasInit#addCommandToHistory
+   * @param {Command} cmd
+   * @returns {undefined}
+  */
+
+  /**
+   * @function module:draw.DrawCanvasInit#changeSVGContent
+   * @returns {undefined}
+   */
+
+  var canvas_;
+  /**
+  * @function module:draw.init
+  * @param {module:draw.DrawCanvasInit} canvas
+  * @returns {undefined}
+  */
+
+  var init$3 = function init(canvas) {
+    canvas_ = canvas;
+  };
+  /**
+  * Updates layer system.
+  * @function module:draw.identifyLayers
+  * @returns {undefined}
+  */
+
+  var identifyLayers = function identifyLayers() {
+    leaveContext();
+    canvas_.getCurrentDrawing().identifyLayers();
+  };
+  /**
+  * Creates a new top-level layer in the drawing with the given name, sets the current layer
+  * to it, and then clears the selection. This function then calls the 'changed' handler.
+  * This is an undoable action.
+  * @function module:draw.createLayer
+  * @param {string} name - The given name
+  * @param {module:history.HistoryRecordingService} hrService
+  * @fires module:svgcanvas.SvgCanvas#event:changed
+  * @returns {undefined}
+  */
+
+  var createLayer = function createLayer(name, hrService) {
+    var newLayer = canvas_.getCurrentDrawing().createLayer(name, historyRecordingService(hrService));
+    canvas_.clearSelection();
+    canvas_.call('changed', [newLayer]);
+  };
+  /**
+   * Creates a new top-level layer in the drawing with the given name, copies all the current layer's contents
+   * to it, and then clears the selection. This function then calls the 'changed' handler.
+   * This is an undoable action.
+   * @function module:draw.cloneLayer
+   * @param {string} name - The given name. If the layer name exists, a new name will be generated.
+   * @param {module:history.HistoryRecordingService} hrService - History recording service
+   * @fires module:svgcanvas.SvgCanvas#event:changed
+   * @returns {undefined}
+   */
+
+  var cloneLayer = function cloneLayer(name, hrService) {
+    // Clone the current layer and make the cloned layer the new current layer
+    var newLayer = canvas_.getCurrentDrawing().cloneLayer(name, historyRecordingService(hrService));
+    canvas_.clearSelection();
+    leaveContext();
+    canvas_.call('changed', [newLayer]);
+  };
+  /**
+  * Deletes the current layer from the drawing and then clears the selection. This function
+  * then calls the 'changed' handler. This is an undoable action.
+  * @function module:draw.deleteCurrentLayer
+  * @fires module:svgcanvas.SvgCanvas#event:changed
+  * @returns {boolean} `true` if an old layer group was found to delete
+  */
+
+  var deleteCurrentLayer = function deleteCurrentLayer() {
+    var currentLayer = canvas_.getCurrentDrawing().getCurrentLayer();
+    var _currentLayer = currentLayer,
+        nextSibling = _currentLayer.nextSibling;
+    var parent = currentLayer.parentNode;
+    currentLayer = canvas_.getCurrentDrawing().deleteCurrentLayer();
+
+    if (currentLayer) {
+      var batchCmd = new BatchCommand('Delete Layer'); // store in our Undo History
+
+      batchCmd.addSubCommand(new RemoveElementCommand(currentLayer, nextSibling, parent));
+      canvas_.addCommandToHistory(batchCmd);
+      canvas_.clearSelection();
+      canvas_.call('changed', [parent]);
+      return true;
+    }
+
+    return false;
+  };
+  /**
+  * Sets the current layer. If the name is not a valid layer name, then this function returns
+  * false. Otherwise it returns true. This is not an undo-able action.
+  * @function module:draw.setCurrentLayer
+  * @param {string} name - The name of the layer you want to switch to.
+  * @returns {boolean} true if the current layer was switched, otherwise false
+  */
+
+  var setCurrentLayer = function setCurrentLayer(name) {
+    var result = canvas_.getCurrentDrawing().setCurrentLayer(toXml(name));
+
+    if (result) {
+      canvas_.clearSelection();
+    }
+
+    return result;
+  };
+  /**
+  * Renames the current layer. If the layer name is not valid (i.e. unique), then this function
+  * does nothing and returns `false`, otherwise it returns `true`. This is an undo-able action.
+  * @function module:draw.renameCurrentLayer
+  * @param {string} newName - the new name you want to give the current layer. This name must
+  * be unique among all layer names.
+  * @fires module:svgcanvas.SvgCanvas#event:changed
+  * @returns {boolean} Whether the rename succeeded
+  */
+
+  var renameCurrentLayer = function renameCurrentLayer(newName) {
+    var drawing = canvas_.getCurrentDrawing();
+    var layer = drawing.getCurrentLayer();
+
+    if (layer) {
+      var result = drawing.setCurrentLayerName(newName, historyRecordingService());
+
+      if (result) {
+        canvas_.call('changed', [layer]);
+        return true;
+      }
+    }
+
+    return false;
+  };
+  /**
+  * Changes the position of the current layer to the new value. If the new index is not valid,
+  * this function does nothing and returns false, otherwise it returns true. This is an
+  * undo-able action.
+  * @function module:draw.setCurrentLayerPosition
+  * @param {Integer} newPos - The zero-based index of the new position of the layer. This should be between
+  * 0 and (number of layers - 1)
+  * @returns {boolean} `true` if the current layer position was changed, `false` otherwise.
+  */
+
+  var setCurrentLayerPosition = function setCurrentLayerPosition(newPos) {
+    var drawing = canvas_.getCurrentDrawing();
+    var result = drawing.setCurrentLayerPosition(newPos);
+
+    if (result) {
+      canvas_.addCommandToHistory(new MoveElementCommand(result.currentGroup, result.oldNextSibling, canvas_.getSVGContent()));
+      return true;
+    }
+
+    return false;
+  };
+  /**
+  * Sets the visibility of the layer. If the layer name is not valid, this function return
+  * `false`, otherwise it returns `true`. This is an undo-able action.
+  * @function module:draw.setLayerVisibility
+  * @param {string} layerName - The name of the layer to change the visibility
+  * @param {boolean} bVisible - Whether the layer should be visible
+  * @returns {boolean} true if the layer's visibility was set, false otherwise
+  */
+
+  var setLayerVisibility = function setLayerVisibility(layerName, bVisible) {
+    var drawing = canvas_.getCurrentDrawing();
+    var prevVisibility = drawing.getLayerVisibility(layerName);
+    var layer = drawing.setLayerVisibility(layerName, bVisible);
+
+    if (layer) {
+      var oldDisplay = prevVisibility ? 'inline' : 'none';
+      canvas_.addCommandToHistory(new ChangeElementCommand(layer, {
+        display: oldDisplay
+      }, 'Layer Visibility'));
+    } else {
+      return false;
+    }
+
+    if (layer === drawing.getCurrentLayer()) {
+      canvas_.clearSelection();
+      canvas_.pathActions.clear();
+    } // call('changed', [selected]);
+
+
+    return true;
+  };
+  /**
+  * Moves the selected elements to layerName. If the name is not a valid layer name, then `false`
+  * is returned. Otherwise it returns `true`. This is an undo-able action.
+  * @function module:draw.moveSelectedToLayer
+  * @param {string} layerName - The name of the layer you want to which you want to move the selected elements
+  * @returns {boolean} Whether the selected elements were moved to the layer.
+  */
+
+  var moveSelectedToLayer = function moveSelectedToLayer(layerName) {
+    // find the layer
+    var drawing = canvas_.getCurrentDrawing();
+    var layer = drawing.getLayerByName(layerName);
+
+    if (!layer) {
+      return false;
+    }
+
+    var batchCmd = new BatchCommand('Move Elements to Layer'); // loop for each selected element and move it
+
+    var selElems = canvas_.getSelectedElements();
+    var i = selElems.length;
+
+    while (i--) {
+      var elem = selElems[i];
+
+      if (!elem) {
+        continue;
+      }
+
+      var oldNextSibling = elem.nextSibling; // TODO: this is pretty brittle!
+
+      var oldLayer = elem.parentNode;
+      layer.append(elem);
+      batchCmd.addSubCommand(new MoveElementCommand(elem, oldNextSibling, oldLayer));
+    }
+
+    canvas_.addCommandToHistory(batchCmd);
+    return true;
+  };
+  /**
+  * @function module:draw.mergeLayer
+  * @param {module:history.HistoryRecordingService} hrService
+  * @returns {undefined}
+  */
+
+  var mergeLayer = function mergeLayer(hrService) {
+    canvas_.getCurrentDrawing().mergeLayer(historyRecordingService(hrService));
+    canvas_.clearSelection();
+    leaveContext();
+    canvas_.changeSVGContent();
+  };
+  /**
+  * @function module:draw.mergeAllLayers
+  * @param {module:history.HistoryRecordingService} hrService
+  * @returns {undefined}
+  */
+
+  var mergeAllLayers = function mergeAllLayers(hrService) {
+    canvas_.getCurrentDrawing().mergeAllLayers(historyRecordingService(hrService));
+    canvas_.clearSelection();
+    leaveContext();
+    canvas_.changeSVGContent();
+  };
+  /**
+  * Return from a group context to the regular kind, make any previously
+  * disabled elements enabled again.
+  * @function module:draw.leaveContext
+  * @fires module:svgcanvas.SvgCanvas#event:contextset
+  * @returns {undefined}
+  */
+
+  var leaveContext = function leaveContext() {
+    var len = disabledElems.length;
+
+    if (len) {
+      for (var i = 0; i < len; i++) {
+        var elem = disabledElems[i];
+        var orig = canvas_.elData(elem, 'orig_opac');
+
+        if (orig !== 1) {
+          elem.setAttribute('opacity', orig);
+        } else {
+          elem.removeAttribute('opacity');
+        }
+
+        elem.setAttribute('style', 'pointer-events: inherit');
+      }
+
+      disabledElems = [];
+      canvas_.clearSelection(true);
+      canvas_.call('contextset', null);
+    }
+
+    canvas_.setCurrentGroup(null);
+  };
+  /**
+  * Set the current context (for in-group editing).
+  * @function module:draw.setContext
+  * @param {Element} elem
+  * @fires module:svgcanvas.SvgCanvas#event:contextset
+  * @returns {undefined}
+  */
+
+  var setContext = function setContext(elem) {
+    leaveContext();
+
+    if (typeof elem === 'string') {
+      elem = getElem(elem);
+    } // Edit inside this group
+
+
+    canvas_.setCurrentGroup(elem); // Disable other elements
+
+    $$4(elem).parentsUntil('#svgcontent').andSelf().siblings().each(function () {
+      var opac = this.getAttribute('opacity') || 1; // Store the original's opacity
+
+      canvas_.elData(this, 'orig_opac', opac);
+      this.setAttribute('opacity', opac * 0.33);
+      this.setAttribute('style', 'pointer-events: none');
+      disabledElems.push(this);
+    });
+    canvas_.clearSelection();
+    canvas_.call('contextset', canvas_.getCurrentGroup());
+  };
+
+  var REVERSE_NS = getReverseNS(); // this defines which elements and attributes that we support
+
+  var svgWhiteList_ = {
+    // SVG Elements
+    a: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'mask', 'opacity', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'xlink:href', 'xlink:title'],
+    circle: ['class', 'clip-path', 'clip-rule', 'cx', 'cy', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'mask', 'opacity', 'r', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],
+    clipPath: ['class', 'clipPathUnits', 'id'],
+    defs: [],
+    style: ['type'],
+    desc: [],
+    ellipse: ['class', 'clip-path', 'clip-rule', 'cx', 'cy', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'mask', 'opacity', 'requiredFeatures', 'rx', 'ry', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],
+    feGaussianBlur: ['class', 'color-interpolation-filters', 'id', 'requiredFeatures', 'stdDeviation'],
+    filter: ['class', 'color-interpolation-filters', 'filterRes', 'filterUnits', 'height', 'id', 'primitiveUnits', 'requiredFeatures', 'width', 'x', 'xlink:href', 'y'],
+    foreignObject: ['class', 'font-size', 'height', 'id', 'opacity', 'requiredFeatures', 'style', 'transform', 'width', 'x', 'y'],
+    g: ['class', 'clip-path', 'clip-rule', 'id', 'display', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'font-family', 'font-size', 'font-style', 'font-weight', 'text-anchor'],
+    image: ['class', 'clip-path', 'clip-rule', 'filter', 'height', 'id', 'mask', 'opacity', 'requiredFeatures', 'style', 'systemLanguage', 'transform', 'width', 'x', 'xlink:href', 'xlink:title', 'y'],
+    line: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'x1', 'x2', 'y1', 'y2'],
+    linearGradient: ['class', 'id', 'gradientTransform', 'gradientUnits', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'x1', 'x2', 'xlink:href', 'y1', 'y2'],
+    marker: ['id', 'class', 'markerHeight', 'markerUnits', 'markerWidth', 'orient', 'preserveAspectRatio', 'refX', 'refY', 'systemLanguage', 'viewBox'],
+    mask: ['class', 'height', 'id', 'maskContentUnits', 'maskUnits', 'width', 'x', 'y'],
+    metadata: ['class', 'id'],
+    path: ['class', 'clip-path', 'clip-rule', 'd', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],
+    pattern: ['class', 'height', 'id', 'patternContentUnits', 'patternTransform', 'patternUnits', 'requiredFeatures', 'style', 'systemLanguage', 'viewBox', 'width', 'x', 'xlink:href', 'y'],
+    polygon: ['class', 'clip-path', 'clip-rule', 'id', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'class', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'points', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],
+    polyline: ['class', 'clip-path', 'clip-rule', 'id', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'points', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],
+    radialGradient: ['class', 'cx', 'cy', 'fx', 'fy', 'gradientTransform', 'gradientUnits', 'id', 'r', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'xlink:href'],
+    rect: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'id', 'mask', 'opacity', 'requiredFeatures', 'rx', 'ry', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'width', 'x', 'y'],
+    stop: ['class', 'id', 'offset', 'requiredFeatures', 'stop-color', 'stop-opacity', 'style', 'systemLanguage'],
+    svg: ['class', 'clip-path', 'clip-rule', 'filter', 'id', 'height', 'mask', 'preserveAspectRatio', 'requiredFeatures', 'style', 'systemLanguage', 'viewBox', 'width', 'x', 'xmlns', 'xmlns:se', 'xmlns:xlink', 'y'],
+    switch: ['class', 'id', 'requiredFeatures', 'systemLanguage'],
+    symbol: ['class', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'id', 'opacity', 'preserveAspectRatio', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'viewBox'],
+    text: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'id', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'text-anchor', 'transform', 'x', 'xml:space', 'y'],
+    textPath: ['class', 'id', 'method', 'requiredFeatures', 'spacing', 'startOffset', 'style', 'systemLanguage', 'transform', 'xlink:href'],
+    title: [],
+    tspan: ['class', 'clip-path', 'clip-rule', 'dx', 'dy', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'id', 'mask', 'opacity', 'requiredFeatures', 'rotate', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'text-anchor', 'textLength', 'transform', 'x', 'xml:space', 'y'],
+    use: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'id', 'mask', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'transform', 'width', 'x', 'xlink:href', 'y'],
+    // MathML Elements
+    annotation: ['encoding'],
+    'annotation-xml': ['encoding'],
+    maction: ['actiontype', 'other', 'selection'],
+    math: ['class', 'id', 'display', 'xmlns'],
+    menclose: ['notation'],
+    merror: [],
+    mfrac: ['linethickness'],
+    mi: ['mathvariant'],
+    mmultiscripts: [],
+    mn: [],
+    mo: ['fence', 'lspace', 'maxsize', 'minsize', 'rspace', 'stretchy'],
+    mover: [],
+    mpadded: ['lspace', 'width', 'height', 'depth', 'voffset'],
+    mphantom: [],
+    mprescripts: [],
+    mroot: [],
+    mrow: ['xlink:href', 'xlink:type', 'xmlns:xlink'],
+    mspace: ['depth', 'height', 'width'],
+    msqrt: [],
+    mstyle: ['displaystyle', 'mathbackground', 'mathcolor', 'mathvariant', 'scriptlevel'],
+    msub: [],
+    msubsup: [],
+    msup: [],
+    mtable: ['align', 'columnalign', 'columnlines', 'columnspacing', 'displaystyle', 'equalcolumns', 'equalrows', 'frame', 'rowalign', 'rowlines', 'rowspacing', 'width'],
+    mtd: ['columnalign', 'columnspan', 'rowalign', 'rowspan'],
+    mtext: [],
+    mtr: ['columnalign', 'rowalign'],
+    munder: [],
+    munderover: [],
+    none: [],
+    semantics: []
+  }; // Produce a Namespace-aware version of svgWhitelist
+
+  var svgWhiteListNS_ = {};
+  Object.entries(svgWhiteList_).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+        elt = _ref2[0],
+        atts = _ref2[1];
+
+    var attNS = {};
+    Object.entries(atts).forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+          i = _ref4[0],
+          att = _ref4[1];
+
+      if (att.includes(':')) {
+        var v = att.split(':');
+        attNS[v[1]] = NS[v[0].toUpperCase()];
+      } else {
+        attNS[att] = att === 'xmlns' ? NS.XMLNS : null;
+      }
+    });
+    svgWhiteListNS_[elt] = attNS;
+  });
+  /**
+  * Sanitizes the input node and its children.
+  * It only keeps what is allowed from our whitelist defined above.
+  * @function module:sanitize.sanitizeSvg
+  * @param {Text|Element} node - The DOM element to be checked (we'll also check its children) or text node to be cleaned up
+  * @returns {undefined}
+  */
+
+  var sanitizeSvg = function sanitizeSvg(node) {
+    // Cleanup text nodes
+    if (node.nodeType === 3) {
+      // 3 === TEXT_NODE
+      // Trim whitespace
+      node.nodeValue = node.nodeValue.replace(/^\s+|\s+$/g, ''); // Remove if empty
+
+      if (!node.nodeValue.length) {
+        node.remove();
+      }
+    } // We only care about element nodes.
+    // Automatically return for all non-element nodes, such as comments, etc.
+
+
+    if (node.nodeType !== 1) {
+      // 1 == ELEMENT_NODE
+      return;
+    }
+
+    var doc = node.ownerDocument;
+    var parent = node.parentNode; // can parent ever be null here?  I think the root node's parent is the document...
+
+    if (!doc || !parent) {
+      return;
+    }
+
+    var allowedAttrs = svgWhiteList_[node.nodeName];
+    var allowedAttrsNS = svgWhiteListNS_[node.nodeName]; // if this element is supported, sanitize it
+
+    if (typeof allowedAttrs !== 'undefined') {
+      var seAttrs = [];
+      var i = node.attributes.length;
+
+      while (i--) {
+        // if the attribute is not in our whitelist, then remove it
+        // could use jQuery's inArray(), but I don't know if that's any better
+        var attr = node.attributes.item(i);
+        var attrName = attr.nodeName;
+        var attrLocalName = attr.localName;
+        var attrNsURI = attr.namespaceURI; // Check that an attribute with the correct localName in the correct namespace is on
+        // our whitelist or is a namespace declaration for one of our allowed namespaces
+
+        if (!({}.hasOwnProperty.call(allowedAttrsNS, attrLocalName) && attrNsURI === allowedAttrsNS[attrLocalName] && attrNsURI !== NS.XMLNS) && !(attrNsURI === NS.XMLNS && REVERSE_NS[attr.value])) {
+          // TODO(codedread): Programmatically add the se: attributes to the NS-aware whitelist.
+          // Bypassing the whitelist to allow se: prefixes.
+          // Is there a more appropriate way to do this?
+          if (attrName.startsWith('se:') || attrName.startsWith('data-')) {
+            seAttrs.push([attrName, attr.value]);
+          }
+
+          node.removeAttributeNS(attrNsURI, attrLocalName);
+        } // Add spaces before negative signs where necessary
+
+
+        if (isGecko()) {
+          switch (attrName) {
+            case 'transform':
+            case 'gradientTransform':
+            case 'patternTransform':
+              {
+                var val = attr.value.replace(/(\d)-/g, '$1 -');
+                node.setAttribute(attrName, val);
+                break;
+              }
+          }
+        } // For the style attribute, rewrite it in terms of XML presentational attributes
+
+
+        if (attrName === 'style') {
+          var props = attr.value.split(';');
+          var p = props.length;
+
+          while (p--) {
+            var _props$p$split = props[p].split(':'),
+                _props$p$split2 = _slicedToArray(_props$p$split, 2),
+                name = _props$p$split2[0],
+                _val = _props$p$split2[1];
+
+            var styleAttrName = (name || '').trim();
+
+            var styleAttrVal = (_val || '').trim(); // Now check that this attribute is supported
+
+
+            if (allowedAttrs.includes(styleAttrName)) {
+              node.setAttribute(styleAttrName, styleAttrVal);
+            }
+          }
+
+          node.removeAttribute('style');
+        }
+      }
+
+      Object.values(seAttrs).forEach(function (_ref5) {
+        var _ref6 = _slicedToArray(_ref5, 2),
+            att = _ref6[0],
+            val = _ref6[1];
+
+        node.setAttributeNS(NS.SE, att, val);
+      }); // for some elements that have a xlink:href, ensure the URI refers to a local element
+      // (but not for links)
+
+      var href = getHref(node);
+
+      if (href && ['filter', 'linearGradient', 'pattern', 'radialGradient', 'textPath', 'use'].includes(node.nodeName)) {
+        // TODO: we simply check if the first character is a #, is this bullet-proof?
+        if (href[0] !== '#') {
+          // remove the attribute (but keep the element)
+          setHref(node, '');
+          node.removeAttributeNS(NS.XLINK, 'href');
+        }
+      } // Safari crashes on a <use> without a xlink:href, so we just remove the node here
+
+
+      if (node.nodeName === 'use' && !getHref(node)) {
+        node.remove();
+        return;
+      } // if the element has attributes pointing to a non-local reference,
+      // need to remove the attribute
+
+
+      Object.values(['clip-path', 'fill', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'stroke'], function (attr) {
+        var val = node.getAttribute(attr);
+
+        if (val) {
+          val = getUrlFromAttr(val); // simply check for first character being a '#'
+
+          if (val && val[0] !== '#') {
+            node.setAttribute(attr, '');
+            node.removeAttribute(attr);
+          }
+        }
+      }); // recurse to children
+
+      i = node.childNodes.length;
+
+      while (i--) {
+        sanitizeSvg(node.childNodes.item(i));
+      } // else (element not supported), remove it
+
+    } else {
+      // remove all children from this node and insert them before this node
+      // FIXME: in the case of animation elements this will hardly ever be correct
+      var children = [];
+
+      while (node.hasChildNodes()) {
+        children.push(parent.insertBefore(node.firstChild, node));
+      } // remove this node from the document altogether
+
+
+      node.remove(); // call sanitizeSvg on each of those children
+
+      var _i = children.length;
+
+      while (_i--) {
+        sanitizeSvg(children[_i]);
+      }
+    }
+  };
+
+  // MIT License
+  // From: https://github.com/uupaa/dynamic-import-polyfill/blob/master/importModule.js
+
+  /**
+   * @module importModule
+   */
+
+  /**
+   * Converts a possible relative URL into an absolute one.
+   * @param {string} url
+   * @returns {string}
+   */
+  function toAbsoluteURL(url) {
+    var a = document.createElement('a');
+    a.setAttribute('href', url); // <a href="hoge.html">
+
+    return a.cloneNode(false).href; // -> "http://example.com/hoge.html"
+  }
+  /**
+   * Add any of the whitelisted attributes to the script tag.
+   * @param {HTMLScriptElement} script
+   * @param {PlainObject.<string, string>} atts
+   * @returns {undefined}
+   */
+
+
+  function addScriptAtts(script, atts) {
+    ['id', 'class', 'type'].forEach(function (prop) {
+      if (prop in atts) {
+        script[prop] = atts[prop];
+      }
+    });
+  } // Additions by Brett
+  /**
+  * @function module:importModule.importSetGlobal
+  * @param {string|string[]} url
+  * @param {module:importModule.ImportConfig} config
+  * @returns {Promise} The promise resolves to either an `ArbitraryModule` or
+  *   any other value depends on the export of the targeted module.
+  */
+
+  function importSetGlobal(_x, _x2) {
+    return _importSetGlobal.apply(this, arguments);
+  }
+  /**
+   *
+   * @author Brett Zamir (other items are from `dynamic-import-polyfill`)
+   * @param {string|string[]} url
+   * @param {PlainObject} [atts={}]
+   * @returns {Promise} Resolves to `undefined` or rejects with an `Error` upon a
+   *   script loading error
+   */
+
+  function _importSetGlobal() {
+    _importSetGlobal = _asyncToGenerator(
+    /*#__PURE__*/
+    regeneratorRuntime.mark(function _callee(url, _ref) {
+      var glob, returnDefault, modularVersion;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              glob = _ref.global, returnDefault = _ref.returnDefault;
+              // Todo: Replace calls to this function with `import()` when supported
+              modularVersion = !('svgEditor' in window) || !window.svgEditor || window.svgEditor.modules !== false;
+
+              if (!modularVersion) {
+                _context.next = 4;
+                break;
+              }
+
+              return _context.abrupt("return", importModule(url, undefined, {
+                returnDefault: returnDefault
+              }));
+
+            case 4:
+              _context.next = 6;
+              return importScript(url);
+
+            case 6:
+              return _context.abrupt("return", window[glob]);
+
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+    return _importSetGlobal.apply(this, arguments);
+  }
+
+  function importScript(url) {
+    var atts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    if (Array.isArray(url)) {
+      return Promise.all(url.map(function (u) {
+        return importScript(u, atts);
+      }));
+    }
+
+    return new Promise(function (resolve, reject) {
+      // eslint-disable-line promise/avoid-new
+      var script = document.createElement('script');
+      /**
+       *
+       * @returns {undefined}
+       */
+
+      function scriptOnError() {
+        reject(new Error("Failed to import: ".concat(url)));
+        destructor();
+      }
+      /**
+       *
+       * @returns {undefined}
+       */
+
+
+      function scriptOnLoad() {
+        resolve();
+        destructor();
+      }
+
+      var destructor = function destructor() {
+        script.removeEventListener('error', scriptOnError);
+        script.removeEventListener('load', scriptOnLoad);
+        script.remove();
+        script.src = '';
+      };
+
+      script.defer = 'defer';
+      addScriptAtts(script, atts);
+      script.addEventListener('error', scriptOnError);
+      script.addEventListener('load', scriptOnLoad);
+      script.src = url;
+      document.head.append(script);
+    });
+  }
+  /**
+   *
+   * @param {string|string[]} url
+   * @param {PlainObject} [atts={}]
+   * @param {PlainObject} opts
+   * @param {boolean} [opts.returnDefault=false} = {}]
+   * @returns {Promise} Resolves to value of loading module or rejects with
+   *   `Error` upon a script loading error.
+   */
+
+  function importModule(url) {
+    var atts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+        _ref2$returnDefault = _ref2.returnDefault,
+        returnDefault = _ref2$returnDefault === void 0 ? false : _ref2$returnDefault;
+
+    if (Array.isArray(url)) {
+      return Promise.all(url.map(function (u) {
+        return importModule(u, atts);
+      }));
+    }
+
+    return new Promise(function (resolve, reject) {
+      // eslint-disable-line promise/avoid-new
+      var vector = '$importModule$' + Math.random().toString(32).slice(2);
+      var script = document.createElement('script');
+      /**
+       *
+       * @returns {undefined}
+       */
+
+      function scriptOnError() {
+        reject(new Error("Failed to import: ".concat(url)));
+        destructor();
+      }
+      /**
+       *
+       * @returns {undefined}
+       */
+
+
+      function scriptOnLoad() {
+        resolve(window[vector]);
+        destructor();
+      }
+
+      var destructor = function destructor() {
+        delete window[vector];
+        script.removeEventListener('error', scriptOnError);
+        script.removeEventListener('load', scriptOnLoad);
+        script.remove();
+        URL.revokeObjectURL(script.src);
+        script.src = '';
+      };
+
+      addScriptAtts(script, atts);
+      script.defer = 'defer';
+      script.type = 'module';
+      script.addEventListener('error', scriptOnError);
+      script.addEventListener('load', scriptOnLoad);
+      var absURL = toAbsoluteURL(url);
+      var loader = "import * as m from '".concat(absURL.replace(/'/g, "\\'"), "'; window.").concat(vector, " = ").concat(returnDefault ? 'm.default || ' : '', "m;"); // export Module
+
+      var blob = new Blob([loader], {
+        type: 'text/javascript'
+      });
+      script.src = URL.createObjectURL(blob);
+      document.head.append(script);
+    });
+  }
+
+  var $$5 = jQuery; // this is how we map paths to our preferred relative segment types
+
+  var pathMap$1 = [0, 'z', 'M', 'm', 'L', 'l', 'C', 'c', 'Q', 'q', 'A', 'a', 'H', 'h', 'V', 'v', 'S', 's', 'T', 't'];
+  /**
+   * @interface module:coords.EditorContext
+   */
+
+  /**
+   * @function module:coords.EditorContext#getGridSnapping
+   * @returns {boolean}
+   */
+
+  /**
+   * @function module:coords.EditorContext#getDrawing
+   * @returns {module:draw.Drawing}
+  */
+
+  /**
+   * @function module:coords.EditorContext#getSVGRoot
+   * @returns {SVGSVGElement}
+  */
+
+  var editorContext_$2 = null;
+  /**
+  * @function module:coords.init
+  * @param {module:coords.EditorContext} editorContext
+  * @returns {undefined}
+  */
+
+  var init$4 = function init(editorContext) {
+    editorContext_$2 = editorContext;
+  };
+  /**
+   * Applies coordinate changes to an element based on the given matrix.
+   * @function module:coords.remapElement
+   * @implements {module:path.EditorContext#remapElement}
+  */
+
+  var remapElement = function remapElement(selected, changes, m) {
+    var remap = function remap(x, y) {
+      return transformPoint(x, y, m);
+    },
+        scalew = function scalew(w) {
+      return m.a * w;
+    },
+        scaleh = function scaleh(h) {
+      return m.d * h;
+    },
+        doSnapping = editorContext_$2.getGridSnapping() && selected.parentNode.parentNode.localName === 'svg',
+        finishUp = function finishUp() {
+      if (doSnapping) {
+        Object.entries(changes).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+              o = _ref2[0],
+              value = _ref2[1];
+
+          changes[o] = snapToGrid(value);
+        });
+      }
+
+      assignAttributes(selected, changes, 1000, true);
+    },
+        box = getBBox(selected);
+
+    for (var i = 0; i < 2; i++) {
+      var type = i === 0 ? 'fill' : 'stroke';
+      var attrVal = selected.getAttribute(type);
+
+      if (attrVal && attrVal.startsWith('url(')) {
+        if (m.a < 0 || m.d < 0) {
+          var grad = getRefElem(attrVal);
+          var newgrad = grad.cloneNode(true);
+
+          if (m.a < 0) {
+            // flip x
+            var x1 = newgrad.getAttribute('x1');
+            var x2 = newgrad.getAttribute('x2');
+            newgrad.setAttribute('x1', -(x1 - 1));
+            newgrad.setAttribute('x2', -(x2 - 1));
+          }
+
+          if (m.d < 0) {
+            // flip y
+            var y1 = newgrad.getAttribute('y1');
+            var y2 = newgrad.getAttribute('y2');
+            newgrad.setAttribute('y1', -(y1 - 1));
+            newgrad.setAttribute('y2', -(y2 - 1));
+          }
+
+          newgrad.id = editorContext_$2.getDrawing().getNextId();
+          findDefs().append(newgrad);
+          selected.setAttribute(type, 'url(#' + newgrad.id + ')');
+        } // Not really working :(
+        // if (selected.tagName === 'path') {
+        //   reorientGrads(selected, m);
+        // }
+
+      }
+    }
+
+    var elName = selected.tagName;
+
+    if (elName === 'g' || elName === 'text' || elName === 'tspan' || elName === 'use') {
+      // if it was a translate, then just update x,y
+      if (m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && (m.e !== 0 || m.f !== 0)) {
+        // [T][M] = [M][T']
+        // therefore [T'] = [M_inv][T][M]
+        var existing = transformListToTransform(selected).matrix,
+            tNew = matrixMultiply(existing.inverse(), m, existing);
+        changes.x = parseFloat(changes.x) + tNew.e;
+        changes.y = parseFloat(changes.y) + tNew.f;
+      } else {
+        // we just absorb all matrices into the element and don't do any remapping
+        var chlist = getTransformList(selected);
+        var mt = editorContext_$2.getSVGRoot().createSVGTransform();
+        mt.setMatrix(matrixMultiply(transformListToTransform(chlist).matrix, m));
+        chlist.clear();
+        chlist.appendItem(mt);
+      }
+    } // now we have a set of changes and an applied reduced transform list
+    // we apply the changes directly to the DOM
+
+
+    switch (elName) {
+      case 'foreignObject':
+      case 'rect':
+      case 'image':
+        {
+          // Allow images to be inverted (give them matrix when flipped)
+          if (elName === 'image' && (m.a < 0 || m.d < 0)) {
+            // Convert to matrix
+            var _chlist = getTransformList(selected);
+
+            var _mt = editorContext_$2.getSVGRoot().createSVGTransform();
+
+            _mt.setMatrix(matrixMultiply(transformListToTransform(_chlist).matrix, m));
+
+            _chlist.clear();
+
+            _chlist.appendItem(_mt);
+          } else {
+            var pt1 = remap(changes.x, changes.y);
+            changes.width = scalew(changes.width);
+            changes.height = scaleh(changes.height);
+            changes.x = pt1.x + Math.min(0, changes.width);
+            changes.y = pt1.y + Math.min(0, changes.height);
+            changes.width = Math.abs(changes.width);
+            changes.height = Math.abs(changes.height);
+          }
+
+          finishUp();
+          break;
+        }
+
+      case 'ellipse':
+        {
+          var c = remap(changes.cx, changes.cy);
+          changes.cx = c.x;
+          changes.cy = c.y;
+          changes.rx = scalew(changes.rx);
+          changes.ry = scaleh(changes.ry);
+          changes.rx = Math.abs(changes.rx);
+          changes.ry = Math.abs(changes.ry);
+          finishUp();
+          break;
+        }
+
+      case 'circle':
+        {
+          var _c = remap(changes.cx, changes.cy);
+
+          changes.cx = _c.x;
+          changes.cy = _c.y; // take the minimum of the new selected box's dimensions for the new circle radius
+
+          var tbox = transformBox(box.x, box.y, box.width, box.height, m);
+          var w = tbox.tr.x - tbox.tl.x,
+              h = tbox.bl.y - tbox.tl.y;
+          changes.r = Math.min(w / 2, h / 2);
+
+          if (changes.r) {
+            changes.r = Math.abs(changes.r);
+          }
+
+          finishUp();
+          break;
+        }
+
+      case 'line':
+        {
+          var _pt = remap(changes.x1, changes.y1);
+
+          var pt2 = remap(changes.x2, changes.y2);
+          changes.x1 = _pt.x;
+          changes.y1 = _pt.y;
+          changes.x2 = pt2.x;
+          changes.y2 = pt2.y;
+        }
+      // Fallthrough
+
+      case 'text':
+      case 'tspan':
+      case 'use':
+        {
+          finishUp();
+          break;
+        }
+
+      case 'g':
+        {
+          var gsvg = $$5(selected).data('gsvg');
+
+          if (gsvg) {
+            assignAttributes(gsvg, changes, 1000, true);
+          }
+
+          break;
+        }
+
+      case 'polyline':
+      case 'polygon':
+        {
+          var len = changes.points.length;
+
+          for (var _i = 0; _i < len; ++_i) {
+            var pt = changes.points[_i];
+
+            var _remap = remap(pt.x, pt.y),
+                x = _remap.x,
+                y = _remap.y;
+
+            changes.points[_i].x = x;
+            changes.points[_i].y = y;
+          } // const len = changes.points.length;
+
+
+          var pstr = '';
+
+          for (var _i2 = 0; _i2 < len; ++_i2) {
+            var _pt2 = changes.points[_i2];
+            pstr += _pt2.x + ',' + _pt2.y + ' ';
+          }
+
+          selected.setAttribute('points', pstr);
+          break;
+        }
+
+      case 'path':
+        {
+          var segList = selected.pathSegList;
+          var _len = segList.numberOfItems;
+          changes.d = [];
+
+          for (var _i3 = 0; _i3 < _len; ++_i3) {
+            var seg = segList.getItem(_i3);
+            changes.d[_i3] = {
+              type: seg.pathSegType,
+              x: seg.x,
+              y: seg.y,
+              x1: seg.x1,
+              y1: seg.y1,
+              x2: seg.x2,
+              y2: seg.y2,
+              r1: seg.r1,
+              r2: seg.r2,
+              angle: seg.angle,
+              largeArcFlag: seg.largeArcFlag,
+              sweepFlag: seg.sweepFlag
+            };
+          }
+
+          _len = changes.d.length;
+          var firstseg = changes.d[0],
+              currentpt = remap(firstseg.x, firstseg.y);
+          changes.d[0].x = currentpt.x;
+          changes.d[0].y = currentpt.y;
+
+          for (var _i4 = 1; _i4 < _len; ++_i4) {
+            var _seg = changes.d[_i4];
+            var _type = _seg.type; // if absolute or first segment, we want to remap x, y, x1, y1, x2, y2
+            // if relative, we want to scalew, scaleh
+
+            if (_type % 2 === 0) {
+              // absolute
+              var thisx = _seg.x !== undefined ? _seg.x : currentpt.x,
+                  // for V commands
+              thisy = _seg.y !== undefined ? _seg.y : currentpt.y; // for H commands
+
+              var _pt3 = remap(thisx, thisy);
+
+              var _pt4 = remap(_seg.x1, _seg.y1);
+
+              var _pt5 = remap(_seg.x2, _seg.y2);
+
+              _seg.x = _pt3.x;
+              _seg.y = _pt3.y;
+              _seg.x1 = _pt4.x;
+              _seg.y1 = _pt4.y;
+              _seg.x2 = _pt5.x;
+              _seg.y2 = _pt5.y;
+              _seg.r1 = scalew(_seg.r1);
+              _seg.r2 = scaleh(_seg.r2);
+            } else {
+              // relative
+              _seg.x = scalew(_seg.x);
+              _seg.y = scaleh(_seg.y);
+              _seg.x1 = scalew(_seg.x1);
+              _seg.y1 = scaleh(_seg.y1);
+              _seg.x2 = scalew(_seg.x2);
+              _seg.y2 = scaleh(_seg.y2);
+              _seg.r1 = scalew(_seg.r1);
+              _seg.r2 = scaleh(_seg.r2);
+            }
+          } // for each segment
+
+
+          var dstr = '';
+          _len = changes.d.length;
+
+          for (var _i5 = 0; _i5 < _len; ++_i5) {
+            var _seg2 = changes.d[_i5];
+            var _type2 = _seg2.type;
+            dstr += pathMap$1[_type2];
+
+            switch (_type2) {
+              case 13: // relative horizontal line (h)
+
+              case 12:
+                // absolute horizontal line (H)
+                dstr += _seg2.x + ' ';
+                break;
+
+              case 15: // relative vertical line (v)
+
+              case 14:
+                // absolute vertical line (V)
+                dstr += _seg2.y + ' ';
+                break;
+
+              case 3: // relative move (m)
+
+              case 5: // relative line (l)
+
+              case 19: // relative smooth quad (t)
+
+              case 2: // absolute move (M)
+
+              case 4: // absolute line (L)
+
+              case 18:
+                // absolute smooth quad (T)
+                dstr += _seg2.x + ',' + _seg2.y + ' ';
+                break;
+
+              case 7: // relative cubic (c)
+
+              case 6:
+                // absolute cubic (C)
+                dstr += _seg2.x1 + ',' + _seg2.y1 + ' ' + _seg2.x2 + ',' + _seg2.y2 + ' ' + _seg2.x + ',' + _seg2.y + ' ';
+                break;
+
+              case 9: // relative quad (q)
+
+              case 8:
+                // absolute quad (Q)
+                dstr += _seg2.x1 + ',' + _seg2.y1 + ' ' + _seg2.x + ',' + _seg2.y + ' ';
+                break;
+
+              case 11: // relative elliptical arc (a)
+
+              case 10:
+                // absolute elliptical arc (A)
+                dstr += _seg2.r1 + ',' + _seg2.r2 + ' ' + _seg2.angle + ' ' + Number(_seg2.largeArcFlag) + ' ' + Number(_seg2.sweepFlag) + ' ' + _seg2.x + ',' + _seg2.y + ' ';
+                break;
+
+              case 17: // relative smooth cubic (s)
+
+              case 16:
+                // absolute smooth cubic (S)
+                dstr += _seg2.x2 + ',' + _seg2.y2 + ' ' + _seg2.x + ',' + _seg2.y + ' ';
+                break;
+            }
+          }
+
+          selected.setAttribute('d', dstr);
+          break;
+        }
+    }
+  };
+
+  /* globals jQuery */
+  var $$6 = jQueryPluginSVG(jQuery);
+  var context_;
+  /**
+  * @interface module:recalculate.EditorContext
+  */
+
+  /**
+   * @function module:recalculate.EditorContext#getSVGRoot
+   * @returns {SVGSVGElement} The root DOM element
+   */
+
+  /**
+   * @function module:recalculate.EditorContext#getStartTransform
+   * @returns {string}
+  */
+
+  /**
+   * @function module:recalculate.EditorContext#setStartTransform
+   * @param {string} transform
+   * @returns {undefined}
+   */
+
+  /**
+  * @function module:recalculate.init
+  * @param {module:recalculate.EditorContext} editorContext
+  * @returns {undefined}
+  */
+
+  var init$5 = function init$$1(editorContext) {
+    context_ = editorContext;
+  };
+  /**
+  * Updates a `<clipPath>`s values based on the given translation of an element.
+  * @function module:recalculate.updateClipPath
+  * @param {string} attr - The clip-path attribute value with the clipPath's ID
+  * @param {Float} tx - The translation's x value
+  * @param {Float} ty - The translation's y value
+  * @returns {undefined}
+  */
+
+  var updateClipPath = function updateClipPath(attr, tx, ty) {
+    var path = getRefElem(attr).firstChild;
+    var cpXform = getTransformList(path);
+    var newxlate = context_.getSVGRoot().createSVGTransform();
+    newxlate.setTranslate(tx, ty);
+    cpXform.appendItem(newxlate); // Update clipPath's dimensions
+
+    recalculateDimensions(path);
+  };
+  /**
+  * Decides the course of action based on the element's transform list.
+  * @function module:recalculate.recalculateDimensions
+  * @param {Element} selected - The DOM element to recalculate
+  * @returns {Command} Undo command object with the resulting change
+  */
+
+  var recalculateDimensions = function recalculateDimensions(selected) {
+    if (isNullish(selected)) {
+      return null;
+    } // Firefox Issue - 1081
+
+
+    if (selected.nodeName === 'svg' && navigator.userAgent.includes('Firefox/20')) {
+      return null;
+    }
+
+    var svgroot = context_.getSVGRoot();
+    var tlist = getTransformList(selected); // remove any unnecessary transforms
+
+    if (tlist && tlist.numberOfItems > 0) {
+      var k = tlist.numberOfItems;
+      var noi = k;
+
+      while (k--) {
+        var xform = tlist.getItem(k);
+
+        if (xform.type === 0) {
+          tlist.removeItem(k); // remove identity matrices
+        } else if (xform.type === 1) {
+          if (isIdentity(xform.matrix)) {
+            if (noi === 1) {
+              // Overcome Chrome bug (though only when noi is 1) with
+              //    `removeItem` preventing `removeAttribute` from
+              //    subsequently working
+              // See https://bugs.chromium.org/p/chromium/issues/detail?id=843901
+              selected.removeAttribute('transform');
+              return null;
+            }
+
+            tlist.removeItem(k);
+          } // remove zero-degree rotations
+
+        } else if (xform.type === 4) {
+          if (xform.angle === 0) {
+            tlist.removeItem(k);
+          }
+        }
+      } // End here if all it has is a rotation
+
+
+      if (tlist.numberOfItems === 1 && getRotationAngle(selected)) {
+        return null;
+      }
+    } // if this element had no transforms, we are done
+
+
+    if (!tlist || tlist.numberOfItems === 0) {
+      // Chrome apparently had a bug that requires clearing the attribute first.
+      selected.setAttribute('transform', ''); // However, this still next line currently doesn't work at all in Chrome
+
+      selected.removeAttribute('transform'); // selected.transform.baseVal.clear(); // Didn't help for Chrome bug
+
+      return null;
+    } // TODO: Make this work for more than 2
+
+
+    if (tlist) {
+      var mxs = [];
+      var _k = tlist.numberOfItems;
+
+      while (_k--) {
+        var _xform = tlist.getItem(_k);
+
+        if (_xform.type === 1) {
+          mxs.push([_xform.matrix, _k]);
+        } else if (mxs.length) {
+          mxs = [];
+        }
+      }
+
+      if (mxs.length === 2) {
+        var mNew = svgroot.createSVGTransformFromMatrix(matrixMultiply(mxs[1][0], mxs[0][0]));
+        tlist.removeItem(mxs[0][1]);
+        tlist.removeItem(mxs[1][1]);
+        tlist.insertItemBefore(mNew, mxs[1][1]);
+      } // combine matrix + translate
+
+
+      _k = tlist.numberOfItems;
+
+      if (_k >= 2 && tlist.getItem(_k - 2).type === 1 && tlist.getItem(_k - 1).type === 2) {
+        var mt = svgroot.createSVGTransform();
+        var m = matrixMultiply(tlist.getItem(_k - 2).matrix, tlist.getItem(_k - 1).matrix);
+        mt.setMatrix(m);
+        tlist.removeItem(_k - 2);
+        tlist.removeItem(_k - 2);
+        tlist.appendItem(mt);
+      }
+    } // If it still has a single [M] or [R][M], return null too (prevents BatchCommand from being returned).
+
+
+    switch (selected.tagName) {
+      // Ignore these elements, as they can absorb the [M]
+      case 'line':
+      case 'polyline':
+      case 'polygon':
+      case 'path':
+        break;
+
+      default:
+        if (tlist.numberOfItems === 1 && tlist.getItem(0).type === 1 || tlist.numberOfItems === 2 && tlist.getItem(0).type === 1 && tlist.getItem(0).type === 4) {
+          return null;
+        }
+
+    } // Grouped SVG element
+
+
+    var gsvg = $$6(selected).data('gsvg'); // we know we have some transforms, so set up return variable
+
+    var batchCmd = new BatchCommand('Transform'); // store initial values that will be affected by reducing the transform list
+
+    var changes = {};
+    var initial = null;
+    var attrs = [];
+
+    switch (selected.tagName) {
+      case 'line':
+        attrs = ['x1', 'y1', 'x2', 'y2'];
+        break;
+
+      case 'circle':
+        attrs = ['cx', 'cy', 'r'];
+        break;
+
+      case 'ellipse':
+        attrs = ['cx', 'cy', 'rx', 'ry'];
+        break;
+
+      case 'foreignObject':
+      case 'rect':
+      case 'image':
+        attrs = ['width', 'height', 'x', 'y'];
+        break;
+
+      case 'use':
+      case 'text':
+      case 'tspan':
+        attrs = ['x', 'y'];
+        break;
+
+      case 'polygon':
+      case 'polyline':
+        {
+          initial = {};
+          initial.points = selected.getAttribute('points');
+          var list = selected.points;
+          var len = list.numberOfItems;
+          changes.points = new Array(len);
+
+          for (var i = 0; i < len; ++i) {
+            var pt = list.getItem(i);
+            changes.points[i] = {
+              x: pt.x,
+              y: pt.y
+            };
+          }
+
+          break;
+        }
+
+      case 'path':
+        initial = {};
+        initial.d = selected.getAttribute('d');
+        changes.d = selected.getAttribute('d');
+        break;
+    } // switch on element type to get initial values
+
+
+    if (attrs.length) {
+      changes = $$6(selected).attr(attrs);
+      $$6.each(changes, function (attr, val) {
+        changes[attr] = convertToNum(attr, val);
+      });
+    } else if (gsvg) {
+      // GSVG exception
+      changes = {
+        x: $$6(gsvg).attr('x') || 0,
+        y: $$6(gsvg).attr('y') || 0
+      };
+    } // if we haven't created an initial array in polygon/polyline/path, then
+    // make a copy of initial values and include the transform
+
+
+    if (isNullish(initial)) {
+      initial = $$6.extend(true, {}, changes);
+      $$6.each(initial, function (attr, val) {
+        initial[attr] = convertToNum(attr, val);
+      });
+    } // save the start transform value too
+
+
+    initial.transform = context_.getStartTransform() || '';
+    var oldcenter, newcenter; // if it's a regular group, we have special processing to flatten transforms
+
+    if (selected.tagName === 'g' && !gsvg || selected.tagName === 'a') {
+      var box = getBBox(selected);
+      oldcenter = {
+        x: box.x + box.width / 2,
+        y: box.y + box.height / 2
+      };
+      newcenter = transformPoint(box.x + box.width / 2, box.y + box.height / 2, transformListToTransform(tlist).matrix); // let m = svgroot.createSVGMatrix();
+      // temporarily strip off the rotate and save the old center
+
+      var gangle = getRotationAngle(selected);
+
+      if (gangle) {
+        var a = gangle * Math.PI / 180;
+        var s;
+
+        if (Math.abs(a) > 1.0e-10) {
+          s = Math.sin(a) / (1 - Math.cos(a));
+        } else {
+          // FIXME: This blows up if the angle is exactly 0!
+          s = 2 / a;
+        }
+
+        for (var _i = 0; _i < tlist.numberOfItems; ++_i) {
+          var _xform2 = tlist.getItem(_i);
+
+          if (_xform2.type === 4) {
+            // extract old center through mystical arts
+            var rm = _xform2.matrix;
+            oldcenter.y = (s * rm.e + rm.f) / 2;
+            oldcenter.x = (rm.e - s * rm.f) / 2;
+            tlist.removeItem(_i);
+            break;
+          }
+        }
+      }
+
+      var N = tlist.numberOfItems;
+      var tx = 0,
+          ty = 0,
+          operation = 0;
+      var firstM;
+
+      if (N) {
+        firstM = tlist.getItem(0).matrix;
+      }
+
+      var oldStartTransform; // first, if it was a scale then the second-last transform will be it
+
+      if (N >= 3 && tlist.getItem(N - 2).type === 3 && tlist.getItem(N - 3).type === 2 && tlist.getItem(N - 1).type === 2) {
+        operation = 3; // scale
+        // if the children are unrotated, pass the scale down directly
+        // otherwise pass the equivalent matrix() down directly
+
+        var tm = tlist.getItem(N - 3).matrix,
+            sm = tlist.getItem(N - 2).matrix,
+            tmn = tlist.getItem(N - 1).matrix;
+        var children = selected.childNodes;
+        var c = children.length;
+
+        while (c--) {
+          var child = children.item(c);
+          tx = 0;
+          ty = 0;
+
+          if (child.nodeType === 1) {
+            var childTlist = getTransformList(child); // some children might not have a transform (<metadata>, <defs>, etc)
+
+            if (!childTlist) {
+              continue;
+            }
+
+            var _m = transformListToTransform(childTlist).matrix; // Convert a matrix to a scale if applicable
+            // if (hasMatrixTransform(childTlist) && childTlist.numberOfItems == 1) {
+            //   if (m.b==0 && m.c==0 && m.e==0 && m.f==0) {
+            //     childTlist.removeItem(0);
+            //     const translateOrigin = svgroot.createSVGTransform(),
+            //       scale = svgroot.createSVGTransform(),
+            //       translateBack = svgroot.createSVGTransform();
+            //     translateOrigin.setTranslate(0, 0);
+            //     scale.setScale(m.a, m.d);
+            //     translateBack.setTranslate(0, 0);
+            //     childTlist.appendItem(translateBack);
+            //     childTlist.appendItem(scale);
+            //     childTlist.appendItem(translateOrigin);
+            //   }
+            // }
+
+            var angle = getRotationAngle(child);
+            oldStartTransform = context_.getStartTransform();
+            context_.setStartTransform(child.getAttribute('transform'));
+
+            if (angle || hasMatrixTransform(childTlist)) {
+              var e2t = svgroot.createSVGTransform();
+              e2t.setMatrix(matrixMultiply(tm, sm, tmn, _m));
+              childTlist.clear();
+              childTlist.appendItem(e2t);
+            } else {
+              // update the transform list with translate,scale,translate
+              // slide the [T][S][-T] from the front to the back
+              // [T][S][-T][M] = [M][T2][S2][-T2]
+              // (only bringing [-T] to the right of [M])
+              // [T][S][-T][M] = [T][S][M][-T2]
+              // [-T2] = [M_inv][-T][M]
+              var t2n = matrixMultiply(_m.inverse(), tmn, _m); // [T2] is always negative translation of [-T2]
+
+              var t2 = svgroot.createSVGMatrix();
+              t2.e = -t2n.e;
+              t2.f = -t2n.f; // [T][S][-T][M] = [M][T2][S2][-T2]
+              // [S2] = [T2_inv][M_inv][T][S][-T][M][-T2_inv]
+
+              var s2 = matrixMultiply(t2.inverse(), _m.inverse(), tm, sm, tmn, _m, t2n.inverse());
+              var translateOrigin = svgroot.createSVGTransform(),
+                  scale = svgroot.createSVGTransform(),
+                  translateBack = svgroot.createSVGTransform();
+              translateOrigin.setTranslate(t2n.e, t2n.f);
+              scale.setScale(s2.a, s2.d);
+              translateBack.setTranslate(t2.e, t2.f);
+              childTlist.appendItem(translateBack);
+              childTlist.appendItem(scale);
+              childTlist.appendItem(translateOrigin);
+              // logMatrix(scale.matrix);
+            } // not rotated
+
+
+            batchCmd.addSubCommand(recalculateDimensions(child)); // TODO: If any <use> have this group as a parent and are
+            // referencing this child, then we need to impose a reverse
+            // scale on it so that when it won't get double-translated
+            // const uses = selected.getElementsByTagNameNS(NS.SVG, 'use');
+            // const href = '#' + child.id;
+            // let u = uses.length;
+            // while (u--) {
+            //   const useElem = uses.item(u);
+            //   if (href == getHref(useElem)) {
+            //     const usexlate = svgroot.createSVGTransform();
+            //     usexlate.setTranslate(-tx,-ty);
+            //     getTransformList(useElem).insertItemBefore(usexlate,0);
+            //     batchCmd.addSubCommand( recalculateDimensions(useElem) );
+            //   }
+            // }
+
+            context_.setStartTransform(oldStartTransform);
+          } // element
+
+        } // for each child
+        // Remove these transforms from group
+
+
+        tlist.removeItem(N - 1);
+        tlist.removeItem(N - 2);
+        tlist.removeItem(N - 3);
+      } else if (N >= 3 && tlist.getItem(N - 1).type === 1) {
+        operation = 3; // scale
+
+        var _m2 = transformListToTransform(tlist).matrix;
+
+        var _e2t = svgroot.createSVGTransform();
+
+        _e2t.setMatrix(_m2);
+
+        tlist.clear();
+        tlist.appendItem(_e2t); // next, check if the first transform was a translate
+        // if we had [ T1 ] [ M ] we want to transform this into [ M ] [ T2 ]
+        // therefore [ T2 ] = [ M_inv ] [ T1 ] [ M ]
+      } else if ((N === 1 || N > 1 && tlist.getItem(1).type !== 3) && tlist.getItem(0).type === 2) {
+        operation = 2; // translate
+
+        var T_M = transformListToTransform(tlist).matrix;
+        tlist.removeItem(0);
+        var mInv = transformListToTransform(tlist).matrix.inverse();
+        var M2 = matrixMultiply(mInv, T_M);
+        tx = M2.e;
+        ty = M2.f;
+
+        if (tx !== 0 || ty !== 0) {
+          // we pass the translates down to the individual children
+          var _children = selected.childNodes;
+          var _c = _children.length;
+          var clipPathsDone = [];
+
+          while (_c--) {
+            var _child = _children.item(_c);
+
+            if (_child.nodeType === 1) {
+              // Check if child has clip-path
+              if (_child.getAttribute('clip-path')) {
+                // tx, ty
+                var attr = _child.getAttribute('clip-path');
+
+                if (!clipPathsDone.includes(attr)) {
+                  updateClipPath(attr, tx, ty);
+                  clipPathsDone.push(attr);
+                }
+              }
+
+              oldStartTransform = context_.getStartTransform();
+              context_.setStartTransform(_child.getAttribute('transform'));
+
+              var _childTlist = getTransformList(_child); // some children might not have a transform (<metadata>, <defs>, etc)
+
+
+              if (_childTlist) {
+                var newxlate = svgroot.createSVGTransform();
+                newxlate.setTranslate(tx, ty);
+
+                if (_childTlist.numberOfItems) {
+                  _childTlist.insertItemBefore(newxlate, 0);
+                } else {
+                  _childTlist.appendItem(newxlate);
+                }
+
+                batchCmd.addSubCommand(recalculateDimensions(_child)); // If any <use> have this group as a parent and are
+                // referencing this child, then impose a reverse translate on it
+                // so that when it won't get double-translated
+
+                var uses = selected.getElementsByTagNameNS(NS.SVG, 'use');
+                var href = '#' + _child.id;
+                var u = uses.length;
+
+                while (u--) {
+                  var useElem = uses.item(u);
+
+                  if (href === getHref(useElem)) {
+                    var usexlate = svgroot.createSVGTransform();
+                    usexlate.setTranslate(-tx, -ty);
+                    getTransformList(useElem).insertItemBefore(usexlate, 0);
+                    batchCmd.addSubCommand(recalculateDimensions(useElem));
+                  }
+                }
+
+                context_.setStartTransform(oldStartTransform);
+              }
+            }
+          }
+
+          context_.setStartTransform(oldStartTransform);
+        } // else, a matrix imposition from a parent group
+        // keep pushing it down to the children
+
+      } else if (N === 1 && tlist.getItem(0).type === 1 && !gangle) {
+        operation = 1;
+        var _m3 = tlist.getItem(0).matrix,
+            _children2 = selected.childNodes;
+        var _c2 = _children2.length;
+
+        while (_c2--) {
+          var _child2 = _children2.item(_c2);
+
+          if (_child2.nodeType === 1) {
+            oldStartTransform = context_.getStartTransform();
+            context_.setStartTransform(_child2.getAttribute('transform'));
+
+            var _childTlist2 = getTransformList(_child2);
+
+            if (!_childTlist2) {
+              continue;
+            }
+
+            var em = matrixMultiply(_m3, transformListToTransform(_childTlist2).matrix);
+            var e2m = svgroot.createSVGTransform();
+            e2m.setMatrix(em);
+
+            _childTlist2.clear();
+
+            _childTlist2.appendItem(e2m, 0);
+
+            batchCmd.addSubCommand(recalculateDimensions(_child2));
+            context_.setStartTransform(oldStartTransform); // Convert stroke
+            // TODO: Find out if this should actually happen somewhere else
+
+            var sw = _child2.getAttribute('stroke-width');
+
+            if (_child2.getAttribute('stroke') !== 'none' && !isNaN(sw)) {
+              var avg = (Math.abs(em.a) + Math.abs(em.d)) / 2;
+
+              _child2.setAttribute('stroke-width', sw * avg);
+            }
+          }
+        }
+
+        tlist.clear(); // else it was just a rotate
+      } else {
+        if (gangle) {
+          var newRot = svgroot.createSVGTransform();
+          newRot.setRotate(gangle, newcenter.x, newcenter.y);
+
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(newRot, 0);
+          } else {
+            tlist.appendItem(newRot);
+          }
+        }
+
+        if (tlist.numberOfItems === 0) {
+          selected.removeAttribute('transform');
+        }
+
+        return null;
+      } // if it was a translate, put back the rotate at the new center
+
+
+      if (operation === 2) {
+        if (gangle) {
+          newcenter = {
+            x: oldcenter.x + firstM.e,
+            y: oldcenter.y + firstM.f
+          };
+
+          var _newRot = svgroot.createSVGTransform();
+
+          _newRot.setRotate(gangle, newcenter.x, newcenter.y);
+
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(_newRot, 0);
+          } else {
+            tlist.appendItem(_newRot);
+          }
+        } // if it was a resize
+
+      } else if (operation === 3) {
+        var _m4 = transformListToTransform(tlist).matrix;
+        var roldt = svgroot.createSVGTransform();
+        roldt.setRotate(gangle, oldcenter.x, oldcenter.y);
+        var rold = roldt.matrix;
+        var rnew = svgroot.createSVGTransform();
+        rnew.setRotate(gangle, newcenter.x, newcenter.y);
+
+        var rnewInv = rnew.matrix.inverse(),
+            _mInv = _m4.inverse(),
+            extrat = matrixMultiply(_mInv, rnewInv, rold, _m4);
+
+        tx = extrat.e;
+        ty = extrat.f;
+
+        if (tx !== 0 || ty !== 0) {
+          // now push this transform down to the children
+          // we pass the translates down to the individual children
+          var _children3 = selected.childNodes;
+          var _c3 = _children3.length;
+
+          while (_c3--) {
+            var _child3 = _children3.item(_c3);
+
+            if (_child3.nodeType === 1) {
+              oldStartTransform = context_.getStartTransform();
+              context_.setStartTransform(_child3.getAttribute('transform'));
+
+              var _childTlist3 = getTransformList(_child3);
+
+              var _newxlate = svgroot.createSVGTransform();
+
+              _newxlate.setTranslate(tx, ty);
+
+              if (_childTlist3.numberOfItems) {
+                _childTlist3.insertItemBefore(_newxlate, 0);
+              } else {
+                _childTlist3.appendItem(_newxlate);
+              }
+
+              batchCmd.addSubCommand(recalculateDimensions(_child3));
+              context_.setStartTransform(oldStartTransform);
+            }
+          }
+        }
+
+        if (gangle) {
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(rnew, 0);
+          } else {
+            tlist.appendItem(rnew);
+          }
+        }
+      } // else, it's a non-group
+
+    } else {
+      // FIXME: box might be null for some elements (<metadata> etc), need to handle this
+      var _box = getBBox(selected); // Paths (and possbly other shapes) will have no BBox while still in <defs>,
+      // but we still may need to recalculate them (see issue 595).
+      // TODO: Figure out how to get BBox from these elements in case they
+      // have a rotation transform
+
+
+      if (!_box && selected.tagName !== 'path') return null;
+
+      var _m5; // = svgroot.createSVGMatrix();
+      // temporarily strip off the rotate and save the old center
+
+
+      var _angle = getRotationAngle(selected);
+
+      if (_angle) {
+        oldcenter = {
+          x: _box.x + _box.width / 2,
+          y: _box.y + _box.height / 2
+        };
+        newcenter = transformPoint(_box.x + _box.width / 2, _box.y + _box.height / 2, transformListToTransform(tlist).matrix);
+
+        var _a = _angle * Math.PI / 180;
+
+        var _s = Math.abs(_a) > 1.0e-10 ? Math.sin(_a) / (1 - Math.cos(_a)) // FIXME: This blows up if the angle is exactly 0!
+        : 2 / _a;
+
+        for (var _i2 = 0; _i2 < tlist.numberOfItems; ++_i2) {
+          var _xform3 = tlist.getItem(_i2);
+
+          if (_xform3.type === 4) {
+            // extract old center through mystical arts
+            var _rm = _xform3.matrix;
+            oldcenter.y = (_s * _rm.e + _rm.f) / 2;
+            oldcenter.x = (_rm.e - _s * _rm.f) / 2;
+            tlist.removeItem(_i2);
+            break;
+          }
+        }
+      } // 2 = translate, 3 = scale, 4 = rotate, 1 = matrix imposition
+
+
+      var _operation = 0;
+      var _N = tlist.numberOfItems; // Check if it has a gradient with userSpaceOnUse, in which case
+      // adjust it by recalculating the matrix transform.
+      // TODO: Make this work in Webkit using transformlist.SVGTransformList
+
+      if (!isWebkit()) {
+        var fill = selected.getAttribute('fill');
+
+        if (fill && fill.startsWith('url(')) {
+          var paint = getRefElem(fill);
+          var type = 'pattern';
+          if (paint.tagName !== type) type = 'gradient';
+          var attrVal = paint.getAttribute(type + 'Units');
+
+          if (attrVal === 'userSpaceOnUse') {
+            // Update the userSpaceOnUse element
+            _m5 = transformListToTransform(tlist).matrix;
+            var gtlist = getTransformList(paint);
+            var gmatrix = transformListToTransform(gtlist).matrix;
+            _m5 = matrixMultiply(_m5, gmatrix);
+            var mStr = 'matrix(' + [_m5.a, _m5.b, _m5.c, _m5.d, _m5.e, _m5.f].join(',') + ')';
+            paint.setAttribute(type + 'Transform', mStr);
+          }
+        }
+      } // first, if it was a scale of a non-skewed element, then the second-last
+      // transform will be the [S]
+      // if we had [M][T][S][T] we want to extract the matrix equivalent of
+      // [T][S][T] and push it down to the element
+
+
+      if (_N >= 3 && tlist.getItem(_N - 2).type === 3 && tlist.getItem(_N - 3).type === 2 && tlist.getItem(_N - 1).type === 2) {
+        // Removed this so a <use> with a given [T][S][T] would convert to a matrix.
+        // Is that bad?
+        //  && selected.nodeName != 'use'
+        _operation = 3; // scale
+
+        _m5 = transformListToTransform(tlist, _N - 3, _N - 1).matrix;
+        tlist.removeItem(_N - 1);
+        tlist.removeItem(_N - 2);
+        tlist.removeItem(_N - 3); // if we had [T][S][-T][M], then this was a skewed element being resized
+        // Thus, we simply combine it all into one matrix
+      } else if (_N === 4 && tlist.getItem(_N - 1).type === 1) {
+        _operation = 3; // scale
+
+        _m5 = transformListToTransform(tlist).matrix;
+
+        var _e2t2 = svgroot.createSVGTransform();
+
+        _e2t2.setMatrix(_m5);
+
+        tlist.clear();
+        tlist.appendItem(_e2t2); // reset the matrix so that the element is not re-mapped
+
+        _m5 = svgroot.createSVGMatrix(); // if we had [R][T][S][-T][M], then this was a rotated matrix-element
+        // if we had [T1][M] we want to transform this into [M][T2]
+        // therefore [ T2 ] = [ M_inv ] [ T1 ] [ M ] and we can push [T2]
+        // down to the element
+      } else if ((_N === 1 || _N > 1 && tlist.getItem(1).type !== 3) && tlist.getItem(0).type === 2) {
+        _operation = 2; // translate
+
+        var oldxlate = tlist.getItem(0).matrix,
+            meq = transformListToTransform(tlist, 1).matrix,
+            meqInv = meq.inverse();
+        _m5 = matrixMultiply(meqInv, oldxlate, meq);
+        tlist.removeItem(0); // else if this child now has a matrix imposition (from a parent group)
+        // we might be able to simplify
+      } else if (_N === 1 && tlist.getItem(0).type === 1 && !_angle) {
+        // Remap all point-based elements
+        _m5 = transformListToTransform(tlist).matrix;
+
+        switch (selected.tagName) {
+          case 'line':
+            changes = $$6(selected).attr(['x1', 'y1', 'x2', 'y2']);
+          // Fallthrough
+
+          case 'polyline':
+          case 'polygon':
+            changes.points = selected.getAttribute('points');
+
+            if (changes.points) {
+              var _list = selected.points;
+              var _len = _list.numberOfItems;
+              changes.points = new Array(_len);
+
+              for (var _i3 = 0; _i3 < _len; ++_i3) {
+                var _pt = _list.getItem(_i3);
+
+                changes.points[_i3] = {
+                  x: _pt.x,
+                  y: _pt.y
+                };
+              }
+            }
+
+          // Fallthrough
+
+          case 'path':
+            changes.d = selected.getAttribute('d');
+            _operation = 1;
+            tlist.clear();
+            break;
+
+          default:
+            break;
+        } // if it was a rotation, put the rotate back and return without a command
+        // (this function has zero work to do for a rotate())
+
+      } else {
+        // operation = 4; // rotation
+        if (_angle) {
+          var _newRot2 = svgroot.createSVGTransform();
+
+          _newRot2.setRotate(_angle, newcenter.x, newcenter.y);
+
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(_newRot2, 0);
+          } else {
+            tlist.appendItem(_newRot2);
+          }
+        }
+
+        if (tlist.numberOfItems === 0) {
+          selected.removeAttribute('transform');
+        }
+
+        return null;
+      } // if it was a translate or resize, we need to remap the element and absorb the xform
+
+
+      if (_operation === 1 || _operation === 2 || _operation === 3) {
+        remapElement(selected, changes, _m5);
+      } // if we are remapping
+      // if it was a translate, put back the rotate at the new center
+
+
+      if (_operation === 2) {
+        if (_angle) {
+          if (!hasMatrixTransform(tlist)) {
+            newcenter = {
+              x: oldcenter.x + _m5.e,
+              y: oldcenter.y + _m5.f
+            };
+          }
+
+          var _newRot3 = svgroot.createSVGTransform();
+
+          _newRot3.setRotate(_angle, newcenter.x, newcenter.y);
+
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(_newRot3, 0);
+          } else {
+            tlist.appendItem(_newRot3);
+          }
+        } // We have special processing for tspans:  Tspans are not transformable
+        // but they can have x,y coordinates (sigh).  Thus, if this was a translate,
+        // on a text element, also translate any tspan children.
+
+
+        if (selected.tagName === 'text') {
+          var _children4 = selected.childNodes;
+          var _c4 = _children4.length;
+
+          while (_c4--) {
+            var _child4 = _children4.item(_c4);
+
+            if (_child4.tagName === 'tspan') {
+              var tspanChanges = {
+                x: $$6(_child4).attr('x') || 0,
+                y: $$6(_child4).attr('y') || 0
+              };
+              remapElement(_child4, tspanChanges, _m5);
+            }
+          }
+        } // [Rold][M][T][S][-T] became [Rold][M]
+        // we want it to be [Rnew][M][Tr] where Tr is the
+        // translation required to re-center it
+        // Therefore, [Tr] = [M_inv][Rnew_inv][Rold][M]
+
+      } else if (_operation === 3 && _angle) {
+        var _transformListToTrans = transformListToTransform(tlist),
+            matrix = _transformListToTrans.matrix;
+
+        var _roldt = svgroot.createSVGTransform();
+
+        _roldt.setRotate(_angle, oldcenter.x, oldcenter.y);
+
+        var _rold = _roldt.matrix;
+
+        var _rnew = svgroot.createSVGTransform();
+
+        _rnew.setRotate(_angle, newcenter.x, newcenter.y);
+
+        var _rnewInv = _rnew.matrix.inverse();
+
+        var _mInv2 = matrix.inverse();
+
+        var _extrat = matrixMultiply(_mInv2, _rnewInv, _rold, matrix);
+
+        remapElement(selected, changes, _extrat);
+
+        if (_angle) {
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(_rnew, 0);
+          } else {
+            tlist.appendItem(_rnew);
+          }
+        }
+      }
+    } // a non-group
+    // if the transform list has been emptied, remove it
+
+
+    if (tlist.numberOfItems === 0) {
+      selected.removeAttribute('transform');
+    }
+
+    batchCmd.addSubCommand(new ChangeElementCommand(selected, initial));
+    return batchCmd;
+  };
+
+  var $$7 = jQuery;
+  var svgFactory_;
+  var config_;
+  var selectorManager_; // A Singleton
+
+  var gripRadius = isTouch() ? 10 : 4;
+  /**
+  * Private class for DOM element selection boxes.
+  */
+
+  var Selector =
+  /*#__PURE__*/
+  function () {
+    /**
+    * @param {Integer} id - Internally identify the selector
+    * @param {Element} elem - DOM element associated with this selector
+    * @param {module:utilities.BBoxObject} [bbox] - Optional bbox to use for initialization (prevents duplicate `getBBox` call).
+    */
+    function Selector(id, elem, bbox) {
+      _classCallCheck(this, Selector);
+
+      // this is the selector's unique number
+      this.id = id; // this holds a reference to the element for which this selector is being used
+
+      this.selectedElement = elem; // this is a flag used internally to track whether the selector is being used or not
+
+      this.locked = true; // this holds a reference to the <g> element that holds all visual elements of the selector
+
+      this.selectorGroup = svgFactory_.createSVGElement({
+        element: 'g',
+        attr: {
+          id: 'selectorGroup' + this.id
+        }
+      }); // this holds a reference to the path rect
+
+      this.selectorRect = this.selectorGroup.appendChild(svgFactory_.createSVGElement({
+        element: 'path',
+        attr: {
+          id: 'selectedBox' + this.id,
+          fill: 'none',
+          stroke: '#22C',
+          'stroke-width': '1',
+          'stroke-dasharray': '5,5',
+          // need to specify this so that the rect is not selectable
+          style: 'pointer-events:none'
+        }
+      })); // this holds a reference to the grip coordinates for this selector
+
+      this.gripCoords = {
+        nw: null,
+        n: null,
+        ne: null,
+        e: null,
+        se: null,
+        s: null,
+        sw: null,
+        w: null
+      };
+      this.reset(this.selectedElement, bbox);
+    }
+    /**
+    * Used to reset the id and element that the selector is attached to.
+    * @param {Element} e - DOM element associated with this selector
+    * @param {module:utilities.BBoxObject} bbox - Optional bbox to use for reset (prevents duplicate getBBox call).
+    * @returns {undefined}
+    */
+
+
+    _createClass(Selector, [{
+      key: "reset",
+      value: function reset(e, bbox) {
+        this.locked = true;
+        this.selectedElement = e;
+        this.resize(bbox);
+        this.selectorGroup.setAttribute('display', 'inline');
+      }
+      /**
+      * Show the resize grips of this selector.
+      * @param {boolean} show - Indicates whether grips should be shown or not
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "showGrips",
+      value: function showGrips(show) {
+        var bShow = show ? 'inline' : 'none';
+        selectorManager_.selectorGripsGroup.setAttribute('display', bShow);
+        var elem = this.selectedElement;
+        this.hasGrips = show;
+
+        if (elem && show) {
+          this.selectorGroup.append(selectorManager_.selectorGripsGroup);
+          Selector.updateGripCursors(getRotationAngle(elem));
+        }
+      }
+      /**
+      * Updates the selector to match the element's size.
+      * @param {module:utilities.BBoxObject} [bbox] - BBox to use for resize (prevents duplicate getBBox call).
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "resize",
+      value: function resize(bbox) {
+        var selectedBox = this.selectorRect,
+            mgr = selectorManager_,
+            selectedGrips = mgr.selectorGrips,
+            selected = this.selectedElement,
+            sw = selected.getAttribute('stroke-width'),
+            currentZoom = svgFactory_.getCurrentZoom();
+        var offset = 1 / currentZoom;
+
+        if (selected.getAttribute('stroke') !== 'none' && !isNaN(sw)) {
+          offset += sw / 2;
+        }
+
+        var tagName = selected.tagName;
+
+        if (tagName === 'text') {
+          offset += 2 / currentZoom;
+        } // loop and transform our bounding box until we reach our first rotation
+
+
+        var tlist = getTransformList(selected);
+        var m = transformListToTransform(tlist).matrix; // This should probably be handled somewhere else, but for now
+        // it keeps the selection box correctly positioned when zoomed
+
+        m.e *= currentZoom;
+        m.f *= currentZoom;
+
+        if (!bbox) {
+          bbox = getBBox(selected);
+        } // TODO: getBBox (previous line) already knows to call getStrokedBBox when tagName === 'g'. Remove this?
+        // TODO: getBBox doesn't exclude 'gsvg' and calls getStrokedBBox for any 'g'. Should getBBox be updated?
+
+
+        if (tagName === 'g' && !$$7.data(selected, 'gsvg')) {
+          // The bbox for a group does not include stroke vals, so we
+          // get the bbox based on its children.
+          var strokedBbox = getStrokedBBox([selected.childNodes]);
+
+          if (strokedBbox) {
+            bbox = strokedBbox;
+          }
+        } // apply the transforms
+
+
+        var l = bbox.x,
+            t = bbox.y,
+            w = bbox.width,
+            h = bbox.height; // bbox = {x: l, y: t, width: w, height: h}; // Not in use
+        // we need to handle temporary transforms too
+        // if skewed, get its transformed box, then find its axis-aligned bbox
+        // *
+
+        offset *= currentZoom;
+        var nbox = transformBox(l * currentZoom, t * currentZoom, w * currentZoom, h * currentZoom, m),
+            aabox = nbox.aabox;
+        var nbax = aabox.x - offset,
+            nbay = aabox.y - offset,
+            nbaw = aabox.width + offset * 2,
+            nbah = aabox.height + offset * 2; // now if the shape is rotated, un-rotate it
+
+        var cx = nbax + nbaw / 2,
+            cy = nbay + nbah / 2;
+        var angle = getRotationAngle(selected);
+
+        if (angle) {
+          var rot = svgFactory_.svgRoot().createSVGTransform();
+          rot.setRotate(-angle, cx, cy);
+          var rotm = rot.matrix;
+          nbox.tl = transformPoint(nbox.tl.x, nbox.tl.y, rotm);
+          nbox.tr = transformPoint(nbox.tr.x, nbox.tr.y, rotm);
+          nbox.bl = transformPoint(nbox.bl.x, nbox.bl.y, rotm);
+          nbox.br = transformPoint(nbox.br.x, nbox.br.y, rotm); // calculate the axis-aligned bbox
+
+          var tl = nbox.tl;
+          var minx = tl.x,
+              miny = tl.y,
+              maxx = tl.x,
+              maxy = tl.y;
+          var min = Math.min,
+              max = Math.max;
+          minx = min(minx, min(nbox.tr.x, min(nbox.bl.x, nbox.br.x))) - offset;
+          miny = min(miny, min(nbox.tr.y, min(nbox.bl.y, nbox.br.y))) - offset;
+          maxx = max(maxx, max(nbox.tr.x, max(nbox.bl.x, nbox.br.x))) + offset;
+          maxy = max(maxy, max(nbox.tr.y, max(nbox.bl.y, nbox.br.y))) + offset;
+          nbax = minx;
+          nbay = miny;
+          nbaw = maxx - minx;
+          nbah = maxy - miny;
+        }
+
+        var dstr = 'M' + nbax + ',' + nbay + ' L' + (nbax + nbaw) + ',' + nbay + ' ' + (nbax + nbaw) + ',' + (nbay + nbah) + ' ' + nbax + ',' + (nbay + nbah) + 'z';
+        selectedBox.setAttribute('d', dstr);
+        var xform = angle ? 'rotate(' + [angle, cx, cy].join(',') + ')' : '';
+        this.selectorGroup.setAttribute('transform', xform); // TODO(codedread): Is this needed?
+        //  if (selected === selectedElements[0]) {
+
+        this.gripCoords = {
+          nw: [nbax, nbay],
+          ne: [nbax + nbaw, nbay],
+          sw: [nbax, nbay + nbah],
+          se: [nbax + nbaw, nbay + nbah],
+          n: [nbax + nbaw / 2, nbay],
+          w: [nbax, nbay + nbah / 2],
+          e: [nbax + nbaw, nbay + nbah / 2],
+          s: [nbax + nbaw / 2, nbay + nbah]
+        };
+        Object.entries(this.gripCoords).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+              dir = _ref2[0],
+              coords = _ref2[1];
+
+          selectedGrips[dir].setAttribute('cx', coords[0]);
+          selectedGrips[dir].setAttribute('cy', coords[1]);
+        }); // we want to go 20 pixels in the negative transformed y direction, ignoring scale
+
+        mgr.rotateGripConnector.setAttribute('x1', nbax + nbaw / 2);
+        mgr.rotateGripConnector.setAttribute('y1', nbay);
+        mgr.rotateGripConnector.setAttribute('x2', nbax + nbaw / 2);
+        mgr.rotateGripConnector.setAttribute('y2', nbay - gripRadius * 5);
+        mgr.rotateGrip.setAttribute('cx', nbax + nbaw / 2);
+        mgr.rotateGrip.setAttribute('cy', nbay - gripRadius * 5); // }
+      }
+    }]);
+
+    return Selector;
+  }();
+  /**
+  * Updates cursors for corner grips on rotation so arrows point the right way.
+  * @param {Float} angle - Current rotation angle in degrees
+  * @returns {undefined}
+  */
+
+  Selector.updateGripCursors = function (angle) {
+    var dirArr = Object.keys(selectorManager_.selectorGrips);
+    var steps = Math.round(angle / 45);
+
+    if (steps < 0) {
+      steps += 8;
+    }
+
+    while (steps > 0) {
+      dirArr.push(dirArr.shift());
+      steps--;
+    }
+
+    Object.values(selectorManager_.selectorGrips).forEach(function (gripElement, i) {
+      gripElement.setAttribute('style', 'cursor:' + dirArr[i] + '-resize');
+    });
+  };
+  /**
+  * Manage all selector objects (selection boxes).
+  */
+
+
+  var SelectorManager =
+  /*#__PURE__*/
+  function () {
+    function SelectorManager() {
+      _classCallCheck(this, SelectorManager);
+
+      // this will hold the <g> element that contains all selector rects/grips
+      this.selectorParentGroup = null; // this is a special rect that is used for multi-select
+
+      this.rubberBandBox = null; // this will hold objects of type Selector (see above)
+
+      this.selectors = []; // this holds a map of SVG elements to their Selector object
+
+      this.selectorMap = {}; // this holds a reference to the grip elements
+
+      this.selectorGrips = {
+        nw: null,
+        n: null,
+        ne: null,
+        e: null,
+        se: null,
+        s: null,
+        sw: null,
+        w: null
+      };
+      this.selectorGripsGroup = null;
+      this.rotateGripConnector = null;
+      this.rotateGrip = null;
+      this.initGroup();
+    }
+    /**
+    * Resets the parent selector group element.
+    * @returns {undefined}
+    */
+
+
+    _createClass(SelectorManager, [{
+      key: "initGroup",
+      value: function initGroup() {
+        var _this = this;
+
+        // remove old selector parent group if it existed
+        if (this.selectorParentGroup && this.selectorParentGroup.parentNode) {
+          this.selectorParentGroup.remove();
+        } // create parent selector group and add it to svgroot
+
+
+        this.selectorParentGroup = svgFactory_.createSVGElement({
+          element: 'g',
+          attr: {
+            id: 'selectorParentGroup'
+          }
+        });
+        this.selectorGripsGroup = svgFactory_.createSVGElement({
+          element: 'g',
+          attr: {
+            display: 'none'
+          }
+        });
+        this.selectorParentGroup.append(this.selectorGripsGroup);
+        svgFactory_.svgRoot().append(this.selectorParentGroup);
+        this.selectorMap = {};
+        this.selectors = [];
+        this.rubberBandBox = null; // add the corner grips
+
+        Object.keys(this.selectorGrips).forEach(function (dir) {
+          var grip = svgFactory_.createSVGElement({
+            element: 'circle',
+            attr: {
+              id: 'selectorGrip_resize_' + dir,
+              fill: '#22C',
+              r: gripRadius,
+              style: 'cursor:' + dir + '-resize',
+              // This expands the mouse-able area of the grips making them
+              // easier to grab with the mouse.
+              // This works in Opera and WebKit, but does not work in Firefox
+              // see https://bugzilla.mozilla.org/show_bug.cgi?id=500174
+              'stroke-width': 2,
+              'pointer-events': 'all'
+            }
+          });
+          $$7.data(grip, 'dir', dir);
+          $$7.data(grip, 'type', 'resize');
+          _this.selectorGrips[dir] = _this.selectorGripsGroup.appendChild(grip);
+        }); // add rotator elems
+
+        this.rotateGripConnector = this.selectorGripsGroup.appendChild(svgFactory_.createSVGElement({
+          element: 'line',
+          attr: {
+            id: 'selectorGrip_rotateconnector',
+            stroke: '#22C',
+            'stroke-width': '1'
+          }
+        }));
+        this.rotateGrip = this.selectorGripsGroup.appendChild(svgFactory_.createSVGElement({
+          element: 'circle',
+          attr: {
+            id: 'selectorGrip_rotate',
+            fill: 'lime',
+            r: gripRadius,
+            stroke: '#22C',
+            'stroke-width': 2,
+            style: 'cursor:url(' + config_.imgPath + 'rotate.png) 12 12, auto;'
+          }
+        }));
+        $$7.data(this.rotateGrip, 'type', 'rotate');
+
+        if ($$7('#canvasBackground').length) {
+          return;
+        }
+
+        var _config_$dimensions = _slicedToArray(config_.dimensions, 2),
+            width = _config_$dimensions[0],
+            height = _config_$dimensions[1];
+
+        var canvasbg = svgFactory_.createSVGElement({
+          element: 'svg',
+          attr: {
+            id: 'canvasBackground',
+            width: width,
+            height: height,
+            x: 0,
+            y: 0,
+            overflow: isWebkit() ? 'none' : 'visible',
+            // Chrome 7 has a problem with this when zooming out
+            style: 'pointer-events:none'
+          }
+        });
+        var rect = svgFactory_.createSVGElement({
+          element: 'rect',
+          attr: {
+            width: '100%',
+            height: '100%',
+            x: 0,
+            y: 0,
+            'stroke-width': 1,
+            stroke: '#000',
+            fill: '#FFF',
+            style: 'pointer-events:none'
+          }
+        }); // Both Firefox and WebKit are too slow with this filter region (especially at higher
+        // zoom levels) and Opera has at least one bug
+        // if (!isOpera()) rect.setAttribute('filter', 'url(#canvashadow)');
+
+        canvasbg.append(rect);
+        svgFactory_.svgRoot().insertBefore(canvasbg, svgFactory_.svgContent()); // Ok to replace above with `svgFactory_.svgContent().before(canvasbg);`?
+      }
+      /**
+      *
+      * @param {Element} elem - DOM element to get the selector for
+      * @param {module:utilities.BBoxObject} [bbox] - Optional bbox to use for reset (prevents duplicate getBBox call).
+      * @returns {Selector} The selector based on the given element
+      */
+
+    }, {
+      key: "requestSelector",
+      value: function requestSelector(elem, bbox) {
+        if (isNullish(elem)) {
+          return null;
+        }
+
+        var N = this.selectors.length; // If we've already acquired one for this element, return it.
+
+        if (_typeof(this.selectorMap[elem.id]) === 'object') {
+          this.selectorMap[elem.id].locked = true;
+          return this.selectorMap[elem.id];
+        }
+
+        for (var i = 0; i < N; ++i) {
+          if (this.selectors[i] && !this.selectors[i].locked) {
+            this.selectors[i].locked = true;
+            this.selectors[i].reset(elem, bbox);
+            this.selectorMap[elem.id] = this.selectors[i];
+            return this.selectors[i];
+          }
+        } // if we reached here, no available selectors were found, we create one
+
+
+        this.selectors[N] = new Selector(N, elem, bbox);
+        this.selectorParentGroup.append(this.selectors[N].selectorGroup);
+        this.selectorMap[elem.id] = this.selectors[N];
+        return this.selectors[N];
+      }
+      /**
+      * Removes the selector of the given element (hides selection box).
+      *
+      * @param {Element} elem - DOM element to remove the selector for
+      * @returns {undefined}
+      */
+
+    }, {
+      key: "releaseSelector",
+      value: function releaseSelector(elem) {
+        if (isNullish(elem)) {
+          return;
+        }
+
+        var N = this.selectors.length,
+            sel = this.selectorMap[elem.id];
+
+        if (!sel.locked) {
+          // TODO(codedread): Ensure this exists in this module.
+          console.log('WARNING! selector was released but was already unlocked'); // eslint-disable-line no-console
+        }
+
+        for (var i = 0; i < N; ++i) {
+          if (this.selectors[i] && this.selectors[i] === sel) {
+            delete this.selectorMap[elem.id];
+            sel.locked = false;
+            sel.selectedElement = null;
+            sel.showGrips(false); // remove from DOM and store reference in JS but only if it exists in the DOM
+
+            try {
+              sel.selectorGroup.setAttribute('display', 'none');
+            } catch (e) {}
+
+            break;
+          }
+        }
+      }
+      /**
+      * @returns {SVGRectElement} The rubberBandBox DOM element. This is the rectangle drawn by
+      * the user for selecting/zooming
+      */
+
+    }, {
+      key: "getRubberBandBox",
+      value: function getRubberBandBox() {
+        if (!this.rubberBandBox) {
+          this.rubberBandBox = this.selectorParentGroup.appendChild(svgFactory_.createSVGElement({
+            element: 'rect',
+            attr: {
+              id: 'selectorRubberBand',
+              fill: '#22C',
+              'fill-opacity': 0.15,
+              stroke: '#22C',
+              'stroke-width': 0.5,
+              display: 'none',
+              style: 'pointer-events:none'
+            }
+          }));
+        }
+
+        return this.rubberBandBox;
+      }
+    }]);
+
+    return SelectorManager;
+  }();
+  /**
+   * An object that creates SVG elements for the canvas.
+   *
+   * @interface module:select.SVGFactory
+   */
+
+  /**
+   * @function module:select.SVGFactory#createSVGElement
+   * @param {module:utilities.EditorContext#addSVGElementFromJson} jsonMap
+   * @returns {SVGElement}
+   */
+
+  /**
+   * @function module:select.SVGFactory#svgRoot
+   * @returns {SVGSVGElement}
+   */
+
+  /**
+   * @function module:select.SVGFactory#svgContent
+   * @returns {SVGSVGElement}
+   */
+
+  /**
+   * @function module:select.SVGFactory#getCurrentZoom
+   * @returns {Float}
+   */
+
+  /**
+   * @typedef {GenericArray} module:select.Dimensions
+   * @property {Integer} length 2
+   * @property {Float} 0 Width
+   * @property {Float} 1 Height
+   */
+
+  /**
+   * @typedef {PlainObject} module:select.Config
+   * @property {string} imgPath
+   * @property {module:select.Dimensions} dimensions
+   */
+
+  /**
+   * Initializes this module.
+   * @function module:select.init
+   * @param {module:select.Config} config - An object containing configurable parameters (imgPath)
+   * @param {module:select.SVGFactory} svgFactory - An object implementing the SVGFactory interface.
+   * @returns {undefined}
+   */
+
+  var init$6 = function init(config, svgFactory) {
+    config_ = config;
+    svgFactory_ = svgFactory;
+    selectorManager_ = new SelectorManager();
+  };
+  /**
+   * @function module:select.getSelectorManager
+   * @returns {module:select.SelectorManager} The SelectorManager instance.
+   */
+
+  var getSelectorManager = function getSelectorManager() {
+    return selectorManager_;
+  };
+
+  var $$8 = jQueryPluginSVG(jQuery);
+  var MoveElementCommand$1 = MoveElementCommand,
+      InsertElementCommand$1 = InsertElementCommand,
+      RemoveElementCommand$1 = RemoveElementCommand,
+      ChangeElementCommand$1 = ChangeElementCommand,
+      BatchCommand$1 = BatchCommand,
+      UndoManager$1 = UndoManager,
+      HistoryEventTypes$1 = HistoryEventTypes;
+
+  if (!window.console) {
+    window.console = {};
+
+    window.console.log = function (str) {
+      /* */
+    };
+
+    window.console.dir = function (str) {
+      /* */
+    };
+  }
+
+  if (window.opera) {
+    window.console.log = function (str) {
+      window.opera.postError(str);
+    };
+
+    window.console.dir = function (str) {
+      /* */
+    };
+  }
+  /**
+  * The main SvgCanvas class that manages all SVG-related functions.
+  * @memberof module:svgcanvas
+  *
+  * @borrows module:coords.remapElement as #remapElement
+  * @borrows module:recalculate.recalculateDimensions as #recalculateDimensions
+  *
+  * @borrows module:utilities.cleanupElement as #cleanupElement
+  * @borrows module:utilities.getStrokedBBoxDefaultVisible as #getStrokedBBox
+  * @borrows module:utilities.getVisibleElements as #getVisibleElements
+  * @borrows module:utilities.findDefs as #findDefs
+  * @borrows module:utilities.getUrlFromAttr as #getUrlFromAttr
+  * @borrows module:utilities.getHref as #getHref
+  * @borrows module:utilities.setHref as #setHref
+  * @borrows module:utilities.getRotationAngle as #getRotationAngle
+  * @borrows module:utilities.getBBox as #getBBox
+  * @borrows module:utilities.getElem as #getElem
+  * @borrows module:utilities.getRefElem as #getRefElem
+  * @borrows module:utilities.assignAttributes as #assignAttributes
+  *
+  * @borrows module:SVGTransformList.getTransformList as #getTransformList
+  * @borrows module:math.matrixMultiply as #matrixMultiply
+  * @borrows module:math.hasMatrixTransform as #hasMatrixTransform
+  * @borrows module:math.transformListToTransform as #transformListToTransform
+  * @borrows module:units.convertToNum as #convertToNum
+  * @borrows module:sanitize.sanitizeSvg as #sanitizeSvg
+  * @borrows module:path.pathActions.linkControlPoints as #linkControlPoints
+  */
+
+
+  var SvgCanvas =
+  /**
+  * @param {HTMLElement} container - The container HTML element that should hold the SVG root element
+  * @param {module:SVGEditor.curConfig} config - An object that contains configuration data
+  */
+  function SvgCanvas(container, config) {
+    _classCallCheck(this, SvgCanvas);
+
+    // Alias Namespace constants
+    // Default configuration options
+    var curConfig = {
+      show_outside_canvas: true,
+      selectNew: true,
+      dimensions: [640, 480]
+    }; // Update config with new one if given
+
+    if (config) {
+      $$8.extend(curConfig, config);
+    } // Array with width/height of canvas
+
+
+    var dimensions = curConfig.dimensions;
+    var canvas = this; // eslint-disable-line consistent-this
+    // "document" element associated with the container (same as window.document using default svg-editor.js)
+    // NOTE: This is not actually a SVG document, but an HTML document.
+
+    var svgdoc = container.ownerDocument; // This is a container for the document being edited, not the document itself.
+
+    /**
+     * @name module:svgcanvas~svgroot
+     * @type {SVGSVGElement}
+     */
+
+    var svgroot = svgdoc.importNode(text2xml('<svg id="svgroot" xmlns="' + NS.SVG + '" xlinkns="' + NS.XLINK + '" ' + 'width="' + dimensions[0] + '" height="' + dimensions[1] + '" x="' + dimensions[0] + '" y="' + dimensions[1] + '" overflow="visible">' + '<defs>' + '<filter id="canvashadow" filterUnits="objectBoundingBox">' + '<feGaussianBlur in="SourceAlpha" stdDeviation="4" result="blur"/>' + '<feOffset in="blur" dx="5" dy="5" result="offsetBlur"/>' + '<feMerge>' + '<feMergeNode in="offsetBlur"/>' + '<feMergeNode in="SourceGraphic"/>' + '</feMerge>' + '</filter>' + '</defs>' + '</svg>').documentElement, true);
+    container.append(svgroot);
+    /**
+     * The actual element that represents the final output SVG element
+     * @name module:svgcanvas~svgcontent
+     * @type {SVGSVGElement}
+     */
+
+    var svgcontent = svgdoc.createElementNS(NS.SVG, 'svg');
+    /**
+    * This function resets the svgcontent element while keeping it in the DOM.
+    * @function module:svgcanvas.SvgCanvas#clearSvgContentElement
+    * @returns {undefined}
+    */
+
+    var clearSvgContentElement = canvas.clearSvgContentElement = function () {
+      $$8(svgcontent).empty(); // TODO: Clear out all other attributes first?
+
+      $$8(svgcontent).attr({
+        id: 'svgcontent',
+        width: dimensions[0],
+        height: dimensions[1],
+        x: dimensions[0],
+        y: dimensions[1],
+        overflow: curConfig.show_outside_canvas ? 'visible' : 'hidden',
+        xmlns: NS.SVG,
+        'xmlns:se': NS.SE,
+        'xmlns:xlink': NS.XLINK
+      }).appendTo(svgroot); // TODO: make this string optional and set by the client
+
+      var comment = svgdoc.createComment(' Created with SVG-edit - https://github.com/SVG-Edit/svgedit');
+      svgcontent.append(comment);
+    };
+
+    clearSvgContentElement(); // Prefix string for element IDs
+
+    var idprefix = 'svg_';
+    /**
+    * Changes the ID prefix to the given value.
+    * @function module:svgcanvas.SvgCanvas#setIdPrefix
+    * @param {string} p - String with the new prefix
+    * @returns {undefined}
+    */
+
+    canvas.setIdPrefix = function (p) {
+      idprefix = p;
+    };
+    /**
+    * Current draw.Drawing object
+    * @type {module:draw.Drawing}
+    * @name module:svgcanvas.SvgCanvas#current_drawing_
+    */
+
+
+    canvas.current_drawing_ = new Drawing(svgcontent, idprefix);
+    /**
+    * Returns the current Drawing.
+    * @function module:svgcanvas.SvgCanvas#getCurrentDrawing
+    * @implements {module:draw.DrawCanvasInit#getCurrentDrawing}
+    */
+
+    var getCurrentDrawing = canvas.getCurrentDrawing = function () {
+      return canvas.current_drawing_;
+    };
+    /**
+    * Float displaying the current zoom level (1 = 100%, .5 = 50%, etc)
+    * @type {Float}
+    */
+
+
+    var currentZoom = 1; // pointer to current group (for in-group editing)
+
+    var currentGroup = null; // Object containing data for the currently selected styles
+
+    var allProperties = {
+      shape: {
+        fill: (curConfig.initFill.color === 'none' ? '' : '#') + curConfig.initFill.color,
+        fill_paint: null,
+        fill_opacity: curConfig.initFill.opacity,
+        stroke: '#' + curConfig.initStroke.color,
+        stroke_paint: null,
+        stroke_opacity: curConfig.initStroke.opacity,
+        stroke_width: curConfig.initStroke.width,
+        stroke_dasharray: 'none',
+        stroke_linejoin: 'miter',
+        stroke_linecap: 'butt',
+        opacity: curConfig.initOpacity
+      }
+    };
+    allProperties.text = $$8.extend(true, {}, allProperties.shape);
+    $$8.extend(allProperties.text, {
+      fill: '#000000',
+      stroke_width: curConfig.text && curConfig.text.stroke_width,
+      font_size: curConfig.text && curConfig.text.font_size,
+      font_family: curConfig.text && curConfig.text.font_family
+    }); // Current shape style properties
+
+    var curShape = allProperties.shape; // Array with all the currently selected elements
+    // default size of 1 until it needs to grow bigger
+
+    var selectedElements = [];
+    /**
+    * @typedef {PlainObject} module:svgcanvas.SVGAsJSON
+    * @property {string} element
+    * @property {PlainObject.<string, string>} attr
+    * @property {module:svgcanvas.SVGAsJSON[]} children
+    */
+
+    /**
+    * @function module:svgcanvas.SvgCanvas#getContentElem
+    * @param {Text|Element} data
+    * @returns {module:svgcanvas.SVGAsJSON}
+    */
+
+    var getJsonFromSvgElement = this.getJsonFromSvgElement = function (data) {
+      // Text node
+      if (data.nodeType === 3) return data.nodeValue;
+      var retval = {
+        element: data.tagName,
+        // namespace: nsMap[data.namespaceURI],
+        attr: {},
+        children: []
+      }; // Iterate attributes
+
+      for (var i = 0, attr; attr = data.attributes[i]; i++) {
+        retval.attr[attr.name] = attr.value;
+      } // Iterate children
+
+
+      for (var _i = 0, node; node = data.childNodes[_i]; _i++) {
+        retval.children[_i] = getJsonFromSvgElement(node);
+      }
+
+      return retval;
+    };
+    /**
+    * This should really be an intersection implementing all rather than a union.
+    * @function module:svgcanvas.SvgCanvas#addSVGElementFromJson
+    * @implements {module:utilities.EditorContext#addSVGElementFromJson|module:path.EditorContext#addSVGElementFromJson}
+    */
+
+
+    var addSVGElementFromJson = this.addSVGElementFromJson = function (data) {
+      if (typeof data === 'string') return svgdoc.createTextNode(data);
+      var shape = getElem(data.attr.id); // if shape is a path but we need to create a rect/ellipse, then remove the path
+
+      var currentLayer = getCurrentDrawing().getCurrentLayer();
+
+      if (shape && data.element !== shape.tagName) {
+        shape.remove();
+        shape = null;
+      }
+
+      if (!shape) {
+        var ns = data.namespace || NS.SVG;
+        shape = svgdoc.createElementNS(ns, data.element);
+
+        if (currentLayer) {
+          (currentGroup || currentLayer).append(shape);
+        }
+      }
+
+      if (data.curStyles) {
+        assignAttributes(shape, {
+          fill: curShape.fill,
+          stroke: curShape.stroke,
+          'stroke-width': curShape.stroke_width,
+          'stroke-dasharray': curShape.stroke_dasharray,
+          'stroke-linejoin': curShape.stroke_linejoin,
+          'stroke-linecap': curShape.stroke_linecap,
+          'stroke-opacity': curShape.stroke_opacity,
+          'fill-opacity': curShape.fill_opacity,
+          opacity: curShape.opacity / 2,
+          style: 'pointer-events:inherit'
+        }, 100);
+      }
+
+      assignAttributes(shape, data.attr, 100);
+      cleanupElement(shape); // Children
+
+      if (data.children) {
+        data.children.forEach(function (child) {
+          shape.append(addSVGElementFromJson(child));
+        });
+      }
+
+      return shape;
+    };
+
+    canvas.getTransformList = getTransformList;
+    canvas.matrixMultiply = matrixMultiply;
+    canvas.hasMatrixTransform = hasMatrixTransform;
+    canvas.transformListToTransform = transformListToTransform;
+    /**
+    * @implements {module:utilities.EditorContext#getBaseUnit}
+    */
+
+    var getBaseUnit = function getBaseUnit() {
+      return curConfig.baseUnit;
+    };
+    /**
+    * initialize from units.js.
+    * Send in an object implementing the ElementContainer interface (see units.js)
+    */
+
+
+    init(
+    /**
+    * @implements {module:units.ElementContainer}
+    */
+    {
+      getBaseUnit: getBaseUnit,
+      getElement: getElem,
+      getHeight: function getHeight() {
+        return svgcontent.getAttribute('height') / currentZoom;
+      },
+      getWidth: function getWidth() {
+        return svgcontent.getAttribute('width') / currentZoom;
+      },
+      getRoundDigits: function getRoundDigits() {
+        return saveOptions.round_digits;
+      }
+    });
+    canvas.convertToNum = convertToNum;
+    /**
+    * This should really be an intersection implementing all rather than a union.
+    * @implements {module:draw.DrawCanvasInit#getSVGContent|module:utilities.EditorContext#getSVGContent}
+    */
+
+    var getSVGContent = function getSVGContent() {
+      return svgcontent;
+    };
+    /**
+    * Should really be an intersection with all needing to apply rather than a union.
+    * @function module:svgcanvas.SvgCanvas#getSelectedElements
+    * @implements {module:utilities.EditorContext#getSelectedElements|module:draw.DrawCanvasInit#getSelectedElements|module:path.EditorContext#getSelectedElements}
+    */
+
+
+    var getSelectedElements = this.getSelectedElems = function () {
+      return selectedElements;
+    };
+
+    var pathActions$$1 = pathActions;
+    /**
+    * This should actually be an intersection as all interfaces should be met.
+    * @implements {module:utilities.EditorContext#getSVGRoot|module:recalculate.EditorContext#getSVGRoot|module:coords.EditorContext#getSVGRoot|module:path.EditorContext#getSVGRoot}
+    */
+
+    var getSVGRoot = function getSVGRoot() {
+      return svgroot;
+    };
+
+    init$2(
+    /**
+    * @implements {module:utilities.EditorContext}
+    */
+    {
+      pathActions: pathActions$$1,
+      // Ok since not modifying
+      getSVGContent: getSVGContent,
+      addSVGElementFromJson: addSVGElementFromJson,
+      getSelectedElements: getSelectedElements,
+      getDOMDocument: function getDOMDocument() {
+        return svgdoc;
+      },
+      getDOMContainer: function getDOMContainer() {
+        return container;
+      },
+      getSVGRoot: getSVGRoot,
+      // TODO: replace this mostly with a way to get the current drawing.
+      getBaseUnit: getBaseUnit,
+      getSnappingStep: function getSnappingStep() {
+        return curConfig.snappingStep;
+      }
+    });
+    canvas.findDefs = findDefs;
+    canvas.getUrlFromAttr = getUrlFromAttr;
+    canvas.getHref = getHref;
+    canvas.setHref = setHref;
+    /* const getBBox = */
+
+    canvas.getBBox = getBBox;
+    canvas.getRotationAngle = getRotationAngle;
+    canvas.getElem = getElem;
+    canvas.getRefElem = getRefElem;
+    canvas.assignAttributes = assignAttributes;
+    this.cleanupElement = cleanupElement;
+    /**
+    * This should actually be an intersection not a union as all should apply.
+    * @implements {module:coords.EditorContext|module:path.EditorContext}
+    */
+
+    var getGridSnapping = function getGridSnapping() {
+      return curConfig.gridSnapping;
+    };
+
+    init$4(
+    /**
+    * @implements {module:coords.EditorContext}
+    */
+    {
+      getDrawing: function getDrawing() {
+        return getCurrentDrawing();
+      },
+      getSVGRoot: getSVGRoot,
+      getGridSnapping: getGridSnapping
+    });
+    this.remapElement = remapElement;
+    init$5(
+    /**
+    * @implements {module:recalculate.EditorContext}
+    */
+    {
+      getSVGRoot: getSVGRoot,
+      getStartTransform: function getStartTransform() {
+        return startTransform;
+      },
+      setStartTransform: function setStartTransform(transform) {
+        startTransform = transform;
+      }
+    });
+    this.recalculateDimensions = recalculateDimensions; // import from sanitize.js
+
+    var nsMap = getReverseNS();
+    canvas.sanitizeSvg = sanitizeSvg;
+    /**
+    * @name undoMgr
+    * @memberof module:svgcanvas.SvgCanvas#
+    * @type {module:history.HistoryEventHandler}
+    */
+
+    var undoMgr = canvas.undoMgr = new UndoManager$1({
+      /**
+       * @param {string} eventType One of the HistoryEvent types
+       * @param {module:history.HistoryCommand} cmd Fulfills the HistoryCommand interface
+       * @fires module:svgcanvas.SvgCanvas#event:changed
+       * @returns {undefined}
+       */
+      handleHistoryEvent: function handleHistoryEvent(eventType, cmd) {
+        var EventTypes = HistoryEventTypes$1; // TODO: handle setBlurOffsets.
+
+        if (eventType === EventTypes.BEFORE_UNAPPLY || eventType === EventTypes.BEFORE_APPLY) {
+          canvas.clearSelection();
+        } else if (eventType === EventTypes.AFTER_APPLY || eventType === EventTypes.AFTER_UNAPPLY) {
+          var elems = cmd.elements();
+          canvas.pathActions.clear();
+          call('changed', elems);
+          var cmdType = cmd.type();
+          var isApply = eventType === EventTypes.AFTER_APPLY;
+
+          if (cmdType === MoveElementCommand$1.type()) {
+            var parent = isApply ? cmd.newParent : cmd.oldParent;
+
+            if (parent === svgcontent) {
+              identifyLayers();
+            }
+          } else if (cmdType === InsertElementCommand$1.type() || cmdType === RemoveElementCommand$1.type()) {
+            if (cmd.parent === svgcontent) {
+              identifyLayers();
+            }
+
+            if (cmdType === InsertElementCommand$1.type()) {
+              if (isApply) {
+                restoreRefElems(cmd.elem);
+              }
+            } else if (!isApply) {
+              restoreRefElems(cmd.elem);
+            }
+
+            if (cmd.elem.tagName === 'use') {
+              setUseData(cmd.elem);
+            }
+          } else if (cmdType === ChangeElementCommand$1.type()) {
+            // if we are changing layer names, re-identify all layers
+            if (cmd.elem.tagName === 'title' && cmd.elem.parentNode.parentNode === svgcontent) {
+              identifyLayers();
+            }
+
+            var values = isApply ? cmd.newValues : cmd.oldValues; // If stdDeviation was changed, update the blur.
+
+            if (values.stdDeviation) {
+              canvas.setBlurOffsets(cmd.elem.parentNode, values.stdDeviation);
+            } // This is resolved in later versions of webkit, perhaps we should
+            // have a featured detection for correct 'use' behavior?
+            // ——————————
+            // Remove & Re-add hack for Webkit (issue 775)
+            // if (cmd.elem.tagName === 'use' && isWebkit()) {
+            //  const {elem} = cmd;
+            //  if (!elem.getAttribute('x') && !elem.getAttribute('y')) {
+            //    const parent = elem.parentNode;
+            //    const sib = elem.nextSibling;
+            //    elem.remove();
+            //    parent.insertBefore(elem, sib);
+            //    // Ok to replace above with this? `sib.before(elem);`
+            //  }
+            // }
+
+          }
+        }
+      }
+    });
+    /**
+    * This should really be an intersection applying to all types rather than a union.
+    * @function module:svgcanvas~addCommandToHistory
+    * @implements {module:path.EditorContext#addCommandToHistory|module:draw.DrawCanvasInit#addCommandToHistory}
+    */
+
+    var addCommandToHistory = function addCommandToHistory(cmd) {
+      canvas.undoMgr.addCommandToHistory(cmd);
+    };
+    /**
+    * This should really be an intersection applying to all types rather than a union.
+    * @function module:svgcanvas.SvgCanvas#getZoom
+    * @implements {module:path.EditorContext#getCurrentZoom|module:select.SVGFactory#getCurrentZoom}
+    */
+
+
+    var getCurrentZoom = this.getZoom = function () {
+      return currentZoom;
+    };
+    /**
+    * This method rounds the incoming value to the nearest value based on the `currentZoom`
+    * @function module:svgcanvas.SvgCanvas#round
+    * @implements {module:path.EditorContext#round}
+    */
+
+
+    var round = this.round = function (val) {
+      return parseInt(val * currentZoom) / currentZoom;
+    };
+
+    init$6(curConfig,
+    /**
+    * Export to select.js
+    * @implements {module:select.SVGFactory}
+    */
+    {
+      createSVGElement: function createSVGElement(jsonMap) {
+        return canvas.addSVGElementFromJson(jsonMap);
+      },
+      svgRoot: function svgRoot() {
+        return svgroot;
+      },
+      svgContent: function svgContent() {
+        return svgcontent;
+      },
+      getCurrentZoom: getCurrentZoom
+    });
+    /**
+    * This object manages selectors for us
+    * @name module:svgcanvas.SvgCanvas#selectorManager
+    * @type {module:select.SelectorManager}
+    */
+
+    var selectorManager = this.selectorManager = getSelectorManager();
+    /**
+    * @function module:svgcanvas.SvgCanvas#getNextId
+    * @implements {module:path.EditorContext#getNextId}
+    */
+
+    var getNextId = canvas.getNextId = function () {
+      return getCurrentDrawing().getNextId();
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getId
+    * @implements {module:path.EditorContext#getId}
+    */
+
+
+    var getId = canvas.getId = function () {
+      return getCurrentDrawing().getId();
+    };
+    /**
+    * The "implements" should really be an intersection applying to all types rather than a union.
+    * @function module:svgcanvas.SvgCanvas#call
+    * @implements {module:draw.DrawCanvasInit#call|module:path.EditorContext#call}
+    * @param {"selected"|"changed"|"contextset"|"pointsAdded"|"extension_added"|"extensions_added"|"message"|"transition"|"zoomed"|"updateCanvas"|"zoomDone"|"saved"|"exported"|"exportedPDF"|"setnonce"|"unsetnonce"|"cleared"} ev - String with the event name
+    * @param {module:svgcanvas.SvgCanvas#event:GenericCanvasEvent} arg - Argument to pass through to the callback function.
+    * @returns {module:svgcanvas.EventHandlerReturn|undefined}
+    */
+
+
+    var call = function call(ev, arg) {
+      if (events[ev]) {
+        return events[ev](window, arg);
+      }
+
+      return undefined;
+    };
+    /**
+    * Clears the selection. The 'selected' handler is then optionally called.
+    * This should really be an intersection applying to all types rather than a union.
+    * @function module:svgcanvas.SvgCanvas#clearSelection
+    * @implements {module:draw.DrawCanvasInit#clearSelection|module:path.EditorContext#clearSelection}
+    * @fires module:svgcanvas.SvgCanvas#event:selected
+    */
+
+
+    var clearSelection = this.clearSelection = function (noCall) {
+      selectedElements.forEach(function (elem) {
+        if (isNullish(elem)) {
+          return;
+        }
+
+        selectorManager.releaseSelector(elem);
+      });
+      selectedElements = [];
+
+      if (!noCall) {
+        call('selected', selectedElements);
+      }
+    };
+    /**
+    * Adds a list of elements to the selection. The 'selected' handler is then called.
+    * @function module:svgcanvas.SvgCanvas#addToSelection
+    * @implements {module:path.EditorContext#addToSelection}
+    * @fires module:svgcanvas.SvgCanvas#event:selected
+    */
+
+
+    var addToSelection = this.addToSelection = function (elemsToAdd, showGrips) {
+      if (!elemsToAdd.length) {
+        return;
+      } // find the first null in our selectedElements array
+
+
+      var j = 0;
+
+      while (j < selectedElements.length) {
+        if (isNullish(selectedElements[j])) {
+          break;
+        }
+
+        ++j;
+      } // now add each element consecutively
+
+
+      var i = elemsToAdd.length;
+
+      while (i--) {
+        var elem = elemsToAdd[i];
+
+        if (!elem) {
+          continue;
+        }
+
+        var bbox = getBBox(elem);
+
+        if (!bbox) {
+          continue;
+        }
+
+        if (elem.tagName === 'a' && elem.childNodes.length === 1) {
+          // Make "a" element's child be the selected element
+          elem = elem.firstChild;
+        } // if it's not already there, add it
+
+
+        if (!selectedElements.includes(elem)) {
+          selectedElements[j] = elem; // only the first selectedBBoxes element is ever used in the codebase these days
+          // if (j === 0) selectedBBoxes[0] = utilsGetBBox(elem);
+
+          j++;
+          var sel = selectorManager.requestSelector(elem, bbox);
+
+          if (selectedElements.length > 1) {
+            sel.showGrips(false);
+          }
+        }
+      }
+
+      call('selected', selectedElements);
+
+      if (showGrips || selectedElements.length === 1) {
+        selectorManager.requestSelector(selectedElements[0]).showGrips(true);
+      } else {
+        selectorManager.requestSelector(selectedElements[0]).showGrips(false);
+      } // make sure the elements are in the correct order
+      // See: https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-compareDocumentPosition
+
+
+      selectedElements.sort(function (a, b) {
+        if (a && b && a.compareDocumentPosition) {
+          return 3 - (b.compareDocumentPosition(a) & 6); // eslint-disable-line no-bitwise
+        }
+
+        if (isNullish(a)) {
+          return 1;
+        }
+
+        return 0;
+      }); // Make sure first elements are not null
+
+      while (isNullish(selectedElements[0])) {
+        selectedElements.shift(0);
+      }
+    };
+    /**
+    * @implements {module:path.EditorContext#getOpacity}
+    */
+
+
+    var getOpacity = function getOpacity() {
+      return curShape.opacity;
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getMouseTarget
+    * @implements {module:path.EditorContext#getMouseTarget}
+    */
+
+
+    var getMouseTarget = this.getMouseTarget = function (evt) {
+      if (isNullish(evt)) {
+        return null;
+      }
+
+      var mouseTarget = evt.target; // if it was a <use>, Opera and WebKit return the SVGElementInstance
+
+      if (mouseTarget.correspondingUseElement) {
+        mouseTarget = mouseTarget.correspondingUseElement;
+      } // for foreign content, go up until we find the foreignObject
+      // WebKit browsers set the mouse target to the svgcanvas div
+
+
+      if ([NS.MATH, NS.HTML].includes(mouseTarget.namespaceURI) && mouseTarget.id !== 'svgcanvas') {
+        while (mouseTarget.nodeName !== 'foreignObject') {
+          mouseTarget = mouseTarget.parentNode;
+
+          if (!mouseTarget) {
+            return svgroot;
+          }
+        }
+      } // Get the desired mouseTarget with jQuery selector-fu
+      // If it's root-like, select the root
+
+
+      var currentLayer = getCurrentDrawing().getCurrentLayer();
+
+      if ([svgroot, container, svgcontent, currentLayer].includes(mouseTarget)) {
+        return svgroot;
+      }
+
+      var $target = $$8(mouseTarget); // If it's a selection grip, return the grip parent
+
+      if ($target.closest('#selectorParentGroup').length) {
+        // While we could instead have just returned mouseTarget,
+        // this makes it easier to indentify as being a selector grip
+        return selectorManager.selectorParentGroup;
+      }
+
+      while (mouseTarget.parentNode !== (currentGroup || currentLayer)) {
+        mouseTarget = mouseTarget.parentNode;
+      } //
+      // // go up until we hit a child of a layer
+      // while (mouseTarget.parentNode.parentNode.tagName == 'g') {
+      //   mouseTarget = mouseTarget.parentNode;
+      // }
+      // Webkit bubbles the mouse event all the way up to the div, so we
+      // set the mouseTarget to the svgroot like the other browsers
+      // if (mouseTarget.nodeName.toLowerCase() == 'div') {
+      //   mouseTarget = svgroot;
+      // }
+
+
+      return mouseTarget;
+    };
+    /**
+    * @namespace {module:path.pathActions} pathActions
+    * @memberof module:svgcanvas.SvgCanvas#
+    * @see module:path.pathActions
+    */
+
+
+    canvas.pathActions = pathActions$$1;
+    /**
+    * @implements {module:path.EditorContext#resetD}
+    */
+
+    function resetD(p) {
+      p.setAttribute('d', pathActions$$1.convertPath(p));
+    }
+
+    init$1(
+    /**
+    * @implements {module:path.EditorContext}
+    */
+    {
+      selectorManager: selectorManager,
+      // Ok since not changing
+      canvas: canvas,
+      // Ok since not changing
+      call: call,
+      resetD: resetD,
+      round: round,
+      clearSelection: clearSelection,
+      addToSelection: addToSelection,
+      addCommandToHistory: addCommandToHistory,
+      remapElement: remapElement,
+      addSVGElementFromJson: addSVGElementFromJson,
+      getGridSnapping: getGridSnapping,
+      getOpacity: getOpacity,
+      getSelectedElements: getSelectedElements,
+      getContainer: function getContainer() {
+        return container;
+      },
+      setStarted: function setStarted(s) {
+        started = s;
+      },
+      getRubberBox: function getRubberBox() {
+        return rubberBox;
+      },
+      setRubberBox: function setRubberBox(rb) {
+        rubberBox = rb;
+        return rubberBox;
+      },
+
+      /**
+       * @param {PlainObject} ptsInfo
+       * @param {boolean} ptsInfo.closedSubpath
+       * @param {SVGCircleElement[]} ptsInfo.grips
+       * @fires module:svgcanvas.SvgCanvas#event:pointsAdded
+       * @fires module:svgcanvas.SvgCanvas#event:selected
+       * @returns {undefined}
+       */
+      addPtsToSelection: function addPtsToSelection(_ref) {
+        var closedSubpath = _ref.closedSubpath,
+            grips = _ref.grips;
+        // TODO: Correct this:
+        pathActions$$1.canDeleteNodes = true;
+        pathActions$$1.closed_subpath = closedSubpath;
+        call('pointsAdded', {
+          closedSubpath: closedSubpath,
+          grips: grips
+        });
+        call('selected', grips);
+      },
+
+      /**
+       * @param {PlainObject} changes
+       * @param {ChangeElementCommand} changes.cmd
+       * @param {SVGPathElement} changes.elem
+       * @fires module:svgcanvas.SvgCanvas#event:changed
+       * @returns {undefined}
+       */
+      endChanges: function endChanges(_ref2) {
+        var cmd = _ref2.cmd,
+            elem = _ref2.elem;
+        addCommandToHistory(cmd);
+        call('changed', [elem]);
+      },
+      getCurrentZoom: getCurrentZoom,
+      getId: getId,
+      getNextId: getNextId,
+      getMouseTarget: getMouseTarget,
+      getCurrentMode: function getCurrentMode() {
+        return currentMode;
+      },
+      setCurrentMode: function setCurrentMode(cm) {
+        currentMode = cm;
+        return currentMode;
+      },
+      getDrawnPath: function getDrawnPath() {
+        return drawnPath;
+      },
+      setDrawnPath: function setDrawnPath(dp) {
+        drawnPath = dp;
+        return drawnPath;
+      },
+      getSVGRoot: getSVGRoot
+    }); // Interface strings, usually for title elements
+
+    var uiStrings = {};
+    var visElems = 'a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use';
+    var refAttrs = ['clip-path', 'fill', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'stroke'];
+    var elData = $$8.data; // Animation element to change the opacity of any newly created element
+
+    var opacAni = document.createElementNS(NS.SVG, 'animate');
+    $$8(opacAni).attr({
+      attributeName: 'opacity',
+      begin: 'indefinite',
+      dur: 1,
+      fill: 'freeze'
+    }).appendTo(svgroot);
+
+    var restoreRefElems = function restoreRefElems(elem) {
+      // Look for missing reference elements, restore any found
+      var attrs = $$8(elem).attr(refAttrs);
+      Object.values(attrs).forEach(function (val) {
+        if (val && val.startsWith('url(')) {
+          var id = getUrlFromAttr(val).substr(1);
+          var ref = getElem(id);
+
+          if (!ref) {
+            findDefs().append(removedElements[id]);
+            delete removedElements[id];
+          }
+        }
+      });
+      var childs = elem.getElementsByTagName('*');
+
+      if (childs.length) {
+        for (var i = 0, l = childs.length; i < l; i++) {
+          restoreRefElems(childs[i]);
+        }
+      }
+    }; // (function () {
+    // TODO For Issue 208: this is a start on a thumbnail
+    //  const svgthumb = svgdoc.createElementNS(NS.SVG, 'use');
+    //  svgthumb.setAttribute('width', '100');
+    //  svgthumb.setAttribute('height', '100');
+    //  setHref(svgthumb, '#svgcontent');
+    //  svgroot.append(svgthumb);
+    // }());
+
+    /**
+     * @typedef {PlainObject} module:svgcanvas.SaveOptions
+     * @property {boolean} apply
+     * @property {"embed"} [image]
+     * @property {Integer} round_digits
+     */
+    // Object to contain image data for raster images that were found encodable
+
+
+    var encodableImages = {},
+        // Object with save options
+
+    /**
+     * @type {module:svgcanvas.SaveOptions}
+     */
+    saveOptions = {
+      round_digits: 5
+    },
+        // Object with IDs for imported files, to see if one was already added
+    importIds = {},
+        // Current text style properties
+    curText = allProperties.text,
+        // Object to contain all included extensions
+    extensions = {},
+        // Map of deleted reference elements
+    removedElements = {};
+    var // String with image URL of last loadable image
+    lastGoodImgUrl = curConfig.imgPath + 'logo.png',
+        // Boolean indicating whether or not a draw action has been started
+    started = false,
+        // String with an element's initial transform attribute value
+    startTransform = null,
+        // String indicating the current editor mode
+    currentMode = 'select',
+        // String with the current direction in which an element is being resized
+    currentResizeMode = 'none',
+        // Current general properties
+    curProperties = curShape,
+        // Array with selected elements' Bounding box object
+    // selectedBBoxes = new Array(1),
+    // The DOM element that was just selected
+    justSelected = null,
+        // DOM element for selection rectangle drawn by the user
+    rubberBox = null,
+        // Array of current BBoxes, used in getIntersectionList().
+    curBBoxes = [],
+        // Canvas point for the most recent right click
+    lastClickPoint = null;
+
+    this.runExtension = function (name, action, vars) {
+      return this.runExtensions(action, vars, false, function (n) {
+        return n === name;
+      });
+    };
+    /**
+    * @typedef {module:svgcanvas.ExtensionMouseDownStatus|module:svgcanvas.ExtensionMouseUpStatus|module:svgcanvas.ExtensionIDsUpdatedStatus|module:locale.ExtensionLocaleData[]|undefined} module:svgcanvas.ExtensionStatus
+    * @tutorial ExtensionDocs
+    */
+
+    /**
+    * @callback module:svgcanvas.ExtensionVarBuilder
+    * @param {string} name The name of the extension
+    * @returns {module:svgcanvas.SvgCanvas#event:ext-addLangData}
+    */
+
+    /**
+    * @callback module:svgcanvas.ExtensionNameFilter
+    * @param {string} name
+    * @returns {boolean}
+    */
+
+    /**
+    * @todo Consider: Should this return an array by default, so extension results aren't overwritten?
+    * @todo Would be easier to document if passing in object with key of action and vars as value; could then define an interface which tied both together
+    * @function module:svgcanvas.SvgCanvas#runExtensions
+    * @param {"mouseDown"|"mouseMove"|"mouseUp"|"zoomChanged"|"IDsUpdated"|"canvasUpdated"|"toolButtonStateUpdate"|"selectedChanged"|"elementTransition"|"elementChanged"|"langReady"|"langChanged"|"addLangData"|"onNewDocument"|"workareaResized"} action
+    * @param {module:svgcanvas.SvgCanvas#event:ext-mouseDown|module:svgcanvas.SvgCanvas#event:ext-mouseMove|module:svgcanvas.SvgCanvas#event:ext-mouseUp|module:svgcanvas.SvgCanvas#event:ext-zoomChanged|module:svgcanvas.SvgCanvas#event:ext-IDsUpdated|module:svgcanvas.SvgCanvas#event:ext-canvasUpdated|module:svgcanvas.SvgCanvas#event:ext-toolButtonStateUpdate|module:svgcanvas.SvgCanvas#event:ext-selectedChanged|module:svgcanvas.SvgCanvas#event:ext-elementTransition|module:svgcanvas.SvgCanvas#event:ext-elementChanged|module:svgcanvas.SvgCanvas#event:ext-langReady|module:svgcanvas.SvgCanvas#event:ext-langChanged|module:svgcanvas.SvgCanvas#event:ext-addLangData|module:svgcanvas.SvgCanvas#event:ext-onNewDocument|module:svgcanvas.SvgCanvas#event:ext-workareaResized|module:svgcanvas.ExtensionVarBuilder} [vars]
+    * @param {boolean} [returnArray]
+    * @param {module:svgcanvas.ExtensionNameFilter} nameFilter
+    * @returns {GenericArray.<module:svgcanvas.ExtensionStatus>|module:svgcanvas.ExtensionStatus|false} See {@tutorial ExtensionDocs} on the ExtensionStatus.
+    */
+
+
+    var runExtensions = this.runExtensions = function (action, vars, returnArray, nameFilter) {
+      var result = returnArray ? [] : false;
+      $$8.each(extensions, function (name, ext) {
+        if (nameFilter && !nameFilter(name)) {
+          return;
+        }
+
+        if (ext && action in ext) {
+          if (typeof vars === 'function') {
+            vars = vars(name); // ext, action
+          }
+
+          if (returnArray) {
+            result.push(ext[action](vars));
+          } else {
+            result = ext[action](vars);
+          }
+        }
+      });
+      return result;
+    };
+    /**
+    * @typedef {PlainObject} module:svgcanvas.ExtensionMouseDownStatus
+    * @property {boolean} started Indicates that creating/editing has started
+    */
+
+    /**
+    * @typedef {PlainObject} module:svgcanvas.ExtensionMouseUpStatus
+    * @property {boolean} keep Indicates if the current element should be kept
+    * @property {boolean} started Indicates if editing should still be considered as "started"
+    * @property {Element} element The element being affected
+    */
+
+    /**
+    * @typedef {PlainObject} module:svgcanvas.ExtensionIDsUpdatedStatus
+    * @property {string[]} remove Contains string IDs (used by `ext-connector.js`)
+    */
+
+    /**
+     * @interface module:svgcanvas.ExtensionInitResponse
+     * @property {module:SVGEditor.ContextTool[]|PlainObject.<string, module:SVGEditor.ContextTool>} [context_tools]
+     * @property {module:SVGEditor.Button[]|PlainObject.<Integer, module:SVGEditor.Button>} [buttons]
+     * @property {string} [svgicons] The location of a local SVG or SVGz file
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#mouseDown
+     * @param {module:svgcanvas.SvgCanvas#event:ext-mouseDown} arg
+     * @returns {undefined|module:svgcanvas.ExtensionMouseDownStatus}
+     */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#mouseMove
+     * @param {module:svgcanvas.SvgCanvas#event:ext-mouseMove} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#mouseUp
+     * @param {module:svgcanvas.SvgCanvas#event:ext-mouseUp} arg
+     * @returns {module:svgcanvas.ExtensionMouseUpStatus}
+     */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#zoomChanged
+     * @param {module:svgcanvas.SvgCanvas#event:ext-zoomChanged} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#IDsUpdated
+     * @param {module:svgcanvas.SvgCanvas#event:ext-IDsUpdated} arg
+     * @returns {module:svgcanvas.ExtensionIDsUpdatedStatus}
+     */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#canvasUpdated
+     * @param {module:svgcanvas.SvgCanvas#event:ext-canvasUpdated} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#toolButtonStateUpdate
+     * @param {module:svgcanvas.SvgCanvas#event:ext-toolButtonStateUpdate} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#selectedChanged
+     * @param {module:svgcanvas.SvgCanvas#event:ext-selectedChanged} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#elementTransition
+     * @param {module:svgcanvas.SvgCanvas#event:ext-elementTransition} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#elementChanged
+     * @param {module:svgcanvas.SvgCanvas#event:ext-elementChanged} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#langReady
+     * @param {module:svgcanvas.SvgCanvas#event:ext-langReady} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#langChanged
+     * @param {module:svgcanvas.SvgCanvas#event:ext-langChanged} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#addLangData
+     * @param {module:svgcanvas.SvgCanvas#event:ext-addLangData} arg
+     * @returns {Promise} Resolves to {@link module:locale.ExtensionLocaleData}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#onNewDocument
+     * @param {module:svgcanvas.SvgCanvas#event:ext-onNewDocument} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#workareaResized
+     * @param {module:svgcanvas.SvgCanvas#event:ext-workareaResized} arg
+     * @returns {undefined}
+    */
+
+    /**
+     * @function module:svgcanvas.ExtensionInitResponse#callback
+     * @this module:SVGEditor
+     * @param {module:svgcanvas.SvgCanvas#event:ext-callback} arg
+     * @returns {undefined}
+    */
+
+    /**
+    * @callback module:svgcanvas.ExtensionInitCallback
+    * @this module:SVGEditor
+    * @param {module:svgcanvas.ExtensionArgumentObject} arg
+    * @returns {Promise} Resolves to [ExtensionInitResponse]{@link module:svgcanvas.ExtensionInitResponse} or `undefined`
+    */
+
+    /**
+    * @typedef {PlainObject} module:svgcanvas.ExtensionInitArgs
+    * @param {external:jQuery} initArgs.$
+    * @param {module:SVGEditor~ImportLocale} initArgs.importLocale
+    */
+
+    /**
+    * Add an extension to the editor.
+    * @function module:svgcanvas.SvgCanvas#addExtension
+    * @param {string} name - String with the ID of the extension. Used internally; no need for i18n.
+    * @param {module:svgcanvas.ExtensionInitCallback} [extInitFunc] - Function supplied by the extension with its data
+    * @param {module:svgcanvas.ExtensionInitArgs} initArgs
+    * @fires module:svgcanvas.SvgCanvas#event:extension_added
+    * @throws {TypeError|Error} `TypeError` if `extInitFunc` is not a function, `Error`
+    *   if extension of supplied name already exists
+    * @returns {Promise} Resolves to `undefined`
+    */
+
+
+    this.addExtension =
+    /*#__PURE__*/
+    function () {
+      var _ref4 = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee(name, extInitFunc, _ref3) {
+        var jq, importLocale, argObj, extObj;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                jq = _ref3.$, importLocale = _ref3.importLocale;
+
+                if (!(typeof extInitFunc !== 'function')) {
+                  _context.next = 3;
+                  break;
+                }
+
+                throw new TypeError('Function argument expected for `svgcanvas.addExtension`');
+
+              case 3:
+                if (!(name in extensions)) {
+                  _context.next = 5;
+                  break;
+                }
+
+                throw new Error('Cannot add extension "' + name + '", an extension by that name already exists.');
+
+              case 5:
+                // Provide private vars/funcs here. Is there a better way to do this?
+
+                /**
+                 * @typedef {module:svgcanvas.PrivateMethods} module:svgcanvas.ExtensionArgumentObject
+                 * @property {SVGSVGElement} svgroot See {@link module:svgcanvas~svgroot}
+                 * @property {SVGSVGElement} svgcontent See {@link module:svgcanvas~svgcontent}
+                 * @property {!(string|Integer)} nonce See {@link module:draw.Drawing#getNonce}
+                 * @property {module:select.SelectorManager} selectorManager
+                 * @property {module:SVGEditor~ImportLocale} importLocale
+                 */
+
+                /**
+                 * @type {module:svgcanvas.ExtensionArgumentObject}
+                 * @see {@link module:svgcanvas.PrivateMethods} source for the other methods/properties
+                 */
+                argObj = $$8.extend(canvas.getPrivateMethods(), {
+                  $: jq,
+                  importLocale: importLocale,
+                  svgroot: svgroot,
+                  svgcontent: svgcontent,
+                  nonce: getCurrentDrawing().getNonce(),
+                  selectorManager: selectorManager
+                });
+                _context.next = 8;
+                return extInitFunc(argObj);
+
+              case 8:
+                extObj = _context.sent;
+
+                if (extObj) {
+                  extObj.name = name;
+                }
+
+                extensions[name] = extObj;
+                return _context.abrupt("return", call('extension_added', extObj));
+
+              case 12:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      return function (_x, _x2, _x3) {
+        return _ref4.apply(this, arguments);
+      };
+    }();
+    /**
+    * This method sends back an array or a NodeList full of elements that
+    * intersect the multi-select rubber-band-box on the currentLayer only.
+    *
+    * We brute-force `getIntersectionList` for browsers that do not support it (Firefox).
+    *
+    * Reference:
+    * Firefox does not implement `getIntersectionList()`, see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=501421}.
+    * @function module:svgcanvas.SvgCanvas#getIntersectionList
+    * @param {SVGRect} rect
+    * @returns {Element[]|NodeList} Bbox elements
+    */
+
+
+    var getIntersectionList = this.getIntersectionList = function (rect) {
+      if (isNullish(rubberBox)) {
+        return null;
+      }
+
+      var parent = currentGroup || getCurrentDrawing().getCurrentLayer();
+      var rubberBBox;
+
+      if (!rect) {
+        rubberBBox = rubberBox.getBBox();
+        var bb = svgcontent.createSVGRect();
+        ['x', 'y', 'width', 'height', 'top', 'right', 'bottom', 'left'].forEach(function (o) {
+          bb[o] = rubberBBox[o] / currentZoom;
+        });
+        rubberBBox = bb;
+      } else {
+        rubberBBox = svgcontent.createSVGRect();
+        rubberBBox.x = rect.x;
+        rubberBBox.y = rect.y;
+        rubberBBox.width = rect.width;
+        rubberBBox.height = rect.height;
+      }
+
+      var resultList = null;
+
+      if (!isIE) {
+        if (typeof svgroot.getIntersectionList === 'function') {
+          // Offset the bbox of the rubber box by the offset of the svgcontent element.
+          rubberBBox.x += parseInt(svgcontent.getAttribute('x'));
+          rubberBBox.y += parseInt(svgcontent.getAttribute('y'));
+          resultList = svgroot.getIntersectionList(rubberBBox, parent);
+        }
+      }
+
+      if (isNullish(resultList) || typeof resultList.item !== 'function') {
+        resultList = [];
+
+        if (!curBBoxes.length) {
+          // Cache all bboxes
+          curBBoxes = getVisibleElementsAndBBoxes(parent);
+        }
+
+        var i = curBBoxes.length;
+
+        while (i--) {
+          if (!rubberBBox.width) {
+            continue;
+          }
+
+          if (rectsIntersect(rubberBBox, curBBoxes[i].bbox)) {
+            resultList.push(curBBoxes[i].elem);
+          }
+        }
+      } // addToSelection expects an array, but it's ok to pass a NodeList
+      // because using square-bracket notation is allowed:
+      // https://www.w3.org/TR/DOM-Level-2-Core/ecma-script-binding.html
+
+
+      return resultList;
+    };
+
+    this.getStrokedBBox = getStrokedBBoxDefaultVisible;
+    this.getVisibleElements = getVisibleElements;
+    /**
+    * @typedef {PlainObject} ElementAndBBox
+    * @property {Element} elem - The element
+    * @property {module:utilities.BBoxObject} bbox - The element's BBox as retrieved from `getStrokedBBoxDefaultVisible`
+    */
+
+    /**
+    * Get all elements that have a BBox (excludes `<defs>`, `<title>`, etc).
+    * Note that 0-opacity, off-screen etc elements are still considered "visible"
+    * for this function.
+    * @function module:svgcanvas.SvgCanvas#getVisibleElementsAndBBoxes
+    * @param {Element} parent - The parent DOM element to search within
+    * @returns {ElementAndBBox[]} An array with objects that include:
+    */
+
+    var getVisibleElementsAndBBoxes = this.getVisibleElementsAndBBoxes = function (parent) {
+      if (!parent) {
+        parent = $$8(svgcontent).children(); // Prevent layers from being included
+      }
+
+      var contentElems = [];
+      $$8(parent).children().each(function (i, elem) {
+        if (elem.getBBox) {
+          contentElems.push({
+            elem: elem,
+            bbox: getStrokedBBoxDefaultVisible([elem])
+          });
+        }
+      });
+      return contentElems.reverse();
+    };
+    /**
+    * Wrap an SVG element into a group element, mark the group as 'gsvg'.
+    * @function module:svgcanvas.SvgCanvas#groupSvgElem
+    * @param {Element} elem - SVG element to wrap
+    * @returns {undefined}
+    */
+
+
+    var groupSvgElem = this.groupSvgElem = function (elem) {
+      var g = document.createElementNS(NS.SVG, 'g');
+      elem.replaceWith(g);
+      $$8(g).append(elem).data('gsvg', elem)[0].id = getNextId();
+    }; // Set scope for these functions
+    // Object to contain editor event names and callback functions
+
+
+    var events = {};
+    canvas.call = call;
+    /**
+     * Array of what was changed (elements, layers)
+     * @event module:svgcanvas.SvgCanvas#event:changed
+     * @type {Element[]}
+     */
+
+    /**
+     * Array of selected elements
+     * @event module:svgcanvas.SvgCanvas#event:selected
+     * @type {Element[]}
+     */
+
+    /**
+     * Array of selected elements
+     * @event module:svgcanvas.SvgCanvas#event:transition
+     * @type {Element[]}
+     */
+
+    /**
+     * The Element is always `SVGGElement`?
+     * If not `null`, will be the set current group element
+     * @event module:svgcanvas.SvgCanvas#event:contextset
+     * @type {null|Element}
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:pointsAdded
+     * @type {PlainObject}
+     * @property {boolean} closedSubpath
+     * @property {SVGCircleElement[]} grips Grips elements
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:zoomed
+     * @type {PlainObject}
+     * @property {Float} x
+     * @property {Float} y
+     * @property {Float} width
+     * @property {Float} height
+     * @property {0.5|2} factor
+     * @see module:SVGEditor.BBoxObjectWithFactor
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:updateCanvas
+     * @type {PlainObject}
+     * @property {false} center
+     * @property {module:math.XYObject} newCtr
+     */
+
+    /**
+     * @typedef {PlainObject} module:svgcanvas.ExtensionInitResponsePlusName
+     * @implements {module:svgcanvas.ExtensionInitResponse}
+     * @property {string} name The extension's resolved ID (whether explicit or based on file name)
+     */
+
+    /**
+     * Generalized extension object response of
+     * [`init()`]{@link module:svgcanvas.ExtensionInitCallback}
+     * along with the name of the extension.
+     * @event module:svgcanvas.SvgCanvas#event:extension_added
+     * @type {module:svgcanvas.ExtensionInitResponsePlusName|undefined}
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:extensions_added
+     * @type {undefined}
+    */
+
+    /**
+     * @typedef {PlainObject} module:svgcanvas.Message
+     * @property {Any} data The data
+     * @property {string} origin The origin
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:message
+     * @type {module:svgcanvas.Message}
+     */
+
+    /**
+     * SVG canvas converted to string
+     * @event module:svgcanvas.SvgCanvas#event:saved
+     * @type {string}
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:setnonce
+     * @type {!(string|Integer)}
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:unsetnonce
+     * @type {undefined}
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:zoomDone
+     * @type {undefined}
+    */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:cleared
+     * @type {undefined}
+    */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:exported
+     * @type {module:svgcanvas.ImageExportedResults}
+     */
+
+    /**
+     * @event module:svgcanvas.SvgCanvas#event:exportedPDF
+     * @type {module:svgcanvas.PDFExportedResults}
+     */
+
+    /**
+     * Creating a cover-all class until {@link https://github.com/jsdoc3/jsdoc/issues/1545} may be supported.
+     * `undefined` may be returned by {@link module:svgcanvas.SvgCanvas#event:extension_added} if the extension's `init` returns `undefined` It is also the type for the following events "zoomDone", "unsetnonce", "cleared", and "extensions_added".
+     * @event module:svgcanvas.SvgCanvas#event:GenericCanvasEvent
+     * @type {module:svgcanvas.SvgCanvas#event:selected|module:svgcanvas.SvgCanvas#event:changed|module:svgcanvas.SvgCanvas#event:contextset|module:svgcanvas.SvgCanvas#event:pointsAdded|module:svgcanvas.SvgCanvas#event:extension_added|module:svgcanvas.SvgCanvas#event:extensions_added|module:svgcanvas.SvgCanvas#event:message|module:svgcanvas.SvgCanvas#event:transition|module:svgcanvas.SvgCanvas#event:zoomed|module:svgcanvas.SvgCanvas#event:updateCanvas|module:svgcanvas.SvgCanvas#event:saved|module:svgcanvas.SvgCanvas#event:exported|module:svgcanvas.SvgCanvas#event:exportedPDF|module:svgcanvas.SvgCanvas#event:setnonce|module:svgcanvas.SvgCanvas#event:unsetnonce|undefined}
+     */
+
+    /**
+     * The promise return, if present, resolves to `undefined`
+     *  (`extension_added`, `exported`, `saved`)
+     * @typedef {Promise|undefined} module:svgcanvas.EventHandlerReturn
+    */
+
+    /**
+    * @callback module:svgcanvas.EventHandler
+    * @param {external:Window} win
+    * @param {module:svgcanvas.SvgCanvas#event:GenericCanvasEvent} arg
+    * @listens module:svgcanvas.SvgCanvas#event:GenericCanvasEvent
+    * @returns {module:svgcanvas.EventHandlerReturn}
+    */
+
+    /**
+    * Attaches a callback function to an event.
+    * @function module:svgcanvas.SvgCanvas#bind
+    * @param {"changed"|"contextset"|"selected"|"pointsAdded"|"extension_added"|"extensions_added"|"message"|"transition"|"zoomed"|"updateCanvas"|"zoomDone"|"saved"|"exported"|"exportedPDF"|"setnonce"|"unsetnonce"|"cleared"} ev - String indicating the name of the event
+    * @param {module:svgcanvas.EventHandler} f - The callback function to bind to the event
+    * @returns {module:svgcanvas.EventHandler} The previous event
+    */
+
+    canvas.bind = function (ev, f) {
+      var old = events[ev];
+      events[ev] = f;
+      return old;
+    };
+    /**
+    * Runs the SVG Document through the sanitizer and then updates its paths.
+    * @function module:svgcanvas.SvgCanvas#prepareSvg
+    * @param {XMLDocument} newDoc - The SVG DOM document
+    * @returns {undefined}
+    */
+
+
+    this.prepareSvg = function (newDoc) {
+      this.sanitizeSvg(newDoc.documentElement); // convert paths into absolute commands
+
+      var paths = _toConsumableArray(newDoc.getElementsByTagNameNS(NS.SVG, 'path'));
+
+      paths.forEach(function (path$$1) {
+        path$$1.setAttribute('d', pathActions$$1.convertPath(path$$1));
+        pathActions$$1.fixEnd(path$$1);
+      });
+    };
+    /**
+    * Hack for Firefox bugs where text element features aren't updated or get
+    * messed up. See issue 136 and issue 137.
+    * This function clones the element and re-selects it.
+    * @function module:svgcanvas~ffClone
+    * @todo Test for this bug on load and add it to "support" object instead of
+    * browser sniffing
+    * @param {Element} elem - The (text) DOM element to clone
+    * @returns {Element} Cloned element
+    */
+
+
+    var ffClone = function ffClone(elem) {
+      if (!isGecko()) {
+        return elem;
+      }
+
+      var clone = elem.cloneNode(true);
+      elem.before(clone);
+      elem.remove();
+      selectorManager.releaseSelector(elem);
+      selectedElements[0] = clone;
+      selectorManager.requestSelector(clone).showGrips(true);
+      return clone;
+    }; // `this.each` is deprecated, if any extension used this it can be recreated by doing this:
+    // * @example $(canvas.getRootElem()).children().each(...)
+    // * @function module:svgcanvas.SvgCanvas#each
+    // this.each = function (cb) {
+    //  $(svgroot).children().each(cb);
+    // };
+
+    /**
+    * Removes any old rotations if present, prepends a new rotation at the
+    * transformed center.
+    * @function module:svgcanvas.SvgCanvas#setRotationAngle
+    * @param {string|Float} val - The new rotation angle in degrees
+    * @param {boolean} preventUndo - Indicates whether the action should be undoable or not
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.setRotationAngle = function (val, preventUndo) {
+      // ensure val is the proper type
+      val = parseFloat(val);
+      var elem = selectedElements[0];
+      var oldTransform = elem.getAttribute('transform');
+      var bbox = getBBox(elem);
+      var cx = bbox.x + bbox.width / 2,
+          cy = bbox.y + bbox.height / 2;
+      var tlist = getTransformList(elem); // only remove the real rotational transform if present (i.e. at index=0)
+
+      if (tlist.numberOfItems > 0) {
+        var xform = tlist.getItem(0);
+
+        if (xform.type === 4) {
+          tlist.removeItem(0);
+        }
+      } // find Rnc and insert it
+
+
+      if (val !== 0) {
+        var center = transformPoint(cx, cy, transformListToTransform(tlist).matrix);
+        var Rnc = svgroot.createSVGTransform();
+        Rnc.setRotate(val, center.x, center.y);
+
+        if (tlist.numberOfItems) {
+          tlist.insertItemBefore(Rnc, 0);
+        } else {
+          tlist.appendItem(Rnc);
+        }
+      } else if (tlist.numberOfItems === 0) {
+        elem.removeAttribute('transform');
+      }
+
+      if (!preventUndo) {
+        // we need to undo it, then redo it so it can be undo-able! :)
+        // TODO: figure out how to make changes to transform list undo-able cross-browser?
+        var newTransform = elem.getAttribute('transform');
+        elem.setAttribute('transform', oldTransform);
+        changeSelectedAttribute('transform', newTransform, selectedElements);
+        call('changed', selectedElements);
+      } // const pointGripContainer = getElem('pathpointgrip_container');
+      // if (elem.nodeName === 'path' && pointGripContainer) {
+      //   pathActions.setPointContainerTransform(elem.getAttribute('transform'));
+      // }
+
+
+      var selector = selectorManager.requestSelector(selectedElements[0]);
+      selector.resize();
+      Selector.updateGripCursors(val);
+    };
+    /**
+    * Runs `recalculateDimensions` on the selected elements,
+    * adding the changes to a single batch command.
+    * @function module:svgcanvas.SvgCanvas#recalculateAllSelectedDimensions
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    var recalculateAllSelectedDimensions = this.recalculateAllSelectedDimensions = function () {
+      var text = currentResizeMode === 'none' ? 'position' : 'size';
+      var batchCmd = new BatchCommand$1(text);
+      var i = selectedElements.length;
+
+      while (i--) {
+        var elem = selectedElements[i]; // if (getRotationAngle(elem) && !hasMatrixTransform(getTransformList(elem))) { continue; }
+
+        var cmd = recalculateDimensions(elem);
+
+        if (cmd) {
+          batchCmd.addSubCommand(cmd);
+        }
+      }
+
+      if (!batchCmd.isEmpty()) {
+        addCommandToHistory(batchCmd);
+        call('changed', selectedElements);
+      }
+    };
+    /**
+     * Debug tool to easily see the current matrix in the browser's console.
+     * @function module:svgcanvas~logMatrix
+     * @param {SVGMatrix} m The matrix
+     * @returns {undefined}
+     */
+
+
+    var logMatrix = function logMatrix(m) {
+      console.log([m.a, m.b, m.c, m.d, m.e, m.f]); // eslint-disable-line no-console
+    }; // Root Current Transformation Matrix in user units
+
+
+    var rootSctm = null;
+    /**
+    * Group: Selection
+    */
+    // TODO: do we need to worry about selectedBBoxes here?
+
+    /**
+    * Selects only the given elements, shortcut for `clearSelection(); addToSelection()`.
+    * @function module:svgcanvas.SvgCanvas#selectOnly
+    * @param {Element[]} elems - an array of DOM elements to be selected
+    * @param {boolean} showGrips - Indicates whether the resize grips should be shown
+    * @returns {undefined}
+    */
+
+    var selectOnly = this.selectOnly = function (elems, showGrips) {
+      clearSelection(true);
+      addToSelection(elems, showGrips);
+    }; // TODO: could use slice here to make this faster?
+    // TODO: should the 'selected' handler
+
+    /**
+    * Removes elements from the selection.
+    * @function module:svgcanvas.SvgCanvas#removeFromSelection
+    * @param {Element[]} elemsToRemove - An array of elements to remove from selection
+    * @returns {undefined}
+    */
+
+    /* const removeFromSelection = */
+
+
+    this.removeFromSelection = function (elemsToRemove) {
+      if (isNullish(selectedElements[0])) {
+        return;
+      }
+
+      if (!elemsToRemove.length) {
+        return;
+      } // find every element and remove it from our array copy
+
+
+      var newSelectedItems = [],
+          len = selectedElements.length;
+
+      for (var i = 0; i < len; ++i) {
+        var elem = selectedElements[i];
+
+        if (elem) {
+          // keep the item
+          if (!elemsToRemove.includes(elem)) {
+            newSelectedItems.push(elem);
+          } else {
+            // remove the item and its selector
+            selectorManager.releaseSelector(elem);
+          }
+        }
+      } // the copy becomes the master now
+
+
+      selectedElements = newSelectedItems;
+    };
+    /**
+    * Clears the selection, then adds all elements in the current layer to the selection.
+    * @function module:svgcanvas.SvgCanvas#selectAllInCurrentLayer
+    * @returns {undefined}
+    */
+
+
+    this.selectAllInCurrentLayer = function () {
+      var currentLayer = getCurrentDrawing().getCurrentLayer();
+
+      if (currentLayer) {
+        currentMode = 'select';
+        selectOnly($$8(currentGroup || currentLayer).children());
+      }
+    };
+
+    var drawnPath = null; // Mouse events
+
+    (function () {
+      var freehand = {
+        minx: null,
+        miny: null,
+        maxx: null,
+        maxy: null
+      };
+      var THRESHOLD_DIST = 0.8,
+          STEP_COUNT = 10;
+      var dAttr = null,
+          startX = null,
+          startY = null,
+          rStartX = null,
+          rStartY = null,
+          initBbox = {},
+          sumDistance = 0,
+          controllPoint2 = {
+        x: 0,
+        y: 0
+      },
+          controllPoint1 = {
+        x: 0,
+        y: 0
+      },
+          start = {
+        x: 0,
+        y: 0
+      },
+          end = {
+        x: 0,
+        y: 0
+      },
+          bSpline = {
+        x: 0,
+        y: 0
+      },
+          nextPos = {
+        x: 0,
+        y: 0
+      },
+          parameter,
+          nextParameter;
+
+      var getBsplinePoint = function getBsplinePoint(t) {
+        var spline = {
+          x: 0,
+          y: 0
+        },
+            p0 = controllPoint2,
+            p1 = controllPoint1,
+            p2 = start,
+            p3 = end,
+            S = 1.0 / 6.0,
+            t2 = t * t,
+            t3 = t2 * t;
+        var m = [[-1, 3, -3, 1], [3, -6, 3, 0], [-3, 0, 3, 0], [1, 4, 1, 0]];
+        spline.x = S * ((p0.x * m[0][0] + p1.x * m[0][1] + p2.x * m[0][2] + p3.x * m[0][3]) * t3 + (p0.x * m[1][0] + p1.x * m[1][1] + p2.x * m[1][2] + p3.x * m[1][3]) * t2 + (p0.x * m[2][0] + p1.x * m[2][1] + p2.x * m[2][2] + p3.x * m[2][3]) * t + (p0.x * m[3][0] + p1.x * m[3][1] + p2.x * m[3][2] + p3.x * m[3][3]));
+        spline.y = S * ((p0.y * m[0][0] + p1.y * m[0][1] + p2.y * m[0][2] + p3.y * m[0][3]) * t3 + (p0.y * m[1][0] + p1.y * m[1][1] + p2.y * m[1][2] + p3.y * m[1][3]) * t2 + (p0.y * m[2][0] + p1.y * m[2][1] + p2.y * m[2][2] + p3.y * m[2][3]) * t + (p0.y * m[3][0] + p1.y * m[3][1] + p2.y * m[3][2] + p3.y * m[3][3]));
+        return {
+          x: spline.x,
+          y: spline.y
+        };
+      };
+      /**
+       * Follows these conditions:
+       * - When we are in a create mode, the element is added to the canvas but the
+       *   action is not recorded until mousing up.
+       * - When we are in select mode, select the element, remember the position
+       *   and do nothing else.
+       * @param {MouseEvent} evt
+       * @fires module:svgcanvas.SvgCanvas#event:ext-mouseDown
+       * @returns {undefined}
+       */
+
+
+      var mouseDown = function mouseDown(evt) {
+        if (canvas.spaceKey || evt.button === 1) {
+          return;
+        }
+
+        var rightClick = evt.button === 2;
+
+        if (evt.altKey) {
+          // duplicate when dragging
+          canvas.cloneSelectedElements(0, 0);
+        }
+
+        rootSctm = $$8('#svgcontent g')[0].getScreenCTM().inverse();
+        var pt = transformPoint(evt.pageX, evt.pageY, rootSctm),
+            mouseX = pt.x * currentZoom,
+            mouseY = pt.y * currentZoom;
+        evt.preventDefault();
+
+        if (rightClick) {
+          currentMode = 'select';
+          lastClickPoint = pt;
+        } // This would seem to be unnecessary...
+        // if (!['select', 'resize'].includes(currentMode)) {
+        //   setGradient();
+        // }
+
+
+        var x = mouseX / currentZoom,
+            y = mouseY / currentZoom;
+        var mouseTarget = getMouseTarget(evt);
+
+        if (mouseTarget.tagName === 'a' && mouseTarget.childNodes.length === 1) {
+          mouseTarget = mouseTarget.firstChild;
+        } // realX/y ignores grid-snap value
+
+
+        var realX = x;
+        rStartX = startX = x;
+        var realY = y;
+        rStartY = startY = y;
+
+        if (curConfig.gridSnapping) {
+          x = snapToGrid(x);
+          y = snapToGrid(y);
+          startX = snapToGrid(startX);
+          startY = snapToGrid(startY);
+        } // if it is a selector grip, then it must be a single element selected,
+        // set the mouseTarget to that and update the mode to rotate/resize
+
+
+        if (mouseTarget === selectorManager.selectorParentGroup && !isNullish(selectedElements[0])) {
+          var grip = evt.target;
+          var griptype = elData(grip, 'type'); // rotating
+
+          if (griptype === 'rotate') {
+            currentMode = 'rotate'; // resizing
+          } else if (griptype === 'resize') {
+            currentMode = 'resize';
+            currentResizeMode = elData(grip, 'dir');
+          }
+
+          mouseTarget = selectedElements[0];
+        }
+
+        startTransform = mouseTarget.getAttribute('transform');
+        var tlist = getTransformList(mouseTarget);
+
+        switch (currentMode) {
+          case 'select':
+            started = true;
+            currentResizeMode = 'none';
+
+            if (rightClick) {
+              started = false;
+            }
+
+            if (mouseTarget !== svgroot) {
+              // if this element is not yet selected, clear selection and select it
+              if (!selectedElements.includes(mouseTarget)) {
+                // only clear selection if shift is not pressed (otherwise, add
+                // element to selection)
+                if (!evt.shiftKey) {
+                  // No need to do the call here as it will be done on addToSelection
+                  clearSelection(true);
+                }
+
+                addToSelection([mouseTarget]);
+                justSelected = mouseTarget;
+                pathActions$$1.clear();
+              } // else if it's a path, go into pathedit mode in mouseup
+
+
+              if (!rightClick) {
+                // insert a dummy transform so if the element(s) are moved it will have
+                // a transform to use for its translate
+                for (var i = 0; i < selectedElements.length; ++i) {
+                  if (isNullish(selectedElements[i])) {
+                    continue;
+                  }
+
+                  var slist = getTransformList(selectedElements[i]);
+
+                  if (slist.numberOfItems) {
+                    slist.insertItemBefore(svgroot.createSVGTransform(), 0);
+                  } else {
+                    slist.appendItem(svgroot.createSVGTransform());
+                  }
+                }
+              }
+            } else if (!rightClick) {
+              clearSelection();
+              currentMode = 'multiselect';
+
+              if (isNullish(rubberBox)) {
+                rubberBox = selectorManager.getRubberBandBox();
+              }
+
+              rStartX *= currentZoom;
+              rStartY *= currentZoom; // console.log('p',[evt.pageX, evt.pageY]);
+              // console.log('c',[evt.clientX, evt.clientY]);
+              // console.log('o',[evt.offsetX, evt.offsetY]);
+              // console.log('s',[startX, startY]);
+
+              assignAttributes(rubberBox, {
+                x: rStartX,
+                y: rStartY,
+                width: 0,
+                height: 0,
+                display: 'inline'
+              }, 100);
+            }
+
+            break;
+
+          case 'zoom':
+            started = true;
+
+            if (isNullish(rubberBox)) {
+              rubberBox = selectorManager.getRubberBandBox();
+            }
+
+            assignAttributes(rubberBox, {
+              x: realX * currentZoom,
+              y: realX * currentZoom,
+              width: 0,
+              height: 0,
+              display: 'inline'
+            }, 100);
+            break;
+
+          case 'resize':
+            {
+              started = true;
+              startX = x;
+              startY = y; // Getting the BBox from the selection box, since we know we
+              // want to orient around it
+
+              initBbox = getBBox($$8('#selectedBox0')[0]);
+              var bb = {};
+              $$8.each(initBbox, function (key, val) {
+                bb[key] = val / currentZoom;
+              });
+              initBbox = bb; // append three dummy transforms to the tlist so that
+              // we can translate,scale,translate in mousemove
+
+              var pos = getRotationAngle(mouseTarget) ? 1 : 0;
+
+              if (hasMatrixTransform(tlist)) {
+                tlist.insertItemBefore(svgroot.createSVGTransform(), pos);
+                tlist.insertItemBefore(svgroot.createSVGTransform(), pos);
+                tlist.insertItemBefore(svgroot.createSVGTransform(), pos);
+              } else {
+                tlist.appendItem(svgroot.createSVGTransform());
+                tlist.appendItem(svgroot.createSVGTransform());
+                tlist.appendItem(svgroot.createSVGTransform());
+
+                if (supportsNonScalingStroke()) {
+                  // Handle crash for newer Chrome and Safari 6 (Mobile and Desktop):
+                  // https://code.google.com/p/svg-edit/issues/detail?id=904
+                  // Chromium issue: https://code.google.com/p/chromium/issues/detail?id=114625
+                  // TODO: Remove this workaround once vendor fixes the issue
+                  var iswebkit = isWebkit();
+                  var delayedStroke;
+
+                  if (iswebkit) {
+                    delayedStroke = function delayedStroke(ele) {
+                      var _stroke = ele.getAttribute('stroke');
+
+                      ele.removeAttribute('stroke'); // Re-apply stroke after delay. Anything higher than 1 seems to cause flicker
+
+                      if (_stroke !== null) setTimeout(function () {
+                        ele.setAttribute('stroke', _stroke);
+                      }, 0);
+                    };
+                  }
+
+                  mouseTarget.style.vectorEffect = 'non-scaling-stroke';
+
+                  if (iswebkit) {
+                    delayedStroke(mouseTarget);
+                  }
+
+                  var all = mouseTarget.getElementsByTagName('*'),
+                      len = all.length;
+
+                  for (var _i2 = 0; _i2 < len; _i2++) {
+                    if (!all[_i2].style) {
+                      // mathML
+                      continue;
+                    }
+
+                    all[_i2].style.vectorEffect = 'non-scaling-stroke';
+
+                    if (iswebkit) {
+                      delayedStroke(all[_i2]);
+                    }
+                  }
+                }
+              }
+
+              break;
+            }
+
+          case 'fhellipse':
+          case 'fhrect':
+          case 'fhpath':
+            start.x = realX;
+            start.y = realY;
+            started = true;
+            dAttr = realX + ',' + realY + ' '; // Commented out as doing nothing now:
+            // strokeW = parseFloat(curShape.stroke_width) === 0 ? 1 : curShape.stroke_width;
+
+            addSVGElementFromJson({
+              element: 'polyline',
+              curStyles: true,
+              attr: {
+                points: dAttr,
+                id: getNextId(),
+                fill: 'none',
+                opacity: curShape.opacity / 2,
+                'stroke-linecap': 'round',
+                style: 'pointer-events:none'
+              }
+            });
+            freehand.minx = realX;
+            freehand.maxx = realX;
+            freehand.miny = realY;
+            freehand.maxy = realY;
+            break;
+
+          case 'image':
+            {
+              started = true;
+              var newImage = addSVGElementFromJson({
+                element: 'image',
+                attr: {
+                  x: x,
+                  y: y,
+                  width: 0,
+                  height: 0,
+                  id: getNextId(),
+                  opacity: curShape.opacity / 2,
+                  style: 'pointer-events:inherit'
+                }
+              });
+              setHref(newImage, lastGoodImgUrl);
+              preventClickDefault(newImage);
+              break;
+            }
+
+          case 'square': // FIXME: once we create the rect, we lose information that this was a square
+          // (for resizing purposes this could be important)
+          // Fallthrough
+
+          case 'rect':
+            started = true;
+            startX = x;
+            startY = y;
+            addSVGElementFromJson({
+              element: 'rect',
+              curStyles: true,
+              attr: {
+                x: x,
+                y: y,
+                width: 0,
+                height: 0,
+                id: getNextId(),
+                opacity: curShape.opacity / 2
+              }
+            });
+            break;
+
+          case 'line':
+            {
+              started = true;
+              var strokeW = Number(curShape.stroke_width) === 0 ? 1 : curShape.stroke_width;
+              addSVGElementFromJson({
+                element: 'line',
+                curStyles: true,
+                attr: {
+                  x1: x,
+                  y1: y,
+                  x2: x,
+                  y2: y,
+                  id: getNextId(),
+                  stroke: curShape.stroke,
+                  'stroke-width': strokeW,
+                  'stroke-dasharray': curShape.stroke_dasharray,
+                  'stroke-linejoin': curShape.stroke_linejoin,
+                  'stroke-linecap': curShape.stroke_linecap,
+                  'stroke-opacity': curShape.stroke_opacity,
+                  fill: 'none',
+                  opacity: curShape.opacity / 2,
+                  style: 'pointer-events:none'
+                }
+              });
+              break;
+            }
+
+          case 'circle':
+            started = true;
+            addSVGElementFromJson({
+              element: 'circle',
+              curStyles: true,
+              attr: {
+                cx: x,
+                cy: y,
+                r: 0,
+                id: getNextId(),
+                opacity: curShape.opacity / 2
+              }
+            });
+            break;
+
+          case 'ellipse':
+            started = true;
+            addSVGElementFromJson({
+              element: 'ellipse',
+              curStyles: true,
+              attr: {
+                cx: x,
+                cy: y,
+                rx: 0,
+                ry: 0,
+                id: getNextId(),
+                opacity: curShape.opacity / 2
+              }
+            });
+            break;
+
+          case 'text':
+            started = true;
+            /* const newText = */
+
+            addSVGElementFromJson({
+              element: 'text',
+              curStyles: true,
+              attr: {
+                x: x,
+                y: y,
+                id: getNextId(),
+                fill: curText.fill,
+                'stroke-width': curText.stroke_width,
+                'font-size': curText.font_size,
+                'font-family': curText.font_family,
+                'text-anchor': 'middle',
+                'xml:space': 'preserve',
+                opacity: curShape.opacity
+              }
+            }); // newText.textContent = 'text';
+
+            break;
+
+          case 'path': // Fall through
+
+          case 'pathedit':
+            startX *= currentZoom;
+            startY *= currentZoom;
+            pathActions$$1.mouseDown(evt, mouseTarget, startX, startY);
+            started = true;
+            break;
+
+          case 'textedit':
+            startX *= currentZoom;
+            startY *= currentZoom;
+            textActions.mouseDown(evt, mouseTarget, startX, startY);
+            started = true;
+            break;
+
+          case 'rotate':
+            started = true; // we are starting an undoable change (a drag-rotation)
+
+            canvas.undoMgr.beginUndoableChange('transform', selectedElements);
+            break;
+
+          default:
+            // This could occur in an extension
+            break;
+        }
+        /**
+         * The main (left) mouse button is held down on the canvas area
+         * @event module:svgcanvas.SvgCanvas#event:ext-mouseDown
+         * @type {PlainObject}
+         * @property {MouseEvent} event The event object
+         * @property {Float} start_x x coordinate on canvas
+         * @property {Float} start_y y coordinate on canvas
+         * @property {Element[]} selectedElements An array of the selected Elements
+        */
+
+
+        var extResult = runExtensions('mouseDown',
+        /** @type {module:svgcanvas.SvgCanvas#event:ext-mouseDown} */
+        {
+          event: evt,
+          start_x: startX,
+          start_y: startY,
+          selectedElements: selectedElements
+        }, true);
+        $$8.each(extResult, function (i, r) {
+          if (r && r.started) {
+            started = true;
+          }
+        });
+      }; // in this function we do not record any state changes yet (but we do update
+      // any elements that are still being created, moved or resized on the canvas)
+
+      /**
+       *
+       * @param {MouseEvent} evt
+       * @fires module:svgcanvas.SvgCanvas#event:transition
+       * @fires module:svgcanvas.SvgCanvas#event:ext-mouseMove
+       * @returns {undefined}
+       */
+
+
+      var mouseMove = function mouseMove(evt) {
+        if (!started) {
+          return;
+        }
+
+        if (evt.button === 1 || canvas.spaceKey) {
+          return;
+        }
+
+        var i,
+            xya,
+            c,
+            cx,
+            cy,
+            dx,
+            dy,
+            len,
+            angle,
+            box,
+            selected = selectedElements[0];
+        var pt = transformPoint(evt.pageX, evt.pageY, rootSctm),
+            mouseX = pt.x * currentZoom,
+            mouseY = pt.y * currentZoom,
+            shape = getElem(getId());
+        var realX = mouseX / currentZoom;
+        var x = realX;
+        var realY = mouseY / currentZoom;
+        var y = realY;
+
+        if (curConfig.gridSnapping) {
+          x = snapToGrid(x);
+          y = snapToGrid(y);
+        }
+
+        evt.preventDefault();
+        var tlist;
+
+        switch (currentMode) {
+          case 'select':
+            {
+              // we temporarily use a translate on the element(s) being dragged
+              // this transform is removed upon mousing up and the element is
+              // relocated to the new location
+              if (selectedElements[0] !== null) {
+                dx = x - startX;
+                dy = y - startY;
+
+                if (curConfig.gridSnapping) {
+                  dx = snapToGrid(dx);
+                  dy = snapToGrid(dy);
+                }
+                /*
+                // Commenting out as currently has no effect
+                if (evt.shiftKey) {
+                  xya = snapToAngle(startX, startY, x, y);
+                  ({x, y} = xya);
+                }
+                */
+
+
+                if (dx !== 0 || dy !== 0) {
+                  len = selectedElements.length;
+
+                  for (i = 0; i < len; ++i) {
+                    selected = selectedElements[i];
+
+                    if (isNullish(selected)) {
+                      break;
+                    } // if (i === 0) {
+                    //   const box = utilsGetBBox(selected);
+                    //     selectedBBoxes[i].x = box.x + dx;
+                    //     selectedBBoxes[i].y = box.y + dy;
+                    // }
+                    // update the dummy transform in our transform list
+                    // to be a translate
+
+
+                    var xform = svgroot.createSVGTransform();
+                    tlist = getTransformList(selected); // Note that if Webkit and there's no ID for this
+                    // element, the dummy transform may have gotten lost.
+                    // This results in unexpected behaviour
+
+                    xform.setTranslate(dx, dy);
+
+                    if (tlist.numberOfItems) {
+                      tlist.replaceItem(xform, 0);
+                    } else {
+                      tlist.appendItem(xform);
+                    } // update our internal bbox that we're tracking while dragging
+
+
+                    selectorManager.requestSelector(selected).resize();
+                  }
+
+                  call('transition', selectedElements);
+                }
+              }
+
+              break;
+            }
+
+          case 'multiselect':
+            {
+              realX *= currentZoom;
+              realY *= currentZoom;
+              assignAttributes(rubberBox, {
+                x: Math.min(rStartX, realX),
+                y: Math.min(rStartY, realY),
+                width: Math.abs(realX - rStartX),
+                height: Math.abs(realY - rStartY)
+              }, 100); // for each selected:
+              // - if newList contains selected, do nothing
+              // - if newList doesn't contain selected, remove it from selected
+              // - for any newList that was not in selectedElements, add it to selected
+
+              var elemsToRemove = selectedElements.slice(),
+                  elemsToAdd = [],
+                  newList = getIntersectionList(); // For every element in the intersection, add if not present in selectedElements.
+
+              len = newList.length;
+
+              for (i = 0; i < len; ++i) {
+                var intElem = newList[i]; // Found an element that was not selected before, so we should add it.
+
+                if (!selectedElements.includes(intElem)) {
+                  elemsToAdd.push(intElem);
+                } // Found an element that was already selected, so we shouldn't remove it.
+
+
+                var foundInd = elemsToRemove.indexOf(intElem);
+
+                if (foundInd !== -1) {
+                  elemsToRemove.splice(foundInd, 1);
+                }
+              }
+
+              if (elemsToRemove.length > 0) {
+                canvas.removeFromSelection(elemsToRemove);
+              }
+
+              if (elemsToAdd.length > 0) {
+                canvas.addToSelection(elemsToAdd);
+              }
+
+              break;
+            }
+
+          case 'resize':
+            {
+              // we track the resize bounding box and translate/scale the selected element
+              // while the mouse is down, when mouse goes up, we use this to recalculate
+              // the shape's coordinates
+              tlist = getTransformList(selected);
+              var hasMatrix = hasMatrixTransform(tlist);
+              box = hasMatrix ? initBbox : getBBox(selected);
+              var left = box.x,
+                  top = box.y,
+                  _box = box,
+                  width = _box.width,
+                  height = _box.height;
+              dx = x - startX;
+              dy = y - startY;
+
+              if (curConfig.gridSnapping) {
+                dx = snapToGrid(dx);
+                dy = snapToGrid(dy);
+                height = snapToGrid(height);
+                width = snapToGrid(width);
+              } // if rotated, adjust the dx,dy values
+
+
+              angle = getRotationAngle(selected);
+
+              if (angle) {
+                var r = Math.sqrt(dx * dx + dy * dy),
+                    theta = Math.atan2(dy, dx) - angle * Math.PI / 180.0;
+                dx = r * Math.cos(theta);
+                dy = r * Math.sin(theta);
+              } // if not stretching in y direction, set dy to 0
+              // if not stretching in x direction, set dx to 0
+
+
+              if (!currentResizeMode.includes('n') && !currentResizeMode.includes('s')) {
+                dy = 0;
+              }
+
+              if (!currentResizeMode.includes('e') && !currentResizeMode.includes('w')) {
+                dx = 0;
+              }
+
+              var // ts = null,
+              tx = 0,
+                  ty = 0,
+                  sy = height ? (height + dy) / height : 1,
+                  sx = width ? (width + dx) / width : 1; // if we are dragging on the north side, then adjust the scale factor and ty
+
+              if (currentResizeMode.includes('n')) {
+                sy = height ? (height - dy) / height : 1;
+                ty = height;
+              } // if we dragging on the east side, then adjust the scale factor and tx
+
+
+              if (currentResizeMode.includes('w')) {
+                sx = width ? (width - dx) / width : 1;
+                tx = width;
+              } // update the transform list with translate,scale,translate
+
+
+              var translateOrigin = svgroot.createSVGTransform(),
+                  scale = svgroot.createSVGTransform(),
+                  translateBack = svgroot.createSVGTransform();
+
+              if (curConfig.gridSnapping) {
+                left = snapToGrid(left);
+                tx = snapToGrid(tx);
+                top = snapToGrid(top);
+                ty = snapToGrid(ty);
+              }
+
+              translateOrigin.setTranslate(-(left + tx), -(top + ty));
+
+              if (evt.shiftKey) {
+                if (sx === 1) {
+                  sx = sy;
+                } else {
+                  sy = sx;
+                }
+              }
+
+              scale.setScale(sx, sy);
+              translateBack.setTranslate(left + tx, top + ty);
+
+              if (hasMatrix) {
+                var diff = angle ? 1 : 0;
+                tlist.replaceItem(translateOrigin, 2 + diff);
+                tlist.replaceItem(scale, 1 + diff);
+                tlist.replaceItem(translateBack, Number(diff));
+              } else {
+                var N = tlist.numberOfItems;
+                tlist.replaceItem(translateBack, N - 3);
+                tlist.replaceItem(scale, N - 2);
+                tlist.replaceItem(translateOrigin, N - 1);
+              }
+
+              selectorManager.requestSelector(selected).resize();
+              call('transition', selectedElements);
+              break;
+            }
+
+          case 'zoom':
+            {
+              realX *= currentZoom;
+              realY *= currentZoom;
+              assignAttributes(rubberBox, {
+                x: Math.min(rStartX * currentZoom, realX),
+                y: Math.min(rStartY * currentZoom, realY),
+                width: Math.abs(realX - rStartX * currentZoom),
+                height: Math.abs(realY - rStartY * currentZoom)
+              }, 100);
+              break;
+            }
+
+          case 'text':
+            {
+              assignAttributes(shape, {
+                x: x,
+                y: y
+              }, 1000);
+              break;
+            }
+
+          case 'line':
+            {
+              if (curConfig.gridSnapping) {
+                x = snapToGrid(x);
+                y = snapToGrid(y);
+              }
+
+              var x2 = x;
+              var y2 = y;
+
+              if (evt.shiftKey) {
+                xya = snapToAngle(startX, startY, x2, y2);
+                x2 = xya.x;
+                y2 = xya.y;
+              }
+
+              shape.setAttribute('x2', x2);
+              shape.setAttribute('y2', y2);
+              break;
+            }
+
+          case 'foreignObject': // fall through
+
+          case 'square': // fall through
+
+          case 'rect': // fall through
+
+          case 'image':
+            {
+              var square = currentMode === 'square' || evt.shiftKey;
+              var w = Math.abs(x - startX),
+                  h = Math.abs(y - startY);
+              var newX, newY;
+
+              if (square) {
+                w = h = Math.max(w, h);
+                newX = startX < x ? startX : startX - w;
+                newY = startY < y ? startY : startY - h;
+              } else {
+                newX = Math.min(startX, x);
+                newY = Math.min(startY, y);
+              }
+
+              if (curConfig.gridSnapping) {
+                w = snapToGrid(w);
+                h = snapToGrid(h);
+                newX = snapToGrid(newX);
+                newY = snapToGrid(newY);
+              }
+
+              assignAttributes(shape, {
+                width: w,
+                height: h,
+                x: newX,
+                y: newY
+              }, 1000);
+              break;
+            }
+
+          case 'circle':
+            {
+              c = $$8(shape).attr(['cx', 'cy']);
+              var _c = c;
+              cx = _c.cx;
+              cy = _c.cy;
+              var rad = Math.sqrt((x - cx) * (x - cx) + (y - cy) * (y - cy));
+
+              if (curConfig.gridSnapping) {
+                rad = snapToGrid(rad);
+              }
+
+              shape.setAttribute('r', rad);
+              break;
+            }
+
+          case 'ellipse':
+            {
+              c = $$8(shape).attr(['cx', 'cy']);
+              var _c2 = c;
+              cx = _c2.cx;
+              cy = _c2.cy;
+
+              if (curConfig.gridSnapping) {
+                x = snapToGrid(x);
+                cx = snapToGrid(cx);
+                y = snapToGrid(y);
+                cy = snapToGrid(cy);
+              }
+
+              shape.setAttribute('rx', Math.abs(x - cx));
+              var ry = Math.abs(evt.shiftKey ? x - cx : y - cy);
+              shape.setAttribute('ry', ry);
+              break;
+            }
+
+          case 'fhellipse':
+          case 'fhrect':
+            {
+              freehand.minx = Math.min(realX, freehand.minx);
+              freehand.maxx = Math.max(realX, freehand.maxx);
+              freehand.miny = Math.min(realY, freehand.miny);
+              freehand.maxy = Math.max(realY, freehand.maxy);
+            }
+          // Fallthrough
+
+          case 'fhpath':
+            {
+              // dAttr += + realX + ',' + realY + ' ';
+              // shape.setAttribute('points', dAttr);
+              end.x = realX;
+              end.y = realY;
+
+              if (controllPoint2.x && controllPoint2.y) {
+                for (i = 0; i < STEP_COUNT - 1; i++) {
+                  parameter = i / STEP_COUNT;
+                  nextParameter = (i + 1) / STEP_COUNT;
+                  bSpline = getBsplinePoint(nextParameter);
+                  nextPos = bSpline;
+                  bSpline = getBsplinePoint(parameter);
+                  sumDistance += Math.sqrt((nextPos.x - bSpline.x) * (nextPos.x - bSpline.x) + (nextPos.y - bSpline.y) * (nextPos.y - bSpline.y));
+
+                  if (sumDistance > THRESHOLD_DIST) {
+                    sumDistance -= THRESHOLD_DIST; // Faster than completely re-writing the points attribute.
+
+                    var point = svgcontent.createSVGPoint();
+                    point.x = bSpline.x;
+                    point.y = bSpline.y;
+                    shape.points.appendItem(point);
+                  }
+                }
+              }
+
+              controllPoint2 = {
+                x: controllPoint1.x,
+                y: controllPoint1.y
+              };
+              controllPoint1 = {
+                x: start.x,
+                y: start.y
+              };
+              start = {
+                x: end.x,
+                y: end.y
+              };
+              break; // update path stretch line coordinates
+            }
+
+          case 'path': // fall through
+
+          case 'pathedit':
+            {
+              x *= currentZoom;
+              y *= currentZoom;
+
+              if (curConfig.gridSnapping) {
+                x = snapToGrid(x);
+                y = snapToGrid(y);
+                startX = snapToGrid(startX);
+                startY = snapToGrid(startY);
+              }
+
+              if (evt.shiftKey) {
+                var path$$1 = path;
+                var x1, y1;
+
+                if (path$$1) {
+                  x1 = path$$1.dragging ? path$$1.dragging[0] : startX;
+                  y1 = path$$1.dragging ? path$$1.dragging[1] : startY;
+                } else {
+                  x1 = startX;
+                  y1 = startY;
+                }
+
+                xya = snapToAngle(x1, y1, x, y);
+                var _xya = xya;
+                x = _xya.x;
+                y = _xya.y;
+              }
+
+              if (rubberBox && rubberBox.getAttribute('display') !== 'none') {
+                realX *= currentZoom;
+                realY *= currentZoom;
+                assignAttributes(rubberBox, {
+                  x: Math.min(rStartX * currentZoom, realX),
+                  y: Math.min(rStartY * currentZoom, realY),
+                  width: Math.abs(realX - rStartX * currentZoom),
+                  height: Math.abs(realY - rStartY * currentZoom)
+                }, 100);
+              }
+
+              pathActions$$1.mouseMove(x, y);
+              break;
+            }
+
+          case 'textedit':
+            {
+              x *= currentZoom;
+              y *= currentZoom; // if (rubberBox && rubberBox.getAttribute('display') !== 'none') {
+              //   assignAttributes(rubberBox, {
+              //     x: Math.min(startX, x),
+              //     y: Math.min(startY, y),
+              //     width: Math.abs(x - startX),
+              //     height: Math.abs(y - startY)
+              //   }, 100);
+              // }
+
+              textActions.mouseMove(mouseX, mouseY);
+              break;
+            }
+
+          case 'rotate':
+            {
+              box = getBBox(selected);
+              cx = box.x + box.width / 2;
+              cy = box.y + box.height / 2;
+              var m = getMatrix(selected),
+                  center = transformPoint(cx, cy, m);
+              cx = center.x;
+              cy = center.y;
+              angle = (Math.atan2(cy - y, cx - x) * (180 / Math.PI) - 90) % 360;
+
+              if (curConfig.gridSnapping) {
+                angle = snapToGrid(angle);
+              }
+
+              if (evt.shiftKey) {
+                // restrict rotations to nice angles (WRS)
+                var snap = 45;
+                angle = Math.round(angle / snap) * snap;
+              }
+
+              canvas.setRotationAngle(angle < -180 ? 360 + angle : angle, true);
+              call('transition', selectedElements);
+              break;
+            }
+
+          default:
+            break;
+        }
+        /**
+        * The mouse has moved on the canvas area
+        * @event module:svgcanvas.SvgCanvas#event:ext-mouseMove
+        * @type {PlainObject}
+        * @property {MouseEvent} event The event object
+        * @property {Float} mouse_x x coordinate on canvas
+        * @property {Float} mouse_y y coordinate on canvas
+        * @property {Element} selected Refers to the first selected element
+        */
+
+
+        runExtensions('mouseMove',
+        /** @type {module:svgcanvas.SvgCanvas#event:ext-mouseMove} */
+        {
+          event: evt,
+          mouse_x: mouseX,
+          mouse_y: mouseY,
+          selected: selected
+        });
+      }; // mouseMove()
+      // - in create mode, the element's opacity is set properly, we create an InsertElementCommand
+      // and store it on the Undo stack
+      // - in move/resize mode, the element's attributes which were affected by the move/resize are
+      // identified, a ChangeElementCommand is created and stored on the stack for those attrs
+      // this is done in when we recalculate the selected dimensions()
+
+      /**
+       *
+       * @param {MouseEvent} evt
+       * @fires module:svgcanvas.SvgCanvas#event:zoomed
+       * @fires module:svgcanvas.SvgCanvas#event:changed
+       * @fires module:svgcanvas.SvgCanvas#event:ext-mouseUp
+       * @returns {undefined}
+       */
+
+
+      var mouseUp = function mouseUp(evt) {
+        if (evt.button === 2) {
+          return;
+        }
+
+        var tempJustSelected = justSelected;
+        justSelected = null;
+
+        if (!started) {
+          return;
+        }
+
+        var pt = transformPoint(evt.pageX, evt.pageY, rootSctm),
+            mouseX = pt.x * currentZoom,
+            mouseY = pt.y * currentZoom,
+            x = mouseX / currentZoom,
+            y = mouseY / currentZoom;
+        var element = getElem(getId());
+        var keep = false;
+        var realX = x;
+        var realY = y; // TODO: Make true when in multi-unit mode
+
+        started = false;
+        var attrs, t;
+
+        switch (currentMode) {
+          // intentionally fall-through to select here
+          case 'resize':
+          case 'multiselect':
+            if (!isNullish(rubberBox)) {
+              rubberBox.setAttribute('display', 'none');
+              curBBoxes = [];
+            }
+
+            currentMode = 'select';
+          // Fallthrough
+
+          case 'select':
+            if (!isNullish(selectedElements[0])) {
+              // if we only have one selected element
+              if (isNullish(selectedElements[1])) {
+                // set our current stroke/fill properties to the element's
+                var selected = selectedElements[0];
+
+                switch (selected.tagName) {
+                  case 'g':
+                  case 'use':
+                  case 'image':
+                  case 'foreignObject':
+                    break;
+
+                  default:
+                    curProperties.fill = selected.getAttribute('fill');
+                    curProperties.fill_opacity = selected.getAttribute('fill-opacity');
+                    curProperties.stroke = selected.getAttribute('stroke');
+                    curProperties.stroke_opacity = selected.getAttribute('stroke-opacity');
+                    curProperties.stroke_width = selected.getAttribute('stroke-width');
+                    curProperties.stroke_dasharray = selected.getAttribute('stroke-dasharray');
+                    curProperties.stroke_linejoin = selected.getAttribute('stroke-linejoin');
+                    curProperties.stroke_linecap = selected.getAttribute('stroke-linecap');
+                }
+
+                if (selected.tagName === 'text') {
+                  curText.font_size = selected.getAttribute('font-size');
+                  curText.font_family = selected.getAttribute('font-family');
+                }
+
+                selectorManager.requestSelector(selected).showGrips(true); // This shouldn't be necessary as it was done on mouseDown...
+                // call('selected', [selected]);
+              } // always recalculate dimensions to strip off stray identity transforms
+
+
+              recalculateAllSelectedDimensions(); // if it was being dragged/resized
+
+              if (realX !== rStartX || realY !== rStartY) {
+                var len = selectedElements.length;
+
+                for (var i = 0; i < len; ++i) {
+                  if (isNullish(selectedElements[i])) {
+                    break;
+                  }
+
+                  if (!selectedElements[i].firstChild) {
+                    // Not needed for groups (incorrectly resizes elems), possibly not needed at all?
+                    selectorManager.requestSelector(selectedElements[i]).resize();
+                  }
+                } // no change in position/size, so maybe we should move to pathedit
+
+              } else {
+                t = evt.target;
+
+                if (selectedElements[0].nodeName === 'path' && isNullish(selectedElements[1])) {
+                  pathActions$$1.select(selectedElements[0]); // if it was a path
+                  // else, if it was selected and this is a shift-click, remove it from selection
+                } else if (evt.shiftKey) {
+                  if (tempJustSelected !== t) {
+                    canvas.removeFromSelection([t]);
+                  }
+                }
+              } // no change in mouse position
+              // Remove non-scaling stroke
+
+
+              if (supportsNonScalingStroke()) {
+                var elem = selectedElements[0];
+
+                if (elem) {
+                  elem.removeAttribute('style');
+                  walkTree(elem, function (el) {
+                    el.removeAttribute('style');
+                  });
+                }
+              }
+            }
+
+            return;
+
+          case 'zoom':
+            {
+              if (!isNullish(rubberBox)) {
+                rubberBox.setAttribute('display', 'none');
+              }
+
+              var factor = evt.shiftKey ? 0.5 : 2;
+              call('zoomed', {
+                x: Math.min(rStartX, realX),
+                y: Math.min(rStartY, realY),
+                width: Math.abs(realX - rStartX),
+                height: Math.abs(realY - rStartY),
+                factor: factor
+              });
+              return;
+            }
+
+          case 'fhpath':
+            {
+              // Check that the path contains at least 2 points; a degenerate one-point path
+              // causes problems.
+              // Webkit ignores how we set the points attribute with commas and uses space
+              // to separate all coordinates, see https://bugs.webkit.org/show_bug.cgi?id=29870
+              sumDistance = 0;
+              controllPoint2 = {
+                x: 0,
+                y: 0
+              };
+              controllPoint1 = {
+                x: 0,
+                y: 0
+              };
+              start = {
+                x: 0,
+                y: 0
+              };
+              end = {
+                x: 0,
+                y: 0
+              };
+              var coords = element.getAttribute('points');
+              var commaIndex = coords.indexOf(',');
+
+              if (commaIndex >= 0) {
+                keep = coords.indexOf(',', commaIndex + 1) >= 0;
+              } else {
+                keep = coords.indexOf(' ', coords.indexOf(' ') + 1) >= 0;
+              }
+
+              if (keep) {
+                element = pathActions$$1.smoothPolylineIntoPath(element);
+              }
+
+              break;
+            }
+
+          case 'line':
+            attrs = $$8(element).attr(['x1', 'x2', 'y1', 'y2']);
+            keep = attrs.x1 !== attrs.x2 || attrs.y1 !== attrs.y2;
+            break;
+
+          case 'foreignObject':
+          case 'square':
+          case 'rect':
+          case 'image':
+            attrs = $$8(element).attr(['width', 'height']); // Image should be kept regardless of size (use inherit dimensions later)
+
+            keep = attrs.width || attrs.height || currentMode === 'image';
+            break;
+
+          case 'circle':
+            keep = element.getAttribute('r') !== '0';
+            break;
+
+          case 'ellipse':
+            attrs = $$8(element).attr(['rx', 'ry']);
+            keep = attrs.rx || attrs.ry;
+            break;
+
+          case 'fhellipse':
+            if (freehand.maxx - freehand.minx > 0 && freehand.maxy - freehand.miny > 0) {
+              element = addSVGElementFromJson({
+                element: 'ellipse',
+                curStyles: true,
+                attr: {
+                  cx: (freehand.minx + freehand.maxx) / 2,
+                  cy: (freehand.miny + freehand.maxy) / 2,
+                  rx: (freehand.maxx - freehand.minx) / 2,
+                  ry: (freehand.maxy - freehand.miny) / 2,
+                  id: getId()
+                }
+              });
+              call('changed', [element]);
+              keep = true;
+            }
+
+            break;
+
+          case 'fhrect':
+            if (freehand.maxx - freehand.minx > 0 && freehand.maxy - freehand.miny > 0) {
+              element = addSVGElementFromJson({
+                element: 'rect',
+                curStyles: true,
+                attr: {
+                  x: freehand.minx,
+                  y: freehand.miny,
+                  width: freehand.maxx - freehand.minx,
+                  height: freehand.maxy - freehand.miny,
+                  id: getId()
+                }
+              });
+              call('changed', [element]);
+              keep = true;
+            }
+
+            break;
+
+          case 'text':
+            keep = true;
+            selectOnly([element]);
+            textActions.start(element);
+            break;
+
+          case 'path':
+            {
+              // set element to null here so that it is not removed nor finalized
+              element = null; // continue to be set to true so that mouseMove happens
+
+              started = true;
+              var res = pathActions$$1.mouseUp(evt, element, mouseX, mouseY);
+              element = res.element;
+              keep = res.keep;
+              break;
+            }
+
+          case 'pathedit':
+            keep = true;
+            element = null;
+            pathActions$$1.mouseUp(evt);
+            break;
+
+          case 'textedit':
+            keep = false;
+            element = null;
+            textActions.mouseUp(evt, mouseX, mouseY);
+            break;
+
+          case 'rotate':
+            {
+              keep = true;
+              element = null;
+              currentMode = 'select';
+              var batchCmd = canvas.undoMgr.finishUndoableChange();
+
+              if (!batchCmd.isEmpty()) {
+                addCommandToHistory(batchCmd);
+              } // perform recalculation to weed out any stray identity transforms that might get stuck
+
+
+              recalculateAllSelectedDimensions();
+              call('changed', selectedElements);
+              break;
+            }
+
+          default:
+            // This could occur in an extension
+            break;
+        }
+        /**
+        * The main (left) mouse button is released (anywhere)
+        * @event module:svgcanvas.SvgCanvas#event:ext-mouseUp
+        * @type {PlainObject}
+        * @property {MouseEvent} event The event object
+        * @property {Float} mouse_x x coordinate on canvas
+        * @property {Float} mouse_y y coordinate on canvas
+        */
+
+
+        var extResult = runExtensions('mouseUp',
+        /** @type {module:svgcanvas.SvgCanvas#event:ext-mouseUp} */
+        {
+          event: evt,
+          mouse_x: mouseX,
+          mouse_y: mouseY
+        }, true);
+        $$8.each(extResult, function (i, r) {
+          if (r) {
+            keep = r.keep || keep;
+            element = r.element;
+            started = r.started || started;
+          }
+        });
+
+        if (!keep && !isNullish(element)) {
+          getCurrentDrawing().releaseId(getId());
+          element.remove();
+          element = null;
+          t = evt.target; // if this element is in a group, go up until we reach the top-level group
+          // just below the layer groups
+          // TODO: once we implement links, we also would have to check for <a> elements
+
+          while (t && t.parentNode && t.parentNode.parentNode && t.parentNode.parentNode.tagName === 'g') {
+            t = t.parentNode;
+          } // if we are not in the middle of creating a path, and we've clicked on some shape,
+          // then go to Select mode.
+          // WebKit returns <div> when the canvas is clicked, Firefox/Opera return <svg>
+
+
+          if ((currentMode !== 'path' || !drawnPath) && t && t.parentNode && t.parentNode.id !== 'selectorParentGroup' && t.id !== 'svgcanvas' && t.id !== 'svgroot') {
+            // switch into "select" mode if we've clicked on an element
+            canvas.setMode('select');
+            selectOnly([t], true);
+          }
+        } else if (!isNullish(element)) {
+          /**
+          * @name module:svgcanvas.SvgCanvas#addedNew
+          * @type {boolean}
+          */
+          canvas.addedNew = true;
+
+          var aniDur = 0.2;
+          var cAni;
+
+          if (opacAni.beginElement && parseFloat(element.getAttribute('opacity')) !== curShape.opacity) {
+            cAni = $$8(opacAni).clone().attr({
+              to: curShape.opacity,
+              dur: aniDur
+            }).appendTo(element);
+
+            try {
+              // Fails in FF4 on foreignObject
+              cAni[0].beginElement();
+            } catch (e) {}
+          } else {
+            aniDur = 0;
+          } // Ideally this would be done on the endEvent of the animation,
+          // but that doesn't seem to be supported in Webkit
+
+
+          setTimeout(function () {
+            if (cAni) {
+              cAni.remove();
+            }
+
+            element.setAttribute('opacity', curShape.opacity);
+            element.setAttribute('style', 'pointer-events:inherit');
+            cleanupElement(element);
+
+            if (currentMode === 'path') {
+              pathActions$$1.toEditMode(element);
+            } else if (curConfig.selectNew) {
+              selectOnly([element], true);
+            } // we create the insert command that is stored on the stack
+            // undo means to call cmd.unapply(), redo means to call cmd.apply()
+
+
+            addCommandToHistory(new InsertElementCommand$1(element));
+            call('changed', [element]);
+          }, aniDur * 1000);
+        }
+
+        startTransform = null;
+      };
+
+      var dblClick = function dblClick(evt) {
+        var evtTarget = evt.target;
+        var parent = evtTarget.parentNode; // Do nothing if already in current group
+
+        if (parent === currentGroup) {
+          return;
+        }
+
+        var mouseTarget = getMouseTarget(evt);
+        var _mouseTarget = mouseTarget,
+            tagName = _mouseTarget.tagName;
+
+        if (tagName === 'text' && currentMode !== 'textedit') {
+          var pt = transformPoint(evt.pageX, evt.pageY, rootSctm);
+          textActions.select(mouseTarget, pt.x, pt.y);
+        }
+
+        if ((tagName === 'g' || tagName === 'a') && getRotationAngle(mouseTarget)) {
+          // TODO: Allow method of in-group editing without having to do
+          // this (similar to editing rotated paths)
+          // Ungroup and regroup
+          pushGroupProperties(mouseTarget);
+          mouseTarget = selectedElements[0];
+          clearSelection(true);
+        } // Reset context
+
+
+        if (currentGroup) {
+          leaveContext();
+        }
+
+        if (parent.tagName !== 'g' && parent.tagName !== 'a' || parent === getCurrentDrawing().getCurrentLayer() || mouseTarget === selectorManager.selectorParentGroup) {
+          // Escape from in-group edit
+          return;
+        }
+
+        setContext(mouseTarget);
+      }; // prevent links from being followed in the canvas
+
+
+      var handleLinkInCanvas = function handleLinkInCanvas(e) {
+        e.preventDefault();
+        return false;
+      }; // Added mouseup to the container here.
+      // TODO(codedread): Figure out why after the Closure compiler, the window mouseup is ignored.
+
+
+      $$8(container).mousedown(mouseDown).mousemove(mouseMove).click(handleLinkInCanvas).dblclick(dblClick).mouseup(mouseUp); // $(window).mouseup(mouseUp);
+      // TODO(rafaelcastrocouto): User preference for shift key and zoom factor
+
+      $$8(container).bind('mousewheel DOMMouseScroll',
+      /**
+       * @param {Event} e
+       * @fires module:svgcanvas.SvgCanvas#event:updateCanvas
+       * @fires module:svgcanvas.SvgCanvas#event:zoomDone
+       * @returns {undefined}
+       */
+      function (e) {
+        if (!e.shiftKey) {
+          return;
+        }
+
+        e.preventDefault();
+        var evt = e.originalEvent;
+        rootSctm = $$8('#svgcontent g')[0].getScreenCTM().inverse();
+        var workarea = $$8('#workarea');
+        var scrbar = 15;
+        var rulerwidth = curConfig.showRulers ? 16 : 0; // mouse relative to content area in content pixels
+
+        var pt = transformPoint(evt.pageX, evt.pageY, rootSctm); // full work area width in screen pixels
+
+        var editorFullW = workarea.width();
+        var editorFullH = workarea.height(); // work area width minus scroll and ruler in screen pixels
+
+        var editorW = editorFullW - scrbar - rulerwidth;
+        var editorH = editorFullH - scrbar - rulerwidth; // work area width in content pixels
+
+        var workareaViewW = editorW * rootSctm.a;
+        var workareaViewH = editorH * rootSctm.d; // content offset from canvas in screen pixels
+
+        var wOffset = workarea.offset();
+        var wOffsetLeft = wOffset.left + rulerwidth;
+        var wOffsetTop = wOffset.top + rulerwidth;
+        var delta = evt.wheelDelta ? evt.wheelDelta : evt.detail ? -evt.detail : 0;
+
+        if (!delta) {
+          return;
+        }
+
+        var factor = Math.max(3 / 4, Math.min(4 / 3, delta));
+        var wZoom, hZoom;
+
+        if (factor > 1) {
+          wZoom = Math.ceil(editorW / workareaViewW * factor * 100) / 100;
+          hZoom = Math.ceil(editorH / workareaViewH * factor * 100) / 100;
+        } else {
+          wZoom = Math.floor(editorW / workareaViewW * factor * 100) / 100;
+          hZoom = Math.floor(editorH / workareaViewH * factor * 100) / 100;
+        }
+
+        var zoomlevel = Math.min(wZoom, hZoom);
+        zoomlevel = Math.min(10, Math.max(0.01, zoomlevel));
+
+        if (zoomlevel === currentZoom) {
+          return;
+        }
+
+        factor = zoomlevel / currentZoom; // top left of workarea in content pixels before zoom
+
+        var topLeftOld = transformPoint(wOffsetLeft, wOffsetTop, rootSctm); // top left of workarea in content pixels after zoom
+
+        var topLeftNew = {
+          x: pt.x - (pt.x - topLeftOld.x) / factor,
+          y: pt.y - (pt.y - topLeftOld.y) / factor
+        }; // top left of workarea in canvas pixels relative to content after zoom
+
+        var topLeftNewCanvas = {
+          x: topLeftNew.x * zoomlevel,
+          y: topLeftNew.y * zoomlevel
+        }; // new center in canvas pixels
+
+        var newCtr = {
+          x: topLeftNewCanvas.x - rulerwidth + editorFullW / 2,
+          y: topLeftNewCanvas.y - rulerwidth + editorFullH / 2
+        };
+        canvas.setZoom(zoomlevel);
+        $$8('#zoom').val((zoomlevel * 100).toFixed(1));
+        call('updateCanvas', {
+          center: false,
+          newCtr: newCtr
+        });
+        call('zoomDone');
+      });
+    })();
+    /**
+    * Group: Text edit functions
+    * Functions relating to editing text elements
+    * @namespace {PlainObject} textActions
+    * @memberof module:svgcanvas.SvgCanvas#
+    */
+
+
+    var textActions = canvas.textActions = function () {
+      var curtext;
+      var textinput;
+      var cursor;
+      var selblock;
+      var blinker;
+      var chardata = [];
+      var textbb; // , transbb;
+
+      var matrix;
+      var lastX, lastY;
+      var allowDbl;
+      /**
+       *
+       * @param {Integer} index
+       * @returns {undefined}
+       */
+
+      function setCursor(index) {
+        var empty = textinput.value === '';
+        $$8(textinput).focus();
+
+        if (!arguments.length) {
+          if (empty) {
+            index = 0;
+          } else {
+            if (textinput.selectionEnd !== textinput.selectionStart) {
+              return;
+            }
+
+            index = textinput.selectionEnd;
+          }
+        }
+
+        var charbb = chardata[index];
+
+        if (!empty) {
+          textinput.setSelectionRange(index, index);
+        }
+
+        cursor = getElem('text_cursor');
+
+        if (!cursor) {
+          cursor = document.createElementNS(NS.SVG, 'line');
+          assignAttributes(cursor, {
+            id: 'text_cursor',
+            stroke: '#333',
+            'stroke-width': 1
+          });
+          cursor = getElem('selectorParentGroup').appendChild(cursor);
+        }
+
+        if (!blinker) {
+          blinker = setInterval(function () {
+            var show = cursor.getAttribute('display') === 'none';
+            cursor.setAttribute('display', show ? 'inline' : 'none');
+          }, 600);
+        }
+
+        var startPt = ptToScreen(charbb.x, textbb.y);
+        var endPt = ptToScreen(charbb.x, textbb.y + textbb.height);
+        assignAttributes(cursor, {
+          x1: startPt.x,
+          y1: startPt.y,
+          x2: endPt.x,
+          y2: endPt.y,
+          visibility: 'visible',
+          display: 'inline'
+        });
+
+        if (selblock) {
+          selblock.setAttribute('d', '');
+        }
+      }
+      /**
+       *
+       * @param {Integer} start
+       * @param {Integer} end
+       * @param {boolean} skipInput
+       * @returns {undefined}
+       */
+
+
+      function setSelection(start, end, skipInput) {
+        if (start === end) {
+          setCursor(end);
+          return;
+        }
+
+        if (!skipInput) {
+          textinput.setSelectionRange(start, end);
+        }
+
+        selblock = getElem('text_selectblock');
+
+        if (!selblock) {
+          selblock = document.createElementNS(NS.SVG, 'path');
+          assignAttributes(selblock, {
+            id: 'text_selectblock',
+            fill: 'green',
+            opacity: 0.5,
+            style: 'pointer-events:none'
+          });
+          getElem('selectorParentGroup').append(selblock);
+        }
+
+        var startbb = chardata[start];
+        var endbb = chardata[end];
+        cursor.setAttribute('visibility', 'hidden');
+        var tl = ptToScreen(startbb.x, textbb.y),
+            tr = ptToScreen(startbb.x + (endbb.x - startbb.x), textbb.y),
+            bl = ptToScreen(startbb.x, textbb.y + textbb.height),
+            br = ptToScreen(startbb.x + (endbb.x - startbb.x), textbb.y + textbb.height);
+        var dstr = 'M' + tl.x + ',' + tl.y + ' L' + tr.x + ',' + tr.y + ' ' + br.x + ',' + br.y + ' ' + bl.x + ',' + bl.y + 'z';
+        assignAttributes(selblock, {
+          d: dstr,
+          display: 'inline'
+        });
+      }
+      /**
+       *
+       * @param {Float} mouseX
+       * @param {Float} mouseY
+       * @returns {Integer}
+       */
+
+
+      function getIndexFromPoint(mouseX, mouseY) {
+        // Position cursor here
+        var pt = svgroot.createSVGPoint();
+        pt.x = mouseX;
+        pt.y = mouseY; // No content, so return 0
+
+        if (chardata.length === 1) {
+          return 0;
+        } // Determine if cursor should be on left or right of character
+
+
+        var charpos = curtext.getCharNumAtPosition(pt);
+
+        if (charpos < 0) {
+          // Out of text range, look at mouse coords
+          charpos = chardata.length - 2;
+
+          if (mouseX <= chardata[0].x) {
+            charpos = 0;
+          }
+        } else if (charpos >= chardata.length - 2) {
+          charpos = chardata.length - 2;
+        }
+
+        var charbb = chardata[charpos];
+        var mid = charbb.x + charbb.width / 2;
+
+        if (mouseX > mid) {
+          charpos++;
+        }
+
+        return charpos;
+      }
+      /**
+       *
+       * @param {Float} mouseX
+       * @param {Float} mouseY
+       * @returns {undefined}
+       */
+
+
+      function setCursorFromPoint(mouseX, mouseY) {
+        setCursor(getIndexFromPoint(mouseX, mouseY));
+      }
+      /**
+       *
+       * @param {Float} x
+       * @param {Float} y
+       * @param {boolean} apply
+       * @returns {undefined}
+       */
+
+
+      function setEndSelectionFromPoint(x, y, apply) {
+        var i1 = textinput.selectionStart;
+        var i2 = getIndexFromPoint(x, y);
+        var start = Math.min(i1, i2);
+        var end = Math.max(i1, i2);
+        setSelection(start, end, !apply);
+      }
+      /**
+       *
+       * @param {Float} xIn
+       * @param {Float} yIn
+       * @returns {module:math.XYObject}
+       */
+
+
+      function screenToPt(xIn, yIn) {
+        var out = {
+          x: xIn,
+          y: yIn
+        };
+        out.x /= currentZoom;
+        out.y /= currentZoom;
+
+        if (matrix) {
+          var pt = transformPoint(out.x, out.y, matrix.inverse());
+          out.x = pt.x;
+          out.y = pt.y;
+        }
+
+        return out;
+      }
+      /**
+       *
+       * @param {Float} xIn
+       * @param {Float} yIn
+       * @returns {module:math.XYObject}
+       */
+
+
+      function ptToScreen(xIn, yIn) {
+        var out = {
+          x: xIn,
+          y: yIn
+        };
+
+        if (matrix) {
+          var pt = transformPoint(out.x, out.y, matrix);
+          out.x = pt.x;
+          out.y = pt.y;
+        }
+
+        out.x *= currentZoom;
+        out.y *= currentZoom;
+        return out;
+      }
+      /*
+      // Not currently in use
+      function hideCursor () {
+        if (cursor) {
+          cursor.setAttribute('visibility', 'hidden');
+        }
+      }
+      */
+
+      /**
+       *
+       * @param {Event} evt
+       * @returns {undefined}
+       */
+
+
+      function selectAll(evt) {
+        setSelection(0, curtext.textContent.length);
+        $$8(this).unbind(evt);
+      }
+      /**
+       *
+       * @param {Event} evt
+       * @returns {undefined}
+       */
+
+
+      function selectWord(evt) {
+        if (!allowDbl || !curtext) {
+          return;
+        }
+
+        var ept = transformPoint(evt.pageX, evt.pageY, rootSctm),
+            mouseX = ept.x * currentZoom,
+            mouseY = ept.y * currentZoom;
+        var pt = screenToPt(mouseX, mouseY);
+        var index = getIndexFromPoint(pt.x, pt.y);
+        var str = curtext.textContent;
+        var first = str.substr(0, index).replace(/[a-z0-9]+$/i, '').length;
+        var m = str.substr(index).match(/^[a-z0-9]+/i);
+        var last = (m ? m[0].length : 0) + index;
+        setSelection(first, last); // Set tripleclick
+
+        $$8(evt.target).click(selectAll);
+        setTimeout(function () {
+          $$8(evt.target).unbind('click', selectAll);
+        }, 300);
+      }
+
+      return (
+        /** @lends module:svgcanvas.SvgCanvas#textActions */
+        {
+          /**
+          * @param {Element} target
+          * @param {Float} x
+          * @param {Float} y
+          * @returns {undefined}
+          */
+          select: function select(target, x, y) {
+            curtext = target;
+            textActions.toEditMode(x, y);
+          },
+
+          /**
+          * @param {Element} elem
+          * @returns {undefined}
+          */
+          start: function start(elem) {
+            curtext = elem;
+            textActions.toEditMode();
+          },
+
+          /**
+          * @param {external:MouseEvent} evt
+          * @param {Element} mouseTarget
+          * @param {Float} startX
+          * @param {Float} startY
+          * @returns {undefined}
+          */
+          mouseDown: function mouseDown(evt, mouseTarget, startX, startY) {
+            var pt = screenToPt(startX, startY);
+            textinput.focus();
+            setCursorFromPoint(pt.x, pt.y);
+            lastX = startX;
+            lastY = startY; // TODO: Find way to block native selection
+          },
+
+          /**
+          * @param {Float} mouseX
+          * @param {Float} mouseY
+          * @returns {undefined}
+          */
+          mouseMove: function mouseMove(mouseX, mouseY) {
+            var pt = screenToPt(mouseX, mouseY);
+            setEndSelectionFromPoint(pt.x, pt.y);
+          },
+
+          /**
+          * @param {external:MouseEvent} evt
+          * @param {Float} mouseX
+          * @param {Float} mouseY
+          * @returns {undefined}
+          */
+          mouseUp: function mouseUp(evt, mouseX, mouseY) {
+            var pt = screenToPt(mouseX, mouseY);
+            setEndSelectionFromPoint(pt.x, pt.y, true); // TODO: Find a way to make this work: Use transformed BBox instead of evt.target
+            // if (lastX === mouseX && lastY === mouseY
+            //   && !rectsIntersect(transbb, {x: pt.x, y: pt.y, width: 0, height: 0})) {
+            //   textActions.toSelectMode(true);
+            // }
+
+            if (evt.target !== curtext && mouseX < lastX + 2 && mouseX > lastX - 2 && mouseY < lastY + 2 && mouseY > lastY - 2) {
+              textActions.toSelectMode(true);
+            }
+          },
+
+          /**
+          * @function
+          * @param {Integer} index
+          * @returns {undefined}
+          */
+          setCursor: setCursor,
+
+          /**
+          * @param {Float} x
+          * @param {Float} y
+          * @returns {undefined}
+          */
+          toEditMode: function toEditMode(x, y) {
+            allowDbl = false;
+            currentMode = 'textedit';
+            selectorManager.requestSelector(curtext).showGrips(false); // Make selector group accept clicks
+
+            /* const selector = */
+
+            selectorManager.requestSelector(curtext); // Do we need this? Has side effect of setting lock, so keeping for now, but next line wasn't being used
+            // const sel = selector.selectorRect;
+
+            textActions.init();
+            $$8(curtext).css('cursor', 'text'); // if (supportsEditableText()) {
+            //   curtext.setAttribute('editable', 'simple');
+            //   return;
+            // }
+
+            if (!arguments.length) {
+              setCursor();
+            } else {
+              var pt = screenToPt(x, y);
+              setCursorFromPoint(pt.x, pt.y);
+            }
+
+            setTimeout(function () {
+              allowDbl = true;
+            }, 300);
+          },
+
+          /**
+          * @param {boolean|Element} selectElem
+          * @fires module:svgcanvas.SvgCanvas#event:selected
+          * @returns {undefined}
+          */
+          toSelectMode: function toSelectMode(selectElem) {
+            currentMode = 'select';
+            clearInterval(blinker);
+            blinker = null;
+
+            if (selblock) {
+              $$8(selblock).attr('display', 'none');
+            }
+
+            if (cursor) {
+              $$8(cursor).attr('visibility', 'hidden');
+            }
+
+            $$8(curtext).css('cursor', 'move');
+
+            if (selectElem) {
+              clearSelection();
+              $$8(curtext).css('cursor', 'move');
+              call('selected', [curtext]);
+              addToSelection([curtext], true);
+            }
+
+            if (curtext && !curtext.textContent.length) {
+              // No content, so delete
+              canvas.deleteSelectedElements();
+            }
+
+            $$8(textinput).blur();
+            curtext = false; // if (supportsEditableText()) {
+            //   curtext.removeAttribute('editable');
+            // }
+          },
+
+          /**
+          * @param {Element} elem
+          * @returns {undefined}
+          */
+          setInputElem: function setInputElem(elem) {
+            textinput = elem; // $(textinput).blur(hideCursor);
+          },
+
+          /**
+          * @returns {undefined}
+          */
+          clear: function clear() {
+            if (currentMode === 'textedit') {
+              textActions.toSelectMode();
+            }
+          },
+
+          /**
+          * @param {Element} inputElem Not in use
+          * @returns {undefined}
+          */
+          init: function init$$1(inputElem) {
+            if (!curtext) {
+              return;
+            }
+
+            var i, end; // if (supportsEditableText()) {
+            //   curtext.select();
+            //   return;
+            // }
+
+            if (!curtext.parentNode) {
+              // Result of the ffClone, need to get correct element
+              curtext = selectedElements[0];
+              selectorManager.requestSelector(curtext).showGrips(false);
+            }
+
+            var str = curtext.textContent;
+            var len = str.length;
+            var xform = curtext.getAttribute('transform');
+            textbb = getBBox(curtext);
+            matrix = xform ? getMatrix(curtext) : null;
+            chardata = [];
+            chardata.length = len;
+            textinput.focus();
+            $$8(curtext).unbind('dblclick', selectWord).dblclick(selectWord);
+
+            if (!len) {
+              end = {
+                x: textbb.x + textbb.width / 2,
+                width: 0
+              };
+            }
+
+            for (i = 0; i < len; i++) {
+              var start = curtext.getStartPositionOfChar(i);
+              end = curtext.getEndPositionOfChar(i);
+
+              if (!supportsGoodTextCharPos()) {
+                var offset = canvas.contentW * currentZoom;
+                start.x -= offset;
+                end.x -= offset;
+                start.x /= currentZoom;
+                end.x /= currentZoom;
+              } // Get a "bbox" equivalent for each character. Uses the
+              // bbox data of the actual text for y, height purposes
+              // TODO: Decide if y, width and height are actually necessary
+
+
+              chardata[i] = {
+                x: start.x,
+                y: textbb.y,
+                // start.y?
+                width: end.x - start.x,
+                height: textbb.height
+              };
+            } // Add a last bbox for cursor at end of text
+
+
+            chardata.push({
+              x: end.x,
+              width: 0
+            });
+            setSelection(textinput.selectionStart, textinput.selectionEnd, true);
+          }
+        }
+      );
+    }();
+    /**
+    * Group: Serialization
+    */
+
+    /**
+    * Looks at DOM elements inside the `<defs>` to see if they are referred to,
+    * removes them from the DOM if they are not.
+    * @function module:svgcanvas.SvgCanvas#removeUnusedDefElems
+    * @returns {Integer} The number of elements that were removed
+    */
+
+
+    var removeUnusedDefElems = this.removeUnusedDefElems = function () {
+      var defs = svgcontent.getElementsByTagNameNS(NS.SVG, 'defs');
+
+      if (!defs || !defs.length) {
+        return 0;
+      } // if (!defs.firstChild) { return; }
+
+
+      var defelemUses = [];
+      var numRemoved = 0;
+      var attrs = ['fill', 'stroke', 'filter', 'marker-start', 'marker-mid', 'marker-end'];
+      var alen = attrs.length;
+      var allEls = svgcontent.getElementsByTagNameNS(NS.SVG, '*');
+      var allLen = allEls.length;
+      var i, j;
+
+      for (i = 0; i < allLen; i++) {
+        var el = allEls[i];
+
+        for (j = 0; j < alen; j++) {
+          var ref = getUrlFromAttr(el.getAttribute(attrs[j]));
+
+          if (ref) {
+            defelemUses.push(ref.substr(1));
+          }
+        } // gradients can refer to other gradients
+
+
+        var href = getHref(el);
+
+        if (href && href.startsWith('#')) {
+          defelemUses.push(href.substr(1));
+        }
+      }
+
+      var defelems = $$8(defs).find('linearGradient, radialGradient, filter, marker, svg, symbol');
+      i = defelems.length;
+
+      while (i--) {
+        var defelem = defelems[i];
+        var id = defelem.id;
+
+        if (!defelemUses.includes(id)) {
+          // Not found, so remove (but remember)
+          removedElements[id] = defelem;
+          defelem.remove();
+          numRemoved++;
+        }
+      }
+
+      return numRemoved;
+    };
+    /**
+    * Main function to set up the SVG content for output.
+    * @function module:svgcanvas.SvgCanvas#svgCanvasToString
+    * @returns {string} The SVG image for output
+    */
+
+
+    this.svgCanvasToString = function () {
+      // keep calling it until there are none to remove
+      while (removeUnusedDefElems() > 0) {} // eslint-disable-line no-empty
+
+
+      pathActions$$1.clear(true); // Keep SVG-Edit comment on top
+
+      $$8.each(svgcontent.childNodes, function (i, node) {
+        if (i && node.nodeType === 8 && node.data.includes('Created with')) {
+          svgcontent.firstChild.before(node);
+        }
+      }); // Move out of in-group editing mode
+
+      if (currentGroup) {
+        leaveContext();
+        selectOnly([currentGroup]);
+      }
+
+      var nakedSvgs = []; // Unwrap gsvg if it has no special attributes (only id and style)
+
+      $$8(svgcontent).find('g:data(gsvg)').each(function () {
+        var attrs = this.attributes;
+        var len = attrs.length;
+
+        for (var i = 0; i < len; i++) {
+          if (attrs[i].nodeName === 'id' || attrs[i].nodeName === 'style') {
+            len--;
+          }
+        } // No significant attributes, so ungroup
+
+
+        if (len <= 0) {
+          var svg = this.firstChild;
+          nakedSvgs.push(svg);
+          $$8(this).replaceWith(svg);
+        }
+      });
+      var output = this.svgToString(svgcontent, 0); // Rewrap gsvg
+
+      if (nakedSvgs.length) {
+        $$8(nakedSvgs).each(function () {
+          groupSvgElem(this);
+        });
+      }
+
+      return output;
+    };
+    /**
+    * Sub function ran on each SVG element to convert it to a string as desired.
+    * @function module:svgcanvas.SvgCanvas#svgToString
+    * @param {Element} elem - The SVG element to convert
+    * @param {Integer} indent - Number of spaces to indent this tag
+    * @returns {string} The given element as an SVG tag
+    */
+
+
+    this.svgToString = function (elem, indent) {
+      var out = [];
+      var unit = curConfig.baseUnit;
+      var unitRe = new RegExp('^-?[\\d\\.]+' + unit + '$');
+
+      if (elem) {
+        cleanupElement(elem);
+
+        var attrs = _toConsumableArray(elem.attributes);
+
+        var childs = elem.childNodes;
+        attrs.sort(function (a, b) {
+          return a.name > b.name ? -1 : 1;
+        });
+
+        for (var i = 0; i < indent; i++) {
+          out.push(' ');
+        }
+
+        out.push('<');
+        out.push(elem.nodeName);
+
+        if (elem.id === 'svgcontent') {
+          // Process root element separately
+          var res = getResolution();
+          var vb = ''; // TODO: Allow this by dividing all values by current baseVal
+          // Note that this also means we should properly deal with this on import
+          // if (curConfig.baseUnit !== 'px') {
+          //   const unit = curConfig.baseUnit;
+          //   const unitM = getTypeMap()[unit];
+          //   res.w = shortFloat(res.w / unitM);
+          //   res.h = shortFloat(res.h / unitM);
+          //   vb = ' viewBox="' + [0, 0, res.w, res.h].join(' ') + '"';
+          //   res.w += unit;
+          //   res.h += unit;
+          // }
+
+          if (unit !== 'px') {
+            res.w = convertUnit(res.w, unit) + unit;
+            res.h = convertUnit(res.h, unit) + unit;
+          }
+
+          out.push(' width="' + res.w + '" height="' + res.h + '"' + vb + ' xmlns="' + NS.SVG + '"');
+          var nsuris = {}; // Check elements for namespaces, add if found
+
+          $$8(elem).find('*').andSelf().each(function () {
+            // const el = this;
+            // for some elements have no attribute
+            var uri = this.namespaceURI;
+
+            if (uri && !nsuris[uri] && nsMap[uri] && nsMap[uri] !== 'xmlns' && nsMap[uri] !== 'xml') {
+              nsuris[uri] = true;
+              out.push(' xmlns:' + nsMap[uri] + '="' + uri + '"');
+            }
+
+            $$8.each(this.attributes, function (i, attr) {
+              var u = attr.namespaceURI;
+
+              if (u && !nsuris[u] && nsMap[u] !== 'xmlns' && nsMap[u] !== 'xml') {
+                nsuris[u] = true;
+                out.push(' xmlns:' + nsMap[u] + '="' + u + '"');
+              }
+            });
+          });
+          var _i3 = attrs.length;
+          var attrNames = ['width', 'height', 'xmlns', 'x', 'y', 'viewBox', 'id', 'overflow'];
+
+          while (_i3--) {
+            var attr = attrs[_i3];
+            var attrVal = toXml(attr.value); // Namespaces have already been dealt with, so skip
+
+            if (attr.nodeName.startsWith('xmlns:')) {
+              continue;
+            } // only serialize attributes we don't use internally
+
+
+            if (attrVal !== '' && !attrNames.includes(attr.localName)) {
+              if (!attr.namespaceURI || nsMap[attr.namespaceURI]) {
+                out.push(' ');
+                out.push(attr.nodeName);
+                out.push('="');
+                out.push(attrVal);
+                out.push('"');
+              }
+            }
+          }
+        } else {
+          // Skip empty defs
+          if (elem.nodeName === 'defs' && !elem.firstChild) {
+            return '';
+          }
+
+          var mozAttrs = ['-moz-math-font-style', '_moz-math-font-style'];
+
+          for (var _i4 = attrs.length - 1; _i4 >= 0; _i4--) {
+            var _attr = attrs[_i4];
+
+            var _attrVal = toXml(_attr.value); // remove bogus attributes added by Gecko
+
+
+            if (mozAttrs.includes(_attr.localName)) {
+              continue;
+            }
+
+            if (_attrVal !== '') {
+              if (_attrVal.startsWith('pointer-events')) {
+                continue;
+              }
+
+              if (_attr.localName === 'class' && _attrVal.startsWith('se_')) {
+                continue;
+              }
+
+              out.push(' ');
+
+              if (_attr.localName === 'd') {
+                _attrVal = pathActions$$1.convertPath(elem, true);
+              }
+
+              if (!isNaN(_attrVal)) {
+                _attrVal = shortFloat(_attrVal);
+              } else if (unitRe.test(_attrVal)) {
+                _attrVal = shortFloat(_attrVal) + unit;
+              } // Embed images when saving
+
+
+              if (saveOptions.apply && elem.nodeName === 'image' && _attr.localName === 'href' && saveOptions.images && saveOptions.images === 'embed') {
+                var img = encodableImages[_attrVal];
+
+                if (img) {
+                  _attrVal = img;
+                }
+              } // map various namespaces to our fixed namespace prefixes
+              // (the default xmlns attribute itself does not get a prefix)
+
+
+              if (!_attr.namespaceURI || _attr.namespaceURI === NS.SVG || nsMap[_attr.namespaceURI]) {
+                out.push(_attr.nodeName);
+                out.push('="');
+                out.push(_attrVal);
+                out.push('"');
+              }
+            }
+          }
+        }
+
+        if (elem.hasChildNodes()) {
+          out.push('>');
+          indent++;
+          var bOneLine = false;
+
+          for (var _i5 = 0; _i5 < childs.length; _i5++) {
+            var child = childs.item(_i5);
+
+            switch (child.nodeType) {
+              case 1:
+                // element node
+                out.push('\n');
+                out.push(this.svgToString(childs.item(_i5), indent));
+                break;
+
+              case 3:
+                {
+                  // text node
+                  var str = child.nodeValue.replace(/^\s+|\s+$/g, '');
+
+                  if (str !== '') {
+                    bOneLine = true;
+                    out.push(String(toXml(str)));
+                  }
+
+                  break;
+                }
+
+              case 4:
+                // cdata node
+                out.push('\n');
+                out.push(new Array(indent + 1).join(' '));
+                out.push('<![CDATA[');
+                out.push(child.nodeValue);
+                out.push(']]>');
+                break;
+
+              case 8:
+                // comment
+                out.push('\n');
+                out.push(new Array(indent + 1).join(' '));
+                out.push('<!--');
+                out.push(child.data);
+                out.push('-->');
+                break;
+            } // switch on node type
+
+          }
+
+          indent--;
+
+          if (!bOneLine) {
+            out.push('\n');
+
+            for (var _i6 = 0; _i6 < indent; _i6++) {
+              out.push(' ');
+            }
+          }
+
+          out.push('</');
+          out.push(elem.nodeName);
+          out.push('>');
+        } else {
+          out.push('/>');
+        }
+      }
+
+      return out.join('');
+    }; // end svgToString()
+
+    /**
+     * Function to run when image data is found
+     * @callback module:svgcanvas.ImageEmbeddedCallback
+     * @param {string|false} result Data URL
+     * @returns {undefined}
+     */
+
+    /**
+    * Converts a given image file to a data URL when possible, then runs a given callback.
+    * @function module:svgcanvas.SvgCanvas#embedImage
+    * @param {string} src - The path/URL of the image
+    * @returns {Promise} Resolves to Data URL (string|false)
+    */
+
+
+    this.embedImage = function (src) {
+      // Todo: Remove this Promise in favor of making an async/await `Image.load` utility
+      return new Promise(function (resolve, reject) {
+        // eslint-disable-line promise/avoid-new
+        // load in the image and once it's loaded, get the dimensions
+        $$8(new Image()).load(function (response, status, xhr) {
+          if (status === 'error') {
+            reject(new Error('Error loading image: ' + xhr.status + ' ' + xhr.statusText));
+            return;
+          } // create a canvas the same size as the raster image
+
+
+          var cvs = document.createElement('canvas');
+          cvs.width = this.width;
+          cvs.height = this.height; // load the raster image into the canvas
+
+          cvs.getContext('2d').drawImage(this, 0, 0); // retrieve the data: URL
+
+          try {
+            var urldata = ';svgedit_url=' + encodeURIComponent(src);
+            urldata = cvs.toDataURL().replace(';base64', urldata + ';base64');
+            encodableImages[src] = urldata;
+          } catch (e) {
+            encodableImages[src] = false;
+          }
+
+          lastGoodImgUrl = src;
+          resolve(encodableImages[src]);
+        }).attr('src', src);
+      });
+    };
+    /**
+    * Sets a given URL to be a "last good image" URL.
+    * @function module:svgcanvas.SvgCanvas#setGoodImage
+    * @param {string} val
+    * @returns {undefined}
+    */
+
+
+    this.setGoodImage = function (val) {
+      lastGoodImgUrl = val;
+    };
+    /**
+    * Does nothing by default, handled by optional widget/extension.
+    * @function module:svgcanvas.SvgCanvas#open
+    * @returns {undefined}
+    */
+
+
+    this.open = function () {
+      /* */
+    };
+    /**
+    * Serializes the current drawing into SVG XML text and passes it to the 'saved' handler.
+    * This function also includes the XML prolog. Clients of the `SvgCanvas` bind their save
+    * function to the 'saved' event.
+    * @function module:svgcanvas.SvgCanvas#save
+    * @param {module:svgcanvas.SaveOptions} opts
+    * @fires module:svgcanvas.SvgCanvas#event:saved
+    * @returns {undefined}
+    */
+
+
+    this.save = function (opts) {
+      // remove the selected outline before serializing
+      clearSelection(); // Update save options if provided
+
+      if (opts) {
+        $$8.extend(saveOptions, opts);
+      }
+
+      saveOptions.apply = true; // no need for doctype, see https://jwatt.org/svg/authoring/#doctype-declaration
+
+      var str = this.svgCanvasToString();
+      call('saved', str);
+    };
+    /**
+    * @typedef {PlainObject} module:svgcanvas.IssuesAndCodes
+    * @property {string[]} issueCodes The locale-independent code names
+    * @property {string[]} issues The localized descriptions
+    */
+
+    /**
+    * Codes only is useful for locale-independent detection.
+    * @returns {module:svgcanvas.IssuesAndCodes}
+    */
+
+
+    function getIssues() {
+      // remove the selected outline before serializing
+      clearSelection(); // Check for known CanVG issues
+
+      var issues = [];
+      var issueCodes = []; // Selector and notice
+
+      var issueList = {
+        feGaussianBlur: uiStrings.exportNoBlur,
+        foreignObject: uiStrings.exportNoforeignObject,
+        '[stroke-dasharray]': uiStrings.exportNoDashArray
+      };
+      var content = $$8(svgcontent); // Add font/text check if Canvas Text API is not implemented
+
+      if (!('font' in $$8('<canvas>')[0].getContext('2d'))) {
+        issueList.text = uiStrings.exportNoText;
+      }
+
+      $$8.each(issueList, function (sel, descr) {
+        if (content.find(sel).length) {
+          issueCodes.push(sel);
+          issues.push(descr);
+        }
+      });
+      return {
+        issues: issues,
+        issueCodes: issueCodes
+      };
+    }
+
+    var canvg;
+    /**
+    * @typedef {"feGaussianBlur"|"foreignObject"|"[stroke-dasharray]"|"text"} module:svgcanvas.IssueCode
+    */
+
+    /**
+    * @typedef {PlainObject} module:svgcanvas.ImageExportedResults
+    * @property {string} datauri Contents as a Data URL
+    * @property {string} bloburl May be the empty string
+    * @property {string} svg The SVG contents as a string
+    * @property {string[]} issues The localization messages of `issueCodes`
+    * @property {module:svgcanvas.IssueCode[]} issueCodes CanVG issues found with the SVG
+    * @property {"PNG"|"JPEG"|"BMP"|"WEBP"|"ICO"} type The chosen image type
+    * @property {"image/png"|"image/jpeg"|"image/bmp"|"image/webp"} mimeType The image MIME type
+    * @property {Float} quality A decimal between 0 and 1 (for use with JPEG or WEBP)
+    * @property {string} exportWindowName A convenience for passing along a `window.name` to target a window on which the export could be added
+    */
+
+    /**
+    * Generates a PNG (or JPG, BMP, WEBP) Data URL based on the current image,
+    * then calls "exported" with an object including the string, image
+    * information, and any issues found.
+    * @function module:svgcanvas.SvgCanvas#rasterExport
+    * @param {"PNG"|"JPEG"|"BMP"|"WEBP"|"ICO"} [imgType="PNG"]
+    * @param {Float} [quality] Between 0 and 1
+    * @param {string} [exportWindowName]
+    * @param {PlainObject} [opts]
+    * @param {boolean} [opts.avoidEvent]
+    * @fires module:svgcanvas.SvgCanvas#event:exported
+    * @todo Confirm/fix ICO type
+    * @returns {Promise} Resolves to {@link module:svgcanvas.ImageExportedResults}
+    */
+
+    this.rasterExport =
+    /*#__PURE__*/
+    function () {
+      var _ref5 = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee2(imgType, quality, exportWindowName) {
+        var opts,
+            type,
+            mimeType,
+            _getIssues,
+            issues,
+            issueCodes,
+            svg,
+            _ref6,
+            c,
+            _args2 = arguments;
+
+        return regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                opts = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : {};
+                type = imgType === 'ICO' ? 'BMP' : imgType || 'PNG';
+                mimeType = 'image/' + type.toLowerCase();
+                _getIssues = getIssues(), issues = _getIssues.issues, issueCodes = _getIssues.issueCodes;
+                svg = this.svgCanvasToString();
+
+                if (canvg) {
+                  _context2.next = 10;
+                  break;
+                }
+
+                _context2.next = 8;
+                return importSetGlobal(curConfig.canvgPath + 'canvg.js', {
+                  global: 'canvg'
+                });
+
+              case 8:
+                _ref6 = _context2.sent;
+                canvg = _ref6.canvg;
+
+              case 10:
+                if (!$$8('#export_canvas').length) {
+                  $$8('<canvas>', {
+                    id: 'export_canvas'
+                  }).hide().appendTo('body');
+                }
+
+                c = $$8('#export_canvas')[0];
+                c.width = canvas.contentW;
+                c.height = canvas.contentH;
+                _context2.next = 16;
+                return canvg(c, svg);
+
+              case 16:
+                return _context2.abrupt("return", new Promise(function (resolve, reject) {
+                  // eslint-disable-line promise/avoid-new
+                  var dataURLType = type.toLowerCase();
+                  var datauri = quality ? c.toDataURL('image/' + dataURLType, quality) : c.toDataURL('image/' + dataURLType);
+                  var bloburl;
+                  /**
+                   * Called when `bloburl` is available for export.
+                   * @returns {undefined}
+                   */
+
+                  function done() {
+                    var obj = {
+                      datauri: datauri,
+                      bloburl: bloburl,
+                      svg: svg,
+                      issues: issues,
+                      issueCodes: issueCodes,
+                      type: imgType,
+                      mimeType: mimeType,
+                      quality: quality,
+                      exportWindowName: exportWindowName
+                    };
+
+                    if (!opts.avoidEvent) {
+                      call('exported', obj);
+                    }
+
+                    resolve(obj);
+                  }
+
+                  if (c.toBlob) {
+                    c.toBlob(function (blob) {
+                      bloburl = createObjectURL(blob);
+                      done();
+                    }, mimeType, quality);
+                    return;
+                  }
+
+                  bloburl = dataURLToObjectURL(datauri);
+                  done();
+                }));
+
+              case 17:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      return function (_x4, _x5, _x6) {
+        return _ref5.apply(this, arguments);
+      };
+    }();
+    /**
+     * @external jsPDF
+     */
+
+    /**
+     * @typedef {undefined|"save"|"arraybuffer"|"blob"|"datauristring"|"dataurlstring"|"dataurlnewwindow"|"datauri"|"dataurl"} external:jsPDF.OutputType
+     * @todo Newer version to add also allows these `outputType` values "bloburi"|"bloburl" which return strings, so document here and for `outputType` of `module:svgcanvas.PDFExportedResults` below if added
+    */
+
+    /**
+    * @typedef {PlainObject} module:svgcanvas.PDFExportedResults
+    * @property {string} svg The SVG PDF output
+    * @property {string|ArrayBuffer|Blob|window} output The output based on the `outputType`;
+    * if `undefined`, "datauristring", "dataurlstring", "datauri",
+    * or "dataurl", will be a string (`undefined` gives a document, while the others
+    * build as Data URLs; "datauri" and "dataurl" change the location of the current page); if
+    * "arraybuffer", will return `ArrayBuffer`; if "blob", returns a `Blob`;
+    * if "dataurlnewwindow", will change the current page's location and return a string
+    * if in Safari and no window object is found; otherwise opens in, and returns, a new `window`
+    * object; if "save", will have the same return as "dataurlnewwindow" if
+    * `navigator.getUserMedia` support is found without `URL.createObjectURL` support; otherwise
+    * returns `undefined` but attempts to save
+    * @property {external:jsPDF.OutputType} outputType
+    * @property {string[]} issues The human-readable localization messages of corresponding `issueCodes`
+    * @property {module:svgcanvas.IssueCode[]} issueCodes
+    * @property {string} exportWindowName
+    */
+
+    /**
+    * Generates a PDF based on the current image, then calls "exportedPDF" with
+    * an object including the string, the data URL, and any issues found.
+    * @function module:svgcanvas.SvgCanvas#exportPDF
+    * @param {string} [exportWindowName] Will also be used for the download file name here
+    * @param {external:jsPDF.OutputType} [outputType="dataurlstring"]
+    * @fires module:svgcanvas.SvgCanvas#event:exportedPDF
+    * @returns {Promise} Resolves to {@link module:svgcanvas.PDFExportedResults}
+    */
+
+
+    this.exportPDF =
+    /*#__PURE__*/
+    function () {
+      var _ref7 = _asyncToGenerator(
+      /*#__PURE__*/
+      regeneratorRuntime.mark(function _callee3(exportWindowName) {
+        var outputType,
+            modularVersion,
+            res,
+            orientation,
+            unit,
+            doc,
+            docTitle,
+            _getIssues2,
+            issues,
+            issueCodes,
+            svg,
+            obj,
+            _args3 = arguments;
+
+        return regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                outputType = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : isChrome() ? 'save' : undefined;
+
+                if (window.jsPDF) {
+                  _context3.next = 7;
+                  break;
+                }
+
+                _context3.next = 4;
+                return importScript([// We do not currently have these paths configurable as they are
+                //   currently global-only, so not Rolled-up
+                'jspdf/underscore-min.js', 'jspdf/jspdf.min.js']);
+
+              case 4:
+                modularVersion = !('svgEditor' in window) || !window.svgEditor || window.svgEditor.modules !== false; // Todo: Switch to `import()` when widely supported and available (also allow customization of path)
+
+                _context3.next = 7;
+                return importScript(curConfig.jspdfPath + 'jspdf.plugin.svgToPdf.js', {
+                  type: modularVersion ? 'module' : 'text/javascript'
+                });
+
+              case 7:
+                res = getResolution();
+                orientation = res.w > res.h ? 'landscape' : 'portrait';
+                unit = 'pt'; // curConfig.baseUnit; // We could use baseUnit, but that is presumably not intended for export purposes
+                // Todo: Give options to use predefined jsPDF formats like "a4", etc. from pull-down (with option to keep customizable)
+
+                doc = jsPDF({
+                  orientation: orientation,
+                  unit: unit,
+                  format: [res.w, res.h] // , compressPdf: true
+
+                });
+                docTitle = getDocumentTitle();
+                doc.setProperties({
+                  title: docTitle
+                  /* ,
+                  subject: '',
+                  author: '',
+                  keywords: '',
+                  creator: '' */
+
+                });
+                _getIssues2 = getIssues(), issues = _getIssues2.issues, issueCodes = _getIssues2.issueCodes;
+                svg = this.svgCanvasToString();
+                doc.addSVG(svg, 0, 0); // doc.output('save'); // Works to open in a new
+                //  window; todo: configure this and other export
+                //  options to optionally work in this manner as
+                //  opposed to opening a new tab
+
+                outputType = outputType || 'dataurlstring';
+                obj = {
+                  svg: svg,
+                  issues: issues,
+                  issueCodes: issueCodes,
+                  exportWindowName: exportWindowName,
+                  outputType: outputType
+                };
+                obj.output = doc.output(outputType, outputType === 'save' ? exportWindowName || 'svg.pdf' : undefined);
+                call('exportedPDF', obj);
+                return _context3.abrupt("return", obj);
+
+              case 21:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      return function (_x7) {
+        return _ref7.apply(this, arguments);
+      };
+    }();
+    /**
+    * Returns the current drawing as raw SVG XML text.
+    * @function module:svgcanvas.SvgCanvas#getSvgString
+    * @returns {string} The current drawing as raw SVG XML text.
+    */
+
+
+    this.getSvgString = function () {
+      saveOptions.apply = false;
+      return this.svgCanvasToString();
+    };
+    /**
+    * This function determines whether to use a nonce in the prefix, when
+    * generating IDs for future documents in SVG-Edit.
+    * If you're controlling SVG-Edit externally, and want randomized IDs, call
+    * this BEFORE calling `svgCanvas.setSvgString`.
+    * @function module:svgcanvas.SvgCanvas#randomizeIds
+    * @param {boolean} [enableRandomization] If true, adds a nonce to the prefix. Thus
+    * `svgCanvas.randomizeIds() <==> svgCanvas.randomizeIds(true)`
+    * @returns {undefined}
+    */
+
+
+    this.randomizeIds = function (enableRandomization) {
+      if (arguments.length > 0 && enableRandomization === false) {
+        randomizeIds(false, getCurrentDrawing());
+      } else {
+        randomizeIds(true, getCurrentDrawing());
+      }
+    };
+    /**
+    * Ensure each element has a unique ID.
+    * @function module:svgcanvas.SvgCanvas#uniquifyElems
+    * @param {Element} g - The parent element of the tree to give unique IDs
+    * @returns {undefined}
+    */
+
+
+    var uniquifyElems = this.uniquifyElems = function (g) {
+      var ids = {}; // TODO: Handle markers and connectors. These are not yet re-identified properly
+      // as their referring elements do not get remapped.
+      //
+      // <marker id='se_marker_end_svg_7'/>
+      // <polyline id='svg_7' se:connector='svg_1 svg_6' marker-end='url(#se_marker_end_svg_7)'/>
+      //
+      // Problem #1: if svg_1 gets renamed, we do not update the polyline's se:connector attribute
+      // Problem #2: if the polyline svg_7 gets renamed, we do not update the marker id nor the polyline's marker-end attribute
+
+      var refElems = ['filter', 'linearGradient', 'pattern', 'radialGradient', 'symbol', 'textPath', 'use'];
+      walkTree(g, function (n) {
+        // if it's an element node
+        if (n.nodeType === 1) {
+          // and the element has an ID
+          if (n.id) {
+            // and we haven't tracked this ID yet
+            if (!(n.id in ids)) {
+              // add this id to our map
+              ids[n.id] = {
+                elem: null,
+                attrs: [],
+                hrefs: []
+              };
+            }
+
+            ids[n.id].elem = n;
+          } // now search for all attributes on this element that might refer
+          // to other elements
+
+
+          $$8.each(refAttrs, function (i, attr) {
+            var attrnode = n.getAttributeNode(attr);
+
+            if (attrnode) {
+              // the incoming file has been sanitized, so we should be able to safely just strip off the leading #
+              var url = getUrlFromAttr(attrnode.value),
+                  refid = url ? url.substr(1) : null;
+
+              if (refid) {
+                if (!(refid in ids)) {
+                  // add this id to our map
+                  ids[refid] = {
+                    elem: null,
+                    attrs: [],
+                    hrefs: []
+                  };
+                }
+
+                ids[refid].attrs.push(attrnode);
+              }
+            }
+          }); // check xlink:href now
+
+          var href = getHref(n); // TODO: what if an <image> or <a> element refers to an element internally?
+
+          if (href && refElems.includes(n.nodeName)) {
+            var refid = href.substr(1);
+
+            if (refid) {
+              if (!(refid in ids)) {
+                // add this id to our map
+                ids[refid] = {
+                  elem: null,
+                  attrs: [],
+                  hrefs: []
+                };
+              }
+
+              ids[refid].hrefs.push(n);
+            }
+          }
+        }
+      }); // in ids, we now have a map of ids, elements and attributes, let's re-identify
+
+      for (var oldid in ids) {
+        if (!oldid) {
+          continue;
+        }
+
+        var elem = ids[oldid].elem;
+
+        if (elem) {
+          var newid = getNextId(); // assign element its new id
+
+          elem.id = newid; // remap all url() attributes
+
+          var attrs = ids[oldid].attrs;
+          var j = attrs.length;
+
+          while (j--) {
+            var attr = attrs[j];
+            attr.ownerElement.setAttribute(attr.name, 'url(#' + newid + ')');
+          } // remap all href attributes
+
+
+          var hreffers = ids[oldid].hrefs;
+          var k = hreffers.length;
+
+          while (k--) {
+            var hreffer = hreffers[k];
+            setHref(hreffer, '#' + newid);
+          }
+        }
+      }
+    };
+    /**
+    * Assigns reference data for each use element.
+    * @function module:svgcanvas.SvgCanvas#setUseData
+    * @param {Element} parent
+    * @returns {undefined}
+    */
+
+
+    var setUseData = this.setUseData = function (parent) {
+      var elems = $$8(parent);
+
+      if (parent.tagName !== 'use') {
+        elems = elems.find('use');
+      }
+
+      elems.each(function () {
+        var id = getHref(this).substr(1);
+        var refElem = getElem(id);
+
+        if (!refElem) {
+          return;
+        }
+
+        $$8(this).data('ref', refElem);
+
+        if (refElem.tagName === 'symbol' || refElem.tagName === 'svg') {
+          $$8(this).data('symbol', refElem).data('ref', refElem);
+        }
+      });
+    };
+    /**
+    * Converts gradients from userSpaceOnUse to objectBoundingBox.
+    * @function module:svgcanvas.SvgCanvas#convertGradients
+    * @param {Element} elem
+    * @returns {undefined}
+    */
+
+
+    var convertGradients = this.convertGradients = function (elem) {
+      var elems = $$8(elem).find('linearGradient, radialGradient');
+
+      if (!elems.length && isWebkit()) {
+        // Bug in webkit prevents regular *Gradient selector search
+        elems = $$8(elem).find('*').filter(function () {
+          return this.tagName.includes('Gradient');
+        });
+      }
+
+      elems.each(function () {
+        var grad = this; // eslint-disable-line consistent-this
+
+        if ($$8(grad).attr('gradientUnits') === 'userSpaceOnUse') {
+          // TODO: Support more than one element with this ref by duplicating parent grad
+          var fillStrokeElems = $$8(svgcontent).find('[fill="url(#' + grad.id + ')"],[stroke="url(#' + grad.id + ')"]');
+
+          if (!fillStrokeElems.length) {
+            return;
+          } // get object's bounding box
+
+
+          var bb = getBBox(fillStrokeElems[0]); // This will occur if the element is inside a <defs> or a <symbol>,
+          // in which we shouldn't need to convert anyway.
+
+          if (!bb) {
+            return;
+          }
+
+          if (grad.tagName === 'linearGradient') {
+            var gCoords = $$8(grad).attr(['x1', 'y1', 'x2', 'y2']); // If has transform, convert
+
+            var tlist = grad.gradientTransform.baseVal;
+
+            if (tlist && tlist.numberOfItems > 0) {
+              var m = transformListToTransform(tlist).matrix;
+              var pt1 = transformPoint(gCoords.x1, gCoords.y1, m);
+              var pt2 = transformPoint(gCoords.x2, gCoords.y2, m);
+              gCoords.x1 = pt1.x;
+              gCoords.y1 = pt1.y;
+              gCoords.x2 = pt2.x;
+              gCoords.y2 = pt2.y;
+              grad.removeAttribute('gradientTransform');
+            }
+
+            $$8(grad).attr({
+              x1: (gCoords.x1 - bb.x) / bb.width,
+              y1: (gCoords.y1 - bb.y) / bb.height,
+              x2: (gCoords.x2 - bb.x) / bb.width,
+              y2: (gCoords.y2 - bb.y) / bb.height
+            });
+            grad.removeAttribute('gradientUnits');
+          } // else {
+          //   Note: radialGradient elements cannot be easily converted
+          //   because userSpaceOnUse will keep circular gradients, while
+          //   objectBoundingBox will x/y scale the gradient according to
+          //   its bbox.
+          //
+          //   For now we'll do nothing, though we should probably have
+          //   the gradient be updated as the element is moved, as
+          //   inkscape/illustrator do.
+          //
+          //   const gCoords = $(grad).attr(['cx', 'cy', 'r']);
+          //
+          //   $(grad).attr({
+          //     cx: (gCoords.cx - bb.x) / bb.width,
+          //     cy: (gCoords.cy - bb.y) / bb.height,
+          //     r: gCoords.r
+          //   });
+          //
+          //   grad.removeAttribute('gradientUnits');
+          // }
+
+        }
+      });
+    };
+    /**
+    * Converts selected/given `<use>` or child SVG element to a group.
+    * @function module:svgcanvas.SvgCanvas#convertToGroup
+    * @param {Element} elem
+    * @fires module:svgcanvas.SvgCanvas#event:selected
+    * @returns {undefined}
+    */
+
+
+    var convertToGroup = this.convertToGroup = function (elem) {
+      if (!elem) {
+        elem = selectedElements[0];
+      }
+
+      var $elem = $$8(elem);
+      var batchCmd = new BatchCommand$1();
+      var ts;
+
+      if ($elem.data('gsvg')) {
+        // Use the gsvg as the new group
+        var svg = elem.firstChild;
+        var pt = $$8(svg).attr(['x', 'y']);
+        $$8(elem.firstChild.firstChild).unwrap();
+        $$8(elem).removeData('gsvg');
+        var tlist = getTransformList(elem);
+        var xform = svgroot.createSVGTransform();
+        xform.setTranslate(pt.x, pt.y);
+        tlist.appendItem(xform);
+        recalculateDimensions(elem);
+        call('selected', [elem]);
+      } else if ($elem.data('symbol')) {
+        elem = $elem.data('symbol');
+        ts = $elem.attr('transform');
+        var pos = $elem.attr(['x', 'y']);
+        var vb = elem.getAttribute('viewBox');
+
+        if (vb) {
+          var nums = vb.split(' ');
+          pos.x -= Number(nums[0]);
+          pos.y -= Number(nums[1]);
+        } // Not ideal, but works
+
+
+        ts += ' translate(' + (pos.x || 0) + ',' + (pos.y || 0) + ')';
+        var prev = $elem.prev(); // Remove <use> element
+
+        batchCmd.addSubCommand(new RemoveElementCommand$1($elem[0], $elem[0].nextSibling, $elem[0].parentNode));
+        $elem.remove(); // See if other elements reference this symbol
+
+        var hasMore = $$8(svgcontent).find('use:data(symbol)').length;
+        var g = svgdoc.createElementNS(NS.SVG, 'g');
+        var childs = elem.childNodes;
+        var i;
+
+        for (i = 0; i < childs.length; i++) {
+          g.append(childs[i].cloneNode(true));
+        } // Duplicate the gradients for Gecko, since they weren't included in the <symbol>
+
+
+        if (isGecko()) {
+          var dupeGrads = $$8(findDefs()).children('linearGradient,radialGradient,pattern').clone();
+          $$8(g).append(dupeGrads);
+        }
+
+        if (ts) {
+          g.setAttribute('transform', ts);
+        }
+
+        var parent = elem.parentNode;
+        uniquifyElems(g); // Put the dupe gradients back into <defs> (after uniquifying them)
+
+        if (isGecko()) {
+          $$8(findDefs()).append($$8(g).find('linearGradient,radialGradient,pattern'));
+        } // now give the g itself a new id
+
+
+        g.id = getNextId();
+        prev.after(g);
+
+        if (parent) {
+          if (!hasMore) {
+            // remove symbol/svg element
+            var _elem = elem,
+                nextSibling = _elem.nextSibling;
+            elem.remove();
+            batchCmd.addSubCommand(new RemoveElementCommand$1(elem, nextSibling, parent));
+          }
+
+          batchCmd.addSubCommand(new InsertElementCommand$1(g));
+        }
+
+        setUseData(g);
+
+        if (isGecko()) {
+          convertGradients(findDefs());
+        } else {
+          convertGradients(g);
+        } // recalculate dimensions on the top-level children so that unnecessary transforms
+        // are removed
+
+
+        walkTreePost(g, function (n) {
+          try {
+            recalculateDimensions(n);
+          } catch (e) {
+            console.log(e); // eslint-disable-line no-console
+          }
+        }); // Give ID for any visible element missing one
+
+        $$8(g).find(visElems).each(function () {
+          if (!this.id) {
+            this.id = getNextId();
+          }
+        });
+        selectOnly([g]);
+        var cm = pushGroupProperties(g, true);
+
+        if (cm) {
+          batchCmd.addSubCommand(cm);
+        }
+
+        addCommandToHistory(batchCmd);
+      } else {
+        console.log('Unexpected element to ungroup:', elem); // eslint-disable-line no-console
+      }
+    };
+    /**
+    * This function sets the current drawing as the input SVG XML.
+    * @function module:svgcanvas.SvgCanvas#setSvgString
+    * @param {string} xmlString - The SVG as XML text.
+    * @param {boolean} [preventUndo=false] - Indicates if we want to do the
+    * changes without adding them to the undo stack - e.g. for initializing a
+    * drawing on page load.
+    * @fires module:svgcanvas.SvgCanvas#event:setnonce
+    * @fires module:svgcanvas.SvgCanvas#event:unsetnonce
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {boolean} This function returns `false` if the set was
+    *     unsuccessful, `true` otherwise.
+    */
+
+
+    this.setSvgString = function (xmlString, preventUndo) {
+      try {
+        // convert string into XML document
+        var newDoc = text2xml(xmlString);
+
+        if (newDoc.firstElementChild && newDoc.firstElementChild.namespaceURI !== NS.SVG) {
+          return false;
+        }
+
+        this.prepareSvg(newDoc);
+        var batchCmd = new BatchCommand$1('Change Source'); // remove old svg document
+
+        var _svgcontent = svgcontent,
+            nextSibling = _svgcontent.nextSibling;
+        var oldzoom = svgroot.removeChild(svgcontent);
+        batchCmd.addSubCommand(new RemoveElementCommand$1(oldzoom, nextSibling, svgroot)); // set new svg document
+        // If DOM3 adoptNode() available, use it. Otherwise fall back to DOM2 importNode()
+
+        if (svgdoc.adoptNode) {
+          svgcontent = svgdoc.adoptNode(newDoc.documentElement);
+        } else {
+          svgcontent = svgdoc.importNode(newDoc.documentElement, true);
+        }
+
+        svgroot.append(svgcontent);
+        var content = $$8(svgcontent);
+        canvas.current_drawing_ = new Drawing(svgcontent, idprefix); // retrieve or set the nonce
+
+        var nonce = getCurrentDrawing().getNonce();
+
+        if (nonce) {
+          call('setnonce', nonce);
+        } else {
+          call('unsetnonce');
+        } // change image href vals if possible
+
+
+        content.find('image').each(function () {
+          var image = this; // eslint-disable-line consistent-this
+
+          preventClickDefault(image);
+          var val = getHref(this);
+
+          if (val) {
+            if (val.startsWith('data:')) {
+              // Check if an SVG-edit data URI
+              var m = val.match(/svgedit_url=(.*?);/);
+
+              if (m) {
+                var url = decodeURIComponent(m[1]);
+                $$8(new Image()).load(function () {
+                  image.setAttributeNS(NS.XLINK, 'xlink:href', url);
+                }).attr('src', url);
+              }
+            } // Add to encodableImages if it loads
+
+
+            canvas.embedImage(val);
+          }
+        }); // Wrap child SVGs in group elements
+
+        content.find('svg').each(function () {
+          // Skip if it's in a <defs>
+          if ($$8(this).closest('defs').length) {
+            return;
+          }
+
+          uniquifyElems(this); // Check if it already has a gsvg group
+
+          var pa = this.parentNode;
+
+          if (pa.childNodes.length === 1 && pa.nodeName === 'g') {
+            $$8(pa).data('gsvg', this);
+            pa.id = pa.id || getNextId();
+          } else {
+            groupSvgElem(this);
+          }
+        }); // For Firefox: Put all paint elems in defs
+
+        if (isGecko()) {
+          content.find('linearGradient, radialGradient, pattern').appendTo(findDefs());
+        } // Set ref element for <use> elements
+        // TODO: This should also be done if the object is re-added through "redo"
+
+
+        setUseData(content);
+        convertGradients(content[0]);
+        var attrs = {
+          id: 'svgcontent',
+          overflow: curConfig.show_outside_canvas ? 'visible' : 'hidden'
+        };
+        var percs = false; // determine proper size
+
+        if (content.attr('viewBox')) {
+          var vb = content.attr('viewBox').split(' ');
+          attrs.width = vb[2];
+          attrs.height = vb[3]; // handle content that doesn't have a viewBox
+        } else {
+          $$8.each(['width', 'height'], function (i, dim) {
+            // Set to 100 if not given
+            var val = content.attr(dim) || '100%';
+
+            if (String(val).substr(-1) === '%') {
+              // Use user units if percentage given
+              percs = true;
+            } else {
+              attrs[dim] = convertToNum(dim, val);
+            }
+          });
+        } // identify layers
+
+
+        identifyLayers(); // Give ID for any visible layer children missing one
+
+        content.children().find(visElems).each(function () {
+          if (!this.id) {
+            this.id = getNextId();
+          }
+        }); // Percentage width/height, so let's base it on visible elements
+
+        if (percs) {
+          var bb = getStrokedBBoxDefaultVisible();
+          attrs.width = bb.width + bb.x;
+          attrs.height = bb.height + bb.y;
+        } // Just in case negative numbers are given or
+        // result from the percs calculation
+
+
+        if (attrs.width <= 0) {
+          attrs.width = 100;
+        }
+
+        if (attrs.height <= 0) {
+          attrs.height = 100;
+        }
+
+        content.attr(attrs);
+        this.contentW = attrs.width;
+        this.contentH = attrs.height;
+        batchCmd.addSubCommand(new InsertElementCommand$1(svgcontent)); // update root to the correct size
+
+        var changes = content.attr(['width', 'height']);
+        batchCmd.addSubCommand(new ChangeElementCommand$1(svgroot, changes)); // reset zoom
+
+        currentZoom = 1; // reset transform lists
+
+        resetListMap();
+        clearSelection();
+        clearData();
+        svgroot.append(selectorManager.selectorParentGroup);
+        if (!preventUndo) addCommandToHistory(batchCmd);
+        call('changed', [svgcontent]);
+      } catch (e) {
+        console.log(e); // eslint-disable-line no-console
+
+        return false;
+      }
+
+      return true;
+    };
+    /**
+    * This function imports the input SVG XML as a `<symbol>` in the `<defs>`, then adds a
+    * `<use>` to the current layer.
+    * @function module:svgcanvas.SvgCanvas#importSvgString
+    * @param {string} xmlString - The SVG as XML text.
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {null|Element} This function returns null if the import was unsuccessful, or the element otherwise.
+    * @todo
+    * - properly handle if namespace is introduced by imported content (must add to svgcontent
+    * and update all prefixes in the imported node)
+    * - properly handle recalculating dimensions, `recalculateDimensions()` doesn't handle
+    * arbitrary transform lists, but makes some assumptions about how the transform list
+    * was obtained
+    */
+
+
+    this.importSvgString = function (xmlString) {
+      var j, ts, useEl;
+
+      try {
+        // Get unique ID
+        var uid = encode64(xmlString.length + xmlString).substr(0, 32);
+        var useExisting = false; // Look for symbol and make sure symbol exists in image
+
+        if (importIds[uid]) {
+          if ($$8(importIds[uid].symbol).parents('#svgroot').length) {
+            useExisting = true;
+          }
+        }
+
+        var batchCmd = new BatchCommand$1('Import Image');
+        var symbol;
+
+        if (useExisting) {
+          symbol = importIds[uid].symbol;
+          ts = importIds[uid].xform;
+        } else {
+          // convert string into XML document
+          var newDoc = text2xml(xmlString);
+          this.prepareSvg(newDoc); // import new svg document into our document
+
+          var svg; // If DOM3 adoptNode() available, use it. Otherwise fall back to DOM2 importNode()
+
+          if (svgdoc.adoptNode) {
+            svg = svgdoc.adoptNode(newDoc.documentElement);
+          } else {
+            svg = svgdoc.importNode(newDoc.documentElement, true);
+          }
+
+          uniquifyElems(svg);
+          var innerw = convertToNum('width', svg.getAttribute('width')),
+              innerh = convertToNum('height', svg.getAttribute('height')),
+              innervb = svg.getAttribute('viewBox'),
+              // if no explicit viewbox, create one out of the width and height
+          vb = innervb ? innervb.split(' ') : [0, 0, innerw, innerh];
+
+          for (j = 0; j < 4; ++j) {
+            vb[j] = Number(vb[j]);
+          } // TODO: properly handle preserveAspectRatio
+
+
+          var // canvasw = +svgcontent.getAttribute('width'),
+          canvash = Number(svgcontent.getAttribute('height')); // imported content should be 1/3 of the canvas on its largest dimension
+
+          if (innerh > innerw) {
+            ts = 'scale(' + canvash / 3 / vb[3] + ')';
+          } else {
+            ts = 'scale(' + canvash / 3 / vb[2] + ')';
+          } // Hack to make recalculateDimensions understand how to scale
+
+
+          ts = 'translate(0) ' + ts + ' translate(0)';
+          symbol = svgdoc.createElementNS(NS.SVG, 'symbol');
+          var defs = findDefs();
+
+          if (isGecko()) {
+            // Move all gradients into root for Firefox, workaround for this bug:
+            // https://bugzilla.mozilla.org/show_bug.cgi?id=353575
+            // TODO: Make this properly undo-able.
+            $$8(svg).find('linearGradient, radialGradient, pattern').appendTo(defs);
+          }
+
+          while (svg.firstChild) {
+            var first = svg.firstChild;
+            symbol.append(first);
+          }
+
+          var attrs = svg.attributes;
+
+          for (var i = 0; i < attrs.length; i++) {
+            var attr = attrs[i];
+            symbol.setAttribute(attr.nodeName, attr.value);
+          }
+
+          symbol.id = getNextId(); // Store data
+
+          importIds[uid] = {
+            symbol: symbol,
+            xform: ts
+          };
+          findDefs().append(symbol);
+          batchCmd.addSubCommand(new InsertElementCommand$1(symbol));
+        }
+
+        useEl = svgdoc.createElementNS(NS.SVG, 'use');
+        useEl.id = getNextId();
+        setHref(useEl, '#' + symbol.id);
+        (currentGroup || getCurrentDrawing().getCurrentLayer()).append(useEl);
+        batchCmd.addSubCommand(new InsertElementCommand$1(useEl));
+        clearSelection();
+        useEl.setAttribute('transform', ts);
+        recalculateDimensions(useEl);
+        $$8(useEl).data('symbol', symbol).data('ref', symbol);
+        addToSelection([useEl]); // TODO: Find way to add this in a recalculateDimensions-parsable way
+        // if (vb[0] !== 0 || vb[1] !== 0) {
+        //   ts = 'translate(' + (-vb[0]) + ',' + (-vb[1]) + ') ' + ts;
+        // }
+
+        addCommandToHistory(batchCmd);
+        call('changed', [svgcontent]);
+      } catch (e) {
+        console.log(e); // eslint-disable-line no-console
+
+        return null;
+      } // we want to return the element so we can automatically select it
+
+
+      return useEl;
+    }; // Could deprecate, but besides external uses, their usage makes clear that
+    //  canvas is a dependency for all of these
+
+
+    var dr = {
+      identifyLayers: identifyLayers,
+      createLayer: createLayer,
+      cloneLayer: cloneLayer,
+      deleteCurrentLayer: deleteCurrentLayer,
+      setCurrentLayer: setCurrentLayer,
+      renameCurrentLayer: renameCurrentLayer,
+      setCurrentLayerPosition: setCurrentLayerPosition,
+      setLayerVisibility: setLayerVisibility,
+      moveSelectedToLayer: moveSelectedToLayer,
+      mergeLayer: mergeLayer,
+      mergeAllLayers: mergeAllLayers,
+      leaveContext: leaveContext,
+      setContext: setContext
+    };
+    Object.entries(dr).forEach(function (_ref8) {
+      var _ref9 = _slicedToArray(_ref8, 2),
+          prop = _ref9[0],
+          propVal = _ref9[1];
+
+      canvas[prop] = propVal;
+    });
+    init$3(
+    /**
+    * @implements {module:draw.DrawCanvasInit}
+    */
+    {
+      pathActions: pathActions$$1,
+      getCurrentGroup: function getCurrentGroup() {
+        return currentGroup;
+      },
+      setCurrentGroup: function setCurrentGroup(cg) {
+        currentGroup = cg;
+      },
+      getSelectedElements: getSelectedElements,
+      getSVGContent: getSVGContent,
+      undoMgr: undoMgr,
+      elData: elData,
+      getCurrentDrawing: getCurrentDrawing,
+      clearSelection: clearSelection,
+      call: call,
+      addCommandToHistory: addCommandToHistory,
+
+      /**
+       * @fires module:svgcanvas.SvgCanvas#event:changed
+       * @returns {undefined}
+       */
+      changeSVGContent: function changeSVGContent() {
+        call('changed', [svgcontent]);
+      }
+    });
+    /**
+    * Group: Document functions
+    */
+
+    /**
+    * Clears the current document. This is not an undoable action.
+    * @function module:svgcanvas.SvgCanvas#clear
+    * @fires module:svgcanvas.SvgCanvas#event:cleared
+    * @returns {undefined}
+    */
+
+    this.clear = function () {
+      pathActions$$1.clear();
+      clearSelection(); // clear the svgcontent node
+
+      canvas.clearSvgContentElement(); // create new document
+
+      canvas.current_drawing_ = new Drawing(svgcontent); // create empty first layer
+
+      canvas.createLayer('Layer 1'); // clear the undo stack
+
+      canvas.undoMgr.resetUndoStack(); // reset the selector manager
+
+      selectorManager.initGroup(); // reset the rubber band box
+
+      rubberBox = selectorManager.getRubberBandBox();
+      call('cleared');
+    }; // Alias function
+
+
+    this.linkControlPoints = pathActions$$1.linkControlPoints;
+    /**
+    * @function module:svgcanvas.SvgCanvas#getContentElem
+    * @returns {Element} The content DOM element
+    */
+
+    this.getContentElem = function () {
+      return svgcontent;
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getRootElem
+    * @returns {SVGSVGElement} The root DOM element
+    */
+
+
+    this.getRootElem = function () {
+      return svgroot;
+    };
+    /**
+    * @typedef {PlainObject} DimensionsAndZoom
+    * @property {Float} w Width
+    * @property {Float} h Height
+    * @property {Float} zoom Zoom
+    */
+
+    /**
+    * @function module:svgcanvas.SvgCanvas#getResolution
+    * @returns {DimensionsAndZoom} The current dimensions and zoom level in an object
+    */
+
+
+    var getResolution = this.getResolution = function () {
+      //    const vb = svgcontent.getAttribute('viewBox').split(' ');
+      //    return {w:vb[2], h:vb[3], zoom: currentZoom};
+      var w = svgcontent.getAttribute('width') / currentZoom;
+      var h = svgcontent.getAttribute('height') / currentZoom;
+      return {
+        w: w,
+        h: h,
+        zoom: currentZoom
+      };
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getSnapToGrid
+    * @returns {boolean} The current snap to grid setting
+    */
+
+
+    this.getSnapToGrid = function () {
+      return curConfig.gridSnapping;
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getVersion
+    * @returns {string} A string which describes the revision number of SvgCanvas.
+    */
+
+
+    this.getVersion = function () {
+      return 'svgcanvas.js ($Rev$)';
+    };
+    /**
+    * Update interface strings with given values.
+    * @function module:svgcanvas.SvgCanvas#setUiStrings
+    * @param {module:path.uiStrings} strs - Object with strings (see the [locales API]{@link module:locale.LocaleStrings} and the [tutorial]{@tutorial LocaleDocs})
+    * @returns {undefined}
+    */
+
+
+    this.setUiStrings = function (strs) {
+      Object.assign(uiStrings, strs.notification);
+      $$8 = jQueryPluginDBox($$8, strs.common);
+      setUiStrings(strs);
+    };
+    /**
+    * Update configuration options with given values.
+    * @function module:svgcanvas.SvgCanvas#setConfig
+    * @param {module:SVGEditor.Config} opts - Object with options
+    * @returns {undefined}
+    */
+
+
+    this.setConfig = function (opts) {
+      Object.assign(curConfig, opts);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getTitle
+    * @param {Element} [elem]
+    * @returns {string|undefined} the current group/SVG's title contents or
+    * `undefined` if no element is passed nd there are no selected elements.
+    */
+
+
+    this.getTitle = function (elem) {
+      elem = elem || selectedElements[0];
+
+      if (!elem) {
+        return undefined;
+      }
+
+      elem = $$8(elem).data('gsvg') || $$8(elem).data('symbol') || elem;
+      var childs = elem.childNodes;
+
+      for (var i = 0; i < childs.length; i++) {
+        if (childs[i].nodeName === 'title') {
+          return childs[i].textContent;
+        }
+      }
+
+      return '';
+    };
+    /**
+    * Sets the group/SVG's title content.
+    * @function module:svgcanvas.SvgCanvas#setGroupTitle
+    * @param {string} val
+    * @todo Combine this with `setDocumentTitle`
+    * @returns {undefined}
+    */
+
+
+    this.setGroupTitle = function (val) {
+      var elem = selectedElements[0];
+      elem = $$8(elem).data('gsvg') || elem;
+      var ts = $$8(elem).children('title');
+      var batchCmd = new BatchCommand$1('Set Label');
+      var title;
+
+      if (!val.length) {
+        // Remove title element
+        var tsNextSibling = ts.nextSibling;
+        batchCmd.addSubCommand(new RemoveElementCommand$1(ts[0], tsNextSibling, elem));
+        ts.remove();
+      } else if (ts.length) {
+        // Change title contents
+        title = ts[0];
+        batchCmd.addSubCommand(new ChangeElementCommand$1(title, {
+          '#text': title.textContent
+        }));
+        title.textContent = val;
+      } else {
+        // Add title element
+        title = svgdoc.createElementNS(NS.SVG, 'title');
+        title.textContent = val;
+        $$8(elem).prepend(title);
+        batchCmd.addSubCommand(new InsertElementCommand$1(title));
+      }
+
+      addCommandToHistory(batchCmd);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getDocumentTitle
+    * @returns {string|undefined} The current document title or an empty string if not found
+    */
+
+
+    var getDocumentTitle = this.getDocumentTitle = function () {
+      return canvas.getTitle(svgcontent);
+    };
+    /**
+    * Adds/updates a title element for the document with the given name.
+    * This is an undoable action.
+    * @function module:svgcanvas.SvgCanvas#setDocumentTitle
+    * @param {string} newTitle - String with the new title
+    * @returns {undefined}
+    */
+
+
+    this.setDocumentTitle = function (newTitle) {
+      var childs = svgcontent.childNodes;
+      var docTitle = false,
+          oldTitle = '';
+      var batchCmd = new BatchCommand$1('Change Image Title');
+
+      for (var i = 0; i < childs.length; i++) {
+        if (childs[i].nodeName === 'title') {
+          docTitle = childs[i];
+          oldTitle = docTitle.textContent;
+          break;
+        }
+      }
+
+      if (!docTitle) {
+        docTitle = svgdoc.createElementNS(NS.SVG, 'title');
+        svgcontent.insertBefore(docTitle, svgcontent.firstChild); // svgcontent.firstChild.before(docTitle); // Ok to replace above with this?
+      }
+
+      if (newTitle.length) {
+        docTitle.textContent = newTitle;
+      } else {
+        // No title given, so element is not necessary
+        docTitle.remove();
+      }
+
+      batchCmd.addSubCommand(new ChangeElementCommand$1(docTitle, {
+        '#text': oldTitle
+      }));
+      addCommandToHistory(batchCmd);
+    };
+    /**
+    * Returns the editor's namespace URL, optionally adding it to the root element.
+    * @function module:svgcanvas.SvgCanvas#getEditorNS
+    * @param {boolean} [add] - Indicates whether or not to add the namespace value
+    * @returns {string} The editor's namespace URL
+    */
+
+
+    this.getEditorNS = function (add) {
+      if (add) {
+        svgcontent.setAttribute('xmlns:se', NS.SE);
+      }
+
+      return NS.SE;
+    };
+    /**
+    * Changes the document's dimensions to the given size.
+    * @function module:svgcanvas.SvgCanvas#setResolution
+    * @param {Float|"fit"} x - Number with the width of the new dimensions in user units.
+    * Can also be the string "fit" to indicate "fit to content".
+    * @param {Float} y - Number with the height of the new dimensions in user units.
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {boolean} Indicates if resolution change was successful.
+    * It will fail on "fit to content" option with no content to fit to.
+    */
+
+
+    this.setResolution = function (x, y) {
+      var res = getResolution();
+      var w = res.w,
+          h = res.h;
+      var batchCmd;
+
+      if (x === 'fit') {
+        // Get bounding box
+        var bbox = getStrokedBBoxDefaultVisible();
+
+        if (bbox) {
+          batchCmd = new BatchCommand$1('Fit Canvas to Content');
+          var visEls = getVisibleElements();
+          addToSelection(visEls);
+          var dx = [],
+              dy = [];
+          $$8.each(visEls, function (i, item) {
+            dx.push(bbox.x * -1);
+            dy.push(bbox.y * -1);
+          });
+          var cmd = canvas.moveSelectedElements(dx, dy, true);
+          batchCmd.addSubCommand(cmd);
+          clearSelection();
+          x = Math.round(bbox.width);
+          y = Math.round(bbox.height);
+        } else {
+          return false;
+        }
+      }
+
+      if (x !== w || y !== h) {
+        if (!batchCmd) {
+          batchCmd = new BatchCommand$1('Change Image Dimensions');
+        }
+
+        x = convertToNum('width', x);
+        y = convertToNum('height', y);
+        svgcontent.setAttribute('width', x);
+        svgcontent.setAttribute('height', y);
+        this.contentW = x;
+        this.contentH = y;
+        batchCmd.addSubCommand(new ChangeElementCommand$1(svgcontent, {
+          width: w,
+          height: h
+        }));
+        svgcontent.setAttribute('viewBox', [0, 0, x / currentZoom, y / currentZoom].join(' '));
+        batchCmd.addSubCommand(new ChangeElementCommand$1(svgcontent, {
+          viewBox: ['0 0', w, h].join(' ')
+        }));
+        addCommandToHistory(batchCmd);
+        call('changed', [svgcontent]);
+      }
+
+      return true;
+    };
+    /**
+    * @typedef {module:jQueryAttr.Attributes} module:svgcanvas.ElementPositionInCanvas
+    * @property {Float} x
+    * @property {Float} y
+    */
+
+    /**
+    * @function module:svgcanvas.SvgCanvas#getOffset
+    * @returns {module:svgcanvas.ElementPositionInCanvas} An object with `x`, `y` values indicating the svgcontent element's
+    * position in the editor's canvas.
+    */
+
+
+    this.getOffset = function () {
+      return $$8(svgcontent).attr(['x', 'y']);
+    };
+    /**
+     * @typedef {PlainObject} module:svgcanvas.ZoomAndBBox
+     * @property {Float} zoom
+     * @property {module:utilities.BBoxObject} bbox
+     */
+
+    /**
+    * Sets the zoom level on the canvas-side based on the given value.
+    * @function module:svgcanvas.SvgCanvas#setBBoxZoom
+    * @param {"selection"|"canvas"|"content"|"layer"|module:SVGEditor.BBoxObjectWithFactor} val - Bounding box object to zoom to or string indicating zoom option. Note: the object value type is defined in `svg-editor.js`
+    * @param {Integer} editorW - The editor's workarea box's width
+    * @param {Integer} editorH - The editor's workarea box's height
+    * @returns {module:svgcanvas.ZoomAndBBox|undefined}
+    */
+
+
+    this.setBBoxZoom = function (val, editorW, editorH) {
+      var spacer = 0.85;
+      var bb;
+
+      var calcZoom = function calcZoom(bb) {
+        // eslint-disable-line no-shadow
+        if (!bb) {
+          return false;
+        }
+
+        var wZoom = Math.round(editorW / bb.width * 100 * spacer) / 100;
+        var hZoom = Math.round(editorH / bb.height * 100 * spacer) / 100;
+        var zoom = Math.min(wZoom, hZoom);
+        canvas.setZoom(zoom);
+        return {
+          zoom: zoom,
+          bbox: bb
+        };
+      };
+
+      if (_typeof(val) === 'object') {
+        bb = val;
+
+        if (bb.width === 0 || bb.height === 0) {
+          var newzoom = bb.zoom ? bb.zoom : currentZoom * bb.factor;
+          canvas.setZoom(newzoom);
+          return {
+            zoom: currentZoom,
+            bbox: bb
+          };
+        }
+
+        return calcZoom(bb);
+      }
+
+      switch (val) {
+        case 'selection':
+          {
+            if (!selectedElements[0]) {
+              return undefined;
+            }
+
+            var selectedElems = $$8.map(selectedElements, function (n) {
+              if (n) {
+                return n;
+              }
+
+              return undefined;
+            });
+            bb = getStrokedBBoxDefaultVisible(selectedElems);
+            break;
+          }
+
+        case 'canvas':
+          {
+            var res = getResolution();
+            spacer = 0.95;
+            bb = {
+              width: res.w,
+              height: res.h,
+              x: 0,
+              y: 0
+            };
+            break;
+          }
+
+        case 'content':
+          bb = getStrokedBBoxDefaultVisible();
+          break;
+
+        case 'layer':
+          bb = getStrokedBBoxDefaultVisible(getVisibleElements(getCurrentDrawing().getCurrentLayer()));
+          break;
+
+        default:
+          return undefined;
+      }
+
+      return calcZoom(bb);
+    };
+    /**
+    * The zoom level has changed. Supplies the new zoom level as a number (not percentage).
+    * @event module:svgcanvas.SvgCanvas#event:ext-zoomChanged
+    * @type {Float}
+    */
+
+    /**
+    * The bottom panel was updated
+    * @event module:svgcanvas.SvgCanvas#event:ext-toolButtonStateUpdate
+    * @type {PlainObject}
+    * @property {boolean} nofill Indicates fill is disabled
+    * @property {boolean} nostroke Indicates stroke is disabled
+    */
+
+    /**
+    * The element selection has changed (elements were added/removed from selection)
+    * @event module:svgcanvas.SvgCanvas#event:ext-selectedChanged
+    * @type {PlainObject}
+    * @property {Element[]} elems Array of the newly selected elements
+    * @property {Element|null} selectedElement The single selected element
+    * @property {boolean} multiselected Indicates whether one or more elements were selected
+    */
+
+    /**
+    * Called when part of element is in process of changing, generally on
+    * mousemove actions like rotate, move, etc.
+    * @event module:svgcanvas.SvgCanvas#event:ext-elementTransition
+    * @type {PlainObject}
+    * @property {Element[]} elems Array of transitioning elements
+    */
+
+    /**
+    * One or more elements were changed
+    * @event module:svgcanvas.SvgCanvas#event:ext-elementChanged
+    * @type {PlainObject}
+    * @property {Element[]} elems Array of the affected elements
+    */
+
+    /**
+    * Invoked as soon as the locale is ready
+    * @event module:svgcanvas.SvgCanvas#event:ext-langReady
+    * @type {PlainObject}
+    * @property {string} lang The two-letter language code
+    * @property {module:SVGEditor.uiStrings} uiStrings
+    * @property {module:SVGEditor~ImportLocale} importLocale
+    */
+
+    /**
+    * The language was changed. Two-letter code of the new language.
+    * @event module:svgcanvas.SvgCanvas#event:ext-langChanged
+    * @type {string}
+    */
+
+    /**
+    * Means for an extension to add locale data. The two-letter language code.
+    * @event module:svgcanvas.SvgCanvas#event:ext-addLangData
+    * @type {PlainObject}
+    * @property {string} lang
+    * @property {module:SVGEditor~ImportLocale} importLocale
+    */
+
+    /**
+     * Called when new image is created
+     * @event module:svgcanvas.SvgCanvas#event:ext-onNewDocument
+     * @type {undefined}
+     */
+
+    /**
+     * Called when sidepanel is resized or toggled
+     * @event module:svgcanvas.SvgCanvas#event:ext-workareaResized
+     * @type {undefined}
+    */
+
+    /**
+     * Called upon addition of the extension, or, if svgicons are set,
+     * after the icons are ready when extension SVG icons have loaded.
+     * @event module:svgcanvas.SvgCanvas#event:ext-callback
+     * @type {undefined}
+    */
+
+    /**
+    * Sets the zoom to the given level.
+    * @function module:svgcanvas.SvgCanvas#setZoom
+    * @param {Float} zoomLevel - Float indicating the zoom level to change to
+    * @fires module:svgcanvas.SvgCanvas#event:ext-zoomChanged
+    * @returns {undefined}
+    */
+
+
+    this.setZoom = function (zoomLevel) {
+      var res = getResolution();
+      svgcontent.setAttribute('viewBox', '0 0 ' + res.w / zoomLevel + ' ' + res.h / zoomLevel);
+      currentZoom = zoomLevel;
+      $$8.each(selectedElements, function (i, elem) {
+        if (!elem) {
+          return;
+        }
+
+        selectorManager.requestSelector(elem).resize();
+      });
+      pathActions$$1.zoomChange();
+      runExtensions('zoomChanged',
+      /** @type {module:svgcanvas.SvgCanvas#event:ext-zoomChanged} */
+      zoomLevel);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getMode
+    * @returns {string} The current editor mode string
+    */
+
+
+    this.getMode = function () {
+      return currentMode;
+    };
+    /**
+    * Sets the editor's mode to the given string.
+    * @function module:svgcanvas.SvgCanvas#setMode
+    * @param {string} name - String with the new mode to change to
+    * @returns {undefined}
+    */
+
+
+    this.setMode = function (name) {
+      pathActions$$1.clear(true);
+      textActions.clear();
+      curProperties = selectedElements[0] && selectedElements[0].nodeName === 'text' ? curText : curShape;
+      currentMode = name;
+    };
+    /**
+    * Group: Element Styling
+    */
+
+    /**
+    * @typedef {PlainObject} module:svgcanvas.PaintOptions
+    * @property {"solidColor"} type
+    */
+
+    /**
+    * @function module:svgcanvas.SvgCanvas#getColor
+    * @param {string} type
+    * @returns {string|module:svgcanvas.PaintOptions|Float|module:jGraduate~Paint} The current fill/stroke option
+    */
+
+
+    this.getColor = function (type) {
+      return curProperties[type];
+    };
+    /**
+    * Change the current stroke/fill color/gradient value.
+    * @function module:svgcanvas.SvgCanvas#setColor
+    * @param {string} type - String indicating fill or stroke
+    * @param {string} val - The value to set the stroke attribute to
+    * @param {boolean} preventUndo - Boolean indicating whether or not this should be an undoable option
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.setColor = function (type, val, preventUndo) {
+      curShape[type] = val;
+      curProperties[type + '_paint'] = {
+        type: 'solidColor'
+      };
+      var elems = [];
+      /**
+       *
+       * @param {Element} e
+       * @returns {undefined}
+       */
+
+      function addNonG(e) {
+        if (e.nodeName !== 'g') {
+          elems.push(e);
+        }
+      }
+
+      var i = selectedElements.length;
+
+      while (i--) {
+        var elem = selectedElements[i];
+
+        if (elem) {
+          if (elem.tagName === 'g') {
+            walkTree(elem, addNonG);
+          } else if (type === 'fill') {
+            if (elem.tagName !== 'polyline' && elem.tagName !== 'line') {
+              elems.push(elem);
+            }
+          } else {
+            elems.push(elem);
+          }
+        }
+      }
+
+      if (elems.length > 0) {
+        if (!preventUndo) {
+          changeSelectedAttribute(type, val, elems);
+          call('changed', elems);
+        } else {
+          changeSelectedAttributeNoUndo(type, val, elems);
+        }
+      }
+    };
+    /**
+    * Apply the current gradient to selected element's fill or stroke.
+    * @function module:svgcanvas.SvgCanvas#setGradient
+    * @param {"fill"|"stroke"} type - String indicating "fill" or "stroke" to apply to an element
+    * @returns {undefined}
+    */
+
+
+    var setGradient = this.setGradient = function (type) {
+      if (!curProperties[type + '_paint'] || curProperties[type + '_paint'].type === 'solidColor') {
+        return;
+      }
+
+      var grad = canvas[type + 'Grad']; // find out if there is a duplicate gradient already in the defs
+
+      var duplicateGrad = findDuplicateGradient(grad);
+      var defs = findDefs(); // no duplicate found, so import gradient into defs
+
+      if (!duplicateGrad) {
+        // const origGrad = grad;
+        grad = defs.appendChild(svgdoc.importNode(grad, true)); // get next id and set it on the grad
+
+        grad.id = getNextId();
+      } else {
+        // use existing gradient
+        grad = duplicateGrad;
+      }
+
+      canvas.setColor(type, 'url(#' + grad.id + ')');
+    };
+    /**
+    * Check if exact gradient already exists.
+    * @function module:svgcanvas~findDuplicateGradient
+    * @param {SVGGradientElement} grad - The gradient DOM element to compare to others
+    * @returns {SVGGradientElement} The existing gradient if found, `null` if not
+    */
+
+
+    var findDuplicateGradient = function findDuplicateGradient(grad) {
+      var defs = findDefs();
+      var existingGrads = $$8(defs).find('linearGradient, radialGradient');
+      var i = existingGrads.length;
+      var radAttrs = ['r', 'cx', 'cy', 'fx', 'fy'];
+
+      while (i--) {
+        var og = existingGrads[i];
+
+        if (grad.tagName === 'linearGradient') {
+          if (grad.getAttribute('x1') !== og.getAttribute('x1') || grad.getAttribute('y1') !== og.getAttribute('y1') || grad.getAttribute('x2') !== og.getAttribute('x2') || grad.getAttribute('y2') !== og.getAttribute('y2')) {
+            continue;
+          }
+        } else {
+          var _ret = function () {
+            var gradAttrs = $$8(grad).attr(radAttrs);
+            var ogAttrs = $$8(og).attr(radAttrs);
+            var diff = false;
+            $$8.each(radAttrs, function (j, attr) {
+              if (gradAttrs[attr] !== ogAttrs[attr]) {
+                diff = true;
+              }
+            });
+
+            if (diff) {
+              return "continue";
+            }
+          }();
+
+          if (_ret === "continue") continue;
+        } // else could be a duplicate, iterate through stops
+
+
+        var stops = grad.getElementsByTagNameNS(NS.SVG, 'stop');
+        var ostops = og.getElementsByTagNameNS(NS.SVG, 'stop');
+
+        if (stops.length !== ostops.length) {
+          continue;
+        }
+
+        var j = stops.length;
+
+        while (j--) {
+          var stop = stops[j];
+          var ostop = ostops[j];
+
+          if (stop.getAttribute('offset') !== ostop.getAttribute('offset') || stop.getAttribute('stop-opacity') !== ostop.getAttribute('stop-opacity') || stop.getAttribute('stop-color') !== ostop.getAttribute('stop-color')) {
+            break;
+          }
+        }
+
+        if (j === -1) {
+          return og;
+        }
+      } // for each gradient in defs
+
+
+      return null;
+    };
+    /**
+    * Set a color/gradient to a fill/stroke.
+    * @function module:svgcanvas.SvgCanvas#setPaint
+    * @param {"fill"|"stroke"} type - String with "fill" or "stroke"
+    * @param {module:jGraduate.jGraduatePaintOptions} paint - The jGraduate paint object to apply
+    * @returns {undefined}
+    */
+
+
+    this.setPaint = function (type, paint) {
+      // make a copy
+      var p = new $$8.jGraduate.Paint(paint);
+      this.setPaintOpacity(type, p.alpha / 100, true); // now set the current paint object
+
+      curProperties[type + '_paint'] = p;
+
+      switch (p.type) {
+        case 'solidColor':
+          this.setColor(type, p.solidColor !== 'none' ? '#' + p.solidColor : 'none');
+          break;
+
+        case 'linearGradient':
+        case 'radialGradient':
+          canvas[type + 'Grad'] = p[p.type];
+          setGradient(type);
+          break;
+      }
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#setStrokePaint
+    * @param {module:jGraduate~Paint} paint
+    * @returns {undefined}
+    */
+
+
+    this.setStrokePaint = function (paint) {
+      this.setPaint('stroke', paint);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#setFillPaint
+    * @param {module:jGraduate~Paint} paint
+    * @returns {undefined}
+    */
+
+
+    this.setFillPaint = function (paint) {
+      this.setPaint('fill', paint);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getStrokeWidth
+    * @returns {Float|string} The current stroke-width value
+    */
+
+
+    this.getStrokeWidth = function () {
+      return curProperties.stroke_width;
+    };
+    /**
+    * Sets the stroke width for the current selected elements.
+    * When attempting to set a line's width to 0, this changes it to 1 instead.
+    * @function module:svgcanvas.SvgCanvas#setStrokeWidth
+    * @param {Float} val - A Float indicating the new stroke width value
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.setStrokeWidth = function (val) {
+      if (val === 0 && ['line', 'path'].includes(currentMode)) {
+        canvas.setStrokeWidth(1);
+        return;
+      }
+
+      curProperties.stroke_width = val;
+      var elems = [];
+      /**
+       *
+       * @param {Element} e
+       * @returns {undefined}
+       */
+
+      function addNonG(e) {
+        if (e.nodeName !== 'g') {
+          elems.push(e);
+        }
+      }
+
+      var i = selectedElements.length;
+
+      while (i--) {
+        var elem = selectedElements[i];
+
+        if (elem) {
+          if (elem.tagName === 'g') {
+            walkTree(elem, addNonG);
+          } else {
+            elems.push(elem);
+          }
+        }
+      }
+
+      if (elems.length > 0) {
+        changeSelectedAttribute('stroke-width', val, elems);
+        call('changed', selectedElements);
+      }
+    };
+    /**
+    * Set the given stroke-related attribute the given value for selected elements.
+    * @function module:svgcanvas.SvgCanvas#setStrokeAttr
+    * @param {string} attr - String with the attribute name
+    * @param {string|Float} val - String or number with the attribute value
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.setStrokeAttr = function (attr, val) {
+      curShape[attr.replace('-', '_')] = val;
+      var elems = [];
+      var i = selectedElements.length;
+
+      while (i--) {
+        var elem = selectedElements[i];
+
+        if (elem) {
+          if (elem.tagName === 'g') {
+            walkTree(elem, function (e) {
+              if (e.nodeName !== 'g') {
+                elems.push(e);
+              }
+            });
+          } else {
+            elems.push(elem);
+          }
+        }
+      }
+
+      if (elems.length > 0) {
+        changeSelectedAttribute(attr, val, elems);
+        call('changed', selectedElements);
+      }
+    };
+    /**
+    * @typedef {PlainObject} module:svgcanvas.StyleOptions
+    * @property {string} fill
+    * @property {Float} fill_opacity
+    * @property {string} stroke
+    * @property {Float} stroke_width
+    * @property {string} stroke_dasharray
+    * @property {string} stroke_linejoin
+    * @property {string} stroke_linecap
+    * @property {Float} stroke_opacity
+    * @property {Float} opacity
+    */
+
+    /**
+    * @function module:svgcanvas.SvgCanvas#getStyle
+    * @returns {module:svgcanvas.StyleOptions} current style options
+    */
+
+
+    this.getStyle = function () {
+      return curShape;
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getOpacity
+    * @returns {Float} the current opacity
+    */
+
+
+    this.getOpacity = getOpacity;
+    /**
+    * Sets the given opacity on the current selected elements.
+    * @function module:svgcanvas.SvgCanvas#setOpacity
+    * @param {string} val
+    * @returns {undefined}
+    */
+
+    this.setOpacity = function (val) {
+      curShape.opacity = val;
+      changeSelectedAttribute('opacity', val);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getFillOpacity
+    * @returns {Float} the current fill opacity
+    */
+
+
+    this.getFillOpacity = function () {
+      return curShape.fill_opacity;
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getStrokeOpacity
+    * @returns {string} the current stroke opacity
+    */
+
+
+    this.getStrokeOpacity = function () {
+      return curShape.stroke_opacity;
+    };
+    /**
+    * Sets the current fill/stroke opacity.
+    * @function module:svgcanvas.SvgCanvas#setPaintOpacity
+    * @param {string} type - String with "fill" or "stroke"
+    * @param {Float} val - Float with the new opacity value
+    * @param {boolean} preventUndo - Indicates whether or not this should be an undoable action
+    * @returns {undefined}
+    */
+
+
+    this.setPaintOpacity = function (type, val, preventUndo) {
+      curShape[type + '_opacity'] = val;
+
+      if (!preventUndo) {
+        changeSelectedAttribute(type + '-opacity', val);
+      } else {
+        changeSelectedAttributeNoUndo(type + '-opacity', val);
+      }
+    };
+    /**
+    * Gets the current fill/stroke opacity.
+    * @function module:svgcanvas.SvgCanvas#getPaintOpacity
+    * @param {"fill"|"stroke"} type - String with "fill" or "stroke"
+    * @returns {Float} Fill/stroke opacity
+    */
+
+
+    this.getPaintOpacity = function (type) {
+      return type === 'fill' ? this.getFillOpacity() : this.getStrokeOpacity();
+    };
+    /**
+    * Gets the `stdDeviation` blur value of the given element.
+    * @function module:svgcanvas.SvgCanvas#getBlur
+    * @param {Element} elem - The element to check the blur value for
+    * @returns {string} stdDeviation blur attribute value
+    */
+
+
+    this.getBlur = function (elem) {
+      var val = 0; // const elem = selectedElements[0];
+
+      if (elem) {
+        var filterUrl = elem.getAttribute('filter');
+
+        if (filterUrl) {
+          var blur = getElem(elem.id + '_blur');
+
+          if (blur) {
+            val = blur.firstChild.getAttribute('stdDeviation');
+          }
+        }
+      }
+
+      return val;
+    };
+
+    (function () {
+      var curCommand = null;
+      var filter = null;
+      var filterHidden = false;
+      /**
+      * Sets the `stdDeviation` blur value on the selected element without being undoable.
+      * @function module:svgcanvas.SvgCanvas#setBlurNoUndo
+      * @param {Float} val - The new `stdDeviation` value
+      * @returns {undefined}
+      */
+
+      canvas.setBlurNoUndo = function (val) {
+        if (!filter) {
+          canvas.setBlur(val);
+          return;
+        }
+
+        if (val === 0) {
+          // Don't change the StdDev, as that will hide the element.
+          // Instead, just remove the value for "filter"
+          changeSelectedAttributeNoUndo('filter', '');
+          filterHidden = true;
+        } else {
+          var elem = selectedElements[0];
+
+          if (filterHidden) {
+            changeSelectedAttributeNoUndo('filter', 'url(#' + elem.id + '_blur)');
+          }
+
+          if (isWebkit()) {
+            // console.log('e', elem); // eslint-disable-line no-console
+            elem.removeAttribute('filter');
+            elem.setAttribute('filter', 'url(#' + elem.id + '_blur)');
+          }
+
+          changeSelectedAttributeNoUndo('stdDeviation', val, [filter.firstChild]);
+          canvas.setBlurOffsets(filter, val);
+        }
+      };
+      /**
+       *
+       * @returns {undefined}
+       */
+
+
+      function finishChange() {
+        var bCmd = canvas.undoMgr.finishUndoableChange();
+        curCommand.addSubCommand(bCmd);
+        addCommandToHistory(curCommand);
+        curCommand = null;
+        filter = null;
+      }
+      /**
+      * Sets the `x`, `y`, `width`, `height` values of the filter element in order to
+      * make the blur not be clipped. Removes them if not neeeded.
+      * @function module:svgcanvas.SvgCanvas#setBlurOffsets
+      * @param {Element} filterElem - The filter DOM element to update
+      * @param {Float} stdDev - The standard deviation value on which to base the offset size
+      * @returns {undefined}
+      */
+
+
+      canvas.setBlurOffsets = function (filterElem, stdDev) {
+        if (stdDev > 3) {
+          // TODO: Create algorithm here where size is based on expected blur
+          assignAttributes(filterElem, {
+            x: '-50%',
+            y: '-50%',
+            width: '200%',
+            height: '200%'
+          }, 100); // Removing these attributes hides text in Chrome (see Issue 579)
+        } else if (!isWebkit()) {
+          filterElem.removeAttribute('x');
+          filterElem.removeAttribute('y');
+          filterElem.removeAttribute('width');
+          filterElem.removeAttribute('height');
+        }
+      };
+      /**
+      * Adds/updates the blur filter to the selected element.
+      * @function module:svgcanvas.SvgCanvas#setBlur
+      * @param {Float} val - Float with the new `stdDeviation` blur value
+      * @param {boolean} complete - Whether or not the action should be completed (to add to the undo manager)
+      * @returns {undefined}
+      */
+
+
+      canvas.setBlur = function (val, complete) {
+        if (curCommand) {
+          finishChange();
+          return;
+        } // Looks for associated blur, creates one if not found
+
+
+        var elem = selectedElements[0];
+        var elemId = elem.id;
+        filter = getElem(elemId + '_blur');
+        val -= 0;
+        var batchCmd = new BatchCommand$1(); // Blur found!
+
+        if (filter) {
+          if (val === 0) {
+            filter = null;
+          }
+        } else {
+          // Not found, so create
+          var newblur = addSVGElementFromJson({
+            element: 'feGaussianBlur',
+            attr: {
+              in: 'SourceGraphic',
+              stdDeviation: val
+            }
+          });
+          filter = addSVGElementFromJson({
+            element: 'filter',
+            attr: {
+              id: elemId + '_blur'
+            }
+          });
+          filter.append(newblur);
+          findDefs().append(filter);
+          batchCmd.addSubCommand(new InsertElementCommand$1(filter));
+        }
+
+        var changes = {
+          filter: elem.getAttribute('filter')
+        };
+
+        if (val === 0) {
+          elem.removeAttribute('filter');
+          batchCmd.addSubCommand(new ChangeElementCommand$1(elem, changes));
+          return;
+        }
+
+        changeSelectedAttribute('filter', 'url(#' + elemId + '_blur)');
+        batchCmd.addSubCommand(new ChangeElementCommand$1(elem, changes));
+        canvas.setBlurOffsets(filter, val);
+        curCommand = batchCmd;
+        canvas.undoMgr.beginUndoableChange('stdDeviation', [filter ? filter.firstChild : null]);
+
+        if (complete) {
+          canvas.setBlurNoUndo(val);
+          finishChange();
+        }
+      };
+    })();
+    /**
+    * Check whether selected element is bold or not.
+    * @function module:svgcanvas.SvgCanvas#getBold
+    * @returns {boolean} Indicates whether or not element is bold
+    */
+
+
+    this.getBold = function () {
+      // should only have one element selected
+      var selected = selectedElements[0];
+
+      if (!isNullish(selected) && selected.tagName === 'text' && isNullish(selectedElements[1])) {
+        return selected.getAttribute('font-weight') === 'bold';
+      }
+
+      return false;
+    };
+    /**
+    * Make the selected element bold or normal.
+    * @function module:svgcanvas.SvgCanvas#setBold
+    * @param {boolean} b - Indicates bold (`true`) or normal (`false`)
+    * @returns {undefined}
+    */
+
+
+    this.setBold = function (b) {
+      var selected = selectedElements[0];
+
+      if (!isNullish(selected) && selected.tagName === 'text' && isNullish(selectedElements[1])) {
+        changeSelectedAttribute('font-weight', b ? 'bold' : 'normal');
+      }
+
+      if (!selectedElements[0].textContent) {
+        textActions.setCursor();
+      }
+    };
+    /**
+    * Check whether selected element is in italics or not.
+    * @function module:svgcanvas.SvgCanvas#getItalic
+    * @returns {boolean} Indicates whether or not element is italic
+    */
+
+
+    this.getItalic = function () {
+      var selected = selectedElements[0];
+
+      if (!isNullish(selected) && selected.tagName === 'text' && isNullish(selectedElements[1])) {
+        return selected.getAttribute('font-style') === 'italic';
+      }
+
+      return false;
+    };
+    /**
+    * Make the selected element italic or normal.
+    * @function module:svgcanvas.SvgCanvas#setItalic
+    * @param {boolean} i - Indicates italic (`true`) or normal (`false`)
+    * @returns {undefined}
+    */
+
+
+    this.setItalic = function (i) {
+      var selected = selectedElements[0];
+
+      if (!isNullish(selected) && selected.tagName === 'text' && isNullish(selectedElements[1])) {
+        changeSelectedAttribute('font-style', i ? 'italic' : 'normal');
+      }
+
+      if (!selectedElements[0].textContent) {
+        textActions.setCursor();
+      }
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getFontFamily
+    * @returns {string} The current font family
+    */
+
+
+    this.getFontFamily = function () {
+      return curText.font_family;
+    };
+    /**
+    * Set the new font family.
+    * @function module:svgcanvas.SvgCanvas#setFontFamily
+    * @param {string} val - String with the new font family
+    * @returns {undefined}
+    */
+
+
+    this.setFontFamily = function (val) {
+      curText.font_family = val;
+      changeSelectedAttribute('font-family', val);
+
+      if (selectedElements[0] && !selectedElements[0].textContent) {
+        textActions.setCursor();
+      }
+    };
+    /**
+    * Set the new font color.
+    * @function module:svgcanvas.SvgCanvas#setFontColor
+    * @param {string} val - String with the new font color
+    * @returns {undefined}
+    */
+
+
+    this.setFontColor = function (val) {
+      curText.fill = val;
+      changeSelectedAttribute('fill', val);
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getFontColor
+    * @returns {string} The current font color
+    */
+
+
+    this.getFontColor = function () {
+      return curText.fill;
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getFontSize
+    * @returns {Float} The current font size
+    */
+
+
+    this.getFontSize = function () {
+      return curText.font_size;
+    };
+    /**
+    * Applies the given font size to the selected element.
+    * @function module:svgcanvas.SvgCanvas#setFontSize
+    * @param {Float} val - Float with the new font size
+    * @returns {undefined}
+    */
+
+
+    this.setFontSize = function (val) {
+      curText.font_size = val;
+      changeSelectedAttribute('font-size', val);
+
+      if (!selectedElements[0].textContent) {
+        textActions.setCursor();
+      }
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#getText
+    * @returns {string} The current text (`textContent`) of the selected element
+    */
+
+
+    this.getText = function () {
+      var selected = selectedElements[0];
+
+      if (isNullish(selected)) {
+        return '';
+      }
+
+      return selected.textContent;
+    };
+    /**
+    * Updates the text element with the given string.
+    * @function module:svgcanvas.SvgCanvas#setTextContent
+    * @param {string} val - String with the new text
+    * @returns {undefined}
+    */
+
+
+    this.setTextContent = function (val) {
+      changeSelectedAttribute('#text', val);
+      textActions.init(val);
+      textActions.setCursor();
+    };
+    /**
+    * Sets the new image URL for the selected image element. Updates its size if
+    * a new URL is given.
+    * @function module:svgcanvas.SvgCanvas#setImageURL
+    * @param {string} val - String with the image URL/path
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.setImageURL = function (val) {
+      var elem = selectedElements[0];
+
+      if (!elem) {
+        return;
+      }
+
+      var attrs = $$8(elem).attr(['width', 'height']);
+      var setsize = !attrs.width || !attrs.height;
+      var curHref = getHref(elem); // Do nothing if no URL change or size change
+
+      if (curHref === val && !setsize) {
+        return;
+      }
+
+      var batchCmd = new BatchCommand$1('Change Image URL');
+      setHref(elem, val);
+      batchCmd.addSubCommand(new ChangeElementCommand$1(elem, {
+        '#href': curHref
+      }));
+      $$8(new Image()).load(function () {
+        var changes = $$8(elem).attr(['width', 'height']);
+        $$8(elem).attr({
+          width: this.width,
+          height: this.height
+        });
+        selectorManager.requestSelector(elem).resize();
+        batchCmd.addSubCommand(new ChangeElementCommand$1(elem, changes));
+        addCommandToHistory(batchCmd);
+        call('changed', [elem]);
+      }).attr('src', val);
+    };
+    /**
+    * Sets the new link URL for the selected anchor element.
+    * @function module:svgcanvas.SvgCanvas#setLinkURL
+    * @param {string} val - String with the link URL/path
+    * @returns {undefined}
+    */
+
+
+    this.setLinkURL = function (val) {
+      var elem = selectedElements[0];
+
+      if (!elem) {
+        return;
+      }
+
+      if (elem.tagName !== 'a') {
+        // See if parent is an anchor
+        var parentsA = $$8(elem).parents('a');
+
+        if (parentsA.length) {
+          elem = parentsA[0];
+        } else {
+          return;
+        }
+      }
+
+      var curHref = getHref(elem);
+
+      if (curHref === val) {
+        return;
+      }
+
+      var batchCmd = new BatchCommand$1('Change Link URL');
+      setHref(elem, val);
+      batchCmd.addSubCommand(new ChangeElementCommand$1(elem, {
+        '#href': curHref
+      }));
+      addCommandToHistory(batchCmd);
+    };
+    /**
+    * Sets the `rx` and `ry` values to the selected `rect` element
+    * to change its corner radius.
+    * @function module:svgcanvas.SvgCanvas#setRectRadius
+    * @param {string|Float} val - The new radius
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.setRectRadius = function (val) {
+      var selected = selectedElements[0];
+
+      if (!isNullish(selected) && selected.tagName === 'rect') {
+        var r = selected.getAttribute('rx');
+
+        if (r !== String(val)) {
+          selected.setAttribute('rx', val);
+          selected.setAttribute('ry', val);
+          addCommandToHistory(new ChangeElementCommand$1(selected, {
+            rx: r,
+            ry: r
+          }, 'Radius'));
+          call('changed', [selected]);
+        }
+      }
+    };
+    /**
+    * Wraps the selected element(s) in an anchor element or converts group to one.
+    * @function module:svgcanvas.SvgCanvas#makeHyperlink
+    * @param {string} url
+    * @returns {undefined}
+    */
+
+
+    this.makeHyperlink = function (url) {
+      canvas.groupSelectedElements('a', url); // TODO: If element is a single "g", convert to "a"
+      //  if (selectedElements.length > 1 && selectedElements[1]) {
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#removeHyperlink
+    * @returns {undefined}
+    */
+
+
+    this.removeHyperlink = function () {
+      canvas.ungroupSelectedElement();
+    };
+    /**
+    * Group: Element manipulation
+    */
+
+    /**
+    * Sets the new segment type to the selected segment(s).
+    * @function module:svgcanvas.SvgCanvas#setSegType
+    * @param {Integer} newType - New segment type. See {@link https://www.w3.org/TR/SVG/paths.html#InterfaceSVGPathSeg} for list
+    * @returns {undefined}
+    */
+
+
+    this.setSegType = function (newType) {
+      pathActions$$1.setSegType(newType);
+    };
+    /**
+    * Convert selected element to a path, or get the BBox of an element-as-path.
+    * @function module:svgcanvas.SvgCanvas#convertToPath
+    * @todo (codedread): Remove the getBBox argument and split this function into two.
+    * @param {Element} elem - The DOM element to be converted
+    * @param {boolean} getBBox - Boolean on whether or not to only return the path's BBox
+    * @returns {undefined|DOMRect|false|SVGPathElement|null} If the getBBox flag is true, the resulting path's bounding box object.
+    * Otherwise the resulting path element is returned.
+    */
+
+
+    this.convertToPath = function (elem, getBBox$$1) {
+      if (isNullish(elem)) {
+        var elems = selectedElements;
+        $$8.each(elems, function (i, el) {
+          if (el) {
+            canvas.convertToPath(el);
+          }
+        });
+        return undefined;
+      }
+
+      if (getBBox$$1) {
+        return getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions$$1);
+      } // TODO: Why is this applying attributes from curShape, then inside utilities.convertToPath it's pulling addition attributes from elem?
+      // TODO: If convertToPath is called with one elem, curShape and elem are probably the same; but calling with multiple is a bug or cool feature.
+
+
+      var attrs = {
+        fill: curShape.fill,
+        'fill-opacity': curShape.fill_opacity,
+        stroke: curShape.stroke,
+        'stroke-width': curShape.stroke_width,
+        'stroke-dasharray': curShape.stroke_dasharray,
+        'stroke-linejoin': curShape.stroke_linejoin,
+        'stroke-linecap': curShape.stroke_linecap,
+        'stroke-opacity': curShape.stroke_opacity,
+        opacity: curShape.opacity,
+        visibility: 'hidden'
+      };
+      return convertToPath(elem, attrs, addSVGElementFromJson, pathActions$$1, clearSelection, addToSelection, hstry, addCommandToHistory);
+    };
+    /**
+    * This function makes the changes to the elements. It does not add the change
+    * to the history stack.
+    * @param {string} attr - Attribute name
+    * @param {string|Float} newValue - String or number with the new attribute value
+    * @param {Element[]} elems - The DOM elements to apply the change to
+    * @returns {undefined}
+    */
+
+
+    var changeSelectedAttributeNoUndo = function changeSelectedAttributeNoUndo(attr, newValue, elems) {
+      if (currentMode === 'pathedit') {
+        // Editing node
+        pathActions$$1.moveNode(attr, newValue);
+      }
+
+      elems = elems || selectedElements;
+      var i = elems.length;
+      var noXYElems = ['g', 'polyline', 'path']; // const goodGAttrs = ['transform', 'opacity', 'filter'];
+
+      var _loop = function _loop() {
+        var elem = elems[i];
+
+        if (isNullish(elem)) {
+          return "continue";
+        } // Set x,y vals on elements that don't have them
+
+
+        if ((attr === 'x' || attr === 'y') && noXYElems.includes(elem.tagName)) {
+          var bbox = getStrokedBBoxDefaultVisible([elem]);
+          var diffX = attr === 'x' ? newValue - bbox.x : 0;
+          var diffY = attr === 'y' ? newValue - bbox.y : 0;
+          canvas.moveSelectedElements(diffX * currentZoom, diffY * currentZoom, true);
+          return "continue";
+        } // only allow the transform/opacity/filter attribute to change on <g> elements, slightly hacky
+        // TODO: FIXME: Missing statement body
+        // if (elem.tagName === 'g' && goodGAttrs.includes(attr)) {}
+
+
+        var oldval = attr === '#text' ? elem.textContent : elem.getAttribute(attr);
+
+        if (isNullish(oldval)) {
+          oldval = '';
+        }
+
+        if (oldval !== String(newValue)) {
+          if (attr === '#text') {
+            // const oldW = utilsGetBBox(elem).width;
+            elem.textContent = newValue; // FF bug occurs on on rotated elements
+
+            if (/rotate/.test(elem.getAttribute('transform'))) {
+              elem = ffClone(elem);
+            } // Hoped to solve the issue of moving text with text-anchor="start",
+            // but this doesn't actually fix it. Hopefully on the right track, though. -Fyrd
+            // const box = getBBox(elem), left = box.x, top = box.y, {width, height} = box,
+            //   dx = width - oldW, dy = 0;
+            // const angle = getRotationAngle(elem, true);
+            // if (angle) {
+            //   const r = Math.sqrt(dx * dx + dy * dy);
+            //   const theta = Math.atan2(dy, dx) - angle;
+            //   dx = r * Math.cos(theta);
+            //   dy = r * Math.sin(theta);
+            //
+            //   elem.setAttribute('x', elem.getAttribute('x') - dx);
+            //   elem.setAttribute('y', elem.getAttribute('y') - dy);
+            // }
+
+          } else if (attr === '#href') {
+            setHref(elem, newValue);
+          } else {
+            elem.setAttribute(attr, newValue);
+          } // Go into "select" mode for text changes
+          // NOTE: Important that this happens AFTER elem.setAttribute() or else attributes like
+          // font-size can get reset to their old value, ultimately by svgEditor.updateContextPanel(),
+          // after calling textActions.toSelectMode() below
+
+
+          if (currentMode === 'textedit' && attr !== '#text' && elem.textContent.length) {
+            textActions.toSelectMode(elem);
+          } // if (i === 0) {
+          //   selectedBBoxes[0] = utilsGetBBox(elem);
+          // }
+          // Use the Firefox ffClone hack for text elements with gradients or
+          // where other text attributes are changed.
+
+
+          if (isGecko() && elem.nodeName === 'text' && /rotate/.test(elem.getAttribute('transform'))) {
+            if (String(newValue).startsWith('url') || ['font-size', 'font-family', 'x', 'y'].includes(attr) && elem.textContent) {
+              elem = ffClone(elem);
+            }
+          } // Timeout needed for Opera & Firefox
+          // codedread: it is now possible for this function to be called with elements
+          // that are not in the selectedElements array, we need to only request a
+          // selector if the element is in that array
+
+
+          if (selectedElements.includes(elem)) {
+            setTimeout(function () {
+              // Due to element replacement, this element may no longer
+              // be part of the DOM
+              if (!elem.parentNode) {
+                return;
+              }
+
+              selectorManager.requestSelector(elem).resize();
+            }, 0);
+          } // if this element was rotated, and we changed the position of this element
+          // we need to update the rotational transform attribute
+
+
+          var angle = getRotationAngle(elem);
+
+          if (angle !== 0 && attr !== 'transform') {
+            var tlist = getTransformList(elem);
+            var n = tlist.numberOfItems;
+
+            while (n--) {
+              var xform = tlist.getItem(n);
+
+              if (xform.type === 4) {
+                // remove old rotate
+                tlist.removeItem(n);
+                var box = getBBox(elem);
+                var center = transformPoint(box.x + box.width / 2, box.y + box.height / 2, transformListToTransform(tlist).matrix);
+                var cx = center.x,
+                    cy = center.y;
+                var newrot = svgroot.createSVGTransform();
+                newrot.setRotate(angle, cx, cy);
+                tlist.insertItemBefore(newrot, n);
+                break;
+              }
+            }
+          }
+        } // if oldValue != newValue
+
+      };
+
+      while (i--) {
+        var _ret2 = _loop();
+
+        if (_ret2 === "continue") continue;
+      } // for each elem
+
+    };
+    /**
+    * Change the given/selected element and add the original value to the history stack.
+    * If you want to change all `selectedElements`, ignore the `elems` argument.
+    * If you want to change only a subset of `selectedElements`, then send the
+    * subset to this function in the `elems` argument.
+    * @function module:svgcanvas.SvgCanvas#changeSelectedAttribute
+    * @param {string} attr - String with the attribute name
+    * @param {string|Float} val - String or number with the new attribute value
+    * @param {Element[]} elems - The DOM elements to apply the change to
+    * @returns {undefined}
+    */
+
+
+    var changeSelectedAttribute = this.changeSelectedAttribute = function (attr, val, elems) {
+      elems = elems || selectedElements;
+      canvas.undoMgr.beginUndoableChange(attr, elems); // const i = elems.length;
+
+      changeSelectedAttributeNoUndo(attr, val, elems);
+      var batchCmd = canvas.undoMgr.finishUndoableChange();
+
+      if (!batchCmd.isEmpty()) {
+        addCommandToHistory(batchCmd);
+      }
+    };
+    /**
+    * Removes all selected elements from the DOM and adds the change to the
+    * history stack.
+    * @function module:svgcanvas.SvgCanvas#deleteSelectedElements
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.deleteSelectedElements = function () {
+      var batchCmd = new BatchCommand$1('Delete Elements');
+      var len = selectedElements.length;
+      var selectedCopy = []; // selectedElements is being deleted
+
+      for (var i = 0; i < len; ++i) {
+        var selected = selectedElements[i];
+
+        if (isNullish(selected)) {
+          break;
+        }
+
+        var parent = selected.parentNode;
+        var t = selected; // this will unselect the element and remove the selectedOutline
+
+        selectorManager.releaseSelector(t); // Remove the path if present.
+
+        removePath_(t.id); // Get the parent if it's a single-child anchor
+
+        if (parent.tagName === 'a' && parent.childNodes.length === 1) {
+          t = parent;
+          parent = parent.parentNode;
+        }
+
+        var _t = t,
+            nextSibling = _t.nextSibling;
+        var elem = parent.removeChild(t);
+        selectedCopy.push(selected); // for the copy
+
+        batchCmd.addSubCommand(new RemoveElementCommand$1(elem, nextSibling, parent));
+      }
+
+      selectedElements = [];
+
+      if (!batchCmd.isEmpty()) {
+        addCommandToHistory(batchCmd);
+      }
+
+      call('changed', selectedCopy);
+      clearSelection();
+    };
+    /**
+    * Removes all selected elements from the DOM and adds the change to the
+    * history stack. Remembers removed elements on the clipboard.
+    * @function module:svgcanvas.SvgCanvas#cutSelectedElements
+    * @returns {undefined}
+    */
+
+
+    this.cutSelectedElements = function () {
+      canvas.copySelectedElements();
+      canvas.deleteSelectedElements();
+    };
+    /**
+    * Remembers the current selected elements on the clipboard.
+    * @function module:svgcanvas.SvgCanvas#copySelectedElements
+    * @returns {undefined}
+    */
+
+
+    this.copySelectedElements = function () {
+      localStorage.setItem('svgedit_clipboard', JSON.stringify(selectedElements.map(function (x) {
+        return getJsonFromSvgElement(x);
+      })));
+      $$8('#cmenu_canvas').enableContextMenuItems('#paste,#paste_in_place');
+    };
+    /**
+    * @function module:svgcanvas.SvgCanvas#pasteElements
+    * @param {"in_place"|"point"|undefined} type
+    * @param {Integer|undefined} x Expected if type is "point"
+    * @param {Integer|undefined} y Expected if type is "point"
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @fires module:svgcanvas.SvgCanvas#event:ext-IDsUpdated
+    * @returns {undefined}
+    */
+
+
+    this.pasteElements = function (type, x, y) {
+      var clipb = JSON.parse(localStorage.getItem('svgedit_clipboard'));
+      var len = clipb.length;
+
+      if (!len) {
+        return;
+      }
+
+      var pasted = [];
+      var batchCmd = new BatchCommand$1('Paste elements'); // const drawing = getCurrentDrawing();
+
+      /**
+      * @typedef {PlainObject.<string, string>} module:svgcanvas.ChangedIDs
+      */
+
+      /**
+       * @type {module:svgcanvas.ChangedIDs}
+       */
+
+      var changedIDs = {}; // Recursively replace IDs and record the changes
+
+      /**
+       *
+       * @param {module:svgcanvas.SVGAsJSON} elem
+       * @returns {undefined}
+       */
+
+      function checkIDs(elem) {
+        if (elem.attr && elem.attr.id) {
+          changedIDs[elem.attr.id] = getNextId();
+          elem.attr.id = changedIDs[elem.attr.id];
+        }
+
+        if (elem.children) elem.children.forEach(checkIDs);
+      }
+
+      clipb.forEach(checkIDs); // Give extensions like the connector extension a chance to reflect new IDs and remove invalid elements
+
+      /**
+      * Triggered when `pasteElements` is called from a paste action (context menu or key)
+      * @event module:svgcanvas.SvgCanvas#event:ext-IDsUpdated
+      * @type {PlainObject}
+      * @property {module:svgcanvas.SVGAsJSON[]} elems
+      * @property {module:svgcanvas.ChangedIDs} changes Maps past ID (on attribute) to current ID
+      */
+
+      runExtensions('IDsUpdated',
+      /** @type {module:svgcanvas.SvgCanvas#event:ext-IDsUpdated} */
+      {
+        elems: clipb,
+        changes: changedIDs
+      }, true).forEach(function (extChanges) {
+        if (!extChanges || !('remove' in extChanges)) return;
+        extChanges.remove.forEach(function (removeID) {
+          clipb = clipb.filter(function (clipBoardItem) {
+            return clipBoardItem.attr.id !== removeID;
+          });
+        });
+      }); // Move elements to lastClickPoint
+
+      while (len--) {
+        var elem = clipb[len];
+
+        if (!elem) {
+          continue;
+        }
+
+        var copy = addSVGElementFromJson(elem);
+        pasted.push(copy);
+        batchCmd.addSubCommand(new InsertElementCommand$1(copy));
+        restoreRefElems(copy);
+      }
+
+      selectOnly(pasted);
+
+      if (type !== 'in_place') {
+        var ctrX, ctrY;
+
+        if (!type) {
+          ctrX = lastClickPoint.x;
+          ctrY = lastClickPoint.y;
+        } else if (type === 'point') {
+          ctrX = x;
+          ctrY = y;
+        }
+
+        var bbox = getStrokedBBoxDefaultVisible(pasted);
+        var cx = ctrX - (bbox.x + bbox.width / 2),
+            cy = ctrY - (bbox.y + bbox.height / 2),
+            dx = [],
+            dy = [];
+        $$8.each(pasted, function (i, item) {
+          dx.push(cx);
+          dy.push(cy);
+        });
+        var cmd = canvas.moveSelectedElements(dx, dy, false);
+        if (cmd) batchCmd.addSubCommand(cmd);
+      }
+
+      addCommandToHistory(batchCmd);
+      call('changed', pasted);
+    };
+    /**
+    * Wraps all the selected elements in a group (`g`) element.
+    * @function module:svgcanvas.SvgCanvas#groupSelectedElements
+    * @param {"a"|"g"} [type="g"] - type of element to group into, defaults to `<g>`
+    * @param {string} [urlArg]
+    * @returns {undefined}
+    */
+
+
+    this.groupSelectedElements = function (type, urlArg) {
+      if (!type) {
+        type = 'g';
+      }
+
+      var cmdStr = '';
+      var url;
+
+      switch (type) {
+        case 'a':
+          {
+            cmdStr = 'Make hyperlink';
+            url = urlArg || '';
+            break;
+          }
+
+        default:
+          {
+            type = 'g';
+            cmdStr = 'Group Elements';
+            break;
+          }
+      }
+
+      var batchCmd = new BatchCommand$1(cmdStr); // create and insert the group element
+
+      var g = addSVGElementFromJson({
+        element: type,
+        attr: {
+          id: getNextId()
+        }
+      });
+
+      if (type === 'a') {
+        setHref(g, url);
+      }
+
+      batchCmd.addSubCommand(new InsertElementCommand$1(g)); // now move all children into the group
+
+      var i = selectedElements.length;
+
+      while (i--) {
+        var elem = selectedElements[i];
+
+        if (isNullish(elem)) {
+          continue;
+        }
+
+        if (elem.parentNode.tagName === 'a' && elem.parentNode.childNodes.length === 1) {
+          elem = elem.parentNode;
+        }
+
+        var oldNextSibling = elem.nextSibling;
+        var oldParent = elem.parentNode;
+        g.append(elem);
+        batchCmd.addSubCommand(new MoveElementCommand$1(elem, oldNextSibling, oldParent));
+      }
+
+      if (!batchCmd.isEmpty()) {
+        addCommandToHistory(batchCmd);
+      } // update selection
+
+
+      selectOnly([g], true);
+    };
+    /**
+    * Pushes all appropriate parent group properties down to its children, then
+    * removes them from the group.
+    * @function module:svgcanvas.SvgCanvas#pushGroupProperties
+    * @param {SVGAElement|SVGGElement} g
+    * @param {boolean} undoable
+    * @returns {BatchCommand|undefined}
+    */
+
+
+    var pushGroupProperties = this.pushGroupProperties = function (g, undoable) {
+      var children = g.childNodes;
+      var len = children.length;
+      var xform = g.getAttribute('transform');
+      var glist = getTransformList(g);
+      var m = transformListToTransform(glist).matrix;
+      var batchCmd = new BatchCommand$1('Push group properties'); // TODO: get all fill/stroke properties from the group that we are about to destroy
+      // "fill", "fill-opacity", "fill-rule", "stroke", "stroke-dasharray", "stroke-dashoffset",
+      // "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity",
+      // "stroke-width"
+      // and then for each child, if they do not have the attribute (or the value is 'inherit')
+      // then set the child's attribute
+
+      var gangle = getRotationAngle(g);
+      var gattrs = $$8(g).attr(['filter', 'opacity']);
+      var gfilter, gblur, changes;
+      var drawing = getCurrentDrawing();
+
+      for (var i = 0; i < len; i++) {
+        var elem = children[i];
+
+        if (elem.nodeType !== 1) {
+          continue;
+        }
+
+        if (gattrs.opacity !== null && gattrs.opacity !== 1) {
+          // const c_opac = elem.getAttribute('opacity') || 1;
+          var newOpac = Math.round((elem.getAttribute('opacity') || 1) * gattrs.opacity * 100) / 100;
+          changeSelectedAttribute('opacity', newOpac, [elem]);
+        }
+
+        if (gattrs.filter) {
+          var cblur = this.getBlur(elem);
+          var origCblur = cblur;
+
+          if (!gblur) {
+            gblur = this.getBlur(g);
+          }
+
+          if (cblur) {
+            // Is this formula correct?
+            cblur = Number(gblur) + Number(cblur);
+          } else if (cblur === 0) {
+            cblur = gblur;
+          } // If child has no current filter, get group's filter or clone it.
+
+
+          if (!origCblur) {
+            // Set group's filter to use first child's ID
+            if (!gfilter) {
+              gfilter = getRefElem(gattrs.filter);
+            } else {
+              // Clone the group's filter
+              gfilter = drawing.copyElem(gfilter);
+              findDefs().append(gfilter);
+            }
+          } else {
+            gfilter = getRefElem(elem.getAttribute('filter'));
+          } // Change this in future for different filters
+
+
+          var suffix = gfilter.firstChild.tagName === 'feGaussianBlur' ? 'blur' : 'filter';
+          gfilter.id = elem.id + '_' + suffix;
+          changeSelectedAttribute('filter', 'url(#' + gfilter.id + ')', [elem]); // Update blur value
+
+          if (cblur) {
+            changeSelectedAttribute('stdDeviation', cblur, [gfilter.firstChild]);
+            canvas.setBlurOffsets(gfilter, cblur);
+          }
+        }
+
+        var chtlist = getTransformList(elem); // Don't process gradient transforms
+
+        if (elem.tagName.includes('Gradient')) {
+          chtlist = null;
+        } // Hopefully not a problem to add this. Necessary for elements like <desc/>
+
+
+        if (!chtlist) {
+          continue;
+        } // Apparently <defs> can get get a transformlist, but we don't want it to have one!
+
+
+        if (elem.tagName === 'defs') {
+          continue;
+        }
+
+        if (glist.numberOfItems) {
+          // TODO: if the group's transform is just a rotate, we can always transfer the
+          // rotate() down to the children (collapsing consecutive rotates and factoring
+          // out any translates)
+          if (gangle && glist.numberOfItems === 1) {
+            // [Rg] [Rc] [Mc]
+            // we want [Tr] [Rc2] [Mc] where:
+            //  - [Rc2] is at the child's current center but has the
+            // sum of the group and child's rotation angles
+            //  - [Tr] is the equivalent translation that this child
+            // undergoes if the group wasn't there
+            // [Tr] = [Rg] [Rc] [Rc2_inv]
+            // get group's rotation matrix (Rg)
+            var rgm = glist.getItem(0).matrix; // get child's rotation matrix (Rc)
+
+            var rcm = svgroot.createSVGMatrix();
+            var cangle = getRotationAngle(elem);
+
+            if (cangle) {
+              rcm = chtlist.getItem(0).matrix;
+            } // get child's old center of rotation
+
+
+            var cbox = getBBox(elem);
+            var ceqm = transformListToTransform(chtlist).matrix;
+            var coldc = transformPoint(cbox.x + cbox.width / 2, cbox.y + cbox.height / 2, ceqm); // sum group and child's angles
+
+            var sangle = gangle + cangle; // get child's rotation at the old center (Rc2_inv)
+
+            var r2 = svgroot.createSVGTransform();
+            r2.setRotate(sangle, coldc.x, coldc.y); // calculate equivalent translate
+
+            var trm = matrixMultiply(rgm, rcm, r2.matrix.inverse()); // set up tlist
+
+            if (cangle) {
+              chtlist.removeItem(0);
+            }
+
+            if (sangle) {
+              if (chtlist.numberOfItems) {
+                chtlist.insertItemBefore(r2, 0);
+              } else {
+                chtlist.appendItem(r2);
+              }
+            }
+
+            if (trm.e || trm.f) {
+              var tr = svgroot.createSVGTransform();
+              tr.setTranslate(trm.e, trm.f);
+
+              if (chtlist.numberOfItems) {
+                chtlist.insertItemBefore(tr, 0);
+              } else {
+                chtlist.appendItem(tr);
+              }
+            }
+          } else {
+            // more complicated than just a rotate
+            // transfer the group's transform down to each child and then
+            // call recalculateDimensions()
+            var oldxform = elem.getAttribute('transform');
+            changes = {};
+            changes.transform = oldxform || '';
+            var newxform = svgroot.createSVGTransform(); // [ gm ] [ chm ] = [ chm ] [ gm' ]
+            // [ gm' ] = [ chmInv ] [ gm ] [ chm ]
+
+            var chm = transformListToTransform(chtlist).matrix,
+                chmInv = chm.inverse();
+            var gm = matrixMultiply(chmInv, m, chm);
+            newxform.setMatrix(gm);
+            chtlist.appendItem(newxform);
+          }
+
+          var cmd = recalculateDimensions(elem);
+
+          if (cmd) {
+            batchCmd.addSubCommand(cmd);
+          }
+        }
+      } // remove transform and make it undo-able
+
+
+      if (xform) {
+        changes = {};
+        changes.transform = xform;
+        g.setAttribute('transform', '');
+        g.removeAttribute('transform');
+        batchCmd.addSubCommand(new ChangeElementCommand$1(g, changes));
+      }
+
+      if (undoable && !batchCmd.isEmpty()) {
+        return batchCmd;
+      }
+
+      return undefined;
+    };
+    /**
+    * Unwraps all the elements in a selected group (`g`) element. This requires
+    * significant recalculations to apply group's transforms, etc. to its children.
+    * @function module:svgcanvas.SvgCanvas#ungroupSelectedElement
+    * @returns {undefined}
+    */
+
+
+    this.ungroupSelectedElement = function () {
+      var g = selectedElements[0];
+
+      if (!g) {
+        return;
+      }
+
+      if ($$8(g).data('gsvg') || $$8(g).data('symbol')) {
+        // Is svg, so actually convert to group
+        convertToGroup(g);
+        return;
+      }
+
+      if (g.tagName === 'use') {
+        // Somehow doesn't have data set, so retrieve
+        var symbol = getElem(getHref(g).substr(1));
+        $$8(g).data('symbol', symbol).data('ref', symbol);
+        convertToGroup(g);
+        return;
+      }
+
+      var parentsA = $$8(g).parents('a');
+
+      if (parentsA.length) {
+        g = parentsA[0];
+      } // Look for parent "a"
+
+
+      if (g.tagName === 'g' || g.tagName === 'a') {
+        var batchCmd = new BatchCommand$1('Ungroup Elements');
+        var cmd = pushGroupProperties(g, true);
+
+        if (cmd) {
+          batchCmd.addSubCommand(cmd);
+        }
+
+        var parent = g.parentNode;
+        var anchor = g.nextSibling;
+        var children = new Array(g.childNodes.length);
+        var i = 0;
+
+        while (g.firstChild) {
+          var elem = g.firstChild;
+          var oldNextSibling = elem.nextSibling;
+          var oldParent = elem.parentNode; // Remove child title elements
+
+          if (elem.tagName === 'title') {
+            var _elem2 = elem,
+                nextSibling = _elem2.nextSibling;
+            batchCmd.addSubCommand(new RemoveElementCommand$1(elem, nextSibling, oldParent));
+            elem.remove();
+            continue;
+          }
+
+          children[i++] = elem = parent.insertBefore(elem, anchor);
+          batchCmd.addSubCommand(new MoveElementCommand$1(elem, oldNextSibling, oldParent));
+        } // remove the group from the selection
+
+
+        clearSelection(); // delete the group element (but make undo-able)
+
+        var gNextSibling = g.nextSibling;
+        g = parent.removeChild(g);
+        batchCmd.addSubCommand(new RemoveElementCommand$1(g, gNextSibling, parent));
+
+        if (!batchCmd.isEmpty()) {
+          addCommandToHistory(batchCmd);
+        } // update selection
+
+
+        addToSelection(children);
+      }
+    };
+    /**
+    * Repositions the selected element to the bottom in the DOM to appear on top of
+    * other elements.
+    * @function module:svgcanvas.SvgCanvas#moveToTopSelectedElement
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.moveToTopSelectedElement = function () {
+      var _selectedElements = selectedElements,
+          _selectedElements2 = _slicedToArray(_selectedElements, 1),
+          selected = _selectedElements2[0];
+
+      if (!isNullish(selected)) {
+        var t = selected;
+        var oldParent = t.parentNode;
+        var oldNextSibling = t.nextSibling;
+        t = t.parentNode.appendChild(t); // If the element actually moved position, add the command and fire the changed
+        // event handler.
+
+        if (oldNextSibling !== t.nextSibling) {
+          addCommandToHistory(new MoveElementCommand$1(t, oldNextSibling, oldParent, 'top'));
+          call('changed', [t]);
+        }
+      }
+    };
+    /**
+    * Repositions the selected element to the top in the DOM to appear under
+    * other elements.
+    * @function module:svgcanvas.SvgCanvas#moveToBottomSelectedElement
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.moveToBottomSelectedElement = function () {
+      var _selectedElements3 = selectedElements,
+          _selectedElements4 = _slicedToArray(_selectedElements3, 1),
+          selected = _selectedElements4[0];
+
+      if (!isNullish(selected)) {
+        var t = selected;
+        var oldParent = t.parentNode;
+        var oldNextSibling = t.nextSibling;
+        var firstChild = t.parentNode.firstChild;
+
+        if (firstChild.tagName === 'title') {
+          firstChild = firstChild.nextSibling;
+        } // This can probably be removed, as the defs should not ever apppear
+        // inside a layer group
+
+
+        if (firstChild.tagName === 'defs') {
+          firstChild = firstChild.nextSibling;
+        }
+
+        t = t.parentNode.insertBefore(t, firstChild); // If the element actually moved position, add the command and fire the changed
+        // event handler.
+
+        if (oldNextSibling !== t.nextSibling) {
+          addCommandToHistory(new MoveElementCommand$1(t, oldNextSibling, oldParent, 'bottom'));
+          call('changed', [t]);
+        }
+      }
+    };
+    /**
+    * Moves the select element up or down the stack, based on the visibly
+    * intersecting elements.
+    * @function module:svgcanvas.SvgCanvas#moveUpDownSelected
+    * @param {"Up"|"Down"} dir - String that's either 'Up' or 'Down'
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {undefined}
+    */
+
+
+    this.moveUpDownSelected = function (dir) {
+      var selected = selectedElements[0];
+
+      if (!selected) {
+        return;
+      }
+
+      curBBoxes = [];
+      var closest, foundCur; // jQuery sorts this list
+
+      var list = $$8(getIntersectionList(getStrokedBBoxDefaultVisible([selected]))).toArray();
+
+      if (dir === 'Down') {
+        list.reverse();
+      }
+
+      $$8.each(list, function () {
+        if (!foundCur) {
+          if (this === selected) {
+            foundCur = true;
+          }
+
+          return true;
+        }
+
+        closest = this; // eslint-disable-line consistent-this
+
+        return false;
+      });
+
+      if (!closest) {
+        return;
+      }
+
+      var t = selected;
+      var oldParent = t.parentNode;
+      var oldNextSibling = t.nextSibling;
+      $$8(closest)[dir === 'Down' ? 'before' : 'after'](t); // If the element actually moved position, add the command and fire the changed
+      // event handler.
+
+      if (oldNextSibling !== t.nextSibling) {
+        addCommandToHistory(new MoveElementCommand$1(t, oldNextSibling, oldParent, 'Move ' + dir));
+        call('changed', [t]);
+      }
+    };
+    /**
+    * Moves selected elements on the X/Y axis.
+    * @function module:svgcanvas.SvgCanvas#moveSelectedElements
+    * @param {Float} dx - Float with the distance to move on the x-axis
+    * @param {Float} dy - Float with the distance to move on the y-axis
+    * @param {boolean} undoable - Boolean indicating whether or not the action should be undoable
+    * @fires module:svgcanvas.SvgCanvas#event:changed
+    * @returns {BatchCommand|undefined} Batch command for the move
+    */
+
+
+    this.moveSelectedElements = function (dx, dy, undoable) {
+      // if undoable is not sent, default to true
+      // if single values, scale them to the zoom
+      if (dx.constructor !== Array) {
+        dx /= currentZoom;
+        dy /= currentZoom;
+      }
+
+      undoable = undoable || true;
+      var batchCmd = new BatchCommand$1('position');
+      var i = selectedElements.length;
+
+      while (i--) {
+        var selected = selectedElements[i];
+
+        if (!isNullish(selected)) {
+          // if (i === 0) {
+          //   selectedBBoxes[0] = utilsGetBBox(selected);
+          // }
+          // const b = {};
+          // for (const j in selectedBBoxes[i]) b[j] = selectedBBoxes[i][j];
+          // selectedBBoxes[i] = b;
+          var xform = svgroot.createSVGTransform();
+          var tlist = getTransformList(selected); // dx and dy could be arrays
+
+          if (dx.constructor === Array) {
+            // if (i === 0) {
+            //   selectedBBoxes[0].x += dx[0];
+            //   selectedBBoxes[0].y += dy[0];
+            // }
+            xform.setTranslate(dx[i], dy[i]);
+          } else {
+            // if (i === 0) {
+            //   selectedBBoxes[0].x += dx;
+            //   selectedBBoxes[0].y += dy;
+            // }
+            xform.setTranslate(dx, dy);
+          }
+
+          if (tlist.numberOfItems) {
+            tlist.insertItemBefore(xform, 0);
+          } else {
+            tlist.appendItem(xform);
+          }
+
+          var cmd = recalculateDimensions(selected);
+
+          if (cmd) {
+            batchCmd.addSubCommand(cmd);
+          }
+
+          selectorManager.requestSelector(selected).resize();
+        }
+      }
+
+      if (!batchCmd.isEmpty()) {
+        if (undoable) {
+          addCommandToHistory(batchCmd);
+        }
+
+        call('changed', selectedElements);
+        return batchCmd;
+      }
+
+      return undefined;
+    };
+    /**
+    * Create deep DOM copies (clones) of all selected elements and move them slightly
+    * from their originals.
+    * @function module:svgcanvas.SvgCanvas#cloneSelectedElements
+    * @param {Float} x Float with the distance to move on the x-axis
+    * @param {Float} y Float with the distance to move on the y-axis
+    * @returns {undefined}
+    */
+
+
+    this.cloneSelectedElements = function (x, y) {
+      var i, elem;
+      var batchCmd = new BatchCommand$1('Clone Elements'); // find all the elements selected (stop at first null)
+
+      var len = selectedElements.length;
+      /**
+       * Sorts an array numerically and ascending.
+       * @param {Element} a
+       * @param {Element} b
+       * @returns {Integer}
+       */
+
+      function sortfunction(a, b) {
+        return $$8(b).index() - $$8(a).index();
+      }
+
+      selectedElements.sort(sortfunction);
+
+      for (i = 0; i < len; ++i) {
+        elem = selectedElements[i];
+
+        if (isNullish(elem)) {
+          break;
+        }
+      } // use slice to quickly get the subset of elements we need
+
+
+      var copiedElements = selectedElements.slice(0, i);
+      this.clearSelection(true); // note that we loop in the reverse way because of the way elements are added
+      // to the selectedElements array (top-first)
+
+      var drawing = getCurrentDrawing();
+      i = copiedElements.length;
+
+      while (i--) {
+        // clone each element and replace it within copiedElements
+        elem = copiedElements[i] = drawing.copyElem(copiedElements[i]);
+        (currentGroup || drawing.getCurrentLayer()).append(elem);
+        batchCmd.addSubCommand(new InsertElementCommand$1(elem));
+      }
+
+      if (!batchCmd.isEmpty()) {
+        addToSelection(copiedElements.reverse()); // Need to reverse for correct selection-adding
+
+        this.moveSelectedElements(x, y, false);
+        addCommandToHistory(batchCmd);
+      }
+    };
+    /**
+    * Aligns selected elements.
+    * @function module:svgcanvas.SvgCanvas#alignSelectedElements
+    * @param {string} type - String with single character indicating the alignment type
+    * @param {"selected"|"largest"|"smallest"|"page"} relativeTo
+    * @returns {undefined}
+    */
+
+
+    this.alignSelectedElements = function (type, relativeTo) {
+      var bboxes = []; // angles = [];
+
+      var len = selectedElements.length;
+
+      if (!len) {
+        return;
+      }
+
+      var minx = Number.MAX_VALUE,
+          maxx = Number.MIN_VALUE,
+          miny = Number.MAX_VALUE,
+          maxy = Number.MIN_VALUE;
+      var curwidth = Number.MIN_VALUE,
+          curheight = Number.MIN_VALUE;
+
+      for (var i = 0; i < len; ++i) {
+        if (isNullish(selectedElements[i])) {
+          break;
+        }
+
+        var elem = selectedElements[i];
+        bboxes[i] = getStrokedBBoxDefaultVisible([elem]); // now bbox is axis-aligned and handles rotation
+
+        switch (relativeTo) {
+          case 'smallest':
+            if ((type === 'l' || type === 'c' || type === 'r') && (curwidth === Number.MIN_VALUE || curwidth > bboxes[i].width) || (type === 't' || type === 'm' || type === 'b') && (curheight === Number.MIN_VALUE || curheight > bboxes[i].height)) {
+              minx = bboxes[i].x;
+              miny = bboxes[i].y;
+              maxx = bboxes[i].x + bboxes[i].width;
+              maxy = bboxes[i].y + bboxes[i].height;
+              curwidth = bboxes[i].width;
+              curheight = bboxes[i].height;
+            }
+
+            break;
+
+          case 'largest':
+            if ((type === 'l' || type === 'c' || type === 'r') && (curwidth === Number.MIN_VALUE || curwidth < bboxes[i].width) || (type === 't' || type === 'm' || type === 'b') && (curheight === Number.MIN_VALUE || curheight < bboxes[i].height)) {
+              minx = bboxes[i].x;
+              miny = bboxes[i].y;
+              maxx = bboxes[i].x + bboxes[i].width;
+              maxy = bboxes[i].y + bboxes[i].height;
+              curwidth = bboxes[i].width;
+              curheight = bboxes[i].height;
+            }
+
+            break;
+
+          default:
+            // 'selected'
+            if (bboxes[i].x < minx) {
+              minx = bboxes[i].x;
+            }
+
+            if (bboxes[i].y < miny) {
+              miny = bboxes[i].y;
+            }
+
+            if (bboxes[i].x + bboxes[i].width > maxx) {
+              maxx = bboxes[i].x + bboxes[i].width;
+            }
+
+            if (bboxes[i].y + bboxes[i].height > maxy) {
+              maxy = bboxes[i].y + bboxes[i].height;
+            }
+
+            break;
+        }
+      } // loop for each element to find the bbox and adjust min/max
+
+
+      if (relativeTo === 'page') {
+        minx = 0;
+        miny = 0;
+        maxx = canvas.contentW;
+        maxy = canvas.contentH;
+      }
+
+      var dx = new Array(len);
+      var dy = new Array(len);
+
+      for (var _i7 = 0; _i7 < len; ++_i7) {
+        if (isNullish(selectedElements[_i7])) {
+          break;
+        } // const elem = selectedElements[i];
+
+
+        var bbox = bboxes[_i7];
+        dx[_i7] = 0;
+        dy[_i7] = 0;
+
+        switch (type) {
+          case 'l':
+            // left (horizontal)
+            dx[_i7] = minx - bbox.x;
+            break;
+
+          case 'c':
+            // center (horizontal)
+            dx[_i7] = (minx + maxx) / 2 - (bbox.x + bbox.width / 2);
+            break;
+
+          case 'r':
+            // right (horizontal)
+            dx[_i7] = maxx - (bbox.x + bbox.width);
+            break;
+
+          case 't':
+            // top (vertical)
+            dy[_i7] = miny - bbox.y;
+            break;
+
+          case 'm':
+            // middle (vertical)
+            dy[_i7] = (miny + maxy) / 2 - (bbox.y + bbox.height / 2);
+            break;
+
+          case 'b':
+            // bottom (vertical)
+            dy[_i7] = maxy - (bbox.y + bbox.height);
+            break;
+        }
+      }
+
+      this.moveSelectedElements(dx, dy);
+    };
+    /**
+    * Group: Additional editor tools
+    */
+
+    /**
+    * @name module:svgcanvas.SvgCanvas#contentW
+    * @type {Float}
+    */
+
+
+    this.contentW = getResolution().w;
+    /**
+    * @name module:svgcanvas.SvgCanvas#contentH
+    * @type {Float}
+    */
+
+    this.contentH = getResolution().h;
+    /**
+    * @typedef {PlainObject} module:svgcanvas.CanvasInfo
+    * @property {Float} x - The canvas' new x coordinate
+    * @property {Float} y - The canvas' new y coordinate
+    * @property {string} oldX - The canvas' old x coordinate
+    * @property {string} oldY - The canvas' old y coordinate
+    * @property {Float} d_x - The x position difference
+    * @property {Float} d_y - The y position difference
+    */
+
+    /**
+    * Updates the editor canvas width/height/position after a zoom has occurred.
+    * @function module:svgcanvas.SvgCanvas#updateCanvas
+    * @param {Float} w - Float with the new width
+    * @param {Float} h - Float with the new height
+    * @fires module:svgcanvas.SvgCanvas#event:ext-canvasUpdated
+    * @returns {module:svgcanvas.CanvasInfo}
+    */
+
+    this.updateCanvas = function (w, h) {
+      svgroot.setAttribute('width', w);
+      svgroot.setAttribute('height', h);
+      var bg = $$8('#canvasBackground')[0];
+      var oldX = svgcontent.getAttribute('x');
+      var oldY = svgcontent.getAttribute('y');
+      var x = (w - this.contentW * currentZoom) / 2;
+      var y = (h - this.contentH * currentZoom) / 2;
+      assignAttributes(svgcontent, {
+        width: this.contentW * currentZoom,
+        height: this.contentH * currentZoom,
+        x: x,
+        y: y,
+        viewBox: '0 0 ' + this.contentW + ' ' + this.contentH
+      });
+      assignAttributes(bg, {
+        width: svgcontent.getAttribute('width'),
+        height: svgcontent.getAttribute('height'),
+        x: x,
+        y: y
+      });
+      var bgImg = getElem('background_image');
+
+      if (bgImg) {
+        assignAttributes(bgImg, {
+          width: '100%',
+          height: '100%'
+        });
+      }
+
+      selectorManager.selectorParentGroup.setAttribute('transform', 'translate(' + x + ',' + y + ')');
+      /**
+      * Invoked upon updates to the canvas.
+      * @event module:svgcanvas.SvgCanvas#event:ext-canvasUpdated
+      * @type {PlainObject}
+      * @property {Integer} new_x
+      * @property {Integer} new_y
+      * @property {string} old_x (Of Integer)
+      * @property {string} old_y (Of Integer)
+      * @property {Integer} d_x
+      * @property {Integer} d_y
+      */
+
+      runExtensions('canvasUpdated',
+      /**
+       * @type {module:svgcanvas.SvgCanvas#event:ext-canvasUpdated}
+       */
+      {
+        new_x: x,
+        new_y: y,
+        old_x: oldX,
+        old_y: oldY,
+        d_x: x - oldX,
+        d_y: y - oldY
+      });
+      return {
+        x: x,
+        y: y,
+        old_x: oldX,
+        old_y: oldY,
+        d_x: x - oldX,
+        d_y: y - oldY
+      };
+    };
+    /**
+    * Set the background of the editor (NOT the actual document).
+    * @function module:svgcanvas.SvgCanvas#setBackground
+    * @param {string} color - String with fill color to apply
+    * @param {string} url - URL or path to image to use
+    * @returns {undefined}
+    */
+
+
+    this.setBackground = function (color, url) {
+      var bg = getElem('canvasBackground');
+      var border = $$8(bg).find('rect')[0];
+      var bgImg = getElem('background_image');
+      border.setAttribute('fill', color);
+
+      if (url) {
+        if (!bgImg) {
+          bgImg = svgdoc.createElementNS(NS.SVG, 'image');
+          assignAttributes(bgImg, {
+            id: 'background_image',
+            width: '100%',
+            height: '100%',
+            preserveAspectRatio: 'xMinYMin',
+            style: 'pointer-events:none'
+          });
+        }
+
+        setHref(bgImg, url);
+        bg.append(bgImg);
+      } else if (bgImg) {
+        bgImg.remove();
+      }
+    };
+    /**
+    * Select the next/previous element within the current layer.
+    * @function module:svgcanvas.SvgCanvas#cycleElement
+    * @param {boolean} next - true = next and false = previous element
+    * @fires module:svgcanvas.SvgCanvas#event:selected
+    * @returns {undefined}
+    */
+
+
+    this.cycleElement = function (next) {
+      var num;
+      var curElem = selectedElements[0];
+      var elem = false;
+      var allElems = getVisibleElements(currentGroup || getCurrentDrawing().getCurrentLayer());
+
+      if (!allElems.length) {
+        return;
+      }
+
+      if (isNullish(curElem)) {
+        num = next ? allElems.length - 1 : 0;
+        elem = allElems[num];
+      } else {
+        var i = allElems.length;
+
+        while (i--) {
+          if (allElems[i] === curElem) {
+            num = next ? i - 1 : i + 1;
+
+            if (num >= allElems.length) {
+              num = 0;
+            } else if (num < 0) {
+              num = allElems.length - 1;
+            }
+
+            elem = allElems[num];
+            break;
+          }
+        }
+      }
+
+      selectOnly([elem], true);
+      call('selected', selectedElements);
+    };
+
+    this.clear();
+    /**
+    * @interface module:svgcanvas.PrivateMethods
+    * @type {PlainObject}
+    * @property {module:svgcanvas~addCommandToHistory} addCommandToHistory
+    * @property {module:history.HistoryCommand} BatchCommand
+    * @property {module:history.HistoryCommand} ChangeElementCommand
+    * @property {module:utilities.decode64} decode64
+    * @property {module:utilities.dropXMLInteralSubset} dropXMLInteralSubset
+    * @property {module:utilities.encode64} encode64
+    * @property {module:svgcanvas~ffClone} ffClone
+    * @property {module:svgcanvas~findDuplicateGradient} findDuplicateGradient
+    * @property {module:utilities.getPathBBox} getPathBBox
+    * @property {module:units.getTypeMap} getTypeMap
+    * @property {module:draw.identifyLayers} identifyLayers
+    * @property {module:history.HistoryCommand} InsertElementCommand
+    * @property {module:browser.isChrome} isChrome
+    * @property {module:math.isIdentity} isIdentity
+    * @property {module:browser.isIE} isIE
+    * @property {module:svgcanvas~logMatrix} logMatrix
+    * @property {module:history.HistoryCommand} MoveElementCommand
+    * @property {module:namespaces.NS} NS
+    * @property {module:utilities.preventClickDefault} preventClickDefault
+    * @property {module:history.HistoryCommand} RemoveElementCommand
+    * @property {module:SVGTransformList.SVGEditTransformList} SVGEditTransformList
+    * @property {module:utilities.text2xml} text2xml
+    * @property {module:math.transformBox} transformBox
+    * @property {module:math.transformPoint} transformPoint
+    * @property {module:utilities.walkTree} walkTree
+    */
+
+    /**
+    * @deprecated getPrivateMethods
+    * Since all methods are/should be public somehow, this function should be removed;
+    *  we might require `import` in place of this in the future once ES6 Modules
+    *  widespread
+    
+    * Being able to access private methods publicly seems wrong somehow,
+    * but currently appears to be the best way to allow testing and provide
+    * access to them to plugins.
+    * @function module:svgcanvas.SvgCanvas#getPrivateMethods
+    * @returns {module:svgcanvas.PrivateMethods}
+    */
+
+    this.getPrivateMethods = function () {
+      var obj = {
+        addCommandToHistory: addCommandToHistory,
+        BatchCommand: BatchCommand$1,
+        ChangeElementCommand: ChangeElementCommand$1,
+        decode64: decode64,
+        dropXMLInteralSubset: dropXMLInteralSubset,
+        encode64: encode64,
+        ffClone: ffClone,
+        findDefs: findDefs,
+        findDuplicateGradient: findDuplicateGradient,
+        getElem: getElem,
+        getPathBBox: getPathBBox,
+        getTypeMap: getTypeMap,
+        getUrlFromAttr: getUrlFromAttr,
+        identifyLayers: identifyLayers,
+        InsertElementCommand: InsertElementCommand$1,
+        isChrome: isChrome,
+        isIdentity: isIdentity,
+        isIE: isIE,
+        logMatrix: logMatrix,
+        MoveElementCommand: MoveElementCommand$1,
+        NS: NS,
+        preventClickDefault: preventClickDefault,
+        RemoveElementCommand: RemoveElementCommand$1,
+        SVGEditTransformList: SVGTransformList,
+        text2xml: text2xml,
+        transformBox: transformBox,
+        transformPoint: transformPoint,
+        walkTree: walkTree
+      };
+      return obj;
+    };
+  } // End constructor
+  ; // End class
+
+  return SvgCanvas;
+
+}());
diff --git a/dist/svgcanvas-iife.min.js b/dist/svgcanvas-iife.min.js
new file mode 100644
index 00000000..fc31ea14
--- /dev/null
+++ b/dist/svgcanvas-iife.min.js
@@ -0,0 +1,2 @@
+var SvgCanvas=function(){"use strict";function e(t){return(e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(t)}function t(e,t,r,n,i,a,s){try{var o=e[a](s),u=o.value}catch(e){return void r(e)}o.done?t(u):Promise.resolve(u).then(n,i)}function r(e){return function(){var r=this,n=arguments;return new Promise(function(i,a){var s=e.apply(r,n);function o(e){t(s,i,a,o,u,"next",e)}function u(e){t(s,i,a,o,u,"throw",e)}o(void 0)})}}function n(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}function a(e,t,r){return t&&i(e.prototype,t),r&&i(e,r),e}function s(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&u(e,t)}function o(e){return(o=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function u(e,t){return(u=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function l(e,t){return!t||"object"!=typeof t&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function h(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){var r=[],n=!0,i=!1,a=void 0;try{for(var s,o=e[Symbol.iterator]();!(n=(s=o.next()).done)&&(r.push(s.value),!t||r.length!==t);n=!0);}catch(e){i=!0,a=e}finally{try{n||null==o.return||o.return()}finally{if(i)throw a}}return r}(e,t)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance")}()}function c(e){return function(e){if(Array.isArray(e)){for(var t=0,r=new Array(e.length);t<e.length;t++)r[t]=e[t];return r}}(e)||function(e){if(Symbol.iterator in Object(e)||"[object Arguments]"===Object.prototype.toString.call(e))return Array.from(e)}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance")}()}function d(t){var r=t.fn.attr;return t.fn.attr=function(t,n){var i=this.length;if(!i)return r.call(this,t,n);for(var a=0;a<i;++a){var s=this[a];if("http://www.w3.org/2000/svg"!==s.namespaceURI)return r.call(this,t,n);if(void 0!==n)s.setAttribute(t,n);else if(Array.isArray(t)){for(var o={},u=t.length;u--;){var l=t[u],c=s.getAttribute(l);(c||"0"===c)&&(c=isNaN(c)?c:c-0),o[l]=c}return o}if("object"!==e(t)){var d=s.getAttribute(t);return(d||"0"===d)&&(d=isNaN(d)?d:d-0),d}for(var m=Object.entries(t),f=0;f<m.length;f++){var g=h(m[f],2),p=g[0],y=g[1];s.setAttribute(p,y)}}return this},t}!function(){if(!("SVGPathSeg"in window)){var e=function(){function e(t,r,i){n(this,e),this.pathSegType=t,this.pathSegTypeAsLetter=r,this._owningPathSegList=i}return a(e,[{key:"_segmentChanged",value:function(){this._owningPathSegList&&this._owningPathSegList.segmentChanged(this)}}]),e}();e.prototype.classname="SVGPathSeg",e.PATHSEG_UNKNOWN=0,e.PATHSEG_CLOSEPATH=1,e.PATHSEG_MOVETO_ABS=2,e.PATHSEG_MOVETO_REL=3,e.PATHSEG_LINETO_ABS=4,e.PATHSEG_LINETO_REL=5,e.PATHSEG_CURVETO_CUBIC_ABS=6,e.PATHSEG_CURVETO_CUBIC_REL=7,e.PATHSEG_CURVETO_QUADRATIC_ABS=8,e.PATHSEG_CURVETO_QUADRATIC_REL=9,e.PATHSEG_ARC_ABS=10,e.PATHSEG_ARC_REL=11,e.PATHSEG_LINETO_HORIZONTAL_ABS=12,e.PATHSEG_LINETO_HORIZONTAL_REL=13,e.PATHSEG_LINETO_VERTICAL_ABS=14,e.PATHSEG_LINETO_VERTICAL_REL=15,e.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS=16,e.PATHSEG_CURVETO_CUBIC_SMOOTH_REL=17,e.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS=18,e.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL=19;var t=function(t){function r(t){return n(this,r),l(this,o(r).call(this,e.PATHSEG_CLOSEPATH,"z",t))}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegClosePath]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter}},{key:"clone",value:function(){return new r(void 0)}}]),r}(),r=function(t){function r(t,i,a){var s;return n(this,r),(s=l(this,o(r).call(this,e.PATHSEG_MOVETO_ABS,"M",t)))._x=i,s._y=a,s}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegMovetoAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y)}}]),r}();Object.defineProperties(r.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0}});var i=function(t){function r(t,i,a){var s;return n(this,r),(s=l(this,o(r).call(this,e.PATHSEG_MOVETO_REL,"m",t)))._x=i,s._y=a,s}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegMovetoRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y)}}]),r}();Object.defineProperties(i.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0}});var u=function(t){function r(t,i,a){var s;return n(this,r),(s=l(this,o(r).call(this,e.PATHSEG_LINETO_ABS,"L",t)))._x=i,s._y=a,s}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegLinetoAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y)}}]),r}();Object.defineProperties(u.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0}});var h=function(t){function r(t,i,a){var s;return n(this,r),(s=l(this,o(r).call(this,e.PATHSEG_LINETO_REL,"l",t)))._x=i,s._y=a,s}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegLinetoRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y)}}]),r}();Object.defineProperties(h.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0}});var c=function(t){function r(t,i,a,s,u,h,c){var d;return n(this,r),(d=l(this,o(r).call(this,e.PATHSEG_CURVETO_CUBIC_ABS,"C",t)))._x=i,d._y=a,d._x1=s,d._y1=u,d._x2=h,d._y2=c,d}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoCubicAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x1+" "+this._y1+" "+this._x2+" "+this._y2+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._x1,this._y1,this._x2,this._y2)}}]),r}();Object.defineProperties(c.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},x1:{get:function(){return this._x1},set:function(e){this._x1=e,this._segmentChanged()},enumerable:!0},y1:{get:function(){return this._y1},set:function(e){this._y1=e,this._segmentChanged()},enumerable:!0},x2:{get:function(){return this._x2},set:function(e){this._x2=e,this._segmentChanged()},enumerable:!0},y2:{get:function(){return this._y2},set:function(e){this._y2=e,this._segmentChanged()},enumerable:!0}});var d=function(t){function r(t,i,a,s,u,h,c){var d;return n(this,r),(d=l(this,o(r).call(this,e.PATHSEG_CURVETO_CUBIC_REL,"c",t)))._x=i,d._y=a,d._x1=s,d._y1=u,d._x2=h,d._y2=c,d}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoCubicRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x1+" "+this._y1+" "+this._x2+" "+this._y2+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._x1,this._y1,this._x2,this._y2)}}]),r}();Object.defineProperties(d.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},x1:{get:function(){return this._x1},set:function(e){this._x1=e,this._segmentChanged()},enumerable:!0},y1:{get:function(){return this._y1},set:function(e){this._y1=e,this._segmentChanged()},enumerable:!0},x2:{get:function(){return this._x2},set:function(e){this._x2=e,this._segmentChanged()},enumerable:!0},y2:{get:function(){return this._y2},set:function(e){this._y2=e,this._segmentChanged()},enumerable:!0}});var m=function(t){function r(t,i,a,s,u){var h;return n(this,r),(h=l(this,o(r).call(this,e.PATHSEG_CURVETO_QUADRATIC_ABS,"Q",t)))._x=i,h._y=a,h._x1=s,h._y1=u,h}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoQuadraticAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x1+" "+this._y1+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._x1,this._y1)}}]),r}();Object.defineProperties(m.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},x1:{get:function(){return this._x1},set:function(e){this._x1=e,this._segmentChanged()},enumerable:!0},y1:{get:function(){return this._y1},set:function(e){this._y1=e,this._segmentChanged()},enumerable:!0}});var f=function(t){function r(t,i,a,s,u){var h;return n(this,r),(h=l(this,o(r).call(this,e.PATHSEG_CURVETO_QUADRATIC_REL,"q",t)))._x=i,h._y=a,h._x1=s,h._y1=u,h}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoQuadraticRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x1+" "+this._y1+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._x1,this._y1)}}]),r}();Object.defineProperties(f.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},x1:{get:function(){return this._x1},set:function(e){this._x1=e,this._segmentChanged()},enumerable:!0},y1:{get:function(){return this._y1},set:function(e){this._y1=e,this._segmentChanged()},enumerable:!0}});var g=function(t){function r(t,i,a,s,u,h,c,d){var m;return n(this,r),(m=l(this,o(r).call(this,e.PATHSEG_ARC_ABS,"A",t)))._x=i,m._y=a,m._r1=s,m._r2=u,m._angle=h,m._largeArcFlag=c,m._sweepFlag=d,m}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegArcAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._r1+" "+this._r2+" "+this._angle+" "+(this._largeArcFlag?"1":"0")+" "+(this._sweepFlag?"1":"0")+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._r1,this._r2,this._angle,this._largeArcFlag,this._sweepFlag)}}]),r}();Object.defineProperties(g.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},r1:{get:function(){return this._r1},set:function(e){this._r1=e,this._segmentChanged()},enumerable:!0},r2:{get:function(){return this._r2},set:function(e){this._r2=e,this._segmentChanged()},enumerable:!0},angle:{get:function(){return this._angle},set:function(e){this._angle=e,this._segmentChanged()},enumerable:!0},largeArcFlag:{get:function(){return this._largeArcFlag},set:function(e){this._largeArcFlag=e,this._segmentChanged()},enumerable:!0},sweepFlag:{get:function(){return this._sweepFlag},set:function(e){this._sweepFlag=e,this._segmentChanged()},enumerable:!0}});var p=function(t){function r(t,i,a,s,u,h,c,d){var m;return n(this,r),(m=l(this,o(r).call(this,e.PATHSEG_ARC_REL,"a",t)))._x=i,m._y=a,m._r1=s,m._r2=u,m._angle=h,m._largeArcFlag=c,m._sweepFlag=d,m}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegArcRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._r1+" "+this._r2+" "+this._angle+" "+(this._largeArcFlag?"1":"0")+" "+(this._sweepFlag?"1":"0")+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._r1,this._r2,this._angle,this._largeArcFlag,this._sweepFlag)}}]),r}();Object.defineProperties(p.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},r1:{get:function(){return this._r1},set:function(e){this._r1=e,this._segmentChanged()},enumerable:!0},r2:{get:function(){return this._r2},set:function(e){this._r2=e,this._segmentChanged()},enumerable:!0},angle:{get:function(){return this._angle},set:function(e){this._angle=e,this._segmentChanged()},enumerable:!0},largeArcFlag:{get:function(){return this._largeArcFlag},set:function(e){this._largeArcFlag=e,this._segmentChanged()},enumerable:!0},sweepFlag:{get:function(){return this._sweepFlag},set:function(e){this._sweepFlag=e,this._segmentChanged()},enumerable:!0}});var y=function(t){function r(t,i){var a;return n(this,r),(a=l(this,o(r).call(this,e.PATHSEG_LINETO_HORIZONTAL_ABS,"H",t)))._x=i,a}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegLinetoHorizontalAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x}},{key:"clone",value:function(){return new r(void 0,this._x)}}]),r}();Object.defineProperty(y.prototype,"x",{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0});var v=function(t){function r(t,i){var a;return n(this,r),(a=l(this,o(r).call(this,e.PATHSEG_LINETO_HORIZONTAL_REL,"h",t)))._x=i,a}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegLinetoHorizontalRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x}},{key:"clone",value:function(){return new r(void 0,this._x)}}]),r}();Object.defineProperty(v.prototype,"x",{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0});var x=function(t){function r(t,i){var a;return n(this,r),(a=l(this,o(r).call(this,e.PATHSEG_LINETO_VERTICAL_ABS,"V",t)))._y=i,a}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegLinetoVerticalAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._y)}}]),r}();Object.defineProperty(x.prototype,"y",{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0});var _=function(t){function r(t,i){var a;return n(this,r),(a=l(this,o(r).call(this,e.PATHSEG_LINETO_VERTICAL_REL,"v",t)))._y=i,a}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegLinetoVerticalRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._y)}}]),r}();Object.defineProperty(_.prototype,"y",{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0});var S=function(t){function r(t,i,a,s,u){var h;return n(this,r),(h=l(this,o(r).call(this,e.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS,"S",t)))._x=i,h._y=a,h._x2=s,h._y2=u,h}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoCubicSmoothAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x2+" "+this._y2+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._x2,this._y2)}}]),r}();Object.defineProperties(S.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},x2:{get:function(){return this._x2},set:function(e){this._x2=e,this._segmentChanged()},enumerable:!0},y2:{get:function(){return this._y2},set:function(e){this._y2=e,this._segmentChanged()},enumerable:!0}});var b=function(t){function r(t,i,a,s,u){var h;return n(this,r),(h=l(this,o(r).call(this,e.PATHSEG_CURVETO_CUBIC_SMOOTH_REL,"s",t)))._x=i,h._y=a,h._x2=s,h._y2=u,h}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoCubicSmoothRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x2+" "+this._y2+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y,this._x2,this._y2)}}]),r}();Object.defineProperties(b.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0},x2:{get:function(){return this._x2},set:function(e){this._x2=e,this._segmentChanged()},enumerable:!0},y2:{get:function(){return this._y2},set:function(e){this._y2=e,this._segmentChanged()},enumerable:!0}});var w=function(t){function r(t,i,a){var s;return n(this,r),(s=l(this,o(r).call(this,e.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS,"T",t)))._x=i,s._y=a,s}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoQuadraticSmoothAbs]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y)}}]),r}();Object.defineProperties(w.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0}});var A=function(t){function r(t,i,a){var s;return n(this,r),(s=l(this,o(r).call(this,e.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL,"t",t)))._x=i,s._y=a,s}return s(r,e),a(r,[{key:"toString",value:function(){return"[object SVGPathSegCurvetoQuadraticSmoothRel]"}},{key:"_asPathString",value:function(){return this.pathSegTypeAsLetter+" "+this._x+" "+this._y}},{key:"clone",value:function(){return new r(void 0,this._x,this._y)}}]),r}();Object.defineProperties(A.prototype,{x:{get:function(){return this._x},set:function(e){this._x=e,this._segmentChanged()},enumerable:!0},y:{get:function(){return this._y},set:function(e){this._y=e,this._segmentChanged()},enumerable:!0}}),SVGPathElement.prototype.createSVGPathSegClosePath=function(){return new t(void 0)},SVGPathElement.prototype.createSVGPathSegMovetoAbs=function(e,t){return new r(void 0,e,t)},SVGPathElement.prototype.createSVGPathSegMovetoRel=function(e,t){return new i(void 0,e,t)},SVGPathElement.prototype.createSVGPathSegLinetoAbs=function(e,t){return new u(void 0,e,t)},SVGPathElement.prototype.createSVGPathSegLinetoRel=function(e,t){return new h(void 0,e,t)},SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs=function(e,t,r,n,i,a){return new c(void 0,e,t,r,n,i,a)},SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel=function(e,t,r,n,i,a){return new d(void 0,e,t,r,n,i,a)},SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs=function(e,t,r,n){return new m(void 0,e,t,r,n)},SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel=function(e,t,r,n){return new f(void 0,e,t,r,n)},SVGPathElement.prototype.createSVGPathSegArcAbs=function(e,t,r,n,i,a,s){return new g(void 0,e,t,r,n,i,a,s)},SVGPathElement.prototype.createSVGPathSegArcRel=function(e,t,r,n,i,a,s){return new p(void 0,e,t,r,n,i,a,s)},SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs=function(e){return new y(void 0,e)},SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel=function(e){return new v(void 0,e)},SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs=function(e){return new x(void 0,e)},SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel=function(e){return new _(void 0,e)},SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs=function(e,t,r,n){return new S(void 0,e,t,r,n)},SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel=function(e,t,r,n){return new b(void 0,e,t,r,n)},SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs=function(e,t){return new w(void 0,e,t)},SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel=function(e,t){return new A(void 0,e,t)},"getPathSegAtLength"in SVGPathElement.prototype||(SVGPathElement.prototype.getPathSegAtLength=function(e){if(void 0===e||!isFinite(e))throw new Error("Invalid arguments.");var t=document.createElementNS("http://www.w3.org/2000/svg","path");t.setAttribute("d",this.getAttribute("d"));var r=t.pathSegList.numberOfItems-1;if(r<=0)return 0;do{if(t.pathSegList.removeItem(r),e>t.getTotalLength())break;r--}while(r>0);return r}),window.SVGPathSeg=e,window.SVGPathSegClosePath=t,window.SVGPathSegMovetoAbs=r,window.SVGPathSegMovetoRel=i,window.SVGPathSegLinetoAbs=u,window.SVGPathSegLinetoRel=h,window.SVGPathSegCurvetoCubicAbs=c,window.SVGPathSegCurvetoCubicRel=d,window.SVGPathSegCurvetoQuadraticAbs=m,window.SVGPathSegCurvetoQuadraticRel=f,window.SVGPathSegArcAbs=g,window.SVGPathSegArcRel=p,window.SVGPathSegLinetoHorizontalAbs=y,window.SVGPathSegLinetoHorizontalRel=v,window.SVGPathSegLinetoVerticalAbs=x,window.SVGPathSegLinetoVerticalRel=_,window.SVGPathSegCurvetoCubicSmoothAbs=S,window.SVGPathSegCurvetoCubicSmoothRel=b,window.SVGPathSegCurvetoQuadraticSmoothAbs=w,window.SVGPathSegCurvetoQuadraticSmoothRel=A}if(!("SVGPathSegList"in window&&"appendItem"in window.SVGPathSegList.prototype)){var k=function(){function e(t){n(this,e),this._pathElement=t,this._list=this._parsePath(this._pathElement.getAttribute("d")),this._mutationObserverConfig={attributes:!0,attributeFilter:["d"]},this._pathElementMutationObserver=new MutationObserver(this._updateListFromPathMutations.bind(this)),this._pathElementMutationObserver.observe(this._pathElement,this._mutationObserverConfig)}return a(e,[{key:"_checkPathSynchronizedToList",value:function(){this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords())}},{key:"_updateListFromPathMutations",value:function(e){if(this._pathElement){var t=!1;e.forEach(function(e){"d"===e.attributeName&&(t=!0)}),t&&(this._list=this._parsePath(this._pathElement.getAttribute("d")))}}},{key:"_writeListToPath",value:function(){this._pathElementMutationObserver.disconnect(),this._pathElement.setAttribute("d",e._pathSegArrayAsString(this._list)),this._pathElementMutationObserver.observe(this._pathElement,this._mutationObserverConfig)}},{key:"segmentChanged",value:function(e){this._writeListToPath()}},{key:"clear",value:function(){this._checkPathSynchronizedToList(),this._list.forEach(function(e){e._owningPathSegList=null}),this._list=[],this._writeListToPath()}},{key:"initialize",value:function(e){return this._checkPathSynchronizedToList(),this._list=[e],e._owningPathSegList=this,this._writeListToPath(),e}},{key:"_checkValidIndex",value:function(e){if(isNaN(e)||e<0||e>=this.numberOfItems)throw new Error("INDEX_SIZE_ERR")}},{key:"getItem",value:function(e){return this._checkPathSynchronizedToList(),this._checkValidIndex(e),this._list[e]}},{key:"insertItemBefore",value:function(e,t){return this._checkPathSynchronizedToList(),t>this.numberOfItems&&(t=this.numberOfItems),e._owningPathSegList&&(e=e.clone()),this._list.splice(t,0,e),e._owningPathSegList=this,this._writeListToPath(),e}},{key:"replaceItem",value:function(e,t){return this._checkPathSynchronizedToList(),e._owningPathSegList&&(e=e.clone()),this._checkValidIndex(t),this._list[t]=e,e._owningPathSegList=this,this._writeListToPath(),e}},{key:"removeItem",value:function(e){this._checkPathSynchronizedToList(),this._checkValidIndex(e);var t=this._list[e];return this._list.splice(e,1),this._writeListToPath(),t}},{key:"appendItem",value:function(e){return this._checkPathSynchronizedToList(),e._owningPathSegList&&(e=e.clone()),this._list.push(e),e._owningPathSegList=this,this._writeListToPath(),e}},{key:"_parsePath",value:function(e){if(!e||!e.length)return[];var t=this,r=function(){function e(){n(this,e),this.pathSegList=[]}return a(e,[{key:"appendSegment",value:function(e){this.pathSegList.push(e)}}]),e}(),i=function(){function e(t){n(this,e),this._string=t,this._currentIndex=0,this._endIndex=this._string.length,this._previousCommand=SVGPathSeg.PATHSEG_UNKNOWN,this._skipOptionalSpaces()}return a(e,[{key:"_isCurrentSpace",value:function(){var e=this._string[this._currentIndex];return e<=" "&&(" "===e||"\n"===e||"\t"===e||"\r"===e||"\f"===e)}},{key:"_skipOptionalSpaces",value:function(){for(;this._currentIndex<this._endIndex&&this._isCurrentSpace();)this._currentIndex++;return this._currentIndex<this._endIndex}},{key:"_skipOptionalSpacesOrDelimiter",value:function(){return!(this._currentIndex<this._endIndex&&!this._isCurrentSpace()&&","!==this._string.charAt(this._currentIndex))&&(this._skipOptionalSpaces()&&this._currentIndex<this._endIndex&&","===this._string.charAt(this._currentIndex)&&(this._currentIndex++,this._skipOptionalSpaces()),this._currentIndex<this._endIndex)}},{key:"hasMoreData",value:function(){return this._currentIndex<this._endIndex}},{key:"peekSegmentType",value:function(){var e=this._string[this._currentIndex];return this._pathSegTypeFromChar(e)}},{key:"_pathSegTypeFromChar",value:function(e){switch(e){case"Z":case"z":return SVGPathSeg.PATHSEG_CLOSEPATH;case"M":return SVGPathSeg.PATHSEG_MOVETO_ABS;case"m":return SVGPathSeg.PATHSEG_MOVETO_REL;case"L":return SVGPathSeg.PATHSEG_LINETO_ABS;case"l":return SVGPathSeg.PATHSEG_LINETO_REL;case"C":return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;case"c":return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;case"Q":return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;case"q":return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;case"A":return SVGPathSeg.PATHSEG_ARC_ABS;case"a":return SVGPathSeg.PATHSEG_ARC_REL;case"H":return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;case"h":return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;case"V":return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;case"v":return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;case"S":return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;case"s":return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;case"T":return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;case"t":return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;default:return SVGPathSeg.PATHSEG_UNKNOWN}}},{key:"_nextCommandHelper",value:function(e,t){return("+"===e||"-"===e||"."===e||e>="0"&&e<="9")&&t!==SVGPathSeg.PATHSEG_CLOSEPATH?t===SVGPathSeg.PATHSEG_MOVETO_ABS?SVGPathSeg.PATHSEG_LINETO_ABS:t===SVGPathSeg.PATHSEG_MOVETO_REL?SVGPathSeg.PATHSEG_LINETO_REL:t:SVGPathSeg.PATHSEG_UNKNOWN}},{key:"initialCommandIsMoveTo",value:function(){if(!this.hasMoreData())return!0;var e=this.peekSegmentType();return e===SVGPathSeg.PATHSEG_MOVETO_ABS||e===SVGPathSeg.PATHSEG_MOVETO_REL}},{key:"_parseNumber",value:function(){var e=0,t=0,r=1,n=0,i=1,a=1,s=this._currentIndex;if(this._skipOptionalSpaces(),this._currentIndex<this._endIndex&&"+"===this._string.charAt(this._currentIndex)?this._currentIndex++:this._currentIndex<this._endIndex&&"-"===this._string.charAt(this._currentIndex)&&(this._currentIndex++,i=-1),!(this._currentIndex===this._endIndex||(this._string.charAt(this._currentIndex)<"0"||this._string.charAt(this._currentIndex)>"9")&&"."!==this._string.charAt(this._currentIndex))){for(var o=this._currentIndex;this._currentIndex<this._endIndex&&this._string.charAt(this._currentIndex)>="0"&&this._string.charAt(this._currentIndex)<="9";)this._currentIndex++;if(this._currentIndex!==o)for(var u=this._currentIndex-1,l=1;u>=o;)t+=l*(this._string.charAt(u--)-"0"),l*=10;if(this._currentIndex<this._endIndex&&"."===this._string.charAt(this._currentIndex)){if(this._currentIndex++,this._currentIndex>=this._endIndex||this._string.charAt(this._currentIndex)<"0"||this._string.charAt(this._currentIndex)>"9")return;for(;this._currentIndex<this._endIndex&&this._string.charAt(this._currentIndex)>="0"&&this._string.charAt(this._currentIndex)<="9";)r*=10,n+=(this._string.charAt(this._currentIndex)-"0")/r,this._currentIndex+=1}if(this._currentIndex!==s&&this._currentIndex+1<this._endIndex&&("e"===this._string.charAt(this._currentIndex)||"E"===this._string.charAt(this._currentIndex))&&"x"!==this._string.charAt(this._currentIndex+1)&&"m"!==this._string.charAt(this._currentIndex+1)){if(this._currentIndex++,"+"===this._string.charAt(this._currentIndex)?this._currentIndex++:"-"===this._string.charAt(this._currentIndex)&&(this._currentIndex++,a=-1),this._currentIndex>=this._endIndex||this._string.charAt(this._currentIndex)<"0"||this._string.charAt(this._currentIndex)>"9")return;for(;this._currentIndex<this._endIndex&&this._string.charAt(this._currentIndex)>="0"&&this._string.charAt(this._currentIndex)<="9";)e*=10,e+=this._string.charAt(this._currentIndex)-"0",this._currentIndex++}var h=t+n;if(h*=i,e&&(h*=Math.pow(10,a*e)),s!==this._currentIndex)return this._skipOptionalSpacesOrDelimiter(),h}}},{key:"_parseArcFlag",value:function(){if(!(this._currentIndex>=this._endIndex)){var e=!1,t=this._string.charAt(this._currentIndex++);if("0"===t)e=!1;else{if("1"!==t)return;e=!0}return this._skipOptionalSpacesOrDelimiter(),e}}},{key:"parseSegment",value:function(){var e=this._string[this._currentIndex],r=this._pathSegTypeFromChar(e);if(r===SVGPathSeg.PATHSEG_UNKNOWN){if(this._previousCommand===SVGPathSeg.PATHSEG_UNKNOWN)return null;if((r=this._nextCommandHelper(e,this._previousCommand))===SVGPathSeg.PATHSEG_UNKNOWN)return null}else this._currentIndex++;switch(this._previousCommand=r,r){case SVGPathSeg.PATHSEG_MOVETO_REL:return new SVGPathSegMovetoRel(t,this._parseNumber(),this._parseNumber());case SVGPathSeg.PATHSEG_MOVETO_ABS:return new SVGPathSegMovetoAbs(t,this._parseNumber(),this._parseNumber());case SVGPathSeg.PATHSEG_LINETO_REL:return new SVGPathSegLinetoRel(t,this._parseNumber(),this._parseNumber());case SVGPathSeg.PATHSEG_LINETO_ABS:return new SVGPathSegLinetoAbs(t,this._parseNumber(),this._parseNumber());case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:return new SVGPathSegLinetoHorizontalRel(t,this._parseNumber());case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:return new SVGPathSegLinetoHorizontalAbs(t,this._parseNumber());case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:return new SVGPathSegLinetoVerticalRel(t,this._parseNumber());case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:return new SVGPathSegLinetoVerticalAbs(t,this._parseNumber());case SVGPathSeg.PATHSEG_CLOSEPATH:return this._skipOptionalSpaces(),new SVGPathSegClosePath(t);case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL:var n={x1:this._parseNumber(),y1:this._parseNumber(),x2:this._parseNumber(),y2:this._parseNumber(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegCurvetoCubicRel(t,n.x,n.y,n.x1,n.y1,n.x2,n.y2);case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS:var i={x1:this._parseNumber(),y1:this._parseNumber(),x2:this._parseNumber(),y2:this._parseNumber(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegCurvetoCubicAbs(t,i.x,i.y,i.x1,i.y1,i.x2,i.y2);case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL:var a={x2:this._parseNumber(),y2:this._parseNumber(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegCurvetoCubicSmoothRel(t,a.x,a.y,a.x2,a.y2);case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:var s={x2:this._parseNumber(),y2:this._parseNumber(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegCurvetoCubicSmoothAbs(t,s.x,s.y,s.x2,s.y2);case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL:var o={x1:this._parseNumber(),y1:this._parseNumber(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegCurvetoQuadraticRel(t,o.x,o.y,o.x1,o.y1);case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS:var u={x1:this._parseNumber(),y1:this._parseNumber(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegCurvetoQuadraticAbs(t,u.x,u.y,u.x1,u.y1);case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:return new SVGPathSegCurvetoQuadraticSmoothRel(t,this._parseNumber(),this._parseNumber());case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:return new SVGPathSegCurvetoQuadraticSmoothAbs(t,this._parseNumber(),this._parseNumber());case SVGPathSeg.PATHSEG_ARC_REL:var l={x1:this._parseNumber(),y1:this._parseNumber(),arcAngle:this._parseNumber(),arcLarge:this._parseArcFlag(),arcSweep:this._parseArcFlag(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegArcRel(t,l.x,l.y,l.x1,l.y1,l.arcAngle,l.arcLarge,l.arcSweep);case SVGPathSeg.PATHSEG_ARC_ABS:var h={x1:this._parseNumber(),y1:this._parseNumber(),arcAngle:this._parseNumber(),arcLarge:this._parseArcFlag(),arcSweep:this._parseArcFlag(),x:this._parseNumber(),y:this._parseNumber()};return new SVGPathSegArcAbs(t,h.x,h.y,h.x1,h.y1,h.arcAngle,h.arcLarge,h.arcSweep);default:throw new Error("Unknown path seg type.")}}}]),e}(),s=new r,o=new i(e);if(!o.initialCommandIsMoveTo())return[];for(;o.hasMoreData();){var u=o.parseSegment();if(!u)return[];s.appendSegment(u)}return s.pathSegList}}]),e}();k.prototype.classname="SVGPathSegList",Object.defineProperty(k.prototype,"numberOfItems",{get:function(){return this._checkPathSynchronizedToList(),this._list.length},enumerable:!0}),k._pathSegArrayAsString=function(e){var t="",r=!0;return e.forEach(function(e){r?(r=!1,t+=e._asPathString()):t+=" "+e._asPathString()}),t},Object.defineProperties(SVGPathElement.prototype,{pathSegList:{get:function(){return this._pathSegList||(this._pathSegList=new k(this)),this._pathSegList},enumerable:!0},normalizedPathSegList:{get:function(){return this.pathSegList},enumerable:!0},animatedPathSegList:{get:function(){return this.pathSegList},enumerable:!0},animatedNormalizedPathSegList:{get:function(){return this.pathSegList},enumerable:!0}}),window.SVGPathSegList=k}}();var m,f={HTML:"http://www.w3.org/1999/xhtml",MATH:"http://www.w3.org/1998/Math/MathML",SE:"http://svg-edit.googlecode.com",SVG:"http://www.w3.org/2000/svg",XLINK:"http://www.w3.org/1999/xlink",XML:"http://www.w3.org/XML/1998/namespace",XMLNS:"http://www.w3.org/2000/xmlns/"},g=function(){var e={};return Object.entries(f).forEach(function(t){var r=h(t,2),n=r[0],i=r[1];e[i]=n.toLowerCase()}),e},p=jQuery,y=(Boolean(document.createElementNS&&document.createElementNS(f.SVG,"svg").createSVGRect),navigator.userAgent),v=document.createElementNS(f.SVG,"svg"),x=Boolean(window.opera),_=y.includes("AppleWebKit"),S=y.includes("Gecko/"),b=y.includes("MSIE"),w=y.includes("Chrome/"),A=(y.includes("Windows"),y.includes("Macintosh"),"ontouchstart"in window),k=Boolean(v.querySelector),C=Boolean(document.evaluate),E=function(){var e=document.createElementNS(f.SVG,"path");e.setAttribute("d","M0,0 10,10");var t=e.pathSegList,r=e.createSVGPathSegLinetoAbs(5,5);try{return t.replaceItem(r,1),!0}catch(e){}return!1}(),P=function(){var e=document.createElementNS(f.SVG,"path");e.setAttribute("d","M0,0 10,10");var t=e.pathSegList,r=e.createSVGPathSegLinetoAbs(5,5);try{return t.insertItemBefore(r,1),!0}catch(e){}return!1}(),G=function(){var e=document.createElementNS(f.SVG,"svg"),t=document.createElementNS(f.SVG,"svg");document.documentElement.append(e),t.setAttribute("x",5),e.append(t);var r=document.createElementNS(f.SVG,"text");r.textContent="a",t.append(r);try{return 0===r.getStartPositionOfChar(0).x}catch(e){return!1}finally{e.remove()}}(),N=function(){var e=document.createElementNS(f.SVG,"svg");document.documentElement.append(e);var t=document.createElementNS(f.SVG,"path");t.setAttribute("d","M0,0 C0,0 10,10 10,0"),e.append(t);var r=t.getBBox();return e.remove(),r.height>4&&r.height<5}(),I=function(){var e=document.createElementNS(f.SVG,"svg");document.documentElement.append(e);var t=document.createElementNS(f.SVG,"path");t.setAttribute("d","M0,0 10,0");var r=document.createElementNS(f.SVG,"path");r.setAttribute("d","M5,0 15,0");var n=document.createElementNS(f.SVG,"g");n.append(t,r),e.append(n);var i=n.getBBox();return e.remove(),15===i.width}(),T=(function(){var e=document.createElementNS(f.SVG,"rect");e.setAttribute("x",.1);var t=!e.cloneNode(!1).getAttribute("x").includes(",");t||p.alert('NOTE: This version of Opera is known to contain bugs in SVG-edit.\nPlease upgrade to the <a href="http://opera.com">latest version</a> in which the problems have been fixed.')}(),(m=document.createElementNS(f.SVG,"rect")).setAttribute("style","vector-effect:non-scaling-stroke"),"non-scaling-stroke"===m.style.vectorEffect),L=function(){var e=document.createElementNS(f.SVG,"rect").transform.baseVal,t=v.createSVGTransform();e.appendItem(t);var r=e.getItem(0);return r instanceof SVGTransform&&t instanceof SVGTransform&&r.type===t.type&&r.angle===t.angle&&r.matrix.a===t.matrix.a&&r.matrix.b===t.matrix.b&&r.matrix.c===t.matrix.c&&r.matrix.d===t.matrix.d&&r.matrix.e===t.matrix.e&&r.matrix.f===t.matrix.f}(),V=function(){return x},O=function(){return _},M=function(){return S},R=function(){return b},B=function(){return w},U=function(){return I},H=function(){return T},j=document.createElementNS(f.SVG,"svg");function F(e){var t=e.matrix,r="";switch(e.type){case 1:r="matrix("+[t.a,t.b,t.c,t.d,t.e,t.f].join(",")+")";break;case 2:r="translate("+t.e+","+t.f+")";break;case 3:r=t.a===t.d?"scale("+t.a+")":"scale("+t.a+","+t.d+")";break;case 4:var n=0,i=0;if(0!==e.angle){var a=1-t.a;i=(a*t.f+t.b*t.e)/(a*a+t.b*t.b),n=(t.e-t.b*i)/a}r="rotate("+e.angle+" "+n+","+i+")"}return r}var D,z={},q=function(){function e(t){n(this,e),this._elem=t||null,this._xforms=[],this._update=function(){for(var e="",t=0;t<this.numberOfItems;++t){e+=F(this._list.getItem(t))+" "}this._elem.setAttribute("transform",e)},this._list=this,this._init=function(){var e=this,t=this._elem.getAttribute("transform");if(t)for(var r=/\s*((scale|matrix|rotate|translate)\s*\(.*?\))\s*,?\s*/,n=!0;n;)n=t.match(r),t=t.replace(r,""),n&&n[1]&&function(){var t=n[1].split(/\s*\(/),r=t[0],i=t[1].match(/\s*(.*?)\s*\)/);i[1]=i[1].replace(/(\d)-/g,"$1 -");var a=i[1].split(/[, ]+/),s="abcdef".split(""),o=j.createSVGMatrix();Object.values(a).forEach(function(e,t){a[t]=parseFloat(e),"matrix"===r&&(o[s[t]]=a[t])});var u=j.createSVGTransform(),l="set"+r.charAt(0).toUpperCase()+r.slice(1),h="matrix"===r?[o]:a;"scale"===r&&1===h.length?h.push(h[0]):"translate"===r&&1===h.length?h.push(0):"rotate"===r&&1===h.length&&h.push(0,0),u[l].apply(u,c(h)),e._list.appendItem(u)}()},this._removeFromOtherLists=function(e){e&&Object.values(z).some(function(t){for(var r=0,n=t._xforms.length;r<n;++r)if(t._xforms[r]===e)return t.removeItem(r),!0;return!1})},this.numberOfItems=0}return a(e,[{key:"clear",value:function(){this.numberOfItems=0,this._xforms=[]}},{key:"initialize",value:function(e){this.numberOfItems=1,this._removeFromOtherLists(e),this._xforms=[e]}},{key:"getItem",value:function(e){if(e<this.numberOfItems&&e>=0)return this._xforms[e];var t=new Error("DOMException with code=INDEX_SIZE_ERR");throw t.code=1,t}},{key:"insertItemBefore",value:function(e,t){var r=null;if(t>=0)if(t<this.numberOfItems){this._removeFromOtherLists(e);var n,i=new Array(this.numberOfItems+1);for(n=0;n<t;++n)i[n]=this._xforms[n];i[n]=e;for(var a=n+1;n<this.numberOfItems;++a,++n)i[a]=this._xforms[n];this.numberOfItems++,this._xforms=i,r=e,this._list._update()}else r=this._list.appendItem(e);return r}},{key:"replaceItem",value:function(e,t){var r=null;return t<this.numberOfItems&&t>=0&&(this._removeFromOtherLists(e),this._xforms[t]=e,r=e,this._list._update()),r}},{key:"removeItem",value:function(e){if(e<this.numberOfItems&&e>=0){var t,r=this._xforms[e],n=new Array(this.numberOfItems-1);for(t=0;t<e;++t)n[t]=this._xforms[t];for(var i=t;i<this.numberOfItems-1;++i,++t)n[i]=this._xforms[t+1];return this.numberOfItems--,this._xforms=n,this._list._update(),r}var a=new Error("DOMException with code=INDEX_SIZE_ERR");throw a.code=1,a}},{key:"appendItem",value:function(e){return this._removeFromOtherLists(e),this._xforms.push(e),this.numberOfItems++,this._list._update(),e}}]),e}(),W=function(e){e.id&&z[e.id]&&delete z[e.id]},Q=function(e){if(!L){var t=e.id||"temp",r=z[t];return r&&"temp"!==t||(z[t]=new q(e),z[t]._init(),r=z[t]),r}return e.transform?e.transform.baseVal:e.gradientTransform?e.gradientTransform.baseVal:e.patternTransform?e.patternTransform.baseVal:null},Y=["x","x1","cx","rx","width"],Z=["y","y1","cy","ry","height"],X={},K=function(){return X},$=function e(t){var r=D.getRoundDigits();return isNaN(t)?Array.isArray(t)?e(t[0])+","+e(t[1]):parseFloat(t).toFixed(r)-0:Number(Number(t).toFixed(r))},J=function(e,t){return t=t||D.getBaseUnit(),$(e/X[t])},ee=function(e,t,r){e.setAttribute(t,r)},te=function(e,t){if(!isNaN(t))return t-0;if("%"===t.substr(-1)){var r=t.substr(0,t.length-1)/100,n=D.getWidth(),i=D.getHeight();return Y.includes(e)?r*n:Z.includes(e)?r*i:r*Math.sqrt(n*n+i*i)/Math.sqrt(2)}var a=t.substr(-2);return t.substr(0,t.length-2)*X[a]},re={BEFORE_APPLY:"before_apply",AFTER_APPLY:"after_apply",BEFORE_UNAPPLY:"before_unapply",AFTER_UNAPPLY:"after_unapply"},ne=function(){function e(){n(this,e)}return a(e,[{key:"getText",value:function(){return this.text}}]),e}(),ie=function(e){function t(e,r,i,a){var s;return n(this,t),(s=l(this,o(t).call(this))).elem=e,s.text=a?"Move "+e.tagName+" to "+a:"Move "+e.tagName,s.oldNextSibling=r,s.oldParent=i,s.newNextSibling=e.nextSibling,s.newParent=e.parentNode,s}return s(t,ne),a(t,[{key:"type",value:function(){return"svgedit.history.MoveElementCommand"}},{key:"apply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_APPLY,this),this.elem=this.newParent.insertBefore(this.elem,this.newNextSibling),e&&e.handleHistoryEvent(re.AFTER_APPLY,this)}},{key:"unapply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_UNAPPLY,this),this.elem=this.oldParent.insertBefore(this.elem,this.oldNextSibling),e&&e.handleHistoryEvent(re.AFTER_UNAPPLY,this)}},{key:"elements",value:function(){return[this.elem]}}]),t}();ie.type=ie.prototype.type;var ae=function(e){function t(e,r){var i;return n(this,t),(i=l(this,o(t).call(this))).elem=e,i.text=r||"Create "+e.tagName,i.parent=e.parentNode,i.nextSibling=i.elem.nextSibling,i}return s(t,ne),a(t,[{key:"type",value:function(){return"svgedit.history.InsertElementCommand"}},{key:"apply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_APPLY,this),this.elem=this.parent.insertBefore(this.elem,this.nextSibling),e&&e.handleHistoryEvent(re.AFTER_APPLY,this)}},{key:"unapply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_UNAPPLY,this),this.parent=this.elem.parentNode,this.elem=this.elem.parentNode.removeChild(this.elem),e&&e.handleHistoryEvent(re.AFTER_UNAPPLY,this)}},{key:"elements",value:function(){return[this.elem]}}]),t}();ae.type=ae.prototype.type;var se=function(e){function t(e,r,i,a){var s;return n(this,t),(s=l(this,o(t).call(this))).elem=e,s.text=a||"Delete "+e.tagName,s.nextSibling=r,s.parent=i,W(e),s}return s(t,ne),a(t,[{key:"type",value:function(){return"svgedit.history.RemoveElementCommand"}},{key:"apply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_APPLY,this),W(this.elem),this.parent=this.elem.parentNode,this.elem=this.parent.removeChild(this.elem),e&&e.handleHistoryEvent(re.AFTER_APPLY,this)}},{key:"unapply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_UNAPPLY,this),W(this.elem),Zt(this.nextSibling)&&window.console&&console.log("Error: reference element was lost"),this.parent.insertBefore(this.elem,this.nextSibling),e&&e.handleHistoryEvent(re.AFTER_UNAPPLY,this)}},{key:"elements",value:function(){return[this.elem]}}]),t}();se.type=se.prototype.type;var oe=function(e){function t(e,r,i){var a;for(var s in n(this,t),(a=l(this,o(t).call(this))).elem=e,a.text=i?"Change "+e.tagName+" "+i:"Change "+e.tagName,a.newValues={},a.oldValues=r,r)a.newValues[s]="#text"===s?e.textContent:"#href"===s?Ct(e):e.getAttribute(s);return a}return s(t,ne),a(t,[{key:"type",value:function(){return"svgedit.history.ChangeElementCommand"}},{key:"apply",value:function(e){var t=this;e&&e.handleHistoryEvent(re.BEFORE_APPLY,this);var r=!1;if(Object.entries(this.newValues).forEach(function(e){var n=h(e,2),i=n[0],a=n[1];a?"#text"===i?t.elem.textContent=a:"#href"===i?Et(t.elem,a):t.elem.setAttribute(i,a):"#text"===i?t.elem.textContent="":(t.elem.setAttribute(i,""),t.elem.removeAttribute(i)),"transform"===i&&(r=!0)}),!r){var n=Ft(this.elem);if(n){var i=this.elem.getBBox(),a=["rotate(",n," ",i.x+i.width/2,",",i.y+i.height/2,")"].join("");a!==this.elem.getAttribute("transform")&&this.elem.setAttribute("transform",a)}}return e&&e.handleHistoryEvent(re.AFTER_APPLY,this),!0}},{key:"unapply",value:function(e){var t=this;e&&e.handleHistoryEvent(re.BEFORE_UNAPPLY,this);var r=!1;if(Object.entries(this.oldValues).forEach(function(e){var n=h(e,2),i=n[0],a=n[1];a?"#text"===i?t.elem.textContent=a:"#href"===i?Et(t.elem,a):t.elem.setAttribute(i,a):"#text"===i?t.elem.textContent="":t.elem.removeAttribute(i),"transform"===i&&(r=!0)}),!r){var n=Ft(this.elem);if(n){var i=this.elem.getBBox(),a=["rotate(",n," ",i.x+i.width/2,",",i.y+i.height/2,")"].join("");a!==this.elem.getAttribute("transform")&&this.elem.setAttribute("transform",a)}}return W(this.elem),e&&e.handleHistoryEvent(re.AFTER_UNAPPLY,this),!0}},{key:"elements",value:function(){return[this.elem]}}]),t}();oe.type=oe.prototype.type;var ue=function(e){function t(e){var r;return n(this,t),(r=l(this,o(t).call(this))).text=e||"Batch Command",r.stack=[],r}return s(t,ne),a(t,[{key:"type",value:function(){return"svgedit.history.BatchCommand"}},{key:"apply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_APPLY,this);for(var t=this.stack.length,r=0;r<t;++r)this.stack[r].apply(e);e&&e.handleHistoryEvent(re.AFTER_APPLY,this)}},{key:"unapply",value:function(e){e&&e.handleHistoryEvent(re.BEFORE_UNAPPLY,this);for(var t=this.stack.length-1;t>=0;t--)this.stack[t].unapply(e);e&&e.handleHistoryEvent(re.AFTER_UNAPPLY,this)}},{key:"elements",value:function(){for(var e=[],t=this.stack.length;t--;)for(var r=this.stack[t].elements(),n=r.length;n--;)e.includes(r[n])||e.push(r[n]);return e}},{key:"addSubCommand",value:function(e){this.stack.push(e)}},{key:"isEmpty",value:function(){return!this.stack.length}}]),t}();ue.type=ue.prototype.type;var le=function(){function e(t){n(this,e),this.handler_=t||null,this.undoStackPointer=0,this.undoStack=[],this.undoChangeStackPointer=-1,this.undoableChangeStack=[]}return a(e,[{key:"resetUndoStack",value:function(){this.undoStack=[],this.undoStackPointer=0}},{key:"getUndoStackSize",value:function(){return this.undoStackPointer}},{key:"getRedoStackSize",value:function(){return this.undoStack.length-this.undoStackPointer}},{key:"getNextUndoCommandText",value:function(){return this.undoStackPointer>0?this.undoStack[this.undoStackPointer-1].getText():""}},{key:"getNextRedoCommandText",value:function(){return this.undoStackPointer<this.undoStack.length?this.undoStack[this.undoStackPointer].getText():""}},{key:"undo",value:function(){this.undoStackPointer>0&&this.undoStack[--this.undoStackPointer].unapply(this.handler_)}},{key:"redo",value:function(){this.undoStackPointer<this.undoStack.length&&this.undoStack.length>0&&this.undoStack[this.undoStackPointer++].apply(this.handler_)}},{key:"addCommandToHistory",value:function(e){this.undoStackPointer<this.undoStack.length&&this.undoStack.length>0&&(this.undoStack=this.undoStack.splice(0,this.undoStackPointer)),this.undoStack.push(e),this.undoStackPointer=this.undoStack.length}},{key:"beginUndoableChange",value:function(e,t){for(var r=++this.undoChangeStackPointer,n=t.length,i=new Array(n),a=new Array(n);n--;){var s=t[n];Zt(s)||(a[n]=s,i[n]=s.getAttribute(e))}this.undoableChangeStack[r]={attrName:e,oldValues:i,elements:a}}},{key:"finishUndoableChange",value:function(){for(var e=this.undoChangeStackPointer--,t=this.undoableChangeStack[e],r=t.attrName,n=new ue("Change "+r),i=t.elements.length;i--;){var a=t.elements[i];if(!Zt(a)){var s={};s[r]=t.oldValues[i],s[r]!==a.getAttribute(r)&&n.addSubCommand(new oe(a,s,r))}}return this.undoableChangeStack[e]=null,n}}]),e}(),he=Object.freeze({HistoryEventTypes:re,MoveElementCommand:ie,InsertElementCommand:ae,RemoveElementCommand:se,ChangeElementCommand:oe,BatchCommand:ue,UndoManager:le}),ce=document.createElementNS(f.SVG,"svg"),de=function(e,t,r){return{x:r.a*e+r.c*t+r.e,y:r.b*e+r.d*t+r.f}},me=function(e){return 1===e.a&&0===e.b&&0===e.c&&1===e.d&&0===e.e&&0===e.f},fe=function(){for(var e=arguments.length,t=new Array(e),r=0;r<e;r++)t[r]=arguments[r];var n=t.reduceRight(function(e,t){return t.multiply(e)});return Math.abs(n.a)<1e-14&&(n.a=0),Math.abs(n.b)<1e-14&&(n.b=0),Math.abs(n.c)<1e-14&&(n.c=0),Math.abs(n.d)<1e-14&&(n.d=0),Math.abs(n.e)<1e-14&&(n.e=0),Math.abs(n.f)<1e-14&&(n.f=0),n},ge=function(e){if(!e)return!1;for(var t=e.numberOfItems;t--;){var r=e.getItem(t);if(1===r.type&&!me(r.matrix))return!0}return!1},pe=function(e,t,r,n,i){var a=de(e,t,i),s=de(e+r,t,i),o=de(e,t+n,i),u=de(e+r,t+n,i),l=Math.min(a.x,s.x,o.x,u.x),h=Math.max(a.x,s.x,o.x,u.x),c=Math.min(a.y,s.y,o.y,u.y);return{tl:a,tr:s,bl:o,br:u,aabox:{x:l,y:c,width:h-l,height:Math.max(a.y,s.y,o.y,u.y)-c}}},ye=function(e,t,r){if(Zt(e))return ce.createSVGTransformFromMatrix(ce.createSVGMatrix());if(t=t||0,r=r||e.numberOfItems-1,(t=parseInt(t))>(r=parseInt(r))){var n=r;r=t,t=n}for(var i=ce.createSVGMatrix(),a=t;a<=r;++a){var s=a>=0&&a<e.numberOfItems?e.getItem(a).matrix:ce.createSVGMatrix();i=fe(i,s)}return ce.createSVGTransformFromMatrix(i)},ve=function(e){var t=Q(e);return ye(t).matrix},xe=function(e,t,r,n){var i=Math.PI/4,a=r-e,s=n-t,o=Math.atan2(s,a),u=Math.sqrt(a*a+s*s),l=Math.round(o/i)*i;return{x:e+u*Math.cos(l),y:t+u*Math.sin(l),a:l}},_e=function(e,t){return t.x<e.x+e.width&&t.x+t.width>e.x&&t.y<e.y+e.height&&t.y+t.height>e.y},Se=jQuery,be={2:["x","y"],4:["x","y"],6:["x","y","x1","y1","x2","y2"],8:["x","y","x1","y1"],10:["x","y","r1","r2","angle","largeArcFlag","sweepFlag"],12:["x"],14:["y"],16:["x","y","x2","y2"],18:["x","y"]},we={},Ae=function(e){Object.assign(we,e.ui)},ke=[],Ce=!0,Ee={},Pe=null,Ge=null,Ne=function(e){Ge=e,ke=[0,"ClosePath"];Se.each(["Moveto","Lineto","CurvetoCubic","CurvetoQuadratic","Arc","LinetoHorizontal","LinetoVertical","CurvetoCubicSmooth","CurvetoQuadraticSmooth"],function(e,t){ke.push(t+"Abs"),ke.push(t+"Rel")})},Ie=function(e,t,r){var n=e.pathSegList;if(P)n.insertItemBefore(t,r);else{for(var i=n.numberOfItems,a=[],s=0;s<i;s++){var o=n.getItem(s);a.push(o)}n.clear();for(var u=0;u<i;u++)u===r&&n.appendItem(t),n.appendItem(a[u])}},Te=function(e,t){var r=e.path,n={x:t?t.x:e.item.x,y:t?t.y:e.item.y};r.matrix&&(n=de(n.x,n.y,r.matrix));var i=Ge.getCurrentZoom();return n.x*=i,n.y*=i,n},Le=function(e,t){var r={x:e.x,y:e.y};t.matrix&&(e=de(r.x,r.y,t.imatrix),r.x=e.x,r.y=e.y);var n=Ge.getCurrentZoom();return r.x/=n,r.y/=n,r},Ve=function(e,t,r){var n=Oe(),i=zt("pathpointgrip_"+e);if(!i){i=document.createElementNS(f.SVG,"circle");var a={id:"pathpointgrip_"+e,display:"none",r:4,fill:"#0FF",stroke:"#00F","stroke-width":2,cursor:"move",style:"pointer-events:all"};"pathNodeTooltip"in we&&(a["xlink:title"]=we.pathNodeTooltip),qt(i,a),i=n.appendChild(i),Se("#pathpointgrip_"+e).dblclick(function(){Pe&&Pe.setSegType()})}return t&&r&&qt(i,{cx:t,cy:r,display:"inline"}),i},Oe=function(){var e=zt("pathpointgrip_container");e||((e=zt("selectorParentGroup").appendChild(document.createElementNS(f.SVG,"g"))).id="pathpointgrip_container");return e},Me=function(e){var t=zt("ctrlpointgrip_"+e);if(t)return t;t=document.createElementNS(f.SVG,"circle");var r={id:"ctrlpointgrip_"+e,display:"none",r:4,fill:"#0FF",stroke:"#55F","stroke-width":1,cursor:"move",style:"pointer-events:all"};return"pathCtrlPtTooltip"in we&&(r["xlink:title"]=we.pathCtrlPtTooltip),qt(t,r),Oe().append(t),t},Re=function(e){var t=zt("ctrlLine_"+e);return t||(t=document.createElementNS(f.SVG,"line"),qt(t,{id:"ctrlLine_"+e,stroke:"#555","stroke-width":1,style:"pointer-events:none"}),Oe().append(t),t)},Be=function(e){var t=e.item,r=e.index;if(!("x1"in t&&"x2"in t))return null;var n={};Oe();for(var i=[Pe.segs[r-1].item,t],a=1;a<3;a++){var s=r+"c"+a,o=n["c"+a+"_line"]=Re(s),u=Te(e,{x:t["x"+a],y:t["y"+a]}),l=Te(e,{x:i[a-1].x,y:i[a-1].y});qt(o,{x1:u.x,y1:u.y,x2:l.x,y2:l.y,display:"inline"}),n["c"+a+"_line"]=o;var h=n["c"+a]=Me(s);qt(h,{cx:u.x,cy:u.y,display:"inline"}),n["c"+a]=h}return n},Ue=function(e,t,r,n){var i=n||Pe.elem,a=i["createSVGPathSeg"+ke[e]].apply(i,c(r));if(E)i.pathSegList.replaceItem(a,t);else{for(var s=i.pathSegList,o=s.numberOfItems,u=[],l=0;l<o;l++){var h=s.getItem(l);u.push(h)}s.clear();for(var d=0;d<o;d++)d===t?s.appendItem(a):s.appendItem(u[d])}},He=function(e,t){var r,n,i=e.index,a=zt("segline_"+i);if(!a){var s=Oe();a=document.createElementNS(f.SVG,"path"),qt(a,{id:"segline_"+i,display:"none",fill:"none",stroke:"#0FF","stroke-width":2,style:"pointer-events:none",d:"M0,0 0,0"}),s.append(a)}if(t){var o=e.prev;if(!o)return a.setAttribute("display","none"),a;var u=Te(o);Ue(2,0,[u.x,u.y],a);for(var l=(r=e.type,n=e.item,be[r].map(function(e){return n[e]})),h=0;h<l.length;h+=2){var c=Te(e,{x:l[h],y:l[h+1]});l[h]=c.x,l[h+1]=c.y}Ue(e.type,1,l,a)}return a},je=function(e,t,r){var n=e.x-r.x,i=e.y-r.y,a=t.x-r.x,s=t.y-r.y;if(!(0===n&&0===i||0===a&&0===s)){var o=Math.sqrt(n*n+i*i),u=Math.sqrt(a*a+s*s),l=Ge.getSVGRoot().createSVGPoint(),h=Ge.getSVGRoot().createSVGPoint(),c=Math.atan2(i,n),d=Math.atan2(s,a);c<0&&(c+=2*Math.PI),d<0&&(d+=2*Math.PI);var m,f,g=Math.abs(c-d),p=Math.abs(Math.PI-g)/2;return c-d>0?(m=g<Math.PI?c+p:c-p,f=g<Math.PI?d-p:d+p):(m=g<Math.PI?c-p:c+p,f=g<Math.PI?d+p:d-p),l.x=o*Math.cos(m)+r.x,l.y=o*Math.sin(m)+r.y,h.x=u*Math.cos(f)+r.x,h.y=u*Math.sin(f)+r.y,[l,h]}},Fe=function(){function e(t,r){n(this,e),this.selected=!1,this.index=t,this.item=r,this.type=r.pathSegType,this.ctrlpts=[],this.ptgrip=null,this.segsel=null}return a(e,[{key:"showCtrlPts",value:function(e){for(var t in this.ctrlpts)({}).hasOwnProperty.call(this.ctrlpts,t)&&this.ctrlpts[t].setAttribute("display",e?"inline":"none")}},{key:"selectCtrls",value:function(e){Se("#ctrlpointgrip_"+this.index+"c1, #ctrlpointgrip_"+this.index+"c2").attr("fill",e?"#0FF":"#EEE")}},{key:"show",value:function(e){this.ptgrip&&(this.ptgrip.setAttribute("display",e?"inline":"none"),this.segsel.setAttribute("display",e?"inline":"none"),this.showCtrlPts(e))}},{key:"select",value:function(e){this.ptgrip&&(this.ptgrip.setAttribute("stroke",e?"#0FF":"#00F"),this.segsel.setAttribute("display",e?"inline":"none"),this.ctrlpts&&this.selectCtrls(e),this.selected=e)}},{key:"addGrip",value:function(){this.ptgrip=function(e,t){var r=e.index,n=Ve(r);if(t){var i=Te(e);qt(n,{cx:i.x,cy:i.y,display:"inline"})}return n}(this,!0),this.ctrlpts=Be(this),this.segsel=He(this,!0)}},{key:"update",value:function(e){if(this.ptgrip){var t=Te(this);qt(this.ptgrip,{cx:t.x,cy:t.y}),He(this,!0),this.ctrlpts&&(e&&(this.item=Pe.elem.pathSegList.getItem(this.index),this.type=this.item.pathSegType),Be(this))}}},{key:"move",value:function(e,t){var r=this.item,n=this.ctrlpts?[r.x+=e,r.y+=t,r.x1,r.y1,r.x2+=e,r.y2+=t]:[r.x+=e,r.y+=t];if(Ue(this.type,this.index,n),this.next&&this.next.ctrlpts){var i=this.next.item,a=[i.x,i.y,i.x1+=e,i.y1+=t,i.x2,i.y2];Ue(this.next.type,this.next.index,a)}if(this.mate){var s=this.mate.item,o=[s.x+=e,s.y+=t];Ue(this.mate.type,this.mate.index,o)}this.update(!0),this.next&&this.next.update(!0)}},{key:"setLinked",value:function(e){var t,r,n;if(2===e){if(r=1,!(t=this.next))return;n=this.item}else{if(r=2,!(t=this.prev))return;n=t.item}var i=t.item;i["x"+r]=n.x+(n.x-this.item["x"+e]),i["y"+r]=n.y+(n.y-this.item["y"+e]);var a=[i.x,i.y,i.x1,i.y1,i.x2,i.y2];Ue(t.type,t.index,a),t.update(!0)}},{key:"moveCtrl",value:function(e,t,r){var n=this.item;n["x"+e]+=t,n["y"+e]+=r;var i=[n.x,n.y,n.x1,n.y1,n.x2,n.y2];Ue(this.type,this.index,i),this.update(!0)}},{key:"setType",value:function(e,t){Ue(e,this.index,t),this.type=e,this.item=Pe.elem.pathSegList.getItem(this.index),this.showCtrlPts(6===e),this.ctrlpts=Be(this),this.update(!0)}}]),e}(),De=function(){function e(t){if(n(this,e),!t||"path"!==t.tagName)throw new Error("svgedit.path.Path constructed without a <path> element");this.elem=t,this.segs=[],this.selected_pts=[],Pe=this,this.init()}return a(e,[{key:"init",value:function(){Se(Oe()).find("*").each(function(){Se(this).attr("display","none")});var e=this.elem.pathSegList,t=e.numberOfItems;this.segs=[],this.selected_pts=[],this.first_seg=null;for(var r=0;r<t;r++){var n=e.getItem(r),i=new Fe(r,n);i.path=this,this.segs.push(i)}for(var a=this.segs,s=null,o=0;o<t;o++){var u=a[o],l=o+1>=t?null:a[o+1],h=o-1<0?null:a[o-1];if(2===u.type){if(h&&1!==h.type){var c=a[s];c.next=a[s+1],c.next.prev=c,c.addGrip()}s=o}else if(l&&1===l.type)u.next=a[s+1],u.next.prev=u,u.mate=a[s],u.addGrip(),Zt(this.first_seg)&&(this.first_seg=u);else if(l)1!==u.type&&(u.addGrip(),l&&2!==l.type&&(u.next=l,u.next.prev=u));else if(1!==u.type){var d=a[s];d.next=a[s+1],d.next.prev=d,d.addGrip(),u.addGrip(),this.first_seg||(this.first_seg=a[s])}}return this}},{key:"eachSeg",value:function(e){for(var t=this.segs.length,r=0;r<t;r++){if(!1===e.call(this.segs[r],r))break}}},{key:"addSeg",value:function(e){var t=this.segs[e];if(t.prev){var r,n,i,a=t.prev;switch(t.item.pathSegType){case 4:n=(t.item.x+a.item.x)/2,i=(t.item.y+a.item.y)/2,r=this.elem.createSVGPathSegLinetoAbs(n,i);break;case 6:var s=(a.item.x+t.item.x1)/2,o=(t.item.x1+t.item.x2)/2,u=(t.item.x2+t.item.x)/2,l=(s+o)/2,h=(o+u)/2;n=(l+h)/2;var c=(a.item.y+t.item.y1)/2,d=(t.item.y1+t.item.y2)/2,m=(t.item.y2+t.item.y)/2,f=(c+d)/2,g=(d+m)/2;i=(f+g)/2,r=this.elem.createSVGPathSegCurvetoCubicAbs(n,i,s,c,l,f);var p=[t.item.x,t.item.y,h,g,u,m];Ue(t.type,e,p)}Ie(this.elem,r,e)}}},{key:"deleteSeg",value:function(e){var t=this.segs[e],r=this.elem.pathSegList;t.show(!1);var n=t.next;if(t.mate){var i=[n.item.x,n.item.y];Ue(2,n.index,i),Ue(4,t.index,i),r.removeItem(t.mate.index)}else if(t.prev)r.removeItem(e);else{var a=[n.item.x,n.item.y];Ue(2,t.next.index,a),r.removeItem(e)}}},{key:"removePtFromSelection",value:function(e){var t=this.selected_pts.indexOf(e);-1!==t&&(this.segs[e].select(!1),this.selected_pts.splice(t,1))}},{key:"clearSelection",value:function(){this.eachSeg(function(){this.select(!1)}),this.selected_pts=[]}},{key:"storeD",value:function(){this.last_d=this.elem.getAttribute("d")}},{key:"show",value:function(e){return this.eachSeg(function(){this.show(e)}),e&&this.selectPt(this.first_seg.index),this}},{key:"movePts",value:function(e,t){for(var r=this.selected_pts.length;r--;){this.segs[this.selected_pts[r]].move(e,t)}}},{key:"moveCtrl",value:function(e,t){var r=this.segs[this.selected_pts[0]];r.moveCtrl(this.dragctrl,e,t),Ce&&r.setLinked(this.dragctrl)}},{key:"setSegType",value:function(e){this.storeD();for(var t,r=this.selected_pts.length;r--;){var n=this.selected_pts[r],i=this.segs[n],a=i.prev;if(a){if(!e)t="Toggle Path Segment Type",e=6===i.type?4:6;e=Number(e);var s=i.item.x,o=i.item.y,u=a.item.x,l=a.item.y,h=void 0;switch(e){case 6:if(i.olditem){var c=i.olditem;h=[s,o,c.x1,c.y1,c.x2,c.y2]}else{var d=s-u,m=o-l;h=[s,o,u+d/3,l+m/3,s-d/3,o-m/3]}break;case 4:h=[s,o],i.olditem=i.item}i.setType(e,h)}}Pe.endChanges(t)}},{key:"selectPt",value:function(e,t){this.clearSelection(),Zt(e)&&this.eachSeg(function(t){this.prev&&(e=t)}),this.addPtsToSelection(e),t&&(this.dragctrl=t,Ce&&this.segs[e].setLinked(t))}},{key:"update",value:function(){var e=this.elem;return Ft(e)?(this.matrix=ve(e),this.imatrix=this.matrix.inverse()):(this.matrix=null,this.imatrix=null),this.eachSeg(function(t){this.item=e.pathSegList.getItem(t),this.update()}),this}},{key:"endChanges",value:function(e){O()&&Ge.resetD(this.elem);var t=new oe(this.elem,{d:this.last_d},e);Ge.endChanges({cmd:t,elem:this.elem})}},{key:"addPtsToSelection",value:function(t){Array.isArray(t)||(t=[t]);for(var r=0;r<t.length;r++){var n=t[r];this.segs[n].ptgrip&&!this.selected_pts.includes(n)&&n>=0&&this.selected_pts.push(n)}this.selected_pts.sort();var i=this.selected_pts.length,a=[];for(a.length=i;i--;){var s=this.selected_pts[i],o=this.segs[s];o.select(!0),a[i]=o.ptgrip}var u=e.subpathIsClosed(this.selected_pts[0]);Ge.addPtsToSelection({grips:a,closedSubpath:u})}}]),e}();De.subpathIsClosed=function(e){var t=!1;return Pe.eachSeg(function(r){return r<=e||2!==this.type&&(1!==this.type||(t=!0,!1))}),t};var ze,qe,We,Qe,Ye,Ze=function(e){var t=Ee[e.id];return t||(t=Ee[e.id]=new De(e)),t},Xe=function(e){e in Ee&&delete Ee[e]},Ke=function(e,t){var r=e-We,n=t-Qe,i=Math.sqrt(r*r+n*n),a=Math.atan2(n,r)+Ye;return r=i*Math.cos(a)+We,n=i*Math.sin(a)+Qe,r-=ze,n-=qe,i=Math.sqrt(r*r+n*n),a=Math.atan2(n,r)-Ye,{x:i*Math.cos(a)+ze,y:i*Math.sin(a)+qe}},$e=function(){var e=Pe.elem;if(Ye=Ft(e,!0)){var t=Pe.oldbbox;We=t.x+t.width/2,Qe=t.y+t.height/2;var r=It(e);ze=r.x+r.width/2,qe=r.y+r.height/2;var n=ze-We,i=qe-Qe,a=Math.sqrt(n*n+i*i),s=Math.atan2(i,n)+Ye;ze=a*Math.cos(s)+We,qe=a*Math.sin(s)+Qe;for(var o=e.pathSegList,u=o.numberOfItems;u;){u-=1;var l=o.getItem(u),h=l.pathSegType;if(1!==h){var c=Ke(l.x,l.y),d=[c.x,c.y];if(!Zt(l.x1)&&!Zt(l.x2)){var m=Ke(l.x1,l.y1),f=Ke(l.x2,l.y2);d.splice(d.length,0,m.x,m.y,f.x,f.y)}Ue(h,u,d)}}It(e);var g=Ge.getSVGRoot().createSVGTransform(),p=Q(e);g.setRotate(180*Ye/Math.PI,ze,qe),p.replaceItem(g,0)}},Je=[0,"z","M","m","L","l","C","c","Q","q","A","a","H","h","V","v","S","s","T","t"],et=function(e,t){for(var r=e.pathSegList,n=r.numberOfItems,i=0,a=0,s="",o=null,u=0;u<n;++u){var l=r.getItem(u),h=l.x||0,c=l.y||0,d=l.x1||0,m=l.y1||0,f=l.x2||0,g=l.y2||0,p=l.pathSegType,y=Je[p]["to"+(t?"Lower":"Upper")+"Case"]();switch(p){case 1:s+="z",o&&!t&&(i=o[0],a=o[1]);break;case 12:h-=i;case 13:t?(i+=h,y="l"):(i=h+=i,y="L"),s+=tt(y,[[h,a]]);break;case 14:c-=a;case 15:t?(a+=c,y="l"):(a=c+=a,y="L"),s+=tt(y,[[i,c]]);break;case 2:case 4:case 18:h-=i,c-=a;case 5:case 3:case 19:t?(i+=h,a+=c):(i=h+=i,a=c+=a),2!==p&&3!==p||(o=[i,a]),s+=tt(y,[[h,c]]);break;case 6:h-=i,d-=i,f-=i,c-=a,m-=a,g-=a;case 7:t?(i+=h,a+=c):(d+=i,f+=i,m+=a,g+=a,i=h+=i,a=c+=a),s+=tt(y,[[d,m],[f,g],[h,c]]);break;case 8:h-=i,d-=i,c-=a,m-=a;case 9:t?(i+=h,a+=c):(d+=i,m+=a,i=h+=i,a=c+=a),s+=tt(y,[[d,m],[h,c]]);break;case 10:h-=i,c-=a;case 11:t?(i+=h,a+=c):(i=h+=i,a=c+=a),s+=tt(y,[[l.r1,l.r2]],[l.angle,l.largeArcFlag?1:0,l.sweepFlag?1:0],[h,c]);break;case 16:h-=i,f-=i,c-=a,g-=a;case 17:t?(i+=h,a+=c):(f+=i,g+=a,i=h+=i,a=c+=a),s+=tt(y,[[f,g],[h,c]])}}return s};function tt(e,t,r,n){Se.each(t,function(e,r){t[e]=$(r)});var i=e+t.join(" ");return r&&(i+=" "+r.join(" ")),n&&(i+=" "+$(n)),i}var rt,nt,it,at,st,ot=(it=!1,at=null,st=!1,{mouseDown:function(e,t,r,n){var i;if("path"!==Ge.getCurrentMode()){if(Pe){var a;if(Pe.storeD(),"pathpointgrip_"===(i=e.target.id).substr(0,14)){a=Pe.cur_pt=parseInt(i.substr(14)),Pe.dragging=[r,n];var s=Pe.segs[a];e.shiftKey?s.selected?Pe.removePtFromSelection(a):Pe.addPtsToSelection(a):((Pe.selected_pts.length<=1||!s.selected)&&Pe.clearSelection(),Pe.addPtsToSelection(a))}else if(i.startsWith("ctrlpointgrip_")){Pe.dragging=[r,n];var o=i.split("_")[1].split("c");a=Number(o[0]);var u=Number(o[1]);Pe.selectPt(a,u)}if(!Pe.dragging){var l=Ge.getRubberBox();Zt(l)&&(l=Ge.setRubberBox(Ge.selectorManager.getRubberBandBox()));var h=Ge.getCurrentZoom();qt(l,{x:r*h,y:n*h,width:0,height:0,display:"inline"},100)}}}else{var c=r,d=n,m=Ge.getCurrentZoom(),g=c/m,p=d/m,y=zt("path_stretch_line");rt=[g,p],Ge.getGridSnapping()&&(g=Qt(g),p=Qt(p),c=Qt(c),d=Qt(d)),y||(y=document.createElementNS(f.SVG,"path"),qt(y,{id:"path_stretch_line",stroke:"#22C","stroke-width":"0.5",fill:"none"}),y=zt("selectorParentGroup").appendChild(y)),y.setAttribute("display","inline");var v,x=Ge.getDrawnPath();if(x){for(var _=x.pathSegList,S=_.numberOfItems,b=6/m,w=!1;S;){S--;var A=_.getItem(S),k=A.x,C=A.y;if(g>=k-b&&g<=k+b&&p>=C-b&&p<=C+b){w=!0;break}}i=Ge.getId(),Xe(i);var E,P,G=zt(i),N=_.numberOfItems;if(w){if(S<=1&&N>=2){var I=_.getItem(0).x,T=_.getItem(0).y;E=4===(P=y.pathSegList.getItem(1)).pathSegType?x.createSVGPathSegLinetoAbs(I,T):x.createSVGPathSegCurvetoCubicAbs(I,T,P.x1/m,P.y1/m,I,T);var L=x.createSVGPathSegClosePath();_.appendItem(E),_.appendItem(L)}else if(N<3)return!1;if(Se(y).remove(),Ge.setDrawnPath(null),Ge.setStarted(!1),it){Pe.matrix&&Ge.remapElement(G,{},Pe.matrix.inverse());var V=G.getAttribute("d"),O=Se(Pe.elem).attr("d");return Se(Pe.elem).attr("d",O+V),Se(G).remove(),Pe.matrix&&$e(),Ne(),ot.toEditMode(Pe.elem),Pe.selectPt(),!1}}else{if(!Se.contains(Ge.getContainer(),Ge.getMouseTarget(e)))return!1;var M=x.pathSegList.numberOfItems,R=x.pathSegList.getItem(M-1),B=R.x,U=R.y;if(e.shiftKey){var H=xe(B,U,g,p);g=H.x,p=H.y}E=4===(P=y.pathSegList.getItem(1)).pathSegType?x.createSVGPathSegLinetoAbs(Ge.round(g),Ge.round(p)):x.createSVGPathSegCurvetoCubicAbs(Ge.round(g),Ge.round(p),P.x1/m,P.y1/m,P.x2/m,P.y2/m),x.pathSegList.appendItem(E),g*=m,p*=m,y.setAttribute("d",["M",g,p,g,p].join(" ")),v=M,it&&(v+=Pe.segs.length),Ve(v,g,p)}}else{var j="M"+g+","+p+" ";Ge.setDrawnPath(Ge.addSVGElementFromJson({element:"path",curStyles:!0,attr:{d:j,id:Ge.getNextId(),opacity:Ge.getOpacity()/2}})),y.setAttribute("d",["M",c,d,c,d].join(" ")),v=it?Pe.segs.length:0,Ve(v,c,d)}}},mouseMove:function(e,t){var r=Ge.getCurrentZoom();st=!0;var n=Ge.getDrawnPath();if("path"!==Ge.getCurrentMode())if(Pe.dragging){var i=Le({x:Pe.dragging[0],y:Pe.dragging[1]},Pe),a=Le({x:e,y:t},Pe),s=a.x-i.x,o=a.y-i.y;Pe.dragging=[e,t],Pe.dragctrl?Pe.moveCtrl(s,o):Pe.movePts(s,o)}else Pe.selected_pts=[],Pe.eachSeg(function(e){if(this.next||this.prev){var t=Ge.getRubberBox().getBBox(),r=Te(this),n={x:r.x,y:r.y,width:0,height:0},i=_e(t,n);this.select(i),i&&Pe.selected_pts.push(this.index)}});else{if(!n)return;var u=n.pathSegList,l=u.numberOfItems-1;if(rt){var h=Me("1c1"),c=Me("0c2");h.setAttribute("cx",e),h.setAttribute("cy",t),h.setAttribute("display","inline");var d=rt[0],m=rt[1],f=d+(d-e/r),g=m+(m-t/r);c.setAttribute("cx",f*r),c.setAttribute("cy",g*r),c.setAttribute("display","inline");var p=Re(1);if(qt(p,{x1:e,y1:t,x2:f*r,y2:g*r,display:"inline"}),0===l)nt=[e,t];else{var y=u.getItem(l-1),v=y.x,x=y.y;6===y.pathSegType?(v+=v-y.x2,x+=x-y.y2):nt&&(v=nt[0]/r,x=nt[1]/r),Ue(6,l,[d,m,v,x,f,g],n)}}else{var _=zt("path_stretch_line");if(_){var S=u.getItem(l);if(6===S.pathSegType){var b=S.x+(S.x-S.x2),w=S.y+(S.y-S.y2);Ue(6,1,[e,t,b*r,w*r,e,t],_)}else nt?Ue(6,1,[e,t,nt[0],nt[1],e,t],_):Ue(4,1,[e,t],_)}}}},mouseUp:function(e,t,r,n){var i=Ge.getDrawnPath();if("path"===Ge.getCurrentMode())return rt=null,i||(t=zt(Ge.getId()),Ge.setStarted(!1),nt=null),{keep:!0,element:t};var a=Ge.getRubberBox();if(Pe.dragging){var s=Pe.cur_pt;Pe.dragging=!1,Pe.dragctrl=!1,Pe.update(),st&&Pe.endChanges("Move path point(s)"),e.shiftKey||st||Pe.selectPt(s)}else a&&"none"!==a.getAttribute("display")?(a.setAttribute("display","none"),a.getAttribute("width")<=2&&a.getAttribute("height")<=2&&ot.toSelectMode(e.target)):ot.toSelectMode(e.target);st=!1},toEditMode:function(e){Pe=Ze(e),Ge.setCurrentMode("pathedit"),Ge.clearSelection(),Pe.show(!0).update(),Pe.oldbbox=It(Pe.elem),it=!1},toSelectMode:function(e){var t=e===Pe.elem;Ge.setCurrentMode("select"),Pe.show(!1),at=!1,Ge.clearSelection(),Pe.matrix&&$e(),t&&(Ge.call("selected",[e]),Ge.addToSelection([e],!0))},addSubPath:function(e){e?(Ge.setCurrentMode("path"),it=!0):(ot.clear(!0),ot.toEditMode(Pe.elem))},select:function(e){at===e?(ot.toEditMode(e),Ge.setCurrentMode("pathedit")):at=e},reorient:function(){var e=Ge.getSelectedElements()[0];if(e&&0!==Ft(e)){var t=new ue("Reorient path"),r={d:e.getAttribute("d"),transform:e.getAttribute("transform")};t.addSubCommand(new oe(e,r)),Ge.clearSelection(),this.resetOrientation(e),Ge.addCommandToHistory(t),Ze(e).show(!1).matrix=null,this.clear(),Ge.addToSelection([e],!0),Ge.call("changed",Ge.getSelectedElements())}},clear:function(e){var t=Ge.getDrawnPath();if(at=null,t){var r=zt(Ge.getId());Se(zt("path_stretch_line")).remove(),Se(r).remove(),Se(zt("pathpointgrip_container")).find("*").attr("display","none"),nt=null,Ge.setDrawnPath(null),Ge.setStarted(!1)}else"pathedit"===Ge.getCurrentMode()&&this.toSelectMode();Pe&&Pe.init().show(!1)},resetOrientation:function(e){if(Zt(e)||"path"!==e.nodeName)return!1;var t=Q(e),r=ye(t).matrix;t.clear(),e.removeAttribute("transform");for(var n=e.pathSegList,i=n.numberOfItems,a=function(t){var i=n.getItem(t),a=i.pathSegType;if(1===a)return"continue";var s=[];Se.each(["",1,2],function(e,t){var n=i["x"+t],a=i["y"+t];if(void 0!==n&&void 0!==a){var o=de(n,a,r);s.splice(s.length,0,o.x,o.y)}}),Ue(a,t,s,e)},s=0;s<i;++s)a(s);!function(e,t){for(var r=It(e),n=0;n<2;n++){var i=0===n?"fill":"stroke",a=e.getAttribute(i);if(a&&a.startsWith("url(")){var s=Dt(a);if("linearGradient"===s.tagName){var o=s.getAttribute("x1")||0,u=s.getAttribute("y1")||0,l=s.getAttribute("x2")||1,h=s.getAttribute("y2")||0;o=r.width*o+r.x,u=r.height*u+r.y,l=r.width*l+r.x,h=r.height*h+r.y;var c=de(o,u,t),d=de(l,h,t),m={};m.x1=(c.x-r.x)/r.width,m.y1=(c.y-r.y)/r.height,m.x2=(d.x-r.x)/r.width,m.y2=(d.y-r.y)/r.height;var f=s.cloneNode(!0);Se(f).attr(m),f.id=Ge.getNextId(),Pt().append(f),e.setAttribute(i,"url(#"+f.id+")")}}}}(e,r)},zoomChange:function(){"pathedit"===Ge.getCurrentMode()&&Pe.update()},getNodePoint:function(){var e=Pe.selected_pts.length?Pe.selected_pts[0]:1,t=Pe.segs[e];return{x:t.item.x,y:t.item.y,type:t.type}},linkControlPoints:function(e){Ce=e},clonePathNode:function(){Pe.storeD();for(var e=Pe.selected_pts,t=e.length,r=[];t--;){var n=e[t];Pe.addSeg(n),r.push(n+t),r.push(n+t+1)}Pe.init().addPtsToSelection(r),Pe.endChanges("Clone path node(s)")},opencloseSubPath:function(){var e=Pe.selected_pts;if(1===e.length){var t,r,n=Pe.elem,i=n.pathSegList,a=e[0],s=null,o=null;if(Pe.eachSeg(function(e){return 2===this.type&&e<=a&&(o=this.item),e<=a||(2===this.type?(s=e,!1):1!==this.type||(s=!1,!1))}),Zt(s)&&(s=Pe.segs.length-1),!1!==s){var u=n.createSVGPathSegLinetoAbs(o.x,o.y),l=n.createSVGPathSegClosePath();return s===Pe.segs.length-1?(i.appendItem(u),i.appendItem(l)):(Ie(n,l,s),Ie(n,u,s)),void Pe.init().selectPt(s+1)}if(Pe.segs[a].mate)return i.removeItem(a),i.removeItem(a),void Pe.init().selectPt(a-1);for(var h=0;h<i.numberOfItems;h++){var c=i.getItem(h);if(2===c.pathSegType)t=h;else if(h===a)i.removeItem(t);else if(1===c.pathSegType&&a<h){r=h-1,i.removeItem(h);break}}for(var d=a-t-1;d--;)Ie(n,i.getItem(t),r);var m=i.getItem(t);Ue(2,t,[m.x,m.y]),Pe.init().selectPt(0)}},deletePathNode:function(){if(ot.canDeleteNodes){Pe.storeD();for(var e=Pe.selected_pts,t=e.length;t--;){var r=e[t];Pe.deleteSeg(r)}if(function e(){var t=Pe.elem.pathSegList,r=t.numberOfItems,n=function(e,r){for(;r--;)t.removeItem(e)};if(r<=1)return!0;for(;r--;){var i=t.getItem(r);if(1===i.pathSegType){var a=t.getItem(r-1),s=t.getItem(r-2);if(2===a.pathSegType){n(r-1,2),e();break}if(2===s.pathSegType){n(r-2,3),e();break}}else if(2===i.pathSegType&&r>0){var o=t.getItem(r-1).pathSegType;if(2===o){n(r-1,1),e();break}if(1===o&&t.numberOfItems-1===r){n(r,1),e();break}}}return!1}(),Pe.elem.pathSegList.numberOfItems<=1)return ot.toSelectMode(Pe.elem),void Ge.canvas.deleteSelectedElements();if(Pe.init(),Pe.clearSelection(),window.opera){var n=Se(Pe.elem);n.attr("d",n.attr("d"))}Pe.endChanges("Delete path node(s)")}},smoothPolylineIntoPath:function(e){var t,r=e.points,n=r.numberOfItems;if(n>=4){var i=r.getItem(0),a=null,s=[];for(s.push(["M",i.x,",",i.y," C"].join("")),t=1;t<=n-4;t+=3){var o=r.getItem(t),u=r.getItem(t+1),l=r.getItem(t+2);if(a){var h=je(a,o,i);if(h&&2===h.length){var c=s[s.length-1].split(",");c[2]=h[0].x,c[3]=h[0].y,s[s.length-1]=c.join(","),o=h[1]}}s.push([o.x,o.y,u.x,u.y,l.x,l.y].join(",")),i=l,a=u}for(s.push("L");t<n;){var d=r.getItem(t);s.push([d.x,d.y].join(",")),t++}s=s.join(" "),e=Ge.addSVGElementFromJson({element:"path",curStyles:!0,attr:{id:Ge.getId(),d:s,fill:"none"}})}return e},setSegType:function(e){Pe.setSegType(e)},moveNode:function(e,t){var r=Pe.selected_pts;if(r.length){Pe.storeD();var n=Pe.segs[r[0]],i={x:0,y:0};i[e]=t-n.item[e],n.move(i.x,i.y),Pe.endChanges("Move path point")}},fixEnd:function(e){for(var t,r=e.pathSegList,n=r.numberOfItems,i=0;i<n;++i){var a=r.getItem(i);if(2===a.pathSegType&&(t=a),1===a.pathSegType){var s=r.getItem(i-1);if(s.x!==t.x||s.y!==t.y){var o=e.createSVGPathSegLinetoAbs(t.x,t.y);Ie(e,o,i),ot.fixEnd(e);break}}}O()&&Ge.resetD(e)},convertPath:et}),ut=d(jQuery),lt="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",ht="a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use".split(","),ct=null,dt=null,mt=null,ft=null,gt=function(e){return e.replace(/(<!DOCTYPE\s+\w*\s*\[).*(\?\]>)/,"$1$2")},pt=function(e){return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;")};function yt(e){if(e=_t(e),window.btoa)return window.btoa(e);var t=new Array(4*Math.floor((e.length+2)/3)),r=0,n=0;do{var i=e.charCodeAt(r++),a=e.charCodeAt(r++),s=e.charCodeAt(r++),o=i>>2,u=(3&i)<<4|a>>4,l=(15&a)<<2|s>>6,h=63&s;isNaN(a)?(l=64,h=64):isNaN(s)&&(h=64),t[n++]=lt.charAt(o),t[n++]=lt.charAt(u),t[n++]=lt.charAt(l),t[n++]=lt.charAt(h)}while(r<e.length);return t.join("")}function vt(e){if(window.atob)return xt(window.atob(e));e=e.replace(/[^A-Za-z0-9+\/=]/g,"");var t="",r=0;do{var n=lt.indexOf(e.charAt(r++)),i=lt.indexOf(e.charAt(r++)),a=lt.indexOf(e.charAt(r++)),s=lt.indexOf(e.charAt(r++)),o=n<<2|i>>4,u=(15&i)<<4|a>>2,l=(3&a)<<6|s;t+=String.fromCharCode(o),64!==a&&(t+=String.fromCharCode(u)),64!==s&&(t+=String.fromCharCode(l))}while(r<e.length);return xt(t)}function xt(e){return decodeURIComponent(escape(e))}var _t=function(e){return unescape(encodeURIComponent(e))},St=function(e){if("undefined"==typeof Uint8Array||"undefined"==typeof Blob||"undefined"==typeof URL||!URL.createObjectURL)return"";for(var t=e.split(","),r=t[0].match(/:(.*?);/)[1],n=atob(t[1]),i=n.length,a=new Uint8Array(i);i--;)a[i]=n.charCodeAt(i);var s=new Blob([a],{type:r});return URL.createObjectURL(s)},bt=function(e){return e&&"undefined"!=typeof URL&&URL.createObjectURL?URL.createObjectURL(e):""},wt=(function(){if("undefined"==typeof Blob)return"";var e=new Blob(["<html><head><title>SVG-edit</title></head><body>&nbsp;</body></html>"],{type:"text/html"});bt(e)}(),function(e){var t,r;e.includes("<svg:svg")&&(e=e.replace(/<(\/?)svg:/g,"<$1").replace("xmlns:svg","xmlns"));try{(r=window.DOMParser?new DOMParser:new window.ActiveXObject("Microsoft.XMLDOM")).async=!1}catch(e){throw new Error("XML Parser could not be instantiated")}try{t=r.loadXML?!!r.loadXML(e)&&r:r.parseFromString(e,"text/xml")}catch(e){throw new Error("Error parsing XML string")}return t}),At=function e(t,r){if(t&&1===t.nodeType){r(t);for(var n=t.childNodes.length;n--;)e(t.childNodes.item(n),r)}},kt=function(e){if(e){if(e.startsWith('url("'))return e.substring(5,e.indexOf('"',6));if(e.startsWith("url('"))return e.substring(5,e.indexOf("'",6));if(e.startsWith("url("))return e.substring(4,e.indexOf(")"))}return null},Ct=function(e){return e.getAttributeNS(f.XLINK,"href")},Et=function(e,t){e.setAttributeNS(f.XLINK,"xlink:href",t)},Pt=function(){var e=ct.getSVGContent(),t=e.getElementsByTagNameNS(f.SVG,"defs");return t.length>0?t=t[0]:(t=e.ownerDocument.createElementNS(f.SVG,"defs"),e.firstChild?e.insertBefore(t,e.firstChild.nextSibling):e.append(t)),t},Gt=function(e){for(var t=e.pathSegList,r=t.numberOfItems,n=[[],[]],i=t.getItem(0),a=[i.x,i.y],s=function(e,t,r,n){return function(i){return 1-Math.pow(i,3)*a[e]+3-Math.pow(i,2)*i*t[e]+3*(1-i)*Math.pow(i,2)*r[e]+Math.pow(i,3)*n[e]}},o=0;o<r;o++){var u=t.getItem(o);if(void 0!==u.x)if(n[0].push(a[0]),n[1].push(a[1]),u.x1){for(var l=[u.x1,u.y1],h=[u.x2,u.y2],c=[u.x,u.y],d=0;d<2;d++){var m=s(d,l,h,c),f=6*a[d]-12*l[d]+6*h[d],g=-3*a[d]+9*l[d]-9*h[d]+3*c[d],p=3*l[d]-3*a[d];if(0!==g){var y=Math.pow(f,2)-4*p*g;if(!(y<0)){var v=(-f+Math.sqrt(y))/(2*g);v>0&&v<1&&n[d].push(m(v));var x=(-f-Math.sqrt(y))/(2*g);x>0&&x<1&&n[d].push(m(x))}}else{if(0===f)continue;var _=-p/f;_>0&&_<1&&n[d].push(m(_))}}a=c}else n[0].push(u.x),n[1].push(u.y)}var S=Math.min.apply(null,n[0]),b=Math.max.apply(null,n[0])-S,w=Math.min.apply(null,n[1]);return{x:S,y:w,width:b,height:Math.max.apply(null,n[1])-w}};function Nt(e){if(U())try{return e.getBBox()}catch(e){}var t,r,n=ut.data(e,"ref"),i=null;n?(r=ut(n).children().clone().attr("visibility","hidden"),ut(ft).append(r),i=r.filter("line, path")):i=ut(e).find("line, path");var a=!1;if(i.length)if(i.each(function(){var e=this.getBBox();e.width&&e.height||(a=!0)}),a){var s=n?r:ut(e).children();t=Bt(s)}else t=e.getBBox();else t=e.getBBox();return n&&r.remove(),t}var It=function(e){var t=e||ct.geSelectedElements()[0];if(1!==e.nodeType)return null;var r,n=t.nodeName,i=null;switch(n){case"text":""===t.textContent?(t.textContent="a",i=t.getBBox(),t.textContent=""):t.getBBox&&(i=t.getBBox());break;case"path":N?t.getBBox&&(i=t.getBBox()):i=Gt(t);break;case"g":case"a":i=Nt(t);break;default:if("use"===n&&(i=Nt(t)),"use"===n||"foreignObject"===n&&O()){if(i||(i=t.getBBox()),!O()){var a={};a.width=i.width,a.height=i.height,a.x=i.x+parseFloat(t.getAttribute("x")||0),a.y=i.y+parseFloat(t.getAttribute("y")||0),i=a}}else if(ht.includes(n))if(t)try{i=t.getBBox()}catch(e){var s=t.getExtentOfChar(0),o=t.getComputedTextLength();i={x:s.x,y:s.y,width:o,height:s.height}}else{var u=ut(t).closest("foreignObject");u.length&&u[0].getBBox&&(i=u[0].getBBox())}}return i&&(i={x:(r=i).x,y:r.y,width:r.width,height:r.height}),i},Tt=function(e){var t="";return ut.each(e,function(e,r){var n=h(r,2),i=n[0],a=n[1];t+=i;for(var s=0;s<a.length;s+=2)t+=a[s]+","+a[s+1]+" "}),t},Lt=function(e){var t,r,n,i,a=1.81;switch(e.tagName){case"ellipse":case"circle":var s=r=ut(e).attr(["rx","ry","cx","cy"]),o=s.cx,u=s.cy,l=r;n=l.rx,i=l.ry,"circle"===e.tagName&&(n=i=ut(e).attr("r")),t=Tt([["M",[o-n,u]],["C",[o-n,u-i/a,o-n/a,u-i,o,u-i]],["C",[o+n/a,u-i,o+n,u-i/a,o+n,u]],["C",[o+n,u+i/a,o+n/a,u+i,o,u+i]],["C",[o-n/a,u+i,o-n,u+i/a,o-n,u]],["Z",[]]]);break;case"path":t=e.getAttribute("d");break;case"line":t="M"+(r=ut(e).attr(["x1","y1","x2","y2"])).x1+","+r.y1+"L"+r.x2+","+r.y2;break;case"polyline":t="M"+e.getAttribute("points");break;case"polygon":t="M"+e.getAttribute("points")+" Z";break;case"rect":var h=ut(e).attr(["rx","ry"]);n=h.rx,i=h.ry;var c=e.getBBox(),d=c.x,m=c.y,f=c.width,g=c.height;a=4-a,t=Tt(n||i?[["M",[d,m+i]],["C",[d,m+i/a,d+n/a,m,d+n,m]],["L",[d+f-n,m]],["C",[d+f-n/a,m,d+f,m+i/a,d+f,m+i]],["L",[d+f,m+g-i]],["C",[d+f,m+g-i/a,d+f-n/a,m+g,d+f-n,m+g]],["L",[d+n,m+g]],["C",[d+n/a,m+g,d,m+g-i/a,d,m+g-i]],["L",[d,m+i]],["Z",[]]]:[["M",[d,m]],["L",[d+f,m]],["L",[d+f,m+g]],["L",[d,m+g]],["L",[d,m]],["Z",[]]])}return t},Vt=function(e){var t={};return ut.each(["marker-start","marker-end","marker-mid","filter","clip-path"],function(){var r=e.getAttribute(this);r&&(t[this]=r)}),t},Ot=function(e,t,r){var n=t({element:"path",attr:Vt(e)}),i=e.getAttribute("transform");i&&n.setAttribute("transform",i);var a=e.parentNode;e.nextSibling?e.before(n):a.append(n);var s=Lt(e);s?n.setAttribute("d",s):n.remove(),r.resetOrientation(n);var o=!1;try{o=n.getBBox()}catch(e){}return n.remove(),o};var Mt=function(e,t,r){var n=It(e);if(!n)return null;var i=Q(e),a=jt(i),s=ge(i);if(a||s){var o=!1;if(function(e,t){var r=e%90;return t||!(r>-.001&&r<.001||r<-89.99||r>89.99)}(a,s)){if(["ellipse","path","line","polyline","polygon"].includes(e.tagName))n=o=Ot(e,t,r);else if("rect"===e.tagName){var u=e.getAttribute("rx"),l=e.getAttribute("ry");(u||l)&&(n=o=Ot(e,t,r))}}if(!o){var h=ye(i).matrix;n=pe(n.x,n.y,n.width,n.height,h).aabox}}return n};function Rt(e){var t=e.getAttribute("stroke-width");return isNaN(t)||"none"===e.getAttribute("stroke")?0:t/2}var Bt=function(e,t,r){if(!e||!e.length)return!1;var n;if(ut.each(e,function(){n||this.parentNode&&(n=Mt(this,t,r))}),void 0===n)return null;var i=n.x+n.width,a=n.y+n.height,s=n.x,o=n.y;if(1===e.length){var u=Rt(e[0]);s-=u,o-=u,i+=u,a+=u}else ut.each(e,function(e,n){var u=Mt(n,t,r);if(u){var l=Rt(n);s=Math.min(s,u.x-l),o=Math.min(o,u.y-l),1===n.nodeType&&(i=Math.max(i,u.x+u.width+l),a=Math.max(a,u.y+u.height+l))}});return n.x=s,n.y=o,n.width=i-s,n.height=a-o,n},Ut=function(e){e||(e=ut(ct.getSVGContent()).children());var t=[];return ut(e).children().each(function(e,r){r.getBBox&&t.push(r)}),t.reverse()},Ht=function(e){return e||(e=Ut()),Bt(e,ct.addSVGElementFromJson,ct.pathActions)},jt=function(e,t){if(!e)return 0;for(var r=e.numberOfItems,n=0;n<r;++n){var i=e.getItem(n);if(4===i.type)return t?i.angle*Math.PI/180:i.angle}return 0},Ft=function(e,t){var r=e||ct.getSelectedElements()[0],n=Q(r);return jt(n,t)},Dt=function(e){return zt(kt(e).substr(1))},zt=k?function(e){return ft.querySelector("#"+e)}:C?function(e){return dt.evaluate('svg:svg[@id="svgroot"]//svg:*[@id="'+e+'"]',mt,function(){return f.SVG},9,null).singleNodeValue}:function(e){return ut(ft).find("[id="+e+"]")[0]},qt=function(e,t,r,n){for(var i=Object.entries(t),a=0;a<i.length;a++){var s=h(i[a],2),o=s[0],u=s[1],l="xml:"===o.substr(0,4)?f.XML:"xlink:"===o.substr(0,6)?f.XLINK:null;l?e.setAttributeNS(l,o,u):n?ee(e,o,u):e.setAttribute(o,u)}},Wt=function(e){var t={"fill-opacity":1,"stop-opacity":1,opacity:1,stroke:"none","stroke-dasharray":"none","stroke-linejoin":"miter","stroke-linecap":"butt","stroke-opacity":1,"stroke-width":1,rx:0,ry:0};"ellipse"===e.nodeName&&(delete t.rx,delete t.ry),Object.entries(t).forEach(function(t){var r=h(t,2),n=r[0],i=r[1];e.getAttribute(n)===String(i)&&e.removeAttribute(n)})},Qt=function(e){var t=ct.getBaseUnit(),r=ct.getSnappingStep();return"px"!==t&&(r*=K()[t]),e=Math.round(e/r)*r},Yt=function(e){ut(e).click(function(e){e.preventDefault()})},Zt=function(e){return null==e},Xt=jQuery,Kt=function(){function e(t,r,i){if(n(this,e),this.name_=t,this.group_=i?null:r,i){var a=i.ownerDocument;this.group_=a.createElementNS(f.SVG,"g");var s=a.createElementNS(f.SVG,"title");s.textContent=t,this.group_.append(s),r?Xt(r).after(this.group_):i.append(this.group_)}$t(this.group_),At(this.group_,function(e){e.setAttribute("style","pointer-events:inherit")}),this.group_.setAttribute("style",i?"pointer-events:all":"pointer-events:none")}return a(e,[{key:"getName",value:function(){return this.name_}},{key:"getGroup",value:function(){return this.group_}},{key:"activate",value:function(){this.group_.setAttribute("style","pointer-events:all")}},{key:"deactivate",value:function(){this.group_.setAttribute("style","pointer-events:none")}},{key:"setVisible",value:function(e){var t=void 0===e||e?"inline":"none";this.group_.getAttribute("display")!==t&&this.group_.setAttribute("display",t)}},{key:"isVisible",value:function(){return"none"!==this.group_.getAttribute("display")}},{key:"getOpacity",value:function(){var e=this.group_.getAttribute("opacity");return Zt(e)?1:parseFloat(e)}},{key:"setOpacity",value:function(e){"number"==typeof e&&e>=0&&e<=1&&this.group_.setAttribute("opacity",e)}},{key:"appendChildren",value:function(e){for(var t=0;t<e.length;++t)this.group_.append(e[t])}},{key:"getTitleElement",value:function(){for(var e=this.group_.childNodes.length,t=0;t<e;++t){var r=this.group_.childNodes.item(t);if(r&&"title"===r.tagName)return r}return null}},{key:"setName",value:function(e,t){var r=this.name_;e=pt(e);var n=this.getTitleElement();return n?(Xt(n).empty(),n.textContent=e,this.name_=e,t&&t.changeElement(n,{"#text":r}),this.name_):null}},{key:"removeGroup",value:function(){var e=this.group_.parentNode.removeChild(this.group_);return this.group_=void 0,e}}]),e}();function $t(e){var t=e.getAttribute("class");Zt(t)||!t.length?e.setAttribute("class",Kt.CLASS_NAME):Kt.CLASS_REGEX.test(t)||e.setAttribute("class",t+" "+Kt.CLASS_NAME)}Kt.CLASS_NAME="layer",Kt.CLASS_REGEX=new RegExp("(\\s|^)"+Kt.CLASS_NAME+"(\\s|$)");var Jt=function(){function e(t){n(this,e),this.undoManager_=t,this.currentBatchCommand_=null,this.batchCommandStack_=[]}return a(e,[{key:"startBatchCommand",value:function(e){return this.undoManager_?(this.currentBatchCommand_=new ue(e),this.batchCommandStack_.push(this.currentBatchCommand_),this):this}},{key:"endBatchCommand",value:function(){if(!this.undoManager_)return this;if(this.currentBatchCommand_){var e=this.currentBatchCommand_;this.batchCommandStack_.pop();var t=this.batchCommandStack_.length;this.currentBatchCommand_=t?this.batchCommandStack_[t-1]:null,this.addCommand_(e)}return this}},{key:"moveElement",value:function(e,t,r,n){return this.undoManager_?(this.addCommand_(new ie(e,t,r,n)),this):this}},{key:"insertElement",value:function(e,t){return this.undoManager_?(this.addCommand_(new ae(e,t)),this):this}},{key:"removeElement",value:function(e,t,r,n){return this.undoManager_?(this.addCommand_(new se(e,t,r,n)),this):this}},{key:"changeElement",value:function(e,t,r){return this.undoManager_?(this.addCommand_(new oe(e,t,r)),this):this}},{key:"addCommand_",value:function(e){if(!this.undoManager_)return this;this.currentBatchCommand_?this.currentBatchCommand_.addSubCommand(e):this.undoManager_.addCommandToHistory(e)}}]),e}();Jt.NO_HISTORY=new Jt;var er=jQuery,tr="a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use".split(","),rr={LET_DOCUMENT_DECIDE:0,ALWAYS_RANDOMIZE:1,NEVER_RANDOMIZE:2},nr=rr.LET_DOCUMENT_DECIDE,ir=[];function ar(e){return e||new Jt(or.undoMgr)}function sr(e){for(var t=1;e.includes("Layer "+t);)t++;return"Layer "+t}var or,ur=function(){function e(t,r){if(n(this,e),!t||!t.tagName||!t.namespaceURI||"svg"!==t.tagName||t.namespaceURI!==f.SVG)throw new Error("Error: svgedit.draw.Drawing instance initialized without a <svg> element");this.svgElem_=t,this.obj_num=0,this.idPrefix=r||"svg_",this.releasedNums=[],this.all_layers=[],this.layer_map={},this.current_layer=null,this.nonce_="";var i=this.svgElem_.getAttributeNS(f.SE,"nonce");i&&nr!==rr.NEVER_RANDOMIZE?this.nonce_=i:nr===rr.ALWAYS_RANDOMIZE&&this.setNonce(Math.floor(100001*Math.random()))}return a(e,[{key:"getElem_",value:function(e){return this.svgElem_.querySelector?this.svgElem_.querySelector("#"+e):er(this.svgElem_).find("[id="+e+"]")[0]}},{key:"getSvgElem",value:function(){return this.svgElem_}},{key:"getNonce",value:function(){return this.nonce_}},{key:"setNonce",value:function(e){this.svgElem_.setAttributeNS(f.XMLNS,"xmlns:se",f.SE),this.svgElem_.setAttributeNS(f.SE,"se:nonce",e),this.nonce_=e}},{key:"clearNonce",value:function(){this.nonce_=""}},{key:"getId",value:function(){return this.nonce_?this.idPrefix+this.nonce_+"_"+this.obj_num:this.idPrefix+this.obj_num}},{key:"getNextId",value:function(){var e=this.obj_num,t=!1;this.releasedNums.length>0?(this.obj_num=this.releasedNums.pop(),t=!0):this.obj_num++;for(var r=this.getId();this.getElem_(r);)t&&(this.obj_num=e,t=!1),this.obj_num++,r=this.getId();return t&&(this.obj_num=e),r}},{key:"releaseId",value:function(e){var t=this.idPrefix+(this.nonce_?this.nonce_+"_":"");if("string"!=typeof e||!e.startsWith(t))return!1;var r=parseInt(e.substr(t.length));return!("number"!=typeof r||r<=0||this.releasedNums.includes(r))&&(this.releasedNums.push(r),!0)}},{key:"getNumLayers",value:function(){return this.all_layers.length}},{key:"hasLayer",value:function(e){return void 0!==this.layer_map[e]}},{key:"getLayerName",value:function(e){return e>=0&&e<this.getNumLayers()?this.all_layers[e].getName():""}},{key:"getCurrentLayer",value:function(){return this.current_layer?this.current_layer.getGroup():null}},{key:"getLayerByName",value:function(e){var t=this.layer_map[e];return t?t.getGroup():null}},{key:"getCurrentLayerName",value:function(){return this.current_layer?this.current_layer.getName():""}},{key:"setCurrentLayerName",value:function(e,t){var r=null;if(this.current_layer){var n=this.current_layer.getName();(r=this.current_layer.setName(e,t))&&(delete this.layer_map[n],this.layer_map[r]=this.current_layer)}return r}},{key:"setCurrentLayerPosition",value:function(e){var t,r=this.getNumLayers();if(!this.current_layer||e<0||e>=r)return null;for(t=0;t<r&&this.all_layers[t]!==this.current_layer;++t);if(t===r)return null;if(t!==e){var n=this.current_layer.getGroup(),i=n.nextSibling,a=null;return e>t?e<r-1&&(a=this.all_layers[e+1].getGroup()):a=this.all_layers[e].getGroup(),this.svgElem_.insertBefore(n,a),this.identifyLayers(),this.setCurrentLayer(this.getLayerName(e)),{currentGroup:n,oldNextSibling:i}}return null}},{key:"mergeLayer",value:function(e){var t=this.current_layer.getGroup(),r=er(t).prev()[0];if(r){e.startBatchCommand("Merge Layer");var n=t.nextSibling;for(e.removeElement(t,n,this.svgElem_);t.firstChild;){var i=t.firstChild;if("title"!==i.localName){var a=i.nextSibling;r.append(i),e.moveElement(i,a,t)}else e.removeElement(i,i.nextSibling,t),i.remove()}this.current_layer.removeGroup();var s=this.all_layers.indexOf(this.current_layer);if(s>0){var o=this.current_layer.getName();this.current_layer=this.all_layers[s-1],this.all_layers.splice(s,1),delete this.layer_map[o]}e.endBatchCommand()}}},{key:"mergeAllLayers",value:function(e){for(this.current_layer=this.all_layers[this.all_layers.length-1],e.startBatchCommand("Merge all Layers");this.all_layers.length>1;)this.mergeLayer(e);e.endBatchCommand()}},{key:"setCurrentLayer",value:function(e){var t=this.layer_map[e];return!!t&&(this.current_layer&&this.current_layer.deactivate(),this.current_layer=t,this.current_layer.activate(),!0)}},{key:"deleteCurrentLayer",value:function(){if(this.current_layer&&this.getNumLayers()>1){var e=this.current_layer.removeGroup();return this.identifyLayers(),e}return null}},{key:"identifyLayers",value:function(){this.all_layers=[],this.layer_map={};for(var e,t=this.svgElem_.childNodes.length,r=[],n=[],i=null,a=!1,s=0;s<t;++s){var o=this.svgElem_.childNodes.item(s);if(o&&1===o.nodeType)if("g"===o.tagName){a=!0;var u=er("title",e=o).text()||(V()&&e.querySelectorAll?er(e.querySelectorAll("title")).text():"");u?(n.push(u),i=new Kt(u,o),this.all_layers.push(i),this.layer_map[u]=i):r.push(o)}else tr.includes(o.nodeName)&&r.push(o)}r.length>0||!a?((i=new Kt(sr(n),null,this.svgElem_)).appendChildren(r),this.all_layers.push(i),this.layer_map[name]=i):i.activate(),this.current_layer=i}},{key:"createLayer",value:function(e,t){this.current_layer&&this.current_layer.deactivate(),(null==e||""===e||this.layer_map[e])&&(e=sr(Object.keys(this.layer_map)));var r=new Kt(e,null,this.svgElem_);return t&&(t.startBatchCommand("Create Layer"),t.insertElement(r.getGroup()),t.endBatchCommand()),this.all_layers.push(r),this.layer_map[e]=r,this.current_layer=r,r.getGroup()}},{key:"cloneLayer",value:function(e,t){if(!this.current_layer)return null;this.current_layer.deactivate(),(null==e||""===e||this.layer_map[e])&&(e=sr(Object.keys(this.layer_map)));for(var r=this.current_layer.getGroup(),n=new Kt(e,r,this.svgElem_),i=n.getGroup(),a=r.childNodes,s=0;s<a.length;s++){var o=a[s];"title"!==o.localName&&i.append(this.copyElem(o))}t&&(t.startBatchCommand("Duplicate Layer"),t.insertElement(i),t.endBatchCommand());var u=this.all_layers.indexOf(this.current_layer);return u>=0?this.all_layers.splice(u+1,0,n):this.all_layers.push(n),this.layer_map[e]=n,this.current_layer=n,i}},{key:"getLayerVisibility",value:function(e){var t=this.layer_map[e];return!!t&&t.isVisible()}},{key:"setLayerVisibility",value:function(e,t){if("boolean"!=typeof t)return null;var r=this.layer_map[e];return r?(r.setVisible(t),r.getGroup()):null}},{key:"getLayerOpacity",value:function(e){var t=this.layer_map[e];return t?t.getOpacity():null}},{key:"setLayerOpacity",value:function(e,t){if(!("number"!=typeof t||t<0||t>1)){var r=this.layer_map[e];r&&r.setOpacity(t)}}},{key:"copyElem",value:function(e){var t=this;return function e(t,r){var n=document.createElementNS(t.namespaceURI,t.nodeName);if(ut.each(t.attributes,function(e,t){"-moz-math-font-style"!==t.localName&&n.setAttributeNS(t.namespaceURI,t.nodeName,t.value)}),n.removeAttribute("id"),n.id=r(),O()&&"path"===t.nodeName){var i=et(t);n.setAttribute("d",i)}if(ut.each(t.childNodes,function(t,i){switch(i.nodeType){case 1:n.append(e(i,r));break;case 3:n.textContent=i.nodeValue}}),ut(t).data("gsvg"))ut(n).data("gsvg",n.firstChild);else if(ut(t).data("symbol")){var a=ut(t).data("symbol");ut(n).data("ref",a).data("symbol",a)}else"image"===n.tagName&&Yt(n);return n}(e,function(){return t.getNextId()})}}]),e}(),lr=function(e,t){(nr=!1===e?rr.NEVER_RANDOMIZE:rr.ALWAYS_RANDOMIZE)!==rr.ALWAYS_RANDOMIZE||t.getNonce()?nr===rr.NEVER_RANDOMIZE&&t.getNonce()&&t.clearNonce():t.setNonce(Math.floor(100001*Math.random()))},hr=function(){Sr(),or.getCurrentDrawing().identifyLayers()},cr=function(e,t){var r=or.getCurrentDrawing().createLayer(e,ar(t));or.clearSelection(),or.call("changed",[r])},dr=function(e,t){var r=or.getCurrentDrawing().cloneLayer(e,ar(t));or.clearSelection(),Sr(),or.call("changed",[r])},mr=function(){var e=or.getCurrentDrawing().getCurrentLayer(),t=e.nextSibling,r=e.parentNode;if(e=or.getCurrentDrawing().deleteCurrentLayer()){var n=new ue("Delete Layer");return n.addSubCommand(new se(e,t,r)),or.addCommandToHistory(n),or.clearSelection(),or.call("changed",[r]),!0}return!1},fr=function(e){var t=or.getCurrentDrawing().setCurrentLayer(pt(e));return t&&or.clearSelection(),t},gr=function(e){var t=or.getCurrentDrawing(),r=t.getCurrentLayer();if(r&&t.setCurrentLayerName(e,ar()))return or.call("changed",[r]),!0;return!1},pr=function(e){var t=or.getCurrentDrawing().setCurrentLayerPosition(e);return!!t&&(or.addCommandToHistory(new ie(t.currentGroup,t.oldNextSibling,or.getSVGContent())),!0)},yr=function(e,t){var r=or.getCurrentDrawing(),n=r.getLayerVisibility(e),i=r.setLayerVisibility(e,t);if(!i)return!1;var a=n?"inline":"none";return or.addCommandToHistory(new oe(i,{display:a},"Layer Visibility")),i===r.getCurrentLayer()&&(or.clearSelection(),or.pathActions.clear()),!0},vr=function(e){var t=or.getCurrentDrawing().getLayerByName(e);if(!t)return!1;for(var r=new ue("Move Elements to Layer"),n=or.getSelectedElements(),i=n.length;i--;){var a=n[i];if(a){var s=a.nextSibling,o=a.parentNode;t.append(a),r.addSubCommand(new ie(a,s,o))}}return or.addCommandToHistory(r),!0},xr=function(e){or.getCurrentDrawing().mergeLayer(ar(e)),or.clearSelection(),Sr(),or.changeSVGContent()},_r=function(e){or.getCurrentDrawing().mergeAllLayers(ar(e)),or.clearSelection(),Sr(),or.changeSVGContent()},Sr=function(){var e=ir.length;if(e){for(var t=0;t<e;t++){var r=ir[t],n=or.elData(r,"orig_opac");1!==n?r.setAttribute("opacity",n):r.removeAttribute("opacity"),r.setAttribute("style","pointer-events: inherit")}ir=[],or.clearSelection(!0),or.call("contextset",null)}or.setCurrentGroup(null)},br=function(e){Sr(),"string"==typeof e&&(e=zt(e)),or.setCurrentGroup(e),er(e).parentsUntil("#svgcontent").andSelf().siblings().each(function(){var e=this.getAttribute("opacity")||1;or.elData(this,"orig_opac",e),this.setAttribute("opacity",.33*e),this.setAttribute("style","pointer-events: none"),ir.push(this)}),or.clearSelection(),or.call("contextset",or.getCurrentGroup())},wr=g(),Ar={a:["class","clip-path","clip-rule","fill","fill-opacity","fill-rule","filter","id","mask","opacity","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform","xlink:href","xlink:title"],circle:["class","clip-path","clip-rule","cx","cy","fill","fill-opacity","fill-rule","filter","id","mask","opacity","r","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform"],clipPath:["class","clipPathUnits","id"],defs:[],style:["type"],desc:[],ellipse:["class","clip-path","clip-rule","cx","cy","fill","fill-opacity","fill-rule","filter","id","mask","opacity","requiredFeatures","rx","ry","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform"],feGaussianBlur:["class","color-interpolation-filters","id","requiredFeatures","stdDeviation"],filter:["class","color-interpolation-filters","filterRes","filterUnits","height","id","primitiveUnits","requiredFeatures","width","x","xlink:href","y"],foreignObject:["class","font-size","height","id","opacity","requiredFeatures","style","transform","width","x","y"],g:["class","clip-path","clip-rule","id","display","fill","fill-opacity","fill-rule","filter","mask","opacity","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform","font-family","font-size","font-style","font-weight","text-anchor"],image:["class","clip-path","clip-rule","filter","height","id","mask","opacity","requiredFeatures","style","systemLanguage","transform","width","x","xlink:href","xlink:title","y"],line:["class","clip-path","clip-rule","fill","fill-opacity","fill-rule","filter","id","marker-end","marker-mid","marker-start","mask","opacity","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform","x1","x2","y1","y2"],linearGradient:["class","id","gradientTransform","gradientUnits","requiredFeatures","spreadMethod","systemLanguage","x1","x2","xlink:href","y1","y2"],marker:["id","class","markerHeight","markerUnits","markerWidth","orient","preserveAspectRatio","refX","refY","systemLanguage","viewBox"],mask:["class","height","id","maskContentUnits","maskUnits","width","x","y"],metadata:["class","id"],path:["class","clip-path","clip-rule","d","fill","fill-opacity","fill-rule","filter","id","marker-end","marker-mid","marker-start","mask","opacity","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform"],pattern:["class","height","id","patternContentUnits","patternTransform","patternUnits","requiredFeatures","style","systemLanguage","viewBox","width","x","xlink:href","y"],polygon:["class","clip-path","clip-rule","id","fill","fill-opacity","fill-rule","filter","id","class","marker-end","marker-mid","marker-start","mask","opacity","points","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform"],polyline:["class","clip-path","clip-rule","id","fill","fill-opacity","fill-rule","filter","marker-end","marker-mid","marker-start","mask","opacity","points","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform"],radialGradient:["class","cx","cy","fx","fy","gradientTransform","gradientUnits","id","r","requiredFeatures","spreadMethod","systemLanguage","xlink:href"],rect:["class","clip-path","clip-rule","fill","fill-opacity","fill-rule","filter","height","id","mask","opacity","requiredFeatures","rx","ry","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform","width","x","y"],stop:["class","id","offset","requiredFeatures","stop-color","stop-opacity","style","systemLanguage"],svg:["class","clip-path","clip-rule","filter","id","height","mask","preserveAspectRatio","requiredFeatures","style","systemLanguage","viewBox","width","x","xmlns","xmlns:se","xmlns:xlink","y"],switch:["class","id","requiredFeatures","systemLanguage"],symbol:["class","fill","fill-opacity","fill-rule","filter","font-family","font-size","font-style","font-weight","id","opacity","preserveAspectRatio","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","transform","viewBox"],text:["class","clip-path","clip-rule","fill","fill-opacity","fill-rule","filter","font-family","font-size","font-style","font-weight","id","mask","opacity","requiredFeatures","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","text-anchor","transform","x","xml:space","y"],textPath:["class","id","method","requiredFeatures","spacing","startOffset","style","systemLanguage","transform","xlink:href"],title:[],tspan:["class","clip-path","clip-rule","dx","dy","fill","fill-opacity","fill-rule","filter","font-family","font-size","font-style","font-weight","id","mask","opacity","requiredFeatures","rotate","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","systemLanguage","text-anchor","textLength","transform","x","xml:space","y"],use:["class","clip-path","clip-rule","fill","fill-opacity","fill-rule","filter","height","id","mask","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","style","transform","width","x","xlink:href","y"],annotation:["encoding"],"annotation-xml":["encoding"],maction:["actiontype","other","selection"],math:["class","id","display","xmlns"],menclose:["notation"],merror:[],mfrac:["linethickness"],mi:["mathvariant"],mmultiscripts:[],mn:[],mo:["fence","lspace","maxsize","minsize","rspace","stretchy"],mover:[],mpadded:["lspace","width","height","depth","voffset"],mphantom:[],mprescripts:[],mroot:[],mrow:["xlink:href","xlink:type","xmlns:xlink"],mspace:["depth","height","width"],msqrt:[],mstyle:["displaystyle","mathbackground","mathcolor","mathvariant","scriptlevel"],msub:[],msubsup:[],msup:[],mtable:["align","columnalign","columnlines","columnspacing","displaystyle","equalcolumns","equalrows","frame","rowalign","rowlines","rowspacing","width"],mtd:["columnalign","columnspan","rowalign","rowspan"],mtext:[],mtr:["columnalign","rowalign"],munder:[],munderover:[],none:[],semantics:[]},kr={};Object.entries(Ar).forEach(function(e){var t=h(e,2),r=t[0],n=t[1],i={};Object.entries(n).forEach(function(e){var t=h(e,2),r=(t[0],t[1]);if(r.includes(":")){var n=r.split(":");i[n[1]]=f[n[0].toUpperCase()]}else i[r]="xmlns"===r?f.XMLNS:null}),kr[r]=i});var Cr=function e(t){if(3===t.nodeType&&(t.nodeValue=t.nodeValue.replace(/^\s+|\s+$/g,""),t.nodeValue.length||t.remove()),1===t.nodeType){var r=t.ownerDocument,n=t.parentNode;if(r&&n){var i=Ar[t.nodeName],a=kr[t.nodeName];if(void 0!==i){for(var s=[],o=t.attributes.length;o--;){var u=t.attributes.item(o),l=u.nodeName,c=u.localName,d=u.namespaceURI;if({}.hasOwnProperty.call(a,c)&&d===a[c]&&d!==f.XMLNS||d===f.XMLNS&&wr[u.value]||((l.startsWith("se:")||l.startsWith("data-"))&&s.push([l,u.value]),t.removeAttributeNS(d,c)),M())switch(l){case"transform":case"gradientTransform":case"patternTransform":var m=u.value.replace(/(\d)-/g,"$1 -");t.setAttribute(l,m)}if("style"===l){for(var g=u.value.split(";"),p=g.length;p--;){var y=h(g[p].split(":"),2),v=y[0],x=y[1],_=(v||"").trim(),S=(x||"").trim();i.includes(_)&&t.setAttribute(_,S)}t.removeAttribute("style")}}Object.values(s).forEach(function(e){var r=h(e,2),n=r[0],i=r[1];t.setAttributeNS(f.SE,n,i)});var b=Ct(t);if(b&&["filter","linearGradient","pattern","radialGradient","textPath","use"].includes(t.nodeName)&&"#"!==b[0]&&(Et(t,""),t.removeAttributeNS(f.XLINK,"href")),"use"===t.nodeName&&!Ct(t))return void t.remove();for(Object.values(["clip-path","fill","filter","marker-end","marker-mid","marker-start","mask","stroke"],function(e){var r=t.getAttribute(e);r&&(r=kt(r))&&"#"!==r[0]&&(t.setAttribute(e,""),t.removeAttribute(e))}),o=t.childNodes.length;o--;)e(t.childNodes.item(o))}else{for(var w=[];t.hasChildNodes();)w.push(n.insertBefore(t.firstChild,t));t.remove();for(var A=w.length;A--;)e(w[A])}}}};function Er(e,t){["id","class","type"].forEach(function(r){r in t&&(e[r]=t[r])})}function Pr(e,t){return Gr.apply(this,arguments)}function Gr(){return(Gr=r(regeneratorRuntime.mark(function e(t,r){var n,i;return regeneratorRuntime.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(n=r.global,i=r.returnDefault,!!("svgEditor"in window&&window.svgEditor&&!1===window.svgEditor.modules)){e.next=4;break}return e.abrupt("return",Ir(t,void 0,{returnDefault:i}));case 4:return e.next=6,Nr(t);case 6:return e.abrupt("return",window[n]);case 7:case"end":return e.stop()}},e,this)}))).apply(this,arguments)}function Nr(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return Array.isArray(e)?Promise.all(e.map(function(e){return Nr(e,t)})):new Promise(function(r,n){var i=document.createElement("script");function a(){n(new Error("Failed to import: ".concat(e))),o()}function s(){r(),o()}var o=function(){i.removeEventListener("error",a),i.removeEventListener("load",s),i.remove(),i.src=""};i.defer="defer",Er(i,t),i.addEventListener("error",a),i.addEventListener("load",s),i.src=e,document.head.append(i)})}function Ir(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},r=(arguments.length>2&&void 0!==arguments[2]?arguments[2]:{}).returnDefault,n=void 0!==r&&r;return Array.isArray(e)?Promise.all(e.map(function(e){return Ir(e,t)})):new Promise(function(r,i){var a="$importModule$"+Math.random().toString(32).slice(2),s=document.createElement("script");function o(){i(new Error("Failed to import: ".concat(e))),l()}function u(){r(window[a]),l()}var l=function(){delete window[a],s.removeEventListener("error",o),s.removeEventListener("load",u),s.remove(),URL.revokeObjectURL(s.src),s.src=""};Er(s,t),s.defer="defer",s.type="module",s.addEventListener("error",o),s.addEventListener("load",u);var h=function(e){var t=document.createElement("a");return t.setAttribute("href",e),t.cloneNode(!1).href}(e),c="import * as m from '".concat(h.replace(/'/g,"\\'"),"'; window.").concat(a," = ").concat(n?"m.default || ":"","m;"),d=new Blob([c],{type:"text/javascript"});s.src=URL.createObjectURL(d),document.head.append(s)})}var Tr,Lr,Vr,Or,Mr=jQuery,Rr=[0,"z","M","m","L","l","C","c","Q","q","A","a","H","h","V","v","S","s","T","t"],Br=null,Ur=function(e,t,r){for(var n=function(e,t){return de(e,t,r)},i=function(e){return r.a*e},a=function(e){return r.d*e},s=Br.getGridSnapping()&&"svg"===e.parentNode.parentNode.localName,o=function(){s&&Object.entries(t).forEach(function(e){var r=h(e,2),n=r[0],i=r[1];t[n]=Qt(i)}),qt(e,t,1e3,!0)},u=It(e),l=0;l<2;l++){var c=0===l?"fill":"stroke",d=e.getAttribute(c);if(d&&d.startsWith("url(")&&(r.a<0||r.d<0)){var m=Dt(d).cloneNode(!0);if(r.a<0){var f=m.getAttribute("x1"),g=m.getAttribute("x2");m.setAttribute("x1",-(f-1)),m.setAttribute("x2",-(g-1))}if(r.d<0){var p=m.getAttribute("y1"),y=m.getAttribute("y2");m.setAttribute("y1",-(p-1)),m.setAttribute("y2",-(y-1))}m.id=Br.getDrawing().getNextId(),Pt().append(m),e.setAttribute(c,"url(#"+m.id+")")}}var v=e.tagName;if("g"===v||"text"===v||"tspan"===v||"use"===v)if(1!==r.a||0!==r.b||0!==r.c||1!==r.d||0===r.e&&0===r.f){var x=Q(e),_=Br.getSVGRoot().createSVGTransform();_.setMatrix(fe(ye(x).matrix,r)),x.clear(),x.appendItem(_)}else{var S=ye(e).matrix,b=fe(S.inverse(),r,S);t.x=parseFloat(t.x)+b.e,t.y=parseFloat(t.y)+b.f}switch(v){case"foreignObject":case"rect":case"image":if("image"===v&&(r.a<0||r.d<0)){var w=Q(e),A=Br.getSVGRoot().createSVGTransform();A.setMatrix(fe(ye(w).matrix,r)),w.clear(),w.appendItem(A)}else{var k=n(t.x,t.y);t.width=i(t.width),t.height=a(t.height),t.x=k.x+Math.min(0,t.width),t.y=k.y+Math.min(0,t.height),t.width=Math.abs(t.width),t.height=Math.abs(t.height)}o();break;case"ellipse":var C=n(t.cx,t.cy);t.cx=C.x,t.cy=C.y,t.rx=i(t.rx),t.ry=a(t.ry),t.rx=Math.abs(t.rx),t.ry=Math.abs(t.ry),o();break;case"circle":var E=n(t.cx,t.cy);t.cx=E.x,t.cy=E.y;var P=pe(u.x,u.y,u.width,u.height,r),G=P.tr.x-P.tl.x,N=P.bl.y-P.tl.y;t.r=Math.min(G/2,N/2),t.r&&(t.r=Math.abs(t.r)),o();break;case"line":var I=n(t.x1,t.y1),T=n(t.x2,t.y2);t.x1=I.x,t.y1=I.y,t.x2=T.x,t.y2=T.y;case"text":case"tspan":case"use":o();break;case"g":var L=Mr(e).data("gsvg");L&&qt(L,t,1e3,!0);break;case"polyline":case"polygon":for(var V=t.points.length,O=0;O<V;++O){var M=t.points[O],R=n(M.x,M.y),B=R.x,U=R.y;t.points[O].x=B,t.points[O].y=U}for(var H="",j=0;j<V;++j){var F=t.points[j];H+=F.x+","+F.y+" "}e.setAttribute("points",H);break;case"path":var D=e.pathSegList,z=D.numberOfItems;t.d=[];for(var q=0;q<z;++q){var W=D.getItem(q);t.d[q]={type:W.pathSegType,x:W.x,y:W.y,x1:W.x1,y1:W.y1,x2:W.x2,y2:W.y2,r1:W.r1,r2:W.r2,angle:W.angle,largeArcFlag:W.largeArcFlag,sweepFlag:W.sweepFlag}}z=t.d.length;var Y=t.d[0],Z=n(Y.x,Y.y);t.d[0].x=Z.x,t.d[0].y=Z.y;for(var X=1;X<z;++X){var K=t.d[X];if(K.type%2==0){var $=n(void 0!==K.x?K.x:Z.x,void 0!==K.y?K.y:Z.y),J=n(K.x1,K.y1),ee=n(K.x2,K.y2);K.x=$.x,K.y=$.y,K.x1=J.x,K.y1=J.y,K.x2=ee.x,K.y2=ee.y,K.r1=i(K.r1),K.r2=a(K.r2)}else K.x=i(K.x),K.y=a(K.y),K.x1=i(K.x1),K.y1=a(K.y1),K.x2=i(K.x2),K.y2=a(K.y2),K.r1=i(K.r1),K.r2=a(K.r2)}var te="";z=t.d.length;for(var re=0;re<z;++re){var ne=t.d[re],ie=ne.type;switch(te+=Rr[ie],ie){case 13:case 12:te+=ne.x+" ";break;case 15:case 14:te+=ne.y+" ";break;case 3:case 5:case 19:case 2:case 4:case 18:te+=ne.x+","+ne.y+" ";break;case 7:case 6:te+=ne.x1+","+ne.y1+" "+ne.x2+","+ne.y2+" "+ne.x+","+ne.y+" ";break;case 9:case 8:te+=ne.x1+","+ne.y1+" "+ne.x+","+ne.y+" ";break;case 11:case 10:te+=ne.r1+","+ne.r2+" "+ne.angle+" "+Number(ne.largeArcFlag)+" "+Number(ne.sweepFlag)+" "+ne.x+","+ne.y+" ";break;case 17:case 16:te+=ne.x2+","+ne.y2+" "+ne.x+","+ne.y+" "}}e.setAttribute("d",te)}},Hr=d(jQuery),jr=function(e,t,r){var n=Dt(e).firstChild,i=Q(n),a=Tr.getSVGRoot().createSVGTransform();a.setTranslate(t,r),i.appendItem(a),Fr(n)},Fr=function e(t){if(Zt(t))return null;if("svg"===t.nodeName&&navigator.userAgent.includes("Firefox/20"))return null;var r=Tr.getSVGRoot(),n=Q(t);if(n&&n.numberOfItems>0){for(var i=n.numberOfItems,a=i;i--;){var s=n.getItem(i);if(0===s.type)n.removeItem(i);else if(1===s.type){if(me(s.matrix)){if(1===a)return t.removeAttribute("transform"),null;n.removeItem(i)}}else 4===s.type&&0===s.angle&&n.removeItem(i)}if(1===n.numberOfItems&&Ft(t))return null}if(!n||0===n.numberOfItems)return t.setAttribute("transform",""),t.removeAttribute("transform"),null;if(n){for(var o=[],u=n.numberOfItems;u--;){var l=n.getItem(u);1===l.type?o.push([l.matrix,u]):o.length&&(o=[])}if(2===o.length){var h=r.createSVGTransformFromMatrix(fe(o[1][0],o[0][0]));n.removeItem(o[0][1]),n.removeItem(o[1][1]),n.insertItemBefore(h,o[1][1])}if((u=n.numberOfItems)>=2&&1===n.getItem(u-2).type&&2===n.getItem(u-1).type){var c=r.createSVGTransform(),d=fe(n.getItem(u-2).matrix,n.getItem(u-1).matrix);c.setMatrix(d),n.removeItem(u-2),n.removeItem(u-2),n.appendItem(c)}}switch(t.tagName){case"line":case"polyline":case"polygon":case"path":break;default:if(1===n.numberOfItems&&1===n.getItem(0).type||2===n.numberOfItems&&1===n.getItem(0).type&&4===n.getItem(0).type)return null}var m,g,p=Hr(t).data("gsvg"),y=new ue("Transform"),v={},x=null,_=[];switch(t.tagName){case"line":_=["x1","y1","x2","y2"];break;case"circle":_=["cx","cy","r"];break;case"ellipse":_=["cx","cy","rx","ry"];break;case"foreignObject":case"rect":case"image":_=["width","height","x","y"];break;case"use":case"text":case"tspan":_=["x","y"];break;case"polygon":case"polyline":(x={}).points=t.getAttribute("points");var S=t.points,b=S.numberOfItems;v.points=new Array(b);for(var w=0;w<b;++w){var A=S.getItem(w);v.points[w]={x:A.x,y:A.y}}break;case"path":(x={}).d=t.getAttribute("d"),v.d=t.getAttribute("d")}if(_.length?(v=Hr(t).attr(_),Hr.each(v,function(e,t){v[e]=te(e,t)})):p&&(v={x:Hr(p).attr("x")||0,y:Hr(p).attr("y")||0}),Zt(x)&&(x=Hr.extend(!0,{},v),Hr.each(x,function(e,t){x[e]=te(e,t)})),x.transform=Tr.getStartTransform()||"","g"===t.tagName&&!p||"a"===t.tagName){var k=It(t);m={x:k.x+k.width/2,y:k.y+k.height/2},g=de(k.x+k.width/2,k.y+k.height/2,ye(n).matrix);var C=Ft(t);if(C){var E,P=C*Math.PI/180;E=Math.abs(P)>1e-10?Math.sin(P)/(1-Math.cos(P)):2/P;for(var G=0;G<n.numberOfItems;++G){var N=n.getItem(G);if(4===N.type){var I=N.matrix;m.y=(E*I.e+I.f)/2,m.x=(I.e-E*I.f)/2,n.removeItem(G);break}}}var T,L,V=n.numberOfItems,M=0,R=0,B=0;if(V&&(T=n.getItem(0).matrix),V>=3&&3===n.getItem(V-2).type&&2===n.getItem(V-3).type&&2===n.getItem(V-1).type){B=3;for(var U=n.getItem(V-3).matrix,H=n.getItem(V-2).matrix,j=n.getItem(V-1).matrix,F=t.childNodes,D=F.length;D--;){var z=F.item(D);if(M=0,R=0,1===z.nodeType){var q=Q(z);if(!q)continue;var W=ye(q).matrix,Y=Ft(z);if(L=Tr.getStartTransform(),Tr.setStartTransform(z.getAttribute("transform")),Y||ge(q)){var Z=r.createSVGTransform();Z.setMatrix(fe(U,H,j,W)),q.clear(),q.appendItem(Z)}else{var X=fe(W.inverse(),j,W),K=r.createSVGMatrix();K.e=-X.e,K.f=-X.f;var $=fe(K.inverse(),W.inverse(),U,H,j,W,X.inverse()),J=r.createSVGTransform(),ee=r.createSVGTransform(),re=r.createSVGTransform();J.setTranslate(X.e,X.f),ee.setScale($.a,$.d),re.setTranslate(K.e,K.f),q.appendItem(re),q.appendItem(ee),q.appendItem(J)}y.addSubCommand(e(z)),Tr.setStartTransform(L)}}n.removeItem(V-1),n.removeItem(V-2),n.removeItem(V-3)}else if(V>=3&&1===n.getItem(V-1).type){B=3;var ne=ye(n).matrix,ie=r.createSVGTransform();ie.setMatrix(ne),n.clear(),n.appendItem(ie)}else if((1===V||V>1&&3!==n.getItem(1).type)&&2===n.getItem(0).type){B=2;var ae=ye(n).matrix;n.removeItem(0);var se=ye(n).matrix.inverse(),le=fe(se,ae);if(M=le.e,R=le.f,0!==M||0!==R){for(var he=t.childNodes,ce=he.length,pe=[];ce--;){var ve=he.item(ce);if(1===ve.nodeType){if(ve.getAttribute("clip-path")){var xe=ve.getAttribute("clip-path");pe.includes(xe)||(jr(xe,M,R),pe.push(xe))}L=Tr.getStartTransform(),Tr.setStartTransform(ve.getAttribute("transform"));var _e=Q(ve);if(_e){var Se=r.createSVGTransform();Se.setTranslate(M,R),_e.numberOfItems?_e.insertItemBefore(Se,0):_e.appendItem(Se),y.addSubCommand(e(ve));for(var be=t.getElementsByTagNameNS(f.SVG,"use"),we="#"+ve.id,Ae=be.length;Ae--;){var ke=be.item(Ae);if(we===Ct(ke)){var Ce=r.createSVGTransform();Ce.setTranslate(-M,-R),Q(ke).insertItemBefore(Ce,0),y.addSubCommand(e(ke))}}Tr.setStartTransform(L)}}}Tr.setStartTransform(L)}}else{if(1!==V||1!==n.getItem(0).type||C){if(C){var Ee=r.createSVGTransform();Ee.setRotate(C,g.x,g.y),n.numberOfItems?n.insertItemBefore(Ee,0):n.appendItem(Ee)}return 0===n.numberOfItems&&t.removeAttribute("transform"),null}B=1;for(var Pe=n.getItem(0).matrix,Ge=t.childNodes,Ne=Ge.length;Ne--;){var Ie=Ge.item(Ne);if(1===Ie.nodeType){L=Tr.getStartTransform(),Tr.setStartTransform(Ie.getAttribute("transform"));var Te=Q(Ie);if(!Te)continue;var Le=fe(Pe,ye(Te).matrix),Ve=r.createSVGTransform();Ve.setMatrix(Le),Te.clear(),Te.appendItem(Ve,0),y.addSubCommand(e(Ie)),Tr.setStartTransform(L);var Oe=Ie.getAttribute("stroke-width");if("none"!==Ie.getAttribute("stroke")&&!isNaN(Oe)){var Me=(Math.abs(Le.a)+Math.abs(Le.d))/2;Ie.setAttribute("stroke-width",Oe*Me)}}}n.clear()}if(2===B){if(C){g={x:m.x+T.e,y:m.y+T.f};var Re=r.createSVGTransform();Re.setRotate(C,g.x,g.y),n.numberOfItems?n.insertItemBefore(Re,0):n.appendItem(Re)}}else if(3===B){var Be=ye(n).matrix,Ue=r.createSVGTransform();Ue.setRotate(C,m.x,m.y);var He=Ue.matrix,je=r.createSVGTransform();je.setRotate(C,g.x,g.y);var Fe=je.matrix.inverse(),De=Be.inverse(),ze=fe(De,Fe,He,Be);if(M=ze.e,R=ze.f,0!==M||0!==R)for(var qe=t.childNodes,We=qe.length;We--;){var Qe=qe.item(We);if(1===Qe.nodeType){L=Tr.getStartTransform(),Tr.setStartTransform(Qe.getAttribute("transform"));var Ye=Q(Qe),Ze=r.createSVGTransform();Ze.setTranslate(M,R),Ye.numberOfItems?Ye.insertItemBefore(Ze,0):Ye.appendItem(Ze),y.addSubCommand(e(Qe)),Tr.setStartTransform(L)}}C&&(n.numberOfItems?n.insertItemBefore(je,0):n.appendItem(je))}}else{var Xe,Ke=It(t);if(!Ke&&"path"!==t.tagName)return null;var $e=Ft(t);if($e){m={x:Ke.x+Ke.width/2,y:Ke.y+Ke.height/2},g=de(Ke.x+Ke.width/2,Ke.y+Ke.height/2,ye(n).matrix);for(var Je=$e*Math.PI/180,et=Math.abs(Je)>1e-10?Math.sin(Je)/(1-Math.cos(Je)):2/Je,tt=0;tt<n.numberOfItems;++tt){var rt=n.getItem(tt);if(4===rt.type){var nt=rt.matrix;m.y=(et*nt.e+nt.f)/2,m.x=(nt.e-et*nt.f)/2,n.removeItem(tt);break}}}var it=0,at=n.numberOfItems;if(!O()){var st=t.getAttribute("fill");if(st&&st.startsWith("url(")){var ot=Dt(st),ut="pattern";if(ot.tagName!==ut&&(ut="gradient"),"userSpaceOnUse"===ot.getAttribute(ut+"Units")){Xe=ye(n).matrix;var lt=Q(ot),ht=ye(lt).matrix,ct="matrix("+[(Xe=fe(Xe,ht)).a,Xe.b,Xe.c,Xe.d,Xe.e,Xe.f].join(",")+")";ot.setAttribute(ut+"Transform",ct)}}}if(at>=3&&3===n.getItem(at-2).type&&2===n.getItem(at-3).type&&2===n.getItem(at-1).type)it=3,Xe=ye(n,at-3,at-1).matrix,n.removeItem(at-1),n.removeItem(at-2),n.removeItem(at-3);else if(4===at&&1===n.getItem(at-1).type){it=3,Xe=ye(n).matrix;var dt=r.createSVGTransform();dt.setMatrix(Xe),n.clear(),n.appendItem(dt),Xe=r.createSVGMatrix()}else if((1===at||at>1&&3!==n.getItem(1).type)&&2===n.getItem(0).type){it=2;var mt=n.getItem(0).matrix,ft=ye(n,1).matrix,gt=ft.inverse();Xe=fe(gt,mt,ft),n.removeItem(0)}else{if(1!==at||1!==n.getItem(0).type||$e){if($e){var pt=r.createSVGTransform();pt.setRotate($e,g.x,g.y),n.numberOfItems?n.insertItemBefore(pt,0):n.appendItem(pt)}return 0===n.numberOfItems&&t.removeAttribute("transform"),null}switch(Xe=ye(n).matrix,t.tagName){case"line":v=Hr(t).attr(["x1","y1","x2","y2"]);case"polyline":case"polygon":if(v.points=t.getAttribute("points"),v.points){var yt=t.points,vt=yt.numberOfItems;v.points=new Array(vt);for(var xt=0;xt<vt;++xt){var _t=yt.getItem(xt);v.points[xt]={x:_t.x,y:_t.y}}}case"path":v.d=t.getAttribute("d"),it=1,n.clear()}}if(1!==it&&2!==it&&3!==it||Ur(t,v,Xe),2===it){if($e){ge(n)||(g={x:m.x+Xe.e,y:m.y+Xe.f});var St=r.createSVGTransform();St.setRotate($e,g.x,g.y),n.numberOfItems?n.insertItemBefore(St,0):n.appendItem(St)}if("text"===t.tagName)for(var bt=t.childNodes,wt=bt.length;wt--;){var At=bt.item(wt);if("tspan"===At.tagName){var kt={x:Hr(At).attr("x")||0,y:Hr(At).attr("y")||0};Ur(At,kt,Xe)}}}else if(3===it&&$e){var Et=ye(n).matrix,Pt=r.createSVGTransform();Pt.setRotate($e,m.x,m.y);var Gt=Pt.matrix,Nt=r.createSVGTransform();Nt.setRotate($e,g.x,g.y);var Tt=Nt.matrix.inverse(),Lt=Et.inverse(),Vt=fe(Lt,Tt,Gt,Et);Ur(t,v,Vt),$e&&(n.numberOfItems?n.insertItemBefore(Nt,0):n.appendItem(Nt))}}return 0===n.numberOfItems&&t.removeAttribute("transform"),y.addSubCommand(new oe(t,x)),y},Dr=jQuery,zr=A?10:4,qr=function(){function e(t,r,i){n(this,e),this.id=t,this.selectedElement=r,this.locked=!0,this.selectorGroup=Lr.createSVGElement({element:"g",attr:{id:"selectorGroup"+this.id}}),this.selectorRect=this.selectorGroup.appendChild(Lr.createSVGElement({element:"path",attr:{id:"selectedBox"+this.id,fill:"none",stroke:"#22C","stroke-width":"1","stroke-dasharray":"5,5",style:"pointer-events:none"}})),this.gripCoords={nw:null,n:null,ne:null,e:null,se:null,s:null,sw:null,w:null},this.reset(this.selectedElement,i)}return a(e,[{key:"reset",value:function(e,t){this.locked=!0,this.selectedElement=e,this.resize(t),this.selectorGroup.setAttribute("display","inline")}},{key:"showGrips",value:function(t){var r=t?"inline":"none";Or.selectorGripsGroup.setAttribute("display",r);var n=this.selectedElement;this.hasGrips=t,n&&t&&(this.selectorGroup.append(Or.selectorGripsGroup),e.updateGripCursors(Ft(n)))}},{key:"resize",value:function(e){var t=this.selectorRect,r=Or,n=r.selectorGrips,i=this.selectedElement,a=i.getAttribute("stroke-width"),s=Lr.getCurrentZoom(),o=1/s;"none"===i.getAttribute("stroke")||isNaN(a)||(o+=a/2);var u=i.tagName;"text"===u&&(o+=2/s);var l=Q(i),c=ye(l).matrix;if(c.e*=s,c.f*=s,e||(e=It(i)),"g"===u&&!Dr.data(i,"gsvg")){var d=Bt([i.childNodes]);d&&(e=d)}var m=e.x,f=e.y,g=e.width,p=e.height;o*=s;var y=pe(m*s,f*s,g*s,p*s,c),v=y.aabox,x=v.x-o,_=v.y-o,S=v.width+2*o,b=v.height+2*o,w=x+S/2,A=_+b/2,k=Ft(i);if(k){var C=Lr.svgRoot().createSVGTransform();C.setRotate(-k,w,A);var E=C.matrix;y.tl=de(y.tl.x,y.tl.y,E),y.tr=de(y.tr.x,y.tr.y,E),y.bl=de(y.bl.x,y.bl.y,E),y.br=de(y.br.x,y.br.y,E);var P=y.tl,G=P.x,N=P.y,I=P.x,T=P.y,L=Math.min,V=Math.max;x=G=L(G,L(y.tr.x,L(y.bl.x,y.br.x)))-o,_=N=L(N,L(y.tr.y,L(y.bl.y,y.br.y)))-o,S=(I=V(I,V(y.tr.x,V(y.bl.x,y.br.x)))+o)-G,b=(T=V(T,V(y.tr.y,V(y.bl.y,y.br.y)))+o)-N}var O="M"+x+","+_+" L"+(x+S)+","+_+" "+(x+S)+","+(_+b)+" "+x+","+(_+b)+"z";t.setAttribute("d",O);var M=k?"rotate("+[k,w,A].join(",")+")":"";this.selectorGroup.setAttribute("transform",M),this.gripCoords={nw:[x,_],ne:[x+S,_],sw:[x,_+b],se:[x+S,_+b],n:[x+S/2,_],w:[x,_+b/2],e:[x+S,_+b/2],s:[x+S/2,_+b]},Object.entries(this.gripCoords).forEach(function(e){var t=h(e,2),r=t[0],i=t[1];n[r].setAttribute("cx",i[0]),n[r].setAttribute("cy",i[1])}),r.rotateGripConnector.setAttribute("x1",x+S/2),r.rotateGripConnector.setAttribute("y1",_),r.rotateGripConnector.setAttribute("x2",x+S/2),r.rotateGripConnector.setAttribute("y2",_-5*zr),r.rotateGrip.setAttribute("cx",x+S/2),r.rotateGrip.setAttribute("cy",_-5*zr)}}]),e}();qr.updateGripCursors=function(e){var t=Object.keys(Or.selectorGrips),r=Math.round(e/45);for(r<0&&(r+=8);r>0;)t.push(t.shift()),r--;Object.values(Or.selectorGrips).forEach(function(e,r){e.setAttribute("style","cursor:"+t[r]+"-resize")})};var Wr=function(){function t(){n(this,t),this.selectorParentGroup=null,this.rubberBandBox=null,this.selectors=[],this.selectorMap={},this.selectorGrips={nw:null,n:null,ne:null,e:null,se:null,s:null,sw:null,w:null},this.selectorGripsGroup=null,this.rotateGripConnector=null,this.rotateGrip=null,this.initGroup()}return a(t,[{key:"initGroup",value:function(){var e=this;if(this.selectorParentGroup&&this.selectorParentGroup.parentNode&&this.selectorParentGroup.remove(),this.selectorParentGroup=Lr.createSVGElement({element:"g",attr:{id:"selectorParentGroup"}}),this.selectorGripsGroup=Lr.createSVGElement({element:"g",attr:{display:"none"}}),this.selectorParentGroup.append(this.selectorGripsGroup),Lr.svgRoot().append(this.selectorParentGroup),this.selectorMap={},this.selectors=[],this.rubberBandBox=null,Object.keys(this.selectorGrips).forEach(function(t){var r=Lr.createSVGElement({element:"circle",attr:{id:"selectorGrip_resize_"+t,fill:"#22C",r:zr,style:"cursor:"+t+"-resize","stroke-width":2,"pointer-events":"all"}});Dr.data(r,"dir",t),Dr.data(r,"type","resize"),e.selectorGrips[t]=e.selectorGripsGroup.appendChild(r)}),this.rotateGripConnector=this.selectorGripsGroup.appendChild(Lr.createSVGElement({element:"line",attr:{id:"selectorGrip_rotateconnector",stroke:"#22C","stroke-width":"1"}})),this.rotateGrip=this.selectorGripsGroup.appendChild(Lr.createSVGElement({element:"circle",attr:{id:"selectorGrip_rotate",fill:"lime",r:zr,stroke:"#22C","stroke-width":2,style:"cursor:url("+Vr.imgPath+"rotate.png) 12 12, auto;"}})),Dr.data(this.rotateGrip,"type","rotate"),!Dr("#canvasBackground").length){var t=h(Vr.dimensions,2),r=t[0],n=t[1],i=Lr.createSVGElement({element:"svg",attr:{id:"canvasBackground",width:r,height:n,x:0,y:0,overflow:O()?"none":"visible",style:"pointer-events:none"}}),a=Lr.createSVGElement({element:"rect",attr:{width:"100%",height:"100%",x:0,y:0,"stroke-width":1,stroke:"#000",fill:"#FFF",style:"pointer-events:none"}});i.append(a),Lr.svgRoot().insertBefore(i,Lr.svgContent())}}},{key:"requestSelector",value:function(t,r){if(Zt(t))return null;var n=this.selectors.length;if("object"===e(this.selectorMap[t.id]))return this.selectorMap[t.id].locked=!0,this.selectorMap[t.id];for(var i=0;i<n;++i)if(this.selectors[i]&&!this.selectors[i].locked)return this.selectors[i].locked=!0,this.selectors[i].reset(t,r),this.selectorMap[t.id]=this.selectors[i],this.selectors[i];return this.selectors[n]=new qr(n,t,r),this.selectorParentGroup.append(this.selectors[n].selectorGroup),this.selectorMap[t.id]=this.selectors[n],this.selectors[n]}},{key:"releaseSelector",value:function(e){if(!Zt(e)){var t=this.selectors.length,r=this.selectorMap[e.id];r.locked||console.log("WARNING! selector was released but was already unlocked");for(var n=0;n<t;++n)if(this.selectors[n]&&this.selectors[n]===r){delete this.selectorMap[e.id],r.locked=!1,r.selectedElement=null,r.showGrips(!1);try{r.selectorGroup.setAttribute("display","none")}catch(e){}break}}}},{key:"getRubberBandBox",value:function(){return this.rubberBandBox||(this.rubberBandBox=this.selectorParentGroup.appendChild(Lr.createSVGElement({element:"rect",attr:{id:"selectorRubberBand",fill:"#22C","fill-opacity":.15,stroke:"#22C","stroke-width":.5,display:"none",style:"pointer-events:none"}}))),this.rubberBandBox}}]),t}(),Qr=d(jQuery),Yr=ie,Zr=ae,Xr=se,Kr=oe,$r=ue,Jr=le,en=re;window.console||(window.console={},window.console.log=function(e){},window.console.dir=function(e){}),window.opera&&(window.console.log=function(e){window.opera.postError(e)},window.console.dir=function(e){});return function t(i,a){n(this,t);var s={show_outside_canvas:!0,selectNew:!0,dimensions:[640,480]};a&&Qr.extend(s,a);var o=s.dimensions,u=this,l=i.ownerDocument,d=l.importNode(wt('<svg id="svgroot" xmlns="'+f.SVG+'" xlinkns="'+f.XLINK+'" width="'+o[0]+'" height="'+o[1]+'" x="'+o[0]+'" y="'+o[1]+'" overflow="visible"><defs><filter id="canvashadow" filterUnits="objectBoundingBox"><feGaussianBlur in="SourceAlpha" stdDeviation="4" result="blur"/><feOffset in="blur" dx="5" dy="5" result="offsetBlur"/><feMerge><feMergeNode in="offsetBlur"/><feMergeNode in="SourceGraphic"/></feMerge></filter></defs></svg>').documentElement,!0);i.append(d);var m=l.createElementNS(f.SVG,"svg");(u.clearSvgContentElement=function(){Qr(m).empty(),Qr(m).attr({id:"svgcontent",width:o[0],height:o[1],x:o[0],y:o[1],overflow:s.show_outside_canvas?"visible":"hidden",xmlns:f.SVG,"xmlns:se":f.SE,"xmlns:xlink":f.XLINK}).appendTo(d);var e=l.createComment(" Created with SVG-edit - https://github.com/SVG-Edit/svgedit");m.append(e)})();var p="svg_";u.setIdPrefix=function(e){p=e},u.current_drawing_=new ur(m,p);var y=u.getCurrentDrawing=function(){return u.current_drawing_},v=1,x=null,_={shape:{fill:("none"===s.initFill.color?"":"#")+s.initFill.color,fill_paint:null,fill_opacity:s.initFill.opacity,stroke:"#"+s.initStroke.color,stroke_paint:null,stroke_opacity:s.initStroke.opacity,stroke_width:s.initStroke.width,stroke_dasharray:"none",stroke_linejoin:"miter",stroke_linecap:"butt",opacity:s.initOpacity}};_.text=Qr.extend(!0,{},_.shape),Qr.extend(_.text,{fill:"#000000",stroke_width:s.text&&s.text.stroke_width,font_size:s.text&&s.text.font_size,font_family:s.text&&s.text.font_family});var S=_.shape,b=[],w=this.getJsonFromSvgElement=function(e){if(3===e.nodeType)return e.nodeValue;for(var t,r={element:e.tagName,attr:{},children:[]},n=0;t=e.attributes[n];n++)r.attr[t.name]=t.value;for(var i,a=0;i=e.childNodes[a];a++)r.children[a]=w(i);return r},A=this.addSVGElementFromJson=function(e){if("string"==typeof e)return l.createTextNode(e);var t=zt(e.attr.id),r=y().getCurrentLayer();if(t&&e.element!==t.tagName&&(t.remove(),t=null),!t){var n=e.namespace||f.SVG;t=l.createElementNS(n,e.element),r&&(x||r).append(t)}return e.curStyles&&qt(t,{fill:S.fill,stroke:S.stroke,"stroke-width":S.stroke_width,"stroke-dasharray":S.stroke_dasharray,"stroke-linejoin":S.stroke_linejoin,"stroke-linecap":S.stroke_linecap,"stroke-opacity":S.stroke_opacity,"fill-opacity":S.fill_opacity,opacity:S.opacity/2,style:"pointer-events:inherit"},100),qt(t,e.attr,100),Wt(t),e.children&&e.children.forEach(function(e){t.append(A(e))}),t};u.getTransformList=Q,u.matrixMultiply=fe,u.hasMatrixTransform=ge,u.transformListToTransform=ye;var k=function(){return s.baseUnit};!function(e){D=e;var t=document.createElementNS(f.SVG,"svg");document.body.append(t);var r=document.createElementNS(f.SVG,"rect");r.setAttribute("width","1em"),r.setAttribute("height","1ex"),r.setAttribute("x","1in"),t.append(r);var n=r.getBBox();t.remove();var i=n.x;X={em:n.width,ex:n.height,in:i,cm:i/2.54,mm:i/25.4,pt:i/72,pc:i/6,px:1,"%":0}}({getBaseUnit:k,getElement:zt,getHeight:function(){return m.getAttribute("height")/v},getWidth:function(){return m.getAttribute("width")/v},getRoundDigits:function(){return we.round_digits}}),u.convertToNum=te;var C,E=function(){return m},P=this.getSelectedElems=function(){return b},N=ot,I=function(){return d};ct=C={pathActions:N,getSVGContent:E,addSVGElementFromJson:A,getSelectedElements:P,getDOMDocument:function(){return l},getDOMContainer:function(){return i},getSVGRoot:I,getBaseUnit:k,getSnappingStep:function(){return s.snappingStep}},dt=C.getDOMDocument(),mt=C.getDOMContainer(),ft=C.getSVGRoot(),u.findDefs=Pt,u.getUrlFromAttr=kt,u.getHref=Ct,u.setHref=Et,u.getBBox=It,u.getRotationAngle=Ft,u.getElem=zt,u.getRefElem=Dt,u.assignAttributes=qt,this.cleanupElement=Wt;var T=function(){return s.gridSnapping};!function(e){Br=e}({getDrawing:function(){return y()},getSVGRoot:I,getGridSnapping:T}),this.remapElement=Ur,function(e){Tr=e}({getSVGRoot:I,getStartTransform:function(){return Ve},setStartTransform:function(e){Ve=e}}),this.recalculateDimensions=Fr;var L=g();u.sanitizeSvg=Cr;var V=u.undoMgr=new Jr({handleHistoryEvent:function(e,t){var r=en;if(e===r.BEFORE_UNAPPLY||e===r.BEFORE_APPLY)u.clearSelection();else if(e===r.AFTER_APPLY||e===r.AFTER_UNAPPLY){var n=t.elements();u.pathActions.clear(),ee("changed",n);var i=t.type(),a=e===r.AFTER_APPLY;if(i===Yr.type())(a?t.newParent:t.oldParent)===m&&hr();else if(i===Zr.type()||i===Xr.type())t.parent===m&&hr(),i===Zr.type()?a&&Se(t.elem):a||Se(t.elem),"use"===t.elem.tagName&&rr(t.elem);else if(i===Kr.type()){"title"===t.elem.tagName&&t.elem.parentNode.parentNode===m&&hr();var s=a?t.newValues:t.oldValues;s.stdDeviation&&u.setBlurOffsets(t.elem.parentNode,s.stdDeviation)}}}}),U=function(e){u.undoMgr.addCommandToHistory(e)},j=this.getZoom=function(){return v},F=this.round=function(e){return parseInt(e*v)/v};!function(e,t){Vr=e,Lr=t,Or=new Wr}(s,{createSVGElement:function(e){return u.addSVGElementFromJson(e)},svgRoot:function(){return d},svgContent:function(){return m},getCurrentZoom:j});var W=this.selectorManager=Or,Y=u.getNextId=function(){return y().getNextId()},Z=u.getId=function(){return y().getId()},ee=function(e,t){if(Qe[e])return Qe[e](window,t)},re=this.clearSelection=function(e){b.forEach(function(e){Zt(e)||W.releaseSelector(e)}),b=[],e||ee("selected",b)},ne=this.addToSelection=function(e,t){if(e.length){for(var r=0;r<b.length&&!Zt(b[r]);)++r;for(var n=e.length;n--;){var i=e[n];if(i){var a=It(i);if(a&&("a"===i.tagName&&1===i.childNodes.length&&(i=i.firstChild),!b.includes(i))){b[r]=i,r++;var s=W.requestSelector(i,a);b.length>1&&s.showGrips(!1)}}}for(ee("selected",b),t||1===b.length?W.requestSelector(b[0]).showGrips(!0):W.requestSelector(b[0]).showGrips(!1),b.sort(function(e,t){return e&&t&&e.compareDocumentPosition?3-(6&t.compareDocumentPosition(e)):Zt(e)?1:0});Zt(b[0]);)b.shift(0)}},ie=function(){return S.opacity},ae=this.getMouseTarget=function(e){if(Zt(e))return null;var t=e.target;if(t.correspondingUseElement&&(t=t.correspondingUseElement),[f.MATH,f.HTML].includes(t.namespaceURI)&&"svgcanvas"!==t.id)for(;"foreignObject"!==t.nodeName;)if(!(t=t.parentNode))return d;var r=y().getCurrentLayer();if([d,i,m,r].includes(t))return d;if(Qr(t).closest("#selectorParentGroup").length)return W.selectorParentGroup;for(;t.parentNode!==(x||r);)t=t.parentNode;return t};u.pathActions=N,Ne({selectorManager:W,canvas:u,call:ee,resetD:function(e){e.setAttribute("d",N.convertPath(e))},round:F,clearSelection:re,addToSelection:ne,addCommandToHistory:U,remapElement:Ur,addSVGElementFromJson:A,getGridSnapping:T,getOpacity:ie,getSelectedElements:P,getContainer:function(){return i},setStarted:function(e){Le=e},getRubberBox:function(){return Ue},setRubberBox:function(e){return Ue=e},addPtsToSelection:function(e){var t=e.closedSubpath,r=e.grips;N.canDeleteNodes=!0,N.closed_subpath=t,ee("pointsAdded",{closedSubpath:t,grips:r}),ee("selected",r)},endChanges:function(e){var t=e.cmd,r=e.elem;U(t),ee("changed",[r])},getCurrentZoom:j,getId:Z,getNextId:Y,getMouseTarget:ae,getCurrentMode:function(){return Oe},setCurrentMode:function(e){return Oe=e},getDrawnPath:function(){return Bt},setDrawnPath:function(e){return Bt=e},getSVGRoot:I});var se={},oe="a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use",ue=["clip-path","fill","filter","marker-end","marker-mid","marker-start","mask","stroke"],le=Qr.data,ce=document.createElementNS(f.SVG,"animate");Qr(ce).attr({attributeName:"opacity",begin:"indefinite",dur:1,fill:"freeze"}).appendTo(d);var Se=function e(t){var r=Qr(t).attr(ue);Object.values(r).forEach(function(e){if(e&&e.startsWith("url(")){var t=kt(e).substr(1);zt(t)||(Pt().append(Ie[t]),delete Ie[t])}});var n=t.getElementsByTagName("*");if(n.length)for(var i=0,a=n.length;i<a;i++)e(n[i])},be={},we={round_digits:5},ke={},Ce=_.text,Ge={},Ie={},Te=s.imgPath+"logo.png",Le=!1,Ve=null,Oe="select",Me="none",Re=S,Be=null,Ue=null,He=[],je=null;this.runExtension=function(e,t,r){return this.runExtensions(t,r,!1,function(t){return t===e})};var Fe=this.runExtensions=function(e,t,r,n){var i=!!r&&[];return Qr.each(Ge,function(a,s){n&&!n(a)||s&&e in s&&("function"==typeof t&&(t=t(a)),r?i.push(s[e](t)):i=s[e](t))}),i};this.addExtension=(De=r(regeneratorRuntime.mark(function e(t,r,n){var i,a,s,o;return regeneratorRuntime.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(i=n.$,a=n.importLocale,"function"==typeof r){e.next=3;break}throw new TypeError("Function argument expected for `svgcanvas.addExtension`");case 3:if(!(t in Ge)){e.next=5;break}throw new Error('Cannot add extension "'+t+'", an extension by that name already exists.');case 5:return s=Qr.extend(u.getPrivateMethods(),{$:i,importLocale:a,svgroot:d,svgcontent:m,nonce:y().getNonce(),selectorManager:W}),e.next=8,r(s);case 8:return(o=e.sent)&&(o.name=t),Ge[t]=o,e.abrupt("return",ee("extension_added",o));case 12:case"end":return e.stop()}},e,this)})),function(e,t,r){return De.apply(this,arguments)});var De;var ze=this.getIntersectionList=function(e){if(Zt(Ue))return null;var t,r=x||y().getCurrentLayer();if(e)(t=m.createSVGRect()).x=e.x,t.y=e.y,t.width=e.width,t.height=e.height;else{t=Ue.getBBox();var n=m.createSVGRect();["x","y","width","height","top","right","bottom","left"].forEach(function(e){n[e]=t[e]/v}),t=n}var i=null;if(R||"function"==typeof d.getIntersectionList&&(t.x+=parseInt(m.getAttribute("x")),t.y+=parseInt(m.getAttribute("y")),i=d.getIntersectionList(t,r)),Zt(i)||"function"!=typeof i.item){i=[],He.length||(He=qe(r));for(var a=He.length;a--;)t.width&&_e(t,He[a].bbox)&&i.push(He[a].elem)}return i};this.getStrokedBBox=Ht,this.getVisibleElements=Ut;var qe=this.getVisibleElementsAndBBoxes=function(e){e||(e=Qr(m).children());var t=[];return Qr(e).children().each(function(e,r){r.getBBox&&t.push({elem:r,bbox:Ht([r])})}),t.reverse()},We=this.groupSvgElem=function(e){var t=document.createElementNS(f.SVG,"g");e.replaceWith(t),Qr(t).append(e).data("gsvg",e)[0].id=Y()},Qe={};u.call=ee,u.bind=function(e,t){var r=Qe[e];return Qe[e]=t,r},this.prepareSvg=function(e){this.sanitizeSvg(e.documentElement),c(e.getElementsByTagNameNS(f.SVG,"path")).forEach(function(e){e.setAttribute("d",N.convertPath(e)),N.fixEnd(e)})};var Ye=function(e){if(!M())return e;var t=e.cloneNode(!0);return e.before(t),e.remove(),W.releaseSelector(e),b[0]=t,W.requestSelector(t).showGrips(!0),t};this.setRotationAngle=function(e,t){e=parseFloat(e);var r=b[0],n=r.getAttribute("transform"),i=It(r),a=i.x+i.width/2,s=i.y+i.height/2,o=Q(r);if(o.numberOfItems>0&&4===o.getItem(0).type&&o.removeItem(0),0!==e){var u=de(a,s,ye(o).matrix),l=d.createSVGTransform();l.setRotate(e,u.x,u.y),o.numberOfItems?o.insertItemBefore(l,0):o.appendItem(l)}else 0===o.numberOfItems&&r.removeAttribute("transform");if(!t){var h=r.getAttribute("transform");r.setAttribute("transform",n),Gr("transform",h,b),ee("changed",b)}W.requestSelector(b[0]).resize(),qr.updateGripCursors(e)};var Ze=this.recalculateAllSelectedDimensions=function(){for(var e=new $r("none"===Me?"position":"size"),t=b.length;t--;){var r=b[t],n=Fr(r);n&&e.addSubCommand(n)}e.isEmpty()||(U(e),ee("changed",b))},Ke=function(e){console.log([e.a,e.b,e.c,e.d,e.e,e.f])},$e=null,Je=this.selectOnly=function(e,t){re(!0),ne(e,t)};this.removeFromSelection=function(e){if(!Zt(b[0])&&e.length){for(var t=[],r=b.length,n=0;n<r;++n){var i=b[n];i&&(e.includes(i)?W.releaseSelector(i):t.push(i))}b=t}},this.selectAllInCurrentLayer=function(){var e=y().getCurrentLayer();e&&(Oe="select",Je(Qr(x||e).children()))};var et,tt,rt,nt,it,at,st,lt,ht,xt,_t,Nt,Tt,Mt,Rt,Bt=null;tt={minx:null,miny:null,maxx:null,maxy:null},rt=null,nt=null,it=null,at=null,st={},lt=0,ht={x:0,y:0},xt={x:0,y:0},_t={x:0,y:0},Nt={x:0,y:0},Tt={x:0,y:0},Mt={x:0,y:0},Rt=function(e){var t={x:0,y:0},r=ht,n=xt,i=_t,a=Nt,s=e*e,o=s*e,u=[[-1,3,-3,1],[3,-6,3,0],[-3,0,3,0],[1,4,1,0]];return t.x=1/6*((r.x*u[0][0]+n.x*u[0][1]+i.x*u[0][2]+a.x*u[0][3])*o+(r.x*u[1][0]+n.x*u[1][1]+i.x*u[1][2]+a.x*u[1][3])*s+(r.x*u[2][0]+n.x*u[2][1]+i.x*u[2][2]+a.x*u[2][3])*e+(r.x*u[3][0]+n.x*u[3][1]+i.x*u[3][2]+a.x*u[3][3])),t.y=1/6*((r.y*u[0][0]+n.y*u[0][1]+i.y*u[0][2]+a.y*u[0][3])*o+(r.y*u[1][0]+n.y*u[1][1]+i.y*u[1][2]+a.y*u[1][3])*s+(r.y*u[2][0]+n.y*u[2][1]+i.y*u[2][2]+a.y*u[2][3])*e+(r.y*u[3][0]+n.y*u[3][1]+i.y*u[3][2]+a.y*u[3][3])),{x:t.x,y:t.y}},Qr(i).mousedown(function(e){if(!u.spaceKey&&1!==e.button){var t=2===e.button;e.altKey&&u.cloneSelectedElements(0,0),$e=Qr("#svgcontent g")[0].getScreenCTM().inverse();var r=de(e.pageX,e.pageY,$e),n=r.x*v,i=r.y*v;e.preventDefault(),t&&(Oe="select",je=r);var a=n/v,o=i/v,l=ae(e);"a"===l.tagName&&1===l.childNodes.length&&(l=l.firstChild);var h=a;it=rt=a;var c=o;if(at=nt=o,s.gridSnapping&&(a=Qt(a),o=Qt(o),rt=Qt(rt),nt=Qt(nt)),l===W.selectorParentGroup&&!Zt(b[0])){var m=e.target,f=le(m,"type");"rotate"===f?Oe="rotate":"resize"===f&&(Oe="resize",Me=le(m,"dir")),l=b[0]}Ve=l.getAttribute("transform");var g=Q(l);switch(Oe){case"select":if(Le=!0,Me="none",t&&(Le=!1),l!==d){if(b.includes(l)||(e.shiftKey||re(!0),ne([l]),Be=l,N.clear()),!t)for(var p=0;p<b.length;++p)if(!Zt(b[p])){var y=Q(b[p]);y.numberOfItems?y.insertItemBefore(d.createSVGTransform(),0):y.appendItem(d.createSVGTransform())}}else t||(re(),Oe="multiselect",Zt(Ue)&&(Ue=W.getRubberBandBox()),qt(Ue,{x:it*=v,y:at*=v,width:0,height:0,display:"inline"},100));break;case"zoom":Le=!0,Zt(Ue)&&(Ue=W.getRubberBandBox()),qt(Ue,{x:h*v,y:h*v,width:0,height:0,display:"inline"},100);break;case"resize":Le=!0,rt=a,nt=o,st=It(Qr("#selectedBox0")[0]);var x={};Qr.each(st,function(e,t){x[e]=t/v}),st=x;var _=Ft(l)?1:0;if(ge(g))g.insertItemBefore(d.createSVGTransform(),_),g.insertItemBefore(d.createSVGTransform(),_),g.insertItemBefore(d.createSVGTransform(),_);else if(g.appendItem(d.createSVGTransform()),g.appendItem(d.createSVGTransform()),g.appendItem(d.createSVGTransform()),H()){var w,k=O();k&&(w=function(e){var t=e.getAttribute("stroke");e.removeAttribute("stroke"),null!==t&&setTimeout(function(){e.setAttribute("stroke",t)},0)}),l.style.vectorEffect="non-scaling-stroke",k&&w(l);for(var C=l.getElementsByTagName("*"),E=C.length,P=0;P<E;P++)C[P].style&&(C[P].style.vectorEffect="non-scaling-stroke",k&&w(C[P]))}break;case"fhellipse":case"fhrect":case"fhpath":_t.x=h,_t.y=c,Le=!0,A({element:"polyline",curStyles:!0,attr:{points:h+","+c+" ",id:Y(),fill:"none",opacity:S.opacity/2,"stroke-linecap":"round",style:"pointer-events:none"}}),tt.minx=h,tt.maxx=h,tt.miny=c,tt.maxy=c;break;case"image":Le=!0;var G=A({element:"image",attr:{x:a,y:o,width:0,height:0,id:Y(),opacity:S.opacity/2,style:"pointer-events:inherit"}});Et(G,Te),Yt(G);break;case"square":case"rect":Le=!0,rt=a,nt=o,A({element:"rect",curStyles:!0,attr:{x:a,y:o,width:0,height:0,id:Y(),opacity:S.opacity/2}});break;case"line":Le=!0;var I=0===Number(S.stroke_width)?1:S.stroke_width;A({element:"line",curStyles:!0,attr:{x1:a,y1:o,x2:a,y2:o,id:Y(),stroke:S.stroke,"stroke-width":I,"stroke-dasharray":S.stroke_dasharray,"stroke-linejoin":S.stroke_linejoin,"stroke-linecap":S.stroke_linecap,"stroke-opacity":S.stroke_opacity,fill:"none",opacity:S.opacity/2,style:"pointer-events:none"}});break;case"circle":Le=!0,A({element:"circle",curStyles:!0,attr:{cx:a,cy:o,r:0,id:Y(),opacity:S.opacity/2}});break;case"ellipse":Le=!0,A({element:"ellipse",curStyles:!0,attr:{cx:a,cy:o,rx:0,ry:0,id:Y(),opacity:S.opacity/2}});break;case"text":Le=!0,A({element:"text",curStyles:!0,attr:{x:a,y:o,id:Y(),fill:Ce.fill,"stroke-width":Ce.stroke_width,"font-size":Ce.font_size,"font-family":Ce.font_family,"text-anchor":"middle","xml:space":"preserve",opacity:S.opacity}});break;case"path":case"pathedit":rt*=v,nt*=v,N.mouseDown(e,l,rt,nt),Le=!0;break;case"textedit":rt*=v,nt*=v,Xt.mouseDown(e,l,rt,nt),Le=!0;break;case"rotate":Le=!0,u.undoMgr.beginUndoableChange("transform",b)}var T=Fe("mouseDown",{event:e,start_x:rt,start_y:nt,selectedElements:b},!0);Qr.each(T,function(e,t){t&&t.started&&(Le=!0)})}}).mousemove(function(e){if(Le&&1!==e.button&&!u.spaceKey){var t,r,n,i,a,o,l,h,c,f,g=b[0],p=de(e.pageX,e.pageY,$e),y=p.x*v,x=p.y*v,_=zt(Z()),S=y/v,w=S,A=x/v,k=A;switch(s.gridSnapping&&(w=Qt(w),k=Qt(k)),e.preventDefault(),Oe){case"select":if(null!==b[0]&&(a=w-rt,o=k-nt,s.gridSnapping&&(a=Qt(a),o=Qt(o)),0!==a||0!==o)){for(l=b.length,t=0;t<l&&(g=b[t],!Zt(g));++t){var C=d.createSVGTransform();f=Q(g),C.setTranslate(a,o),f.numberOfItems?f.replaceItem(C,0):f.appendItem(C),W.requestSelector(g).resize()}ee("transition",b)}break;case"multiselect":S*=v,A*=v,qt(Ue,{x:Math.min(it,S),y:Math.min(at,A),width:Math.abs(S-it),height:Math.abs(A-at)},100);var E=b.slice(),P=[],G=ze();for(l=G.length,t=0;t<l;++t){var I=G[t];b.includes(I)||P.push(I);var T=E.indexOf(I);-1!==T&&E.splice(T,1)}E.length>0&&u.removeFromSelection(E),P.length>0&&u.addToSelection(P);break;case"resize":f=Q(g);var L=ge(f),V=(c=L?st:It(g)).x,O=c.y,M=c,R=M.width,B=M.height;if(a=w-rt,o=k-nt,s.gridSnapping&&(a=Qt(a),o=Qt(o),B=Qt(B),R=Qt(R)),h=Ft(g)){var U=Math.sqrt(a*a+o*o),H=Math.atan2(o,a)-h*Math.PI/180;a=U*Math.cos(H),o=U*Math.sin(H)}Me.includes("n")||Me.includes("s")||(o=0),Me.includes("e")||Me.includes("w")||(a=0);var j=0,F=0,D=B?(B+o)/B:1,z=R?(R+a)/R:1;Me.includes("n")&&(D=B?(B-o)/B:1,F=B),Me.includes("w")&&(z=R?(R-a)/R:1,j=R);var q=d.createSVGTransform(),Y=d.createSVGTransform(),X=d.createSVGTransform();if(s.gridSnapping&&(V=Qt(V),j=Qt(j),O=Qt(O),F=Qt(F)),q.setTranslate(-(V+j),-(O+F)),e.shiftKey&&(1===z?z=D:D=z),Y.setScale(z,D),X.setTranslate(V+j,O+F),L){var K=h?1:0;f.replaceItem(q,2+K),f.replaceItem(Y,1+K),f.replaceItem(X,Number(K))}else{var $=f.numberOfItems;f.replaceItem(X,$-3),f.replaceItem(Y,$-2),f.replaceItem(q,$-1)}W.requestSelector(g).resize(),ee("transition",b);break;case"zoom":S*=v,A*=v,qt(Ue,{x:Math.min(it*v,S),y:Math.min(at*v,A),width:Math.abs(S-it*v),height:Math.abs(A-at*v)},100);break;case"text":qt(_,{x:w,y:k},1e3);break;case"line":s.gridSnapping&&(w=Qt(w),k=Qt(k));var J=w,te=k;e.shiftKey&&(J=(r=xe(rt,nt,J,te)).x,te=r.y),_.setAttribute("x2",J),_.setAttribute("y2",te);break;case"foreignObject":case"square":case"rect":case"image":var re,ne,ie="square"===Oe||e.shiftKey,ae=Math.abs(w-rt),se=Math.abs(k-nt);ie?(ae=se=Math.max(ae,se),re=rt<w?rt:rt-ae,ne=nt<k?nt:nt-se):(re=Math.min(rt,w),ne=Math.min(nt,k)),s.gridSnapping&&(ae=Qt(ae),se=Qt(se),re=Qt(re),ne=Qt(ne)),qt(_,{width:ae,height:se,x:re,y:ne},1e3);break;case"circle":var oe=Qr(_).attr(["cx","cy"]);n=oe.cx,i=oe.cy;var ue=Math.sqrt((w-n)*(w-n)+(k-i)*(k-i));s.gridSnapping&&(ue=Qt(ue)),_.setAttribute("r",ue);break;case"ellipse":var le=Qr(_).attr(["cx","cy"]);n=le.cx,i=le.cy,s.gridSnapping&&(w=Qt(w),n=Qt(n),k=Qt(k),i=Qt(i)),_.setAttribute("rx",Math.abs(w-n));var he=Math.abs(e.shiftKey?w-n:k-i);_.setAttribute("ry",he);break;case"fhellipse":case"fhrect":tt.minx=Math.min(S,tt.minx),tt.maxx=Math.max(S,tt.maxx),tt.miny=Math.min(A,tt.miny),tt.maxy=Math.max(A,tt.maxy);case"fhpath":if(Nt.x=S,Nt.y=A,ht.x&&ht.y)for(t=0;t<9;t++)if(et=t/10,Tt=Rt((t+1)/10),Mt=Tt,Tt=Rt(et),(lt+=Math.sqrt((Mt.x-Tt.x)*(Mt.x-Tt.x)+(Mt.y-Tt.y)*(Mt.y-Tt.y)))>.8){lt-=.8;var ce=m.createSVGPoint();ce.x=Tt.x,ce.y=Tt.y,_.points.appendItem(ce)}ht={x:xt.x,y:xt.y},xt={x:_t.x,y:_t.y},_t={x:Nt.x,y:Nt.y};break;case"path":case"pathedit":if(w*=v,k*=v,s.gridSnapping&&(w=Qt(w),k=Qt(k),rt=Qt(rt),nt=Qt(nt)),e.shiftKey){var me,fe,pe=Pe;pe?(me=pe.dragging?pe.dragging[0]:rt,fe=pe.dragging?pe.dragging[1]:nt):(me=rt,fe=nt);var ye=r=xe(me,fe,w,k);w=ye.x,k=ye.y}Ue&&"none"!==Ue.getAttribute("display")&&(S*=v,A*=v,qt(Ue,{x:Math.min(it*v,S),y:Math.min(at*v,A),width:Math.abs(S-it*v),height:Math.abs(A-at*v)},100)),N.mouseMove(w,k);break;case"textedit":w*=v,k*=v,Xt.mouseMove(y,x);break;case"rotate":n=(c=It(g)).x+c.width/2,i=c.y+c.height/2;var _e=ve(g),Se=de(n,i,_e);n=Se.x,i=Se.y,h=(Math.atan2(i-k,n-w)*(180/Math.PI)-90)%360,s.gridSnapping&&(h=Qt(h)),e.shiftKey&&(h=45*Math.round(h/45)),u.setRotationAngle(h<-180?360+h:h,!0),ee("transition",b)}Fe("mouseMove",{event:e,mouse_x:y,mouse_y:x,selected:g})}}).click(function(e){return e.preventDefault(),!1}).dblclick(function(e){var t=e.target.parentNode;if(t!==x){var r=ae(e),n=r.tagName;if("text"===n&&"textedit"!==Oe){var i=de(e.pageX,e.pageY,$e);Xt.select(r,i.x,i.y)}"g"!==n&&"a"!==n||!Ft(r)||(Ir(r),r=b[0],re(!0)),x&&Sr(),"g"!==t.tagName&&"a"!==t.tagName||t===y().getCurrentLayer()||r===W.selectorParentGroup||br(r)}}).mouseup(function(e){if(2!==e.button){var t=Be;if(Be=null,Le){var r,n,i=de(e.pageX,e.pageY,$e),a=i.x*v,o=i.y*v,l=a/v,h=o/v,c=zt(Z()),d=!1,m=l,f=h;switch(Le=!1,Oe){case"resize":case"multiselect":Zt(Ue)||(Ue.setAttribute("display","none"),He=[]),Oe="select";case"select":if(!Zt(b[0])){if(Zt(b[1])){var g=b[0];switch(g.tagName){case"g":case"use":case"image":case"foreignObject":break;default:Re.fill=g.getAttribute("fill"),Re.fill_opacity=g.getAttribute("fill-opacity"),Re.stroke=g.getAttribute("stroke"),Re.stroke_opacity=g.getAttribute("stroke-opacity"),Re.stroke_width=g.getAttribute("stroke-width"),Re.stroke_dasharray=g.getAttribute("stroke-dasharray"),Re.stroke_linejoin=g.getAttribute("stroke-linejoin"),Re.stroke_linecap=g.getAttribute("stroke-linecap")}"text"===g.tagName&&(Ce.font_size=g.getAttribute("font-size"),Ce.font_family=g.getAttribute("font-family")),W.requestSelector(g).showGrips(!0)}if(Ze(),m!==it||f!==at)for(var p=b.length,x=0;x<p&&!Zt(b[x]);++x)b[x].firstChild||W.requestSelector(b[x]).resize();else n=e.target,"path"===b[0].nodeName&&Zt(b[1])?N.select(b[0]):e.shiftKey&&t!==n&&u.removeFromSelection([n]);if(H()){var _=b[0];_&&(_.removeAttribute("style"),At(_,function(e){e.removeAttribute("style")}))}}return;case"zoom":Zt(Ue)||Ue.setAttribute("display","none");var w=e.shiftKey?.5:2;return void ee("zoomed",{x:Math.min(it,m),y:Math.min(at,f),width:Math.abs(m-it),height:Math.abs(f-at),factor:w});case"fhpath":lt=0,ht={x:0,y:0},xt={x:0,y:0},_t={x:0,y:0},Nt={x:0,y:0};var k=c.getAttribute("points"),C=k.indexOf(",");(d=C>=0?k.indexOf(",",C+1)>=0:k.indexOf(" ",k.indexOf(" ")+1)>=0)&&(c=N.smoothPolylineIntoPath(c));break;case"line":r=Qr(c).attr(["x1","x2","y1","y2"]),d=r.x1!==r.x2||r.y1!==r.y2;break;case"foreignObject":case"square":case"rect":case"image":r=Qr(c).attr(["width","height"]),d=r.width||r.height||"image"===Oe;break;case"circle":d="0"!==c.getAttribute("r");break;case"ellipse":r=Qr(c).attr(["rx","ry"]),d=r.rx||r.ry;break;case"fhellipse":tt.maxx-tt.minx>0&&tt.maxy-tt.miny>0&&(c=A({element:"ellipse",curStyles:!0,attr:{cx:(tt.minx+tt.maxx)/2,cy:(tt.miny+tt.maxy)/2,rx:(tt.maxx-tt.minx)/2,ry:(tt.maxy-tt.miny)/2,id:Z()}}),ee("changed",[c]),d=!0);break;case"fhrect":tt.maxx-tt.minx>0&&tt.maxy-tt.miny>0&&(c=A({element:"rect",curStyles:!0,attr:{x:tt.minx,y:tt.miny,width:tt.maxx-tt.minx,height:tt.maxy-tt.miny,id:Z()}}),ee("changed",[c]),d=!0);break;case"text":d=!0,Je([c]),Xt.start(c);break;case"path":c=null,Le=!0;var E=N.mouseUp(e,c,a,o);c=E.element,d=E.keep;break;case"pathedit":d=!0,c=null,N.mouseUp(e);break;case"textedit":d=!1,c=null,Xt.mouseUp(e,a,o);break;case"rotate":d=!0,c=null,Oe="select";var P=u.undoMgr.finishUndoableChange();P.isEmpty()||U(P),Ze(),ee("changed",b)}var G=Fe("mouseUp",{event:e,mouse_x:a,mouse_y:o},!0);if(Qr.each(G,function(e,t){t&&(d=t.keep||d,c=t.element,Le=t.started||Le)}),d||Zt(c)){if(!Zt(c)){u.addedNew=!0;var I,T=.2;if(ce.beginElement&&parseFloat(c.getAttribute("opacity"))!==S.opacity){I=Qr(ce).clone().attr({to:S.opacity,dur:T}).appendTo(c);try{I[0].beginElement()}catch(e){}}else T=0;setTimeout(function(){I&&I.remove(),c.setAttribute("opacity",S.opacity),c.setAttribute("style","pointer-events:inherit"),Wt(c),"path"===Oe?N.toEditMode(c):s.selectNew&&Je([c],!0),U(new Zr(c)),ee("changed",[c])},1e3*T)}}else{for(y().releaseId(Z()),c.remove(),c=null,n=e.target;n&&n.parentNode&&n.parentNode.parentNode&&"g"===n.parentNode.parentNode.tagName;)n=n.parentNode;"path"===Oe&&Bt||!n||!n.parentNode||"selectorParentGroup"===n.parentNode.id||"svgcanvas"===n.id||"svgroot"===n.id||(u.setMode("select"),Je([n],!0))}Ve=null}}}),Qr(i).bind("mousewheel DOMMouseScroll",function(e){if(e.shiftKey){e.preventDefault();var t=e.originalEvent;$e=Qr("#svgcontent g")[0].getScreenCTM().inverse();var r=Qr("#workarea"),n=s.showRulers?16:0,i=de(t.pageX,t.pageY,$e),a=r.width(),o=r.height(),l=a-15-n,h=o-15-n,c=l*$e.a,d=h*$e.d,m=r.offset(),f=m.left+n,g=m.top+n,p=t.wheelDelta?t.wheelDelta:t.detail?-t.detail:0;if(p){var y,x,_=Math.max(.75,Math.min(4/3,p));_>1?(y=Math.ceil(l/c*_*100)/100,x=Math.ceil(h/d*_*100)/100):(y=Math.floor(l/c*_*100)/100,x=Math.floor(h/d*_*100)/100);var S=Math.min(y,x);if((S=Math.min(10,Math.max(.01,S)))!==v){_=S/v;var b=de(f,g,$e),w={x:(i.x-(i.x-b.x)/_)*S-n+a/2,y:(i.y-(i.y-b.y)/_)*S-n+o/2};u.setZoom(S),Qr("#zoom").val((100*S).toFixed(1)),ee("updateCanvas",{center:!1,newCtr:w}),ee("zoomDone")}}}});var jt,Xt=u.textActions=function(){var e,t,r,n,i,a,s,o,l,h,c=[];function m(e){var s=""===t.value;if(Qr(t).focus(),!arguments.length)if(s)e=0;else{if(t.selectionEnd!==t.selectionStart)return;e=t.selectionEnd}var o=c[e];s||t.setSelectionRange(e,e),(r=zt("text_cursor"))||(r=document.createElementNS(f.SVG,"line"),qt(r,{id:"text_cursor",stroke:"#333","stroke-width":1}),r=zt("selectorParentGroup").appendChild(r)),i||(i=setInterval(function(){var e="none"===r.getAttribute("display");r.setAttribute("display",e?"inline":"none")},600));var u=S(o.x,a.y),l=S(o.x,a.y+a.height);qt(r,{x1:u.x,y1:u.y,x2:l.x,y2:l.y,visibility:"visible",display:"inline"}),n&&n.setAttribute("d","")}function g(e,i,s){if(e!==i){s||t.setSelectionRange(e,i),(n=zt("text_selectblock"))||(n=document.createElementNS(f.SVG,"path"),qt(n,{id:"text_selectblock",fill:"green",opacity:.5,style:"pointer-events:none"}),zt("selectorParentGroup").append(n));var o=c[e],u=c[i];r.setAttribute("visibility","hidden");var l=S(o.x,a.y),h=S(o.x+(u.x-o.x),a.y),d=S(o.x,a.y+a.height),g=S(o.x+(u.x-o.x),a.y+a.height),p="M"+l.x+","+l.y+" L"+h.x+","+h.y+" "+g.x+","+g.y+" "+d.x+","+d.y+"z";qt(n,{d:p,display:"inline"})}else m(i)}function p(t,r){var n=d.createSVGPoint();if(n.x=t,n.y=r,1===c.length)return 0;var i=e.getCharNumAtPosition(n);i<0?(i=c.length-2,t<=c[0].x&&(i=0)):i>=c.length-2&&(i=c.length-2);var a=c[i];return t>a.x+a.width/2&&i++,i}function y(e,t){m(p(e,t))}function x(e,r,n){var i=t.selectionStart,a=p(e,r);g(Math.min(i,a),Math.max(i,a),!n)}function _(e,t){var r={x:e,y:t};if(r.x/=v,r.y/=v,s){var n=de(r.x,r.y,s.inverse());r.x=n.x,r.y=n.y}return r}function S(e,t){var r={x:e,y:t};if(s){var n=de(r.x,r.y,s);r.x=n.x,r.y=n.y}return r.x*=v,r.y*=v,r}function w(t){g(0,e.textContent.length),Qr(this).unbind(t)}function A(t){if(h&&e){var r=de(t.pageX,t.pageY,$e),n=_(r.x*v,r.y*v),i=p(n.x,n.y),a=e.textContent,s=a.substr(0,i).replace(/[a-z0-9]+$/i,"").length,o=a.substr(i).match(/^[a-z0-9]+/i);g(s,(o?o[0].length:0)+i),Qr(t.target).click(w),setTimeout(function(){Qr(t.target).unbind("click",w)},300)}}return{select:function(t,r,n){e=t,Xt.toEditMode(r,n)},start:function(t){e=t,Xt.toEditMode()},mouseDown:function(e,r,n,i){var a=_(n,i);t.focus(),y(a.x,a.y),o=n,l=i},mouseMove:function(e,t){var r=_(e,t);x(r.x,r.y)},mouseUp:function(t,r,n){var i=_(r,n);x(i.x,i.y,!0),t.target!==e&&r<o+2&&r>o-2&&n<l+2&&n>l-2&&Xt.toSelectMode(!0)},setCursor:m,toEditMode:function(t,r){if(h=!1,Oe="textedit",W.requestSelector(e).showGrips(!1),W.requestSelector(e),Xt.init(),Qr(e).css("cursor","text"),arguments.length){var n=_(t,r);y(n.x,n.y)}else m();setTimeout(function(){h=!0},300)},toSelectMode:function(a){Oe="select",clearInterval(i),i=null,n&&Qr(n).attr("display","none"),r&&Qr(r).attr("visibility","hidden"),Qr(e).css("cursor","move"),a&&(re(),Qr(e).css("cursor","move"),ee("selected",[e]),ne([e],!0)),e&&!e.textContent.length&&u.deleteSelectedElements(),Qr(t).blur(),e=!1},setInputElem:function(e){t=e},clear:function(){"textedit"===Oe&&Xt.toSelectMode()},init:function(r){if(e){var n,i;e.parentNode||(e=b[0],W.requestSelector(e).showGrips(!1));var o=e.textContent.length,l=e.getAttribute("transform");for(a=It(e),s=l?ve(e):null,(c=[]).length=o,t.focus(),Qr(e).unbind("dblclick",A).dblclick(A),o||(i={x:a.x+a.width/2,width:0}),n=0;n<o;n++){var h=e.getStartPositionOfChar(n);if(i=e.getEndPositionOfChar(n),!G){var d=u.contentW*v;h.x-=d,i.x-=d,h.x/=v,i.x/=v}c[n]={x:h.x,y:a.y,width:i.x-h.x,height:a.height}}c.push({x:i.x,width:0}),g(t.selectionStart,t.selectionEnd,!0)}}}}(),Kt=this.removeUnusedDefElems=function(){var e=m.getElementsByTagNameNS(f.SVG,"defs");if(!e||!e.length)return 0;var t,r,n=[],i=0,a=["fill","stroke","filter","marker-start","marker-mid","marker-end"],s=a.length,o=m.getElementsByTagNameNS(f.SVG,"*"),u=o.length;for(t=0;t<u;t++){var l=o[t];for(r=0;r<s;r++){var h=kt(l.getAttribute(a[r]));h&&n.push(h.substr(1))}var c=Ct(l);c&&c.startsWith("#")&&n.push(c.substr(1))}var d=Qr(e).find("linearGradient, radialGradient, filter, marker, svg, symbol");for(t=d.length;t--;){var g=d[t],p=g.id;n.includes(p)||(Ie[p]=g,g.remove(),i++)}return i};function $t(){re();var e=[],t=[],r={feGaussianBlur:se.exportNoBlur,foreignObject:se.exportNoforeignObject,"[stroke-dasharray]":se.exportNoDashArray},n=Qr(m);return"font"in Qr("<canvas>")[0].getContext("2d")||(r.text=se.exportNoText),Qr.each(r,function(r,i){n.find(r).length&&(t.push(r),e.push(i))}),{issues:e,issueCodes:t}}this.svgCanvasToString=function(){for(;Kt()>0;);N.clear(!0),Qr.each(m.childNodes,function(e,t){e&&8===t.nodeType&&t.data.includes("Created with")&&m.firstChild.before(t)}),x&&(Sr(),Je([x]));var e=[];Qr(m).find("g:data(gsvg)").each(function(){for(var t=this.attributes,r=t.length,n=0;n<r;n++)"id"!==t[n].nodeName&&"style"!==t[n].nodeName||r--;if(r<=0){var i=this.firstChild;e.push(i),Qr(this).replaceWith(i)}});var t=this.svgToString(m,0);return e.length&&Qr(e).each(function(){We(this)}),t},this.svgToString=function(e,t){var r=[],n=s.baseUnit,i=new RegExp("^-?[\\d\\.]+"+n+"$");if(e){Wt(e);var a=c(e.attributes),o=e.childNodes;a.sort(function(e,t){return e.name>t.name?-1:1});for(var u=0;u<t;u++)r.push(" ");if(r.push("<"),r.push(e.nodeName),"svgcontent"===e.id){var l=sr();"px"!==n&&(l.w=J(l.w,n)+n,l.h=J(l.h,n)+n),r.push(' width="'+l.w+'" height="'+l.h+'" xmlns="'+f.SVG+'"');var h={};Qr(e).find("*").andSelf().each(function(){var e=this.namespaceURI;e&&!h[e]&&L[e]&&"xmlns"!==L[e]&&"xml"!==L[e]&&(h[e]=!0,r.push(" xmlns:"+L[e]+'="'+e+'"')),Qr.each(this.attributes,function(e,t){var n=t.namespaceURI;n&&!h[n]&&"xmlns"!==L[n]&&"xml"!==L[n]&&(h[n]=!0,r.push(" xmlns:"+L[n]+'="'+n+'"'))})});for(var d=a.length,m=["width","height","xmlns","x","y","viewBox","id","overflow"];d--;){var g=a[d],p=pt(g.value);g.nodeName.startsWith("xmlns:")||""===p||m.includes(g.localName)||g.namespaceURI&&!L[g.namespaceURI]||(r.push(" "),r.push(g.nodeName),r.push('="'),r.push(p),r.push('"'))}}else{if("defs"===e.nodeName&&!e.firstChild)return"";for(var y=["-moz-math-font-style","_moz-math-font-style"],v=a.length-1;v>=0;v--){var x=a[v],_=pt(x.value);if(!y.includes(x.localName)&&""!==_){if(_.startsWith("pointer-events"))continue;if("class"===x.localName&&_.startsWith("se_"))continue;if(r.push(" "),"d"===x.localName&&(_=N.convertPath(e,!0)),isNaN(_)?i.test(_)&&(_=$(_)+n):_=$(_),we.apply&&"image"===e.nodeName&&"href"===x.localName&&we.images&&"embed"===we.images){var S=be[_];S&&(_=S)}x.namespaceURI&&x.namespaceURI!==f.SVG&&!L[x.namespaceURI]||(r.push(x.nodeName),r.push('="'),r.push(_),r.push('"'))}}}if(e.hasChildNodes()){r.push(">"),t++;for(var b=!1,w=0;w<o.length;w++){var A=o.item(w);switch(A.nodeType){case 1:r.push("\n"),r.push(this.svgToString(o.item(w),t));break;case 3:var k=A.nodeValue.replace(/^\s+|\s+$/g,"");""!==k&&(b=!0,r.push(String(pt(k))));break;case 4:r.push("\n"),r.push(new Array(t+1).join(" ")),r.push("<![CDATA["),r.push(A.nodeValue),r.push("]]>");break;case 8:r.push("\n"),r.push(new Array(t+1).join(" ")),r.push("\x3c!--"),r.push(A.data),r.push("--\x3e")}}if(t--,!b){r.push("\n");for(var C=0;C<t;C++)r.push(" ")}r.push("</"),r.push(e.nodeName),r.push(">")}else r.push("/>")}return r.join("")},this.embedImage=function(e){return new Promise(function(t,r){Qr(new Image).load(function(n,i,a){if("error"!==i){var s=document.createElement("canvas");s.width=this.width,s.height=this.height,s.getContext("2d").drawImage(this,0,0);try{var o=";svgedit_url="+encodeURIComponent(e);o=s.toDataURL().replace(";base64",o+";base64"),be[e]=o}catch(t){be[e]=!1}Te=e,t(be[e])}else r(new Error("Error loading image: "+a.status+" "+a.statusText))}).attr("src",e)})},this.setGoodImage=function(e){Te=e},this.open=function(){},this.save=function(e){re(),e&&Qr.extend(we,e),we.apply=!0;var t=this.svgCanvasToString();ee("saved",t)},this.rasterExport=(er=r(regeneratorRuntime.mark(function e(t,r,n){var i,a,o,l,h,c,d,m,f,g=arguments;return regeneratorRuntime.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(i=g.length>3&&void 0!==g[3]?g[3]:{},o="image/"+(a="ICO"===t?"BMP":t||"PNG").toLowerCase(),l=$t(),h=l.issues,c=l.issueCodes,d=this.svgCanvasToString(),jt){e.next=10;break}return e.next=8,Pr(s.canvgPath+"canvg.js",{global:"canvg"});case 8:m=e.sent,jt=m.canvg;case 10:return Qr("#export_canvas").length||Qr("<canvas>",{id:"export_canvas"}).hide().appendTo("body"),(f=Qr("#export_canvas")[0]).width=u.contentW,f.height=u.contentH,e.next=16,jt(f,d);case 16:return e.abrupt("return",new Promise(function(e,s){var u,l=a.toLowerCase(),m=r?f.toDataURL("image/"+l,r):f.toDataURL("image/"+l);function g(){var a={datauri:m,bloburl:u,svg:d,issues:h,issueCodes:c,type:t,mimeType:o,quality:r,exportWindowName:n};i.avoidEvent||ee("exported",a),e(a)}f.toBlob?f.toBlob(function(e){u=bt(e),g()},o,r):(u=St(m),g())}));case 17:case"end":return e.stop()}},e,this)})),function(e,t,r){return er.apply(this,arguments)}),this.exportPDF=(Jt=r(regeneratorRuntime.mark(function e(t){var r,n,i,a,o,u,l,h,c,d,m,f=arguments;return regeneratorRuntime.wrap(function(e){for(;;)switch(e.prev=e.next){case 0:if(r=f.length>1&&void 0!==f[1]?f[1]:B()?"save":void 0,window.jsPDF){e.next=7;break}return e.next=4,Nr(["jspdf/underscore-min.js","jspdf/jspdf.min.js"]);case 4:return n=!("svgEditor"in window&&window.svgEditor&&!1===window.svgEditor.modules),e.next=7,Nr(s.jspdfPath+"jspdf.plugin.svgToPdf.js",{type:n?"module":"text/javascript"});case 7:return i=sr(),a=i.w>i.h?"landscape":"portrait",o=jsPDF({orientation:a,unit:"pt",format:[i.w,i.h]}),u=wr(),o.setProperties({title:u}),l=$t(),h=l.issues,c=l.issueCodes,d=this.svgCanvasToString(),o.addSVG(d,0,0),(m={svg:d,issues:h,issueCodes:c,exportWindowName:t,outputType:r=r||"dataurlstring"}).output=o.output(r,"save"===r?t||"svg.pdf":void 0),ee("exportedPDF",m),e.abrupt("return",m);case 21:case"end":return e.stop()}},e,this)})),function(e){return Jt.apply(this,arguments)}),this.getSvgString=function(){return we.apply=!1,this.svgCanvasToString()},this.randomizeIds=function(e){arguments.length>0&&!1===e?lr(!1,y()):lr(!0,y())};var Jt;var er;var tr=this.uniquifyElems=function(e){var t={},r=["filter","linearGradient","pattern","radialGradient","symbol","textPath","use"];for(var n in At(e,function(e){if(1===e.nodeType){e.id&&(e.id in t||(t[e.id]={elem:null,attrs:[],hrefs:[]}),t[e.id].elem=e),Qr.each(ue,function(r,n){var i=e.getAttributeNode(n);if(i){var a=kt(i.value),s=a?a.substr(1):null;s&&(s in t||(t[s]={elem:null,attrs:[],hrefs:[]}),t[s].attrs.push(i))}});var n=Ct(e);if(n&&r.includes(e.nodeName)){var i=n.substr(1);i&&(i in t||(t[i]={elem:null,attrs:[],hrefs:[]}),t[i].hrefs.push(e))}}}),t)if(n){var i=t[n].elem;if(i){var a=Y();i.id=a;for(var s=t[n].attrs,o=s.length;o--;){var u=s[o];u.ownerElement.setAttribute(u.name,"url(#"+a+")")}for(var l=t[n].hrefs,h=l.length;h--;){var c=l[h];Et(c,"#"+a)}}}},rr=this.setUseData=function(e){var t=Qr(e);"use"!==e.tagName&&(t=t.find("use")),t.each(function(){var e=Ct(this).substr(1),t=zt(e);t&&(Qr(this).data("ref",t),"symbol"!==t.tagName&&"svg"!==t.tagName||Qr(this).data("symbol",t).data("ref",t))})},nr=this.convertGradients=function(e){var t=Qr(e).find("linearGradient, radialGradient");!t.length&&O()&&(t=Qr(e).find("*").filter(function(){return this.tagName.includes("Gradient")})),t.each(function(){if("userSpaceOnUse"===Qr(this).attr("gradientUnits")){var e=Qr(m).find('[fill="url(#'+this.id+')"],[stroke="url(#'+this.id+')"]');if(!e.length)return;var t=It(e[0]);if(!t)return;if("linearGradient"===this.tagName){var r=Qr(this).attr(["x1","y1","x2","y2"]),n=this.gradientTransform.baseVal;if(n&&n.numberOfItems>0){var i=ye(n).matrix,a=de(r.x1,r.y1,i),s=de(r.x2,r.y2,i);r.x1=a.x,r.y1=a.y,r.x2=s.x,r.y2=s.y,this.removeAttribute("gradientTransform")}Qr(this).attr({x1:(r.x1-t.x)/t.width,y1:(r.y1-t.y)/t.height,x2:(r.x2-t.x)/t.width,y2:(r.y2-t.y)/t.height}),this.removeAttribute("gradientUnits")}}})},ir=this.convertToGroup=function(e){e||(e=b[0]);var t,r=Qr(e),n=new $r;if(r.data("gsvg")){var i=e.firstChild,a=Qr(i).attr(["x","y"]);Qr(e.firstChild.firstChild).unwrap(),Qr(e).removeData("gsvg");var s=Q(e),o=d.createSVGTransform();o.setTranslate(a.x,a.y),s.appendItem(o),Fr(e),ee("selected",[e])}else if(r.data("symbol")){e=r.data("symbol"),t=r.attr("transform");var u=r.attr(["x","y"]),h=e.getAttribute("viewBox");if(h){var c=h.split(" ");u.x-=Number(c[0]),u.y-=Number(c[1])}t+=" translate("+(u.x||0)+","+(u.y||0)+")";var g=r.prev();n.addSubCommand(new Xr(r[0],r[0].nextSibling,r[0].parentNode)),r.remove();var p,y=Qr(m).find("use:data(symbol)").length,v=l.createElementNS(f.SVG,"g"),x=e.childNodes;for(p=0;p<x.length;p++)v.append(x[p].cloneNode(!0));if(M()){var _=Qr(Pt()).children("linearGradient,radialGradient,pattern").clone();Qr(v).append(_)}t&&v.setAttribute("transform",t);var S=e.parentNode;if(tr(v),M()&&Qr(Pt()).append(Qr(v).find("linearGradient,radialGradient,pattern")),v.id=Y(),g.after(v),S){if(!y){var w=e.nextSibling;e.remove(),n.addSubCommand(new Xr(e,w,S))}n.addSubCommand(new Zr(v))}rr(v),M()?nr(Pt()):nr(v),function(e,t){if(e&&1===e.nodeType){for(var r=e.childNodes.length;r--;)At(e.childNodes.item(r),t);t(e)}}(v,function(e){try{Fr(e)}catch(e){console.log(e)}}),Qr(v).find(oe).each(function(){this.id||(this.id=Y())}),Je([v]);var A=Ir(v,!0);A&&n.addSubCommand(A),U(n)}else console.log("Unexpected element to ungroup:",e)};this.setSvgString=function(e,t){try{var r=wt(e);if(r.firstElementChild&&r.firstElementChild.namespaceURI!==f.SVG)return!1;this.prepareSvg(r);var n=new $r("Change Source"),i=m.nextSibling,a=d.removeChild(m);n.addSubCommand(new Xr(a,i,d)),m=l.adoptNode?l.adoptNode(r.documentElement):l.importNode(r.documentElement,!0),d.append(m);var o=Qr(m);u.current_drawing_=new ur(m,p);var h=y().getNonce();h?ee("setnonce",h):ee("unsetnonce"),o.find("image").each(function(){var e=this;Yt(e);var t=Ct(this);if(t){if(t.startsWith("data:")){var r=t.match(/svgedit_url=(.*?);/);if(r){var n=decodeURIComponent(r[1]);Qr(new Image).load(function(){e.setAttributeNS(f.XLINK,"xlink:href",n)}).attr("src",n)}}u.embedImage(t)}}),o.find("svg").each(function(){if(!Qr(this).closest("defs").length){tr(this);var e=this.parentNode;1===e.childNodes.length&&"g"===e.nodeName?(Qr(e).data("gsvg",this),e.id=e.id||Y()):We(this)}}),M()&&o.find("linearGradient, radialGradient, pattern").appendTo(Pt()),rr(o),nr(o[0]);var c={id:"svgcontent",overflow:s.show_outside_canvas?"visible":"hidden"},g=!1;if(o.attr("viewBox")){var x=o.attr("viewBox").split(" ");c.width=x[2],c.height=x[3]}else Qr.each(["width","height"],function(e,t){var r=o.attr(t)||"100%";"%"===String(r).substr(-1)?g=!0:c[t]=te(t,r)});if(hr(),o.children().find(oe).each(function(){this.id||(this.id=Y())}),g){var _=Ht();c.width=_.width+_.x,c.height=_.height+_.y}c.width<=0&&(c.width=100),c.height<=0&&(c.height=100),o.attr(c),this.contentW=c.width,this.contentH=c.height,n.addSubCommand(new Zr(m));var S=o.attr(["width","height"]);n.addSubCommand(new Kr(d,S)),v=1,z={},re(),Ee={},d.append(W.selectorParentGroup),t||U(n),ee("changed",[m])}catch(e){return console.log(e),!1}return!0},this.importSvgString=function(e){var t,r,n;try{var i=yt(e.length+e).substr(0,32),a=!1;ke[i]&&Qr(ke[i].symbol).parents("#svgroot").length&&(a=!0);var s,o=new $r("Import Image");if(a)s=ke[i].symbol,r=ke[i].xform;else{var u,h=wt(e);this.prepareSvg(h),u=l.adoptNode?l.adoptNode(h.documentElement):l.importNode(h.documentElement,!0),tr(u);var c=te("width",u.getAttribute("width")),d=te("height",u.getAttribute("height")),g=u.getAttribute("viewBox"),p=g?g.split(" "):[0,0,c,d];for(t=0;t<4;++t)p[t]=Number(p[t]);var v=Number(m.getAttribute("height"));r="translate(0) "+(r=d>c?"scale("+v/3/p[3]+")":"scale("+v/3/p[2]+")")+" translate(0)",s=l.createElementNS(f.SVG,"symbol");var _=Pt();for(M()&&Qr(u).find("linearGradient, radialGradient, pattern").appendTo(_);u.firstChild;){var S=u.firstChild;s.append(S)}for(var b=u.attributes,w=0;w<b.length;w++){var A=b[w];s.setAttribute(A.nodeName,A.value)}s.id=Y(),ke[i]={symbol:s,xform:r},Pt().append(s),o.addSubCommand(new Zr(s))}(n=l.createElementNS(f.SVG,"use")).id=Y(),Et(n,"#"+s.id),(x||y().getCurrentLayer()).append(n),o.addSubCommand(new Zr(n)),re(),n.setAttribute("transform",r),Fr(n),Qr(n).data("symbol",s).data("ref",s),ne([n]),U(o),ee("changed",[m])}catch(e){return console.log(e),null}return n};var ar={identifyLayers:hr,createLayer:cr,cloneLayer:dr,deleteCurrentLayer:mr,setCurrentLayer:fr,renameCurrentLayer:gr,setCurrentLayerPosition:pr,setLayerVisibility:yr,moveSelectedToLayer:vr,mergeLayer:xr,mergeAllLayers:_r,leaveContext:Sr,setContext:br};Object.entries(ar).forEach(function(e){var t=h(e,2),r=t[0],n=t[1];u[r]=n}),function(e){or=e}({pathActions:N,getCurrentGroup:function(){return x},setCurrentGroup:function(e){x=e},getSelectedElements:P,getSVGContent:E,undoMgr:V,elData:le,getCurrentDrawing:y,clearSelection:re,call:ee,addCommandToHistory:U,changeSVGContent:function(){ee("changed",[m])}}),this.clear=function(){N.clear(),re(),u.clearSvgContentElement(),u.current_drawing_=new ur(m),u.createLayer("Layer 1"),u.undoMgr.resetUndoStack(),W.initGroup(),Ue=W.getRubberBandBox(),ee("cleared")},this.linkControlPoints=N.linkControlPoints,this.getContentElem=function(){return m},this.getRootElem=function(){return d};var sr=this.getResolution=function(){return{w:m.getAttribute("width")/v,h:m.getAttribute("height")/v,zoom:v}};this.getSnapToGrid=function(){return s.gridSnapping},this.getVersion=function(){return"svgcanvas.js ($Rev$)"},this.setUiStrings=function(t){Object.assign(se,t.notification),Qr=function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ok:"Ok",cancel:"Cancel"};t("#dialog_container").draggable({cancel:"#dialog_content, #dialog_buttons *",containment:"window"}).css("position","absolute");var n=t("#dialog_box"),i=t("#dialog_buttons"),a=t("#dialog_content");function s(s,o,u,l,h,c){a.html("<p>"+o.replace(/\n/g,"</p><p>")+"</p>").toggleClass("prompt","prompt"===s),i.empty();var d=t('<input type="button" value="'+r.ok+'">').appendTo(i);return new Promise(function(o,m){var f,g;if("alert"!==s&&t('<input type="button" value="'+r.cancel+'">').appendTo(i).click(function(){n.hide(),o(!1)}),"prompt"===s)(f=t('<input type="text">').prependTo(i)).val(u||""),f.bind("keydown","return",function(){d.click()});else if("select"===s){var p=t('<div style="text-align:center;">');if(f=t("<select>").appendTo(p),c){var y=t("<label>").text(c.label);(g=t('<input type="checkbox">').appendTo(y)).val(c.value),c.tooltip&&y.attr("title",c.tooltip),g.prop("checked",Boolean(c.checked)),p.append(t("<div>").append(y))}t.each(l||[],function(r,n){"object"===e(n)?f.append(t("<option>").val(n.value).html(n.text)):f.append(t("<option>").html(n))}),a.append(p),u&&f.val(u),h&&f.bind("change","return",h),f.bind("keydown","return",function(){d.click()})}else"process"===s&&d.hide();n.show(),d.click(function(){n.hide();var e="prompt"!==s&&"select"!==s||f.val();o(g?{response:e,checked:g.prop("checked")}:e)}).focus(),"prompt"!==s&&"select"!==s||f.focus()})}return t.alert=function(e){return s("alert",e)},t.confirm=function(e){return s("confirm",e)},t.process_cancel=function(e){return s("process",e)},t.prompt=function(e){return s("prompt",e,arguments.length>1&&void 0!==arguments[1]?arguments[1]:"")},t.select=function(e,t,r,n,i){return s("select",e,n,t,r,i)},t}(Qr,t.common),Ae(t)},this.setConfig=function(e){Object.assign(s,e)},this.getTitle=function(e){if(e=e||b[0]){for(var t=(e=Qr(e).data("gsvg")||Qr(e).data("symbol")||e).childNodes,r=0;r<t.length;r++)if("title"===t[r].nodeName)return t[r].textContent;return""}},this.setGroupTitle=function(e){var t=b[0];t=Qr(t).data("gsvg")||t;var r,n=Qr(t).children("title"),i=new $r("Set Label");if(e.length)n.length?(r=n[0],i.addSubCommand(new Kr(r,{"#text":r.textContent})),r.textContent=e):((r=l.createElementNS(f.SVG,"title")).textContent=e,Qr(t).prepend(r),i.addSubCommand(new Zr(r)));else{var a=n.nextSibling;i.addSubCommand(new Xr(n[0],a,t)),n.remove()}U(i)};var wr=this.getDocumentTitle=function(){return u.getTitle(m)};this.setDocumentTitle=function(e){for(var t=m.childNodes,r=!1,n="",i=new $r("Change Image Title"),a=0;a<t.length;a++)if("title"===t[a].nodeName){n=(r=t[a]).textContent;break}r||(r=l.createElementNS(f.SVG,"title"),m.insertBefore(r,m.firstChild)),e.length?r.textContent=e:r.remove(),i.addSubCommand(new Kr(r,{"#text":n})),U(i)},this.getEditorNS=function(e){return e&&m.setAttribute("xmlns:se",f.SE),f.SE},this.setResolution=function(e,t){var r,n=sr(),i=n.w,a=n.h;if("fit"===e){var s=Ht();if(!s)return!1;r=new $r("Fit Canvas to Content");var o=Ut();ne(o);var l=[],h=[];Qr.each(o,function(e,t){l.push(-1*s.x),h.push(-1*s.y)});var c=u.moveSelectedElements(l,h,!0);r.addSubCommand(c),re(),e=Math.round(s.width),t=Math.round(s.height)}return e===i&&t===a||(r||(r=new $r("Change Image Dimensions")),e=te("width",e),t=te("height",t),m.setAttribute("width",e),m.setAttribute("height",t),this.contentW=e,this.contentH=t,r.addSubCommand(new Kr(m,{width:i,height:a})),m.setAttribute("viewBox",[0,0,e/v,t/v].join(" ")),r.addSubCommand(new Kr(m,{viewBox:["0 0",i,a].join(" ")})),U(r),ee("changed",[m])),!0},this.getOffset=function(){return Qr(m).attr(["x","y"])},this.setBBoxZoom=function(t,r,n){var i,a=.85,s=function(e){if(!e)return!1;var t=Math.round(r/e.width*100*a)/100,i=Math.round(n/e.height*100*a)/100,s=Math.min(t,i);return u.setZoom(s),{zoom:s,bbox:e}};if("object"===e(t)){if(0===(i=t).width||0===i.height){var o=i.zoom?i.zoom:v*i.factor;return u.setZoom(o),{zoom:v,bbox:i}}return s(i)}switch(t){case"selection":if(!b[0])return;var l=Qr.map(b,function(e){if(e)return e});i=Ht(l);break;case"canvas":var h=sr();a=.95,i={width:h.w,height:h.h,x:0,y:0};break;case"content":i=Ht();break;case"layer":i=Ht(Ut(y().getCurrentLayer()));break;default:return}return s(i)},this.setZoom=function(e){var t=sr();m.setAttribute("viewBox","0 0 "+t.w/e+" "+t.h/e),v=e,Qr.each(b,function(e,t){t&&W.requestSelector(t).resize()}),N.zoomChange(),Fe("zoomChanged",e)},this.getMode=function(){return Oe},this.setMode=function(e){N.clear(!0),Xt.clear(),Re=b[0]&&"text"===b[0].nodeName?Ce:S,Oe=e},this.getColor=function(e){return Re[e]},this.setColor=function(e,t,r){S[e]=t,Re[e+"_paint"]={type:"solidColor"};var n=[];function i(e){"g"!==e.nodeName&&n.push(e)}for(var a=b.length;a--;){var s=b[a];s&&("g"===s.tagName?At(s,i):"fill"===e?"polyline"!==s.tagName&&"line"!==s.tagName&&n.push(s):n.push(s))}n.length>0&&(r?Er(e,t,n):(Gr(e,t,n),ee("changed",n)))};var Ar=this.setGradient=function(e){if(Re[e+"_paint"]&&"solidColor"!==Re[e+"_paint"].type){var t=u[e+"Grad"],r=kr(t),n=Pt();r?t=r:(t=n.appendChild(l.importNode(t,!0))).id=Y(),u.setColor(e,"url(#"+t.id+")")}},kr=function(e){for(var t=Pt(),r=Qr(t).find("linearGradient, radialGradient"),n=r.length,i=["r","cx","cy","fx","fy"];n--;){var a=r[n];if("linearGradient"===e.tagName){if(e.getAttribute("x1")!==a.getAttribute("x1")||e.getAttribute("y1")!==a.getAttribute("y1")||e.getAttribute("x2")!==a.getAttribute("x2")||e.getAttribute("y2")!==a.getAttribute("y2"))continue}else if("continue"===function(){var t=Qr(e).attr(i),r=Qr(a).attr(i),n=!1;if(Qr.each(i,function(e,i){t[i]!==r[i]&&(n=!0)}),n)return"continue"}())continue;var s=e.getElementsByTagNameNS(f.SVG,"stop"),o=a.getElementsByTagNameNS(f.SVG,"stop");if(s.length===o.length){for(var u=s.length;u--;){var l=s[u],h=o[u];if(l.getAttribute("offset")!==h.getAttribute("offset")||l.getAttribute("stop-opacity")!==h.getAttribute("stop-opacity")||l.getAttribute("stop-color")!==h.getAttribute("stop-color"))break}if(-1===u)return a}}return null};this.setPaint=function(e,t){var r=new Qr.jGraduate.Paint(t);switch(this.setPaintOpacity(e,r.alpha/100,!0),Re[e+"_paint"]=r,r.type){case"solidColor":this.setColor(e,"none"!==r.solidColor?"#"+r.solidColor:"none");break;case"linearGradient":case"radialGradient":u[e+"Grad"]=r[r.type],Ar(e)}},this.setStrokePaint=function(e){this.setPaint("stroke",e)},this.setFillPaint=function(e){this.setPaint("fill",e)},this.getStrokeWidth=function(){return Re.stroke_width},this.setStrokeWidth=function(e){if(0===e&&["line","path"].includes(Oe))u.setStrokeWidth(1);else{Re.stroke_width=e;for(var t=[],r=b.length;r--;){var n=b[r];n&&("g"===n.tagName?At(n,i):t.push(n))}t.length>0&&(Gr("stroke-width",e,t),ee("changed",b))}function i(e){"g"!==e.nodeName&&t.push(e)}},this.setStrokeAttr=function(e,t){S[e.replace("-","_")]=t;for(var r=[],n=b.length;n--;){var i=b[n];i&&("g"===i.tagName?At(i,function(e){"g"!==e.nodeName&&r.push(e)}):r.push(i))}r.length>0&&(Gr(e,t,r),ee("changed",b))},this.getStyle=function(){return S},this.getOpacity=ie,this.setOpacity=function(e){S.opacity=e,Gr("opacity",e)},this.getFillOpacity=function(){return S.fill_opacity},this.getStrokeOpacity=function(){return S.stroke_opacity},this.setPaintOpacity=function(e,t,r){S[e+"_opacity"]=t,r?Er(e+"-opacity",t):Gr(e+"-opacity",t)},this.getPaintOpacity=function(e){return"fill"===e?this.getFillOpacity():this.getStrokeOpacity()},this.getBlur=function(e){var t=0;if(e&&e.getAttribute("filter")){var r=zt(e.id+"_blur");r&&(t=r.firstChild.getAttribute("stdDeviation"))}return t},function(){var e=null,t=null,r=!1;function n(){var r=u.undoMgr.finishUndoableChange();e.addSubCommand(r),U(e),e=null,t=null}u.setBlurNoUndo=function(e){if(t)if(0===e)Er("filter",""),r=!0;else{var n=b[0];r&&Er("filter","url(#"+n.id+"_blur)"),O()&&(n.removeAttribute("filter"),n.setAttribute("filter","url(#"+n.id+"_blur)")),Er("stdDeviation",e,[t.firstChild]),u.setBlurOffsets(t,e)}else u.setBlur(e)},u.setBlurOffsets=function(e,t){t>3?qt(e,{x:"-50%",y:"-50%",width:"200%",height:"200%"},100):O()||(e.removeAttribute("x"),e.removeAttribute("y"),e.removeAttribute("width"),e.removeAttribute("height"))},u.setBlur=function(r,i){if(e)n();else{var a=b[0],s=a.id;t=zt(s+"_blur"),r-=0;var o=new $r;if(t)0===r&&(t=null);else{var l=A({element:"feGaussianBlur",attr:{in:"SourceGraphic",stdDeviation:r}});(t=A({element:"filter",attr:{id:s+"_blur"}})).append(l),Pt().append(t),o.addSubCommand(new Zr(t))}var h={filter:a.getAttribute("filter")};if(0===r)return a.removeAttribute("filter"),void o.addSubCommand(new Kr(a,h));Gr("filter","url(#"+s+"_blur)"),o.addSubCommand(new Kr(a,h)),u.setBlurOffsets(t,r),e=o,u.undoMgr.beginUndoableChange("stdDeviation",[t?t.firstChild:null]),i&&(u.setBlurNoUndo(r),n())}}}(),this.getBold=function(){var e=b[0];return!(Zt(e)||"text"!==e.tagName||!Zt(b[1]))&&"bold"===e.getAttribute("font-weight")},this.setBold=function(e){var t=b[0];!Zt(t)&&"text"===t.tagName&&Zt(b[1])&&Gr("font-weight",e?"bold":"normal"),b[0].textContent||Xt.setCursor()},this.getItalic=function(){var e=b[0];return!(Zt(e)||"text"!==e.tagName||!Zt(b[1]))&&"italic"===e.getAttribute("font-style")},this.setItalic=function(e){var t=b[0];!Zt(t)&&"text"===t.tagName&&Zt(b[1])&&Gr("font-style",e?"italic":"normal"),b[0].textContent||Xt.setCursor()},this.getFontFamily=function(){return Ce.font_family},this.setFontFamily=function(e){Ce.font_family=e,Gr("font-family",e),b[0]&&!b[0].textContent&&Xt.setCursor()},this.setFontColor=function(e){Ce.fill=e,Gr("fill",e)},this.getFontColor=function(){return Ce.fill},this.getFontSize=function(){return Ce.font_size},this.setFontSize=function(e){Ce.font_size=e,Gr("font-size",e),b[0].textContent||Xt.setCursor()},this.getText=function(){var e=b[0];return Zt(e)?"":e.textContent},this.setTextContent=function(e){Gr("#text",e),Xt.init(e),Xt.setCursor()},this.setImageURL=function(e){var t=b[0];if(t){var r=Qr(t).attr(["width","height"]),n=!r.width||!r.height,i=Ct(t);if(i!==e||n){var a=new $r("Change Image URL");Et(t,e),a.addSubCommand(new Kr(t,{"#href":i})),Qr(new Image).load(function(){var e=Qr(t).attr(["width","height"]);Qr(t).attr({width:this.width,height:this.height}),W.requestSelector(t).resize(),a.addSubCommand(new Kr(t,e)),U(a),ee("changed",[t])}).attr("src",e)}}},this.setLinkURL=function(e){var t=b[0];if(t){if("a"!==t.tagName){var r=Qr(t).parents("a");if(!r.length)return;t=r[0]}var n=Ct(t);if(n!==e){var i=new $r("Change Link URL");Et(t,e),i.addSubCommand(new Kr(t,{"#href":n})),U(i)}}},this.setRectRadius=function(e){var t=b[0];if(!Zt(t)&&"rect"===t.tagName){var r=t.getAttribute("rx");r!==String(e)&&(t.setAttribute("rx",e),t.setAttribute("ry",e),U(new Kr(t,{rx:r,ry:r},"Radius")),ee("changed",[t]))}},this.makeHyperlink=function(e){u.groupSelectedElements("a",e)},this.removeHyperlink=function(){u.ungroupSelectedElement()},this.setSegType=function(e){N.setSegType(e)},this.convertToPath=function(e,t){if(!Zt(e))return t?Ot(e,A,N):function(e,t,r,n,i,a,s,o){var u=new s.BatchCommand("Convert element to Path"),l=r({element:"path",attr:t=ut.extend({},t,Vt(e))}),h=e.getAttribute("transform");h&&l.setAttribute("transform",h);var c=e.id,d=e.parentNode;e.nextSibling?e.before(l):d.append(l);var m=Lt(e);if(m){if(l.setAttribute("d",m),h){var f=Q(l);ge(f)&&n.resetOrientation(l)}var g=e.nextSibling;return u.addSubCommand(new s.RemoveElementCommand(e,g,parent)),u.addSubCommand(new s.InsertElementCommand(l)),i(),e.remove(),l.setAttribute("id",c),l.removeAttribute("visibility"),a([l],!0),o(u),l}return l.remove(),null}(e,{fill:S.fill,"fill-opacity":S.fill_opacity,stroke:S.stroke,"stroke-width":S.stroke_width,"stroke-dasharray":S.stroke_dasharray,"stroke-linejoin":S.stroke_linejoin,"stroke-linecap":S.stroke_linecap,"stroke-opacity":S.stroke_opacity,opacity:S.opacity,visibility:"hidden"},A,N,re,ne,he,U);var r=b;Qr.each(r,function(e,t){t&&u.convertToPath(t)})};var Er=function(e,t,r){"pathedit"===Oe&&N.moveNode(e,t);for(var n=(r=r||b).length,i=["g","polyline","path"],a=function(){var a=r[n];if(Zt(a))return"continue";if(("x"===e||"y"===e)&&i.includes(a.tagName)){var s=Ht([a]),o="x"===e?t-s.x:0,l="y"===e?t-s.y:0;return u.moveSelectedElements(o*v,l*v,!0),"continue"}var h="#text"===e?a.textContent:a.getAttribute(e);if(Zt(h)&&(h=""),h!==String(t)){"#text"===e?(a.textContent=t,/rotate/.test(a.getAttribute("transform"))&&(a=Ye(a))):"#href"===e?Et(a,t):a.setAttribute(e,t),"textedit"===Oe&&"#text"!==e&&a.textContent.length&&Xt.toSelectMode(a),M()&&"text"===a.nodeName&&/rotate/.test(a.getAttribute("transform"))&&(String(t).startsWith("url")||["font-size","font-family","x","y"].includes(e)&&a.textContent)&&(a=Ye(a)),b.includes(a)&&setTimeout(function(){a.parentNode&&W.requestSelector(a).resize()},0);var c=Ft(a);if(0!==c&&"transform"!==e)for(var m=Q(a),f=m.numberOfItems;f--;)if(4===m.getItem(f).type){m.removeItem(f);var g=It(a),p=de(g.x+g.width/2,g.y+g.height/2,ye(m).matrix),y=p.x,x=p.y,_=d.createSVGTransform();_.setRotate(c,y,x),m.insertItemBefore(_,f);break}}};n--;)a()},Gr=this.changeSelectedAttribute=function(e,t,r){r=r||b,u.undoMgr.beginUndoableChange(e,r),Er(e,t,r);var n=u.undoMgr.finishUndoableChange();n.isEmpty()||U(n)};this.deleteSelectedElements=function(){for(var e=new $r("Delete Elements"),t=b.length,r=[],n=0;n<t;++n){var i=b[n];if(Zt(i))break;var a=i.parentNode,s=i;W.releaseSelector(s),Xe(s.id),"a"===a.tagName&&1===a.childNodes.length&&(s=a,a=a.parentNode);var o=s.nextSibling,u=a.removeChild(s);r.push(i),e.addSubCommand(new Xr(u,o,a))}b=[],e.isEmpty()||U(e),ee("changed",r),re()},this.cutSelectedElements=function(){u.copySelectedElements(),u.deleteSelectedElements()},this.copySelectedElements=function(){localStorage.setItem("svgedit_clipboard",JSON.stringify(b.map(function(e){return w(e)}))),Qr("#cmenu_canvas").enableContextMenuItems("#paste,#paste_in_place")},this.pasteElements=function(e,t,r){var n=JSON.parse(localStorage.getItem("svgedit_clipboard")),i=n.length;if(i){var a=[],s=new $r("Paste elements"),o={};for(n.forEach(function e(t){t.attr&&t.attr.id&&(o[t.attr.id]=Y(),t.attr.id=o[t.attr.id]),t.children&&t.children.forEach(e)}),Fe("IDsUpdated",{elems:n,changes:o},!0).forEach(function(e){e&&"remove"in e&&e.remove.forEach(function(e){n=n.filter(function(t){return t.attr.id!==e})})});i--;){var l=n[i];if(l){var h=A(l);a.push(h),s.addSubCommand(new Zr(h)),Se(h)}}if(Je(a),"in_place"!==e){var c,d;e?"point"===e&&(c=t,d=r):(c=je.x,d=je.y);var m=Ht(a),f=c-(m.x+m.width/2),g=d-(m.y+m.height/2),p=[],y=[];Qr.each(a,function(e,t){p.push(f),y.push(g)});var v=u.moveSelectedElements(p,y,!1);v&&s.addSubCommand(v)}U(s),ee("changed",a)}},this.groupSelectedElements=function(e,t){e||(e="g");var r,n="";switch(e){case"a":n="Make hyperlink",r=t||"";break;default:e="g",n="Group Elements"}var i=new $r(n),a=A({element:e,attr:{id:Y()}});"a"===e&&Et(a,r),i.addSubCommand(new Zr(a));for(var s=b.length;s--;){var o=b[s];if(!Zt(o)){"a"===o.parentNode.tagName&&1===o.parentNode.childNodes.length&&(o=o.parentNode);var u=o.nextSibling,l=o.parentNode;a.append(o),i.addSubCommand(new Yr(o,u,l))}}i.isEmpty()||U(i),Je([a],!0)};var Ir=this.pushGroupProperties=function(e,t){for(var r,n,i,a=e.childNodes,s=a.length,o=e.getAttribute("transform"),l=Q(e),h=ye(l).matrix,c=new $r("Push group properties"),m=Ft(e),f=Qr(e).attr(["filter","opacity"]),g=y(),p=0;p<s;p++){var v=a[p];if(1===v.nodeType){if(null!==f.opacity&&1!==f.opacity){var x=Math.round((v.getAttribute("opacity")||1)*f.opacity*100)/100;Gr("opacity",x,[v])}if(f.filter){var _=this.getBlur(v),S=_;n||(n=this.getBlur(e)),_?_=Number(n)+Number(_):0===_&&(_=n),S?r=Dt(v.getAttribute("filter")):r?(r=g.copyElem(r),Pt().append(r)):r=Dt(f.filter);var b="feGaussianBlur"===r.firstChild.tagName?"blur":"filter";r.id=v.id+"_"+b,Gr("filter","url(#"+r.id+")",[v]),_&&(Gr("stdDeviation",_,[r.firstChild]),u.setBlurOffsets(r,_))}var w=Q(v);if(v.tagName.includes("Gradient")&&(w=null),w&&"defs"!==v.tagName&&l.numberOfItems){if(m&&1===l.numberOfItems){var A=l.getItem(0).matrix,k=d.createSVGMatrix(),C=Ft(v);C&&(k=w.getItem(0).matrix);var E=It(v),P=ye(w).matrix,G=de(E.x+E.width/2,E.y+E.height/2,P),N=m+C,I=d.createSVGTransform();I.setRotate(N,G.x,G.y);var T=fe(A,k,I.matrix.inverse());if(C&&w.removeItem(0),N&&(w.numberOfItems?w.insertItemBefore(I,0):w.appendItem(I)),T.e||T.f){var L=d.createSVGTransform();L.setTranslate(T.e,T.f),w.numberOfItems?w.insertItemBefore(L,0):w.appendItem(L)}}else{var V=v.getAttribute("transform");(i={}).transform=V||"";var O=d.createSVGTransform(),M=ye(w).matrix,R=M.inverse(),B=fe(R,h,M);O.setMatrix(B),w.appendItem(O)}var U=Fr(v);U&&c.addSubCommand(U)}}}if(o&&((i={}).transform=o,e.setAttribute("transform",""),e.removeAttribute("transform"),c.addSubCommand(new Kr(e,i))),t&&!c.isEmpty())return c};this.ungroupSelectedElement=function(){var e=b[0];if(e)if(Qr(e).data("gsvg")||Qr(e).data("symbol"))ir(e);else{if("use"===e.tagName){var t=zt(Ct(e).substr(1));return Qr(e).data("symbol",t).data("ref",t),void ir(e)}var r=Qr(e).parents("a");if(r.length&&(e=r[0]),"g"===e.tagName||"a"===e.tagName){var n=new $r("Ungroup Elements"),i=Ir(e,!0);i&&n.addSubCommand(i);for(var a=e.parentNode,s=e.nextSibling,o=new Array(e.childNodes.length),u=0;e.firstChild;){var l=e.firstChild,h=l.nextSibling,c=l.parentNode;if("title"!==l.tagName)o[u++]=l=a.insertBefore(l,s),n.addSubCommand(new Yr(l,h,c));else{var d=l.nextSibling;n.addSubCommand(new Xr(l,d,c)),l.remove()}}re();var m=e.nextSibling;e=a.removeChild(e),n.addSubCommand(new Xr(e,m,a)),n.isEmpty()||U(n),ne(o)}}},this.moveToTopSelectedElement=function(){var e=h(b,1)[0];if(!Zt(e)){var t=e,r=t.parentNode,n=t.nextSibling;n!==(t=t.parentNode.appendChild(t)).nextSibling&&(U(new Yr(t,n,r,"top")),ee("changed",[t]))}},this.moveToBottomSelectedElement=function(){var e=h(b,1)[0];if(!Zt(e)){var t=e,r=t.parentNode,n=t.nextSibling,i=t.parentNode.firstChild;"title"===i.tagName&&(i=i.nextSibling),"defs"===i.tagName&&(i=i.nextSibling),n!==(t=t.parentNode.insertBefore(t,i)).nextSibling&&(U(new Yr(t,n,r,"bottom")),ee("changed",[t]))}},this.moveUpDownSelected=function(e){var t=b[0];if(t){var r,n;He=[];var i=Qr(ze(Ht([t]))).toArray();if("Down"===e&&i.reverse(),Qr.each(i,function(){return n?(r=this,!1):(this===t&&(n=!0),!0)}),r){var a=t,s=a.parentNode,o=a.nextSibling;Qr(r)["Down"===e?"before":"after"](a),o!==a.nextSibling&&(U(new Yr(a,o,s,"Move "+e)),ee("changed",[a]))}}},this.moveSelectedElements=function(e,t,r){e.constructor!==Array&&(e/=v,t/=v),r=r||!0;for(var n=new $r("position"),i=b.length;i--;){var a=b[i];if(!Zt(a)){var s=d.createSVGTransform(),o=Q(a);e.constructor===Array?s.setTranslate(e[i],t[i]):s.setTranslate(e,t),o.numberOfItems?o.insertItemBefore(s,0):o.appendItem(s);var u=Fr(a);u&&n.addSubCommand(u),W.requestSelector(a).resize()}}if(!n.isEmpty())return r&&U(n),ee("changed",b),n},this.cloneSelectedElements=function(e,t){var r,n,i=new $r("Clone Elements"),a=b.length;for(b.sort(function(e,t){return Qr(t).index()-Qr(e).index()}),r=0;r<a&&(n=b[r],!Zt(n));++r);var s=b.slice(0,r);this.clearSelection(!0);var o=y();for(r=s.length;r--;)n=s[r]=o.copyElem(s[r]),(x||o.getCurrentLayer()).append(n),i.addSubCommand(new Zr(n));i.isEmpty()||(ne(s.reverse()),this.moveSelectedElements(e,t,!1),U(i))},this.alignSelectedElements=function(e,t){var r=[],n=b.length;if(n){for(var i=Number.MAX_VALUE,a=Number.MIN_VALUE,s=Number.MAX_VALUE,o=Number.MIN_VALUE,l=Number.MIN_VALUE,h=Number.MIN_VALUE,c=0;c<n&&!Zt(b[c]);++c){var d=b[c];switch(r[c]=Ht([d]),t){case"smallest":(("l"===e||"c"===e||"r"===e)&&(l===Number.MIN_VALUE||l>r[c].width)||("t"===e||"m"===e||"b"===e)&&(h===Number.MIN_VALUE||h>r[c].height))&&(i=r[c].x,s=r[c].y,a=r[c].x+r[c].width,o=r[c].y+r[c].height,l=r[c].width,h=r[c].height);break;case"largest":(("l"===e||"c"===e||"r"===e)&&(l===Number.MIN_VALUE||l<r[c].width)||("t"===e||"m"===e||"b"===e)&&(h===Number.MIN_VALUE||h<r[c].height))&&(i=r[c].x,s=r[c].y,a=r[c].x+r[c].width,o=r[c].y+r[c].height,l=r[c].width,h=r[c].height);break;default:r[c].x<i&&(i=r[c].x),r[c].y<s&&(s=r[c].y),r[c].x+r[c].width>a&&(a=r[c].x+r[c].width),r[c].y+r[c].height>o&&(o=r[c].y+r[c].height)}}"page"===t&&(i=0,s=0,a=u.contentW,o=u.contentH);for(var m=new Array(n),f=new Array(n),g=0;g<n&&!Zt(b[g]);++g){var p=r[g];switch(m[g]=0,f[g]=0,e){case"l":m[g]=i-p.x;break;case"c":m[g]=(i+a)/2-(p.x+p.width/2);break;case"r":m[g]=a-(p.x+p.width);break;case"t":f[g]=s-p.y;break;case"m":f[g]=(s+o)/2-(p.y+p.height/2);break;case"b":f[g]=o-(p.y+p.height)}}this.moveSelectedElements(m,f)}},this.contentW=sr().w,this.contentH=sr().h,this.updateCanvas=function(e,t){d.setAttribute("width",e),d.setAttribute("height",t);var r=Qr("#canvasBackground")[0],n=m.getAttribute("x"),i=m.getAttribute("y"),a=(e-this.contentW*v)/2,s=(t-this.contentH*v)/2;qt(m,{width:this.contentW*v,height:this.contentH*v,x:a,y:s,viewBox:"0 0 "+this.contentW+" "+this.contentH}),qt(r,{width:m.getAttribute("width"),height:m.getAttribute("height"),x:a,y:s});var o=zt("background_image");return o&&qt(o,{width:"100%",height:"100%"}),W.selectorParentGroup.setAttribute("transform","translate("+a+","+s+")"),Fe("canvasUpdated",{new_x:a,new_y:s,old_x:n,old_y:i,d_x:a-n,d_y:s-i}),{x:a,y:s,old_x:n,old_y:i,d_x:a-n,d_y:s-i}},this.setBackground=function(e,t){var r=zt("canvasBackground"),n=Qr(r).find("rect")[0],i=zt("background_image");n.setAttribute("fill",e),t?(i||(i=l.createElementNS(f.SVG,"image"),qt(i,{id:"background_image",width:"100%",height:"100%",preserveAspectRatio:"xMinYMin",style:"pointer-events:none"})),Et(i,t),r.append(i)):i&&i.remove()},this.cycleElement=function(e){var t,r=b[0],n=!1,i=Ut(x||y().getCurrentLayer());if(i.length){if(Zt(r))n=i[t=e?i.length-1:0];else for(var a=i.length;a--;)if(i[a]===r){(t=e?a-1:a+1)>=i.length?t=0:t<0&&(t=i.length-1),n=i[t];break}Je([n],!0),ee("selected",b)}},this.clear(),this.getPrivateMethods=function(){return{addCommandToHistory:U,BatchCommand:$r,ChangeElementCommand:Kr,decode64:vt,dropXMLInteralSubset:gt,encode64:yt,ffClone:Ye,findDefs:Pt,findDuplicateGradient:kr,getElem:zt,getPathBBox:Gt,getTypeMap:K,getUrlFromAttr:kt,identifyLayers:hr,InsertElementCommand:Zr,isChrome:B,isIdentity:me,isIE:R,logMatrix:Ke,MoveElementCommand:Yr,NS:f,preventClickDefault:Yt,RemoveElementCommand:Xr,SVGEditTransformList:q,text2xml:wt,transformBox:pe,transformPoint:de,walkTree:At}}}}();
+//# sourceMappingURL=svgcanvas-iife.min.js.map
diff --git a/dist/svgcanvas-iife.min.js.map b/dist/svgcanvas-iife.min.js.map
new file mode 100644
index 00000000..43088b51
--- /dev/null
+++ b/dist/svgcanvas-iife.min.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"svgcanvas-iife.min.js","sources":["../editor/jQuery.attr.js","../editor/svgpathseg.js","../editor/namespaces.js","../editor/browser.js","../editor/svgtransformlist.js","../editor/units.js","../editor/history.js","../editor/math.js","../editor/path.js","../editor/utilities.js","../editor/layer.js","../editor/historyrecording.js","../editor/draw.js","../editor/sanitize.js","../editor/external/dynamic-import-polyfill/importModule.js","../editor/coords.js","../editor/recalculate.js","../editor/select.js","../editor/svgcanvas.js","../editor/dbox.js"],"sourcesContent":["/**\n * jQuery module to work with SVG attributes\n * @module jQueryAttr\n * @license MIT\n */\n\n/**\n* This fixes `$(...).attr()` to work as expected with SVG elements.\n* Does not currently use `*AttributeNS()` since we rarely need that.\n* Adds {@link external:jQuery.fn.attr}.\n* See {@link https://api.jquery.com/attr/} for basic documentation of `.attr()`.\n*\n* Additional functionality:\n* - When getting attributes, a string that's a number is returned as type number.\n* - If an array is supplied as the first parameter, multiple values are returned\n*    as an object with values for each given attribute.\n* @function module:jQueryAttr.jQueryAttr\n* @param {external:jQuery} $ The jQuery object to which to add the plug-in\n* @returns {external:jQuery}\n*/\nexport default function jQueryPluginSVG ($) {\n  const proxied = $.fn.attr,\n    svgns = 'http://www.w3.org/2000/svg';\n  /**\n  * @typedef {PlainObject.<string, string|Float>} module:jQueryAttr.Attributes\n  */\n  /**\n  * @function external:jQuery.fn.attr\n  * @param {string|string[]|PlainObject.<string, string>} key\n  * @param {string} value\n  * @returns {external:jQuery|module:jQueryAttr.Attributes}\n  */\n  $.fn.attr = function (key, value) {\n    const len = this.length;\n    if (!len) { return proxied.call(this, key, value); }\n    for (let i = 0; i < len; ++i) {\n      const elem = this[i];\n      // set/get SVG attribute\n      if (elem.namespaceURI === svgns) {\n        // Setting attribute\n        if (value !== undefined) {\n          elem.setAttribute(key, value);\n        } else if (Array.isArray(key)) {\n          // Getting attributes from array\n          const obj = {};\n          let j = key.length;\n\n          while (j--) {\n            const aname = key[j];\n            let attr = elem.getAttribute(aname);\n            // This returns a number when appropriate\n            if (attr || attr === '0') {\n              attr = isNaN(attr) ? attr : (attr - 0);\n            }\n            obj[aname] = attr;\n          }\n          return obj;\n        }\n        if (typeof key === 'object') {\n          // Setting attributes from object\n          for (const [name, val] of Object.entries(key)) {\n            elem.setAttribute(name, val);\n          }\n        // Getting attribute\n        } else {\n          let attr = elem.getAttribute(key);\n          if (attr || attr === '0') {\n            attr = isNaN(attr) ? attr : (attr - 0);\n          }\n          return attr;\n        }\n      } else {\n        return proxied.call(this, key, value);\n      }\n    }\n    return this;\n  };\n  return $;\n}\n","/* globals SVGPathSeg, SVGPathSegMovetoRel, SVGPathSegMovetoAbs,\n    SVGPathSegMovetoRel, SVGPathSegLinetoRel, SVGPathSegLinetoAbs,\n    SVGPathSegLinetoHorizontalRel, SVGPathSegLinetoHorizontalAbs,\n    SVGPathSegLinetoVerticalRel, SVGPathSegLinetoVerticalAbs,\n    SVGPathSegClosePath, SVGPathSegCurvetoCubicRel,\n    SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicSmoothRel,\n    SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoQuadraticRel,\n    SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticSmoothRel,\n    SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegArcRel, SVGPathSegArcAbs */\n/**\n* SVGPathSeg API polyfill\n* https://github.com/progers/pathseg\n*\n* This is a drop-in replacement for the `SVGPathSeg` and `SVGPathSegList` APIs\n* that were removed from SVG2 ({@link https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html}),\n* including the latest spec changes which were implemented in Firefox 43 and\n* Chrome 46.\n*/\n/* eslint-disable no-shadow, class-methods-use-this */\n// Linting: We avoid `no-shadow` as ESLint thinks these are still available globals\n// Linting: We avoid `class-methods-use-this` as this is a polyfill that must\n//   follow the conventions\n(() => {\nif (!('SVGPathSeg' in window)) {\n  // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg\n  class SVGPathSeg {\n    constructor (type, typeAsLetter, owningPathSegList) {\n      this.pathSegType = type;\n      this.pathSegTypeAsLetter = typeAsLetter;\n      this._owningPathSegList = owningPathSegList;\n    }\n    // Notify owning PathSegList on any changes so they can be synchronized back to the path element.\n    _segmentChanged () {\n      if (this._owningPathSegList) {\n        this._owningPathSegList.segmentChanged(this);\n      }\n    }\n  }\n  SVGPathSeg.prototype.classname = 'SVGPathSeg';\n\n  SVGPathSeg.PATHSEG_UNKNOWN = 0;\n  SVGPathSeg.PATHSEG_CLOSEPATH = 1;\n  SVGPathSeg.PATHSEG_MOVETO_ABS = 2;\n  SVGPathSeg.PATHSEG_MOVETO_REL = 3;\n  SVGPathSeg.PATHSEG_LINETO_ABS = 4;\n  SVGPathSeg.PATHSEG_LINETO_REL = 5;\n  SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6;\n  SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7;\n  SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8;\n  SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9;\n  SVGPathSeg.PATHSEG_ARC_ABS = 10;\n  SVGPathSeg.PATHSEG_ARC_REL = 11;\n  SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12;\n  SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13;\n  SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14;\n  SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15;\n  SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;\n  SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;\n  SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;\n  SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;\n\n  class SVGPathSegClosePath extends SVGPathSeg {\n    constructor (owningPathSegList) {\n      super(SVGPathSeg.PATHSEG_CLOSEPATH, 'z', owningPathSegList);\n    }\n    toString () { return '[object SVGPathSegClosePath]'; }\n    _asPathString () { return this.pathSegTypeAsLetter; }\n    clone () { return new SVGPathSegClosePath(undefined); }\n  }\n\n  class SVGPathSegMovetoAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y) {\n      super(SVGPathSeg.PATHSEG_MOVETO_ABS, 'M', owningPathSegList);\n      this._x = x;\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegMovetoAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegMovetoAbs(undefined, this._x, this._y); }\n  }\n  Object.defineProperties(SVGPathSegMovetoAbs.prototype, {\n    x: {\n      get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true\n    },\n    y: {\n      get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true\n    }\n  });\n\n  class SVGPathSegMovetoRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y) {\n      super(SVGPathSeg.PATHSEG_MOVETO_REL, 'm', owningPathSegList);\n      this._x = x;\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegMovetoRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegMovetoRel(undefined, this._x, this._y); }\n  }\n  Object.defineProperties(SVGPathSegMovetoRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegLinetoAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y) {\n      super(SVGPathSeg.PATHSEG_LINETO_ABS, 'L', owningPathSegList);\n      this._x = x;\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegLinetoAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegLinetoAbs(undefined, this._x, this._y); }\n  }\n  Object.defineProperties(SVGPathSegLinetoAbs.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegLinetoRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y) {\n      super(SVGPathSeg.PATHSEG_LINETO_REL, 'l', owningPathSegList);\n      this._x = x;\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegLinetoRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegLinetoRel(undefined, this._x, this._y); }\n  }\n  Object.defineProperties(SVGPathSegLinetoRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoCubicAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, x1, y1, x2, y2) {\n      super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, 'C', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._x1 = x1;\n      this._y1 = y1;\n      this._x2 = x2;\n      this._y2 = y2;\n    }\n    toString () { return '[object SVGPathSegCurvetoCubicAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoCubicAbs.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n    y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true},\n    x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n    y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoCubicRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, x1, y1, x2, y2) {\n      super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, 'c', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._x1 = x1;\n      this._y1 = y1;\n      this._x2 = x2;\n      this._y2 = y2;\n    }\n    toString () { return '[object SVGPathSegCurvetoCubicRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoCubicRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n    y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true},\n    x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n    y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, x1, y1) {\n      super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, 'Q', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._x1 = x1;\n      this._y1 = y1;\n    }\n    toString () { return '[object SVGPathSegCurvetoQuadraticAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoQuadraticAbs.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n    y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, x1, y1) {\n      super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, 'q', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._x1 = x1;\n      this._y1 = y1;\n    }\n    toString () { return '[object SVGPathSegCurvetoQuadraticRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoQuadraticRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n    y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegArcAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {\n      super(SVGPathSeg.PATHSEG_ARC_ABS, 'A', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._r1 = r1;\n      this._r2 = r2;\n      this._angle = angle;\n      this._largeArcFlag = largeArcFlag;\n      this._sweepFlag = sweepFlag;\n    }\n    toString () { return '[object SVGPathSegArcAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); }\n  }\n  Object.defineProperties(SVGPathSegArcAbs.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    r1: {get () { return this._r1; }, set (r1) { this._r1 = r1; this._segmentChanged(); }, enumerable: true},\n    r2: {get () { return this._r2; }, set (r2) { this._r2 = r2; this._segmentChanged(); }, enumerable: true},\n    angle: {get () { return this._angle; }, set (angle) { this._angle = angle; this._segmentChanged(); }, enumerable: true},\n    largeArcFlag: {get () { return this._largeArcFlag; }, set (largeArcFlag) { this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true},\n    sweepFlag: {get () { return this._sweepFlag; }, set (sweepFlag) { this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegArcRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {\n      super(SVGPathSeg.PATHSEG_ARC_REL, 'a', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._r1 = r1;\n      this._r2 = r2;\n      this._angle = angle;\n      this._largeArcFlag = largeArcFlag;\n      this._sweepFlag = sweepFlag;\n    }\n    toString () { return '[object SVGPathSegArcRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); }\n  }\n  Object.defineProperties(SVGPathSegArcRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    r1: {get () { return this._r1; }, set (r1) { this._r1 = r1; this._segmentChanged(); }, enumerable: true},\n    r2: {get () { return this._r2; }, set (r2) { this._r2 = r2; this._segmentChanged(); }, enumerable: true},\n    angle: {get () { return this._angle; }, set (angle) { this._angle = angle; this._segmentChanged(); }, enumerable: true},\n    largeArcFlag: {get () { return this._largeArcFlag; }, set (largeArcFlag) { this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true},\n    sweepFlag: {get () { return this._sweepFlag; }, set (sweepFlag) { this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x) {\n      super(SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, 'H', owningPathSegList);\n      this._x = x;\n    }\n    toString () { return '[object SVGPathSegLinetoHorizontalAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x; }\n    clone () { return new SVGPathSegLinetoHorizontalAbs(undefined, this._x); }\n  }\n  Object.defineProperty(SVGPathSegLinetoHorizontalAbs.prototype, 'x', {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true});\n\n  class SVGPathSegLinetoHorizontalRel extends SVGPathSeg {\n    constructor (owningPathSegList, x) {\n      super(SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, 'h', owningPathSegList);\n      this._x = x;\n    }\n    toString () { return '[object SVGPathSegLinetoHorizontalRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x; }\n    clone () { return new SVGPathSegLinetoHorizontalRel(undefined, this._x); }\n  }\n  Object.defineProperty(SVGPathSegLinetoHorizontalRel.prototype, 'x', {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true});\n\n  class SVGPathSegLinetoVerticalAbs extends SVGPathSeg {\n    constructor (owningPathSegList, y) {\n      super(SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, 'V', owningPathSegList);\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegLinetoVerticalAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._y; }\n    clone () { return new SVGPathSegLinetoVerticalAbs(undefined, this._y); }\n  }\n  Object.defineProperty(SVGPathSegLinetoVerticalAbs.prototype, 'y', {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true});\n\n  class SVGPathSegLinetoVerticalRel extends SVGPathSeg {\n    constructor (owningPathSegList, y) {\n      super(SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, 'v', owningPathSegList);\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegLinetoVerticalRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._y; }\n    clone () { return new SVGPathSegLinetoVerticalRel(undefined, this._y); }\n  }\n  Object.defineProperty(SVGPathSegLinetoVerticalRel.prototype, 'y', {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true});\n\n  class SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, x2, y2) {\n      super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, 'S', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._x2 = x2;\n      this._y2 = y2;\n    }\n    toString () { return '[object SVGPathSegCurvetoCubicSmoothAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoCubicSmoothAbs.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n    y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y, x2, y2) {\n      super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, 's', owningPathSegList);\n      this._x = x;\n      this._y = y;\n      this._x2 = x2;\n      this._y2 = y2;\n    }\n    toString () { return '[object SVGPathSegCurvetoCubicSmoothRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoCubicSmoothRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n    x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n    y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {\n    constructor (owningPathSegList, x, y) {\n      super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, 'T', owningPathSegList);\n      this._x = x;\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegCurvetoQuadraticSmoothAbs]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoQuadraticSmoothAbs.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n  });\n\n  class SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {\n    constructor (owningPathSegList, x, y) {\n      super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, 't', owningPathSegList);\n      this._x = x;\n      this._y = y;\n    }\n    toString () { return '[object SVGPathSegCurvetoQuadraticSmoothRel]'; }\n    _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n    clone () { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y); }\n  }\n  Object.defineProperties(SVGPathSegCurvetoQuadraticSmoothRel.prototype, {\n    x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n    y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n  });\n\n  // Add createSVGPathSeg* functions to SVGPathElement.\n  // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement.\n  SVGPathElement.prototype.createSVGPathSegClosePath = function () { return new SVGPathSegClosePath(undefined); };\n  SVGPathElement.prototype.createSVGPathSegMovetoAbs = function (x, y) { return new SVGPathSegMovetoAbs(undefined, x, y); };\n  SVGPathElement.prototype.createSVGPathSegMovetoRel = function (x, y) { return new SVGPathSegMovetoRel(undefined, x, y); };\n  SVGPathElement.prototype.createSVGPathSegLinetoAbs = function (x, y) { return new SVGPathSegLinetoAbs(undefined, x, y); };\n  SVGPathElement.prototype.createSVGPathSegLinetoRel = function (x, y) { return new SVGPathSegLinetoRel(undefined, x, y); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function (x, y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function (x, y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function (x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function (x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1); };\n  SVGPathElement.prototype.createSVGPathSegArcAbs = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); };\n  SVGPathElement.prototype.createSVGPathSegArcRel = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); };\n  SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function (x) { return new SVGPathSegLinetoHorizontalAbs(undefined, x); };\n  SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function (x) { return new SVGPathSegLinetoHorizontalRel(undefined, x); };\n  SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function (y) { return new SVGPathSegLinetoVerticalAbs(undefined, y); };\n  SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function (y) { return new SVGPathSegLinetoVerticalRel(undefined, y); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function (x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function (x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function (x, y) { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y); };\n  SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function (x, y) { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y); };\n\n  if (!('getPathSegAtLength' in SVGPathElement.prototype)) {\n    // Add getPathSegAtLength to SVGPathElement.\n    // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-__svg__SVGPathElement__getPathSegAtLength\n    // This polyfill requires SVGPathElement.getTotalLength to implement the distance-along-a-path algorithm.\n    SVGPathElement.prototype.getPathSegAtLength = function (distance) {\n      if (distance === undefined || !isFinite(distance)) {\n        throw new Error('Invalid arguments.');\n      }\n\n      const measurementElement = document.createElementNS('http://www.w3.org/2000/svg', 'path');\n      measurementElement.setAttribute('d', this.getAttribute('d'));\n      let lastPathSegment = measurementElement.pathSegList.numberOfItems - 1;\n\n      // If the path is empty, return 0.\n      if (lastPathSegment <= 0) {\n        return 0;\n      }\n\n      do {\n        measurementElement.pathSegList.removeItem(lastPathSegment);\n        if (distance > measurementElement.getTotalLength()) {\n          break;\n        }\n        lastPathSegment--;\n      } while (lastPathSegment > 0);\n      return lastPathSegment;\n    };\n  }\n\n  window.SVGPathSeg = SVGPathSeg;\n  window.SVGPathSegClosePath = SVGPathSegClosePath;\n  window.SVGPathSegMovetoAbs = SVGPathSegMovetoAbs;\n  window.SVGPathSegMovetoRel = SVGPathSegMovetoRel;\n  window.SVGPathSegLinetoAbs = SVGPathSegLinetoAbs;\n  window.SVGPathSegLinetoRel = SVGPathSegLinetoRel;\n  window.SVGPathSegCurvetoCubicAbs = SVGPathSegCurvetoCubicAbs;\n  window.SVGPathSegCurvetoCubicRel = SVGPathSegCurvetoCubicRel;\n  window.SVGPathSegCurvetoQuadraticAbs = SVGPathSegCurvetoQuadraticAbs;\n  window.SVGPathSegCurvetoQuadraticRel = SVGPathSegCurvetoQuadraticRel;\n  window.SVGPathSegArcAbs = SVGPathSegArcAbs;\n  window.SVGPathSegArcRel = SVGPathSegArcRel;\n  window.SVGPathSegLinetoHorizontalAbs = SVGPathSegLinetoHorizontalAbs;\n  window.SVGPathSegLinetoHorizontalRel = SVGPathSegLinetoHorizontalRel;\n  window.SVGPathSegLinetoVerticalAbs = SVGPathSegLinetoVerticalAbs;\n  window.SVGPathSegLinetoVerticalRel = SVGPathSegLinetoVerticalRel;\n  window.SVGPathSegCurvetoCubicSmoothAbs = SVGPathSegCurvetoCubicSmoothAbs;\n  window.SVGPathSegCurvetoCubicSmoothRel = SVGPathSegCurvetoCubicSmoothRel;\n  window.SVGPathSegCurvetoQuadraticSmoothAbs = SVGPathSegCurvetoQuadraticSmoothAbs;\n  window.SVGPathSegCurvetoQuadraticSmoothRel = SVGPathSegCurvetoQuadraticSmoothRel;\n}\n\n// Checking for SVGPathSegList in window checks for the case of an implementation without the\n// SVGPathSegList API.\n// The second check for appendItem is specific to Firefox 59+ which removed only parts of the\n// SVGPathSegList API (e.g., appendItem). In this case we need to re-implement the entire API\n// so the polyfill data (i.e., _list) is used throughout.\nif (!('SVGPathSegList' in window) || !('appendItem' in window.SVGPathSegList.prototype)) {\n  // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList\n  class SVGPathSegList {\n    constructor (pathElement) {\n      this._pathElement = pathElement;\n      this._list = this._parsePath(this._pathElement.getAttribute('d'));\n\n      // Use a MutationObserver to catch changes to the path's \"d\" attribute.\n      this._mutationObserverConfig = {attributes: true, attributeFilter: ['d']};\n      this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this));\n      this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);\n    }\n    // Process any pending mutations to the path element and update the list as needed.\n    // This should be the first call of all public functions and is needed because\n    // MutationObservers are not synchronous so we can have pending asynchronous mutations.\n    _checkPathSynchronizedToList () {\n      this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords());\n    }\n\n    _updateListFromPathMutations (mutationRecords) {\n      if (!this._pathElement) {\n        return;\n      }\n      let hasPathMutations = false;\n      mutationRecords.forEach((record) => {\n        if (record.attributeName === 'd') {\n          hasPathMutations = true;\n        }\n      });\n      if (hasPathMutations) {\n        this._list = this._parsePath(this._pathElement.getAttribute('d'));\n      }\n    }\n\n    // Serialize the list and update the path's 'd' attribute.\n    _writeListToPath () {\n      this._pathElementMutationObserver.disconnect();\n      this._pathElement.setAttribute('d', SVGPathSegList._pathSegArrayAsString(this._list));\n      this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);\n    }\n\n    // When a path segment changes the list needs to be synchronized back to the path element.\n    segmentChanged (pathSeg) {\n      this._writeListToPath();\n    }\n\n    clear () {\n      this._checkPathSynchronizedToList();\n\n      this._list.forEach((pathSeg) => {\n        pathSeg._owningPathSegList = null;\n      });\n      this._list = [];\n      this._writeListToPath();\n    }\n\n    initialize (newItem) {\n      this._checkPathSynchronizedToList();\n\n      this._list = [newItem];\n      newItem._owningPathSegList = this;\n      this._writeListToPath();\n      return newItem;\n    }\n\n    _checkValidIndex (index) {\n      if (isNaN(index) || index < 0 || index >= this.numberOfItems) {\n        throw new Error('INDEX_SIZE_ERR');\n      }\n    }\n\n    getItem (index) {\n      this._checkPathSynchronizedToList();\n\n      this._checkValidIndex(index);\n      return this._list[index];\n    }\n\n    insertItemBefore (newItem, index) {\n      this._checkPathSynchronizedToList();\n\n      // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.\n      if (index > this.numberOfItems) {\n        index = this.numberOfItems;\n      }\n      if (newItem._owningPathSegList) {\n        // SVG2 spec says to make a copy.\n        newItem = newItem.clone();\n      }\n      this._list.splice(index, 0, newItem);\n      newItem._owningPathSegList = this;\n      this._writeListToPath();\n      return newItem;\n    }\n\n    replaceItem (newItem, index) {\n      this._checkPathSynchronizedToList();\n\n      if (newItem._owningPathSegList) {\n        // SVG2 spec says to make a copy.\n        newItem = newItem.clone();\n      }\n      this._checkValidIndex(index);\n      this._list[index] = newItem;\n      newItem._owningPathSegList = this;\n      this._writeListToPath();\n      return newItem;\n    }\n\n    removeItem (index) {\n      this._checkPathSynchronizedToList();\n\n      this._checkValidIndex(index);\n      const item = this._list[index];\n      this._list.splice(index, 1);\n      this._writeListToPath();\n      return item;\n    }\n\n    appendItem (newItem) {\n      this._checkPathSynchronizedToList();\n\n      if (newItem._owningPathSegList) {\n        // SVG2 spec says to make a copy.\n        newItem = newItem.clone();\n      }\n      this._list.push(newItem);\n      newItem._owningPathSegList = this;\n      // TODO: Optimize this to just append to the existing attribute.\n      this._writeListToPath();\n      return newItem;\n    }\n\n    // This closely follows SVGPathParser::parsePath from Source/core/svg/SVGPathParser.cpp.\n    _parsePath (string) {\n      if (!string || !string.length) {\n        return [];\n      }\n\n      const owningPathSegList = this; // eslint-disable-line consistent-this\n\n      class Builder {\n        constructor () {\n          this.pathSegList = [];\n        }\n        appendSegment (pathSeg) {\n          this.pathSegList.push(pathSeg);\n        }\n      }\n\n      class Source {\n        constructor (string) {\n          this._string = string;\n          this._currentIndex = 0;\n          this._endIndex = this._string.length;\n          this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN;\n\n          this._skipOptionalSpaces();\n        }\n        _isCurrentSpace () {\n          const character = this._string[this._currentIndex];\n          return character <= ' ' && (character === ' ' || character === '\\n' || character === '\\t' || character === '\\r' || character === '\\f');\n        }\n\n        _skipOptionalSpaces () {\n          while (this._currentIndex < this._endIndex && this._isCurrentSpace()) {\n            this._currentIndex++;\n          }\n          return this._currentIndex < this._endIndex;\n        }\n\n        _skipOptionalSpacesOrDelimiter () {\n          if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) !== ',') {\n            return false;\n          }\n          if (this._skipOptionalSpaces()) {\n            if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === ',') {\n              this._currentIndex++;\n              this._skipOptionalSpaces();\n            }\n          }\n          return this._currentIndex < this._endIndex;\n        }\n\n        hasMoreData () {\n          return this._currentIndex < this._endIndex;\n        }\n\n        peekSegmentType () {\n          const lookahead = this._string[this._currentIndex];\n          return this._pathSegTypeFromChar(lookahead);\n        }\n\n        _pathSegTypeFromChar (lookahead) {\n          switch (lookahead) {\n          case 'Z':\n          case 'z':\n            return SVGPathSeg.PATHSEG_CLOSEPATH;\n          case 'M':\n            return SVGPathSeg.PATHSEG_MOVETO_ABS;\n          case 'm':\n            return SVGPathSeg.PATHSEG_MOVETO_REL;\n          case 'L':\n            return SVGPathSeg.PATHSEG_LINETO_ABS;\n          case 'l':\n            return SVGPathSeg.PATHSEG_LINETO_REL;\n          case 'C':\n            return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;\n          case 'c':\n            return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;\n          case 'Q':\n            return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;\n          case 'q':\n            return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;\n          case 'A':\n            return SVGPathSeg.PATHSEG_ARC_ABS;\n          case 'a':\n            return SVGPathSeg.PATHSEG_ARC_REL;\n          case 'H':\n            return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;\n          case 'h':\n            return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;\n          case 'V':\n            return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;\n          case 'v':\n            return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;\n          case 'S':\n            return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;\n          case 's':\n            return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;\n          case 'T':\n            return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;\n          case 't':\n            return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;\n          default:\n            return SVGPathSeg.PATHSEG_UNKNOWN;\n          }\n        }\n\n        _nextCommandHelper (lookahead, previousCommand) {\n          // Check for remaining coordinates in the current command.\n          if ((lookahead === '+' || lookahead === '-' || lookahead === '.' || (lookahead >= '0' && lookahead <= '9')) && previousCommand !== SVGPathSeg.PATHSEG_CLOSEPATH) {\n            if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_ABS) {\n              return SVGPathSeg.PATHSEG_LINETO_ABS;\n            }\n            if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_REL) {\n              return SVGPathSeg.PATHSEG_LINETO_REL;\n            }\n            return previousCommand;\n          }\n          return SVGPathSeg.PATHSEG_UNKNOWN;\n        }\n\n        initialCommandIsMoveTo () {\n          // If the path is empty it is still valid, so return true.\n          if (!this.hasMoreData()) {\n            return true;\n          }\n          const command = this.peekSegmentType();\n          // Path must start with moveTo.\n          return command === SVGPathSeg.PATHSEG_MOVETO_ABS || command === SVGPathSeg.PATHSEG_MOVETO_REL;\n        }\n\n        // Parse a number from an SVG path. This very closely follows genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp.\n        // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF\n        _parseNumber () {\n          let exponent = 0;\n          let integer = 0;\n          let frac = 1;\n          let decimal = 0;\n          let sign = 1;\n          let expsign = 1;\n\n          const startIndex = this._currentIndex;\n\n          this._skipOptionalSpaces();\n\n          // Read the sign.\n          if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '+') {\n            this._currentIndex++;\n          } else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '-') {\n            this._currentIndex++;\n            sign = -1;\n          }\n\n          if (this._currentIndex === this._endIndex || ((this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') && this._string.charAt(this._currentIndex) !== '.')) {\n            // The first character of a number must be one of [0-9+-.].\n            return undefined;\n          }\n\n          // Read the integer part, build right-to-left.\n          const startIntPartIndex = this._currentIndex;\n          while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {\n            this._currentIndex++; // Advance to first non-digit.\n          }\n\n          if (this._currentIndex !== startIntPartIndex) {\n            let scanIntPartIndex = this._currentIndex - 1;\n            let multiplier = 1;\n            while (scanIntPartIndex >= startIntPartIndex) {\n              integer += multiplier * (this._string.charAt(scanIntPartIndex--) - '0');\n              multiplier *= 10;\n            }\n          }\n\n          // Read the decimals.\n          if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '.') {\n            this._currentIndex++;\n\n            // There must be a least one digit following the .\n            if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') {\n              return undefined;\n            }\n            while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {\n              frac *= 10;\n              decimal += (this._string.charAt(this._currentIndex) - '0') / frac;\n              this._currentIndex += 1;\n            }\n          }\n\n          // Read the exponent part.\n          if (this._currentIndex !== startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) === 'e' || this._string.charAt(this._currentIndex) === 'E') && (this._string.charAt(this._currentIndex + 1) !== 'x' && this._string.charAt(this._currentIndex + 1) !== 'm')) {\n            this._currentIndex++;\n\n            // Read the sign of the exponent.\n            if (this._string.charAt(this._currentIndex) === '+') {\n              this._currentIndex++;\n            } else if (this._string.charAt(this._currentIndex) === '-') {\n              this._currentIndex++;\n              expsign = -1;\n            }\n\n            // There must be an exponent.\n            if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') {\n              return undefined;\n            }\n\n            while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {\n              exponent *= 10;\n              exponent += (this._string.charAt(this._currentIndex) - '0');\n              this._currentIndex++;\n            }\n          }\n\n          let number = integer + decimal;\n          number *= sign;\n\n          if (exponent) {\n            number *= 10 ** (expsign * exponent);\n          }\n\n          if (startIndex === this._currentIndex) {\n            return undefined;\n          }\n\n          this._skipOptionalSpacesOrDelimiter();\n\n          return number;\n        }\n\n        _parseArcFlag () {\n          if (this._currentIndex >= this._endIndex) {\n            return undefined;\n          }\n          let flag = false;\n          const flagChar = this._string.charAt(this._currentIndex++);\n          if (flagChar === '0') {\n            flag = false;\n          } else if (flagChar === '1') {\n            flag = true;\n          } else {\n            return undefined;\n          }\n\n          this._skipOptionalSpacesOrDelimiter();\n          return flag;\n        }\n\n        parseSegment () {\n          const lookahead = this._string[this._currentIndex];\n          let command = this._pathSegTypeFromChar(lookahead);\n          if (command === SVGPathSeg.PATHSEG_UNKNOWN) {\n            // Possibly an implicit command. Not allowed if this is the first command.\n            if (this._previousCommand === SVGPathSeg.PATHSEG_UNKNOWN) {\n              return null;\n            }\n            command = this._nextCommandHelper(lookahead, this._previousCommand);\n            if (command === SVGPathSeg.PATHSEG_UNKNOWN) {\n              return null;\n            }\n          } else {\n            this._currentIndex++;\n          }\n\n          this._previousCommand = command;\n\n          switch (command) {\n          case SVGPathSeg.PATHSEG_MOVETO_REL:\n            return new SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());\n          case SVGPathSeg.PATHSEG_MOVETO_ABS:\n            return new SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());\n          case SVGPathSeg.PATHSEG_LINETO_REL:\n            return new SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());\n          case SVGPathSeg.PATHSEG_LINETO_ABS:\n            return new SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());\n          case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:\n            return new SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber());\n          case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:\n            return new SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber());\n          case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:\n            return new SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber());\n          case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:\n            return new SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber());\n          case SVGPathSeg.PATHSEG_CLOSEPATH:\n            this._skipOptionalSpaces();\n            return new SVGPathSegClosePath(owningPathSegList);\n          case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL: {\n            const points = {x1: this._parseNumber(), y1: this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);\n          } case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS: {\n            const points = {x1: this._parseNumber(), y1: this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegCurvetoCubicAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);\n          } case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL: {\n            const points = {x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, points.x, points.y, points.x2, points.y2);\n          } case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: {\n            const points = {x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, points.x, points.y, points.x2, points.y2);\n          } case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL: {\n            const points = {x1: this._parseNumber(), y1: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegCurvetoQuadraticRel(owningPathSegList, points.x, points.y, points.x1, points.y1);\n          } case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS: {\n            const points = {x1: this._parseNumber(), y1: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegCurvetoQuadraticAbs(owningPathSegList, points.x, points.y, points.x1, points.y1);\n          } case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:\n            return new SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber());\n          case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:\n            return new SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber());\n          case SVGPathSeg.PATHSEG_ARC_REL: {\n            const points = {x1: this._parseNumber(), y1: this._parseNumber(), arcAngle: this._parseNumber(), arcLarge: this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegArcRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);\n          } case SVGPathSeg.PATHSEG_ARC_ABS: {\n            const points = {x1: this._parseNumber(), y1: this._parseNumber(), arcAngle: this._parseNumber(), arcLarge: this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(), y: this._parseNumber()};\n            return new SVGPathSegArcAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);\n          } default:\n            throw new Error('Unknown path seg type.');\n          }\n        }\n      }\n\n      const builder = new Builder();\n      const source = new Source(string);\n\n      if (!source.initialCommandIsMoveTo()) {\n        return [];\n      }\n      while (source.hasMoreData()) {\n        const pathSeg = source.parseSegment();\n        if (!pathSeg) {\n          return [];\n        }\n        builder.appendSegment(pathSeg);\n      }\n\n      return builder.pathSegList;\n    }\n  }\n\n  SVGPathSegList.prototype.classname = 'SVGPathSegList';\n\n  Object.defineProperty(SVGPathSegList.prototype, 'numberOfItems', {\n    get () {\n      this._checkPathSynchronizedToList();\n      return this._list.length;\n    },\n    enumerable: true\n  });\n\n  SVGPathSegList._pathSegArrayAsString = function (pathSegArray) {\n    let string = '';\n    let first = true;\n    pathSegArray.forEach((pathSeg) => {\n      if (first) {\n        first = false;\n        string += pathSeg._asPathString();\n      } else {\n        string += ' ' + pathSeg._asPathString();\n      }\n    });\n    return string;\n  };\n\n  // Add the pathSegList accessors to SVGPathElement.\n  // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData\n  Object.defineProperties(SVGPathElement.prototype, {\n    pathSegList: {\n      get () {\n        if (!this._pathSegList) {\n          this._pathSegList = new SVGPathSegList(this);\n        }\n        return this._pathSegList;\n      },\n      enumerable: true\n    },\n    // FIXME: The following are not implemented and simply return SVGPathElement.pathSegList.\n    normalizedPathSegList: {get () { return this.pathSegList; }, enumerable: true},\n    animatedPathSegList: {get () { return this.pathSegList; }, enumerable: true},\n    animatedNormalizedPathSegList: {get () { return this.pathSegList; }, enumerable: true}\n  });\n  window.SVGPathSegList = SVGPathSegList;\n}\n})();\n","/**\n * Namespaces or tools therefor\n * @module namespaces\n * @license MIT\n*/\n\n/**\n* Common namepaces constants in alpha order\n* @enum {string}\n* @type {PlainObject}\n* @memberof module:namespaces\n*/\nexport const NS = {\n  HTML: 'http://www.w3.org/1999/xhtml',\n  MATH: 'http://www.w3.org/1998/Math/MathML',\n  SE: 'http://svg-edit.googlecode.com',\n  SVG: 'http://www.w3.org/2000/svg',\n  XLINK: 'http://www.w3.org/1999/xlink',\n  XML: 'http://www.w3.org/XML/1998/namespace',\n  XMLNS: 'http://www.w3.org/2000/xmlns/' // see http://www.w3.org/TR/REC-xml-names/#xmlReserved\n};\n\n/**\n* @function module:namespaces.getReverseNS\n* @returns {string} The NS with key values switched and lowercase\n*/\nexport const getReverseNS = function () {\n  const reverseNS = {};\n  Object.entries(NS).forEach(([name, URI]) => {\n    reverseNS[URI] = name.toLowerCase();\n  });\n  return reverseNS;\n};\n","/* globals jQuery */\n/**\n * Browser detection\n * @module browser\n * @license MIT\n *\n * @copyright 2010 Jeff Schiller, 2010 Alexis Deveria\n */\n\n// Dependencies:\n// 1) jQuery (for $.alert())\n\nimport './svgpathseg.js';\nimport {NS} from './namespaces.js';\n\nconst $ = jQuery;\n\nconst supportsSVG_ = (function () {\nreturn Boolean(document.createElementNS && document.createElementNS(NS.SVG, 'svg').createSVGRect);\n}());\n\n/**\n * @function module:browser.supportsSvg\n * @returns {boolean}\n*/\nexport const supportsSvg = () => supportsSVG_;\n\nconst {userAgent} = navigator;\nconst svg = document.createElementNS(NS.SVG, 'svg');\n\n// Note: Browser sniffing should only be used if no other detection method is possible\nconst isOpera_ = Boolean(window.opera);\nconst isWebkit_ = userAgent.includes('AppleWebKit');\nconst isGecko_ = userAgent.includes('Gecko/');\nconst isIE_ = userAgent.includes('MSIE');\nconst isChrome_ = userAgent.includes('Chrome/');\nconst isWindows_ = userAgent.includes('Windows');\nconst isMac_ = userAgent.includes('Macintosh');\nconst isTouch_ = 'ontouchstart' in window;\n\nconst supportsSelectors_ = (function () {\nreturn Boolean(svg.querySelector);\n}());\n\nconst supportsXpath_ = (function () {\nreturn Boolean(document.evaluate);\n}());\n\n// segList functions (for FF1.5 and 2.0)\nconst supportsPathReplaceItem_ = (function () {\nconst path = document.createElementNS(NS.SVG, 'path');\npath.setAttribute('d', 'M0,0 10,10');\nconst seglist = path.pathSegList;\nconst seg = path.createSVGPathSegLinetoAbs(5, 5);\ntry {\n  seglist.replaceItem(seg, 1);\n  return true;\n} catch (err) {}\nreturn false;\n}());\n\nconst supportsPathInsertItemBefore_ = (function () {\nconst path = document.createElementNS(NS.SVG, 'path');\npath.setAttribute('d', 'M0,0 10,10');\nconst seglist = path.pathSegList;\nconst seg = path.createSVGPathSegLinetoAbs(5, 5);\ntry {\n  seglist.insertItemBefore(seg, 1);\n  return true;\n} catch (err) {}\nreturn false;\n}());\n\n// text character positioning (for IE9 and now Chrome)\nconst supportsGoodTextCharPos_ = (function () {\nconst svgroot = document.createElementNS(NS.SVG, 'svg');\nconst svgcontent = document.createElementNS(NS.SVG, 'svg');\ndocument.documentElement.append(svgroot);\nsvgcontent.setAttribute('x', 5);\nsvgroot.append(svgcontent);\nconst text = document.createElementNS(NS.SVG, 'text');\ntext.textContent = 'a';\nsvgcontent.append(text);\ntry { // Chrome now fails here\n  const pos = text.getStartPositionOfChar(0).x;\n  return (pos === 0);\n} catch (err) {\n  return false;\n} finally {\n  svgroot.remove();\n}\n}());\n\nconst supportsPathBBox_ = (function () {\nconst svgcontent = document.createElementNS(NS.SVG, 'svg');\ndocument.documentElement.append(svgcontent);\nconst path = document.createElementNS(NS.SVG, 'path');\npath.setAttribute('d', 'M0,0 C0,0 10,10 10,0');\nsvgcontent.append(path);\nconst bbox = path.getBBox();\nsvgcontent.remove();\nreturn (bbox.height > 4 && bbox.height < 5);\n}());\n\n// Support for correct bbox sizing on groups with horizontal/vertical lines\nconst supportsHVLineContainerBBox_ = (function () {\nconst svgcontent = document.createElementNS(NS.SVG, 'svg');\ndocument.documentElement.append(svgcontent);\nconst path = document.createElementNS(NS.SVG, 'path');\npath.setAttribute('d', 'M0,0 10,0');\nconst path2 = document.createElementNS(NS.SVG, 'path');\npath2.setAttribute('d', 'M5,0 15,0');\nconst g = document.createElementNS(NS.SVG, 'g');\ng.append(path, path2);\nsvgcontent.append(g);\nconst bbox = g.getBBox();\nsvgcontent.remove();\n// Webkit gives 0, FF gives 10, Opera (correctly) gives 15\nreturn (bbox.width === 15);\n}());\n\nconst supportsEditableText_ = (function () {\n// TODO: Find better way to check support for this\nreturn isOpera_;\n}());\n\nconst supportsGoodDecimals_ = (function () {\n// Correct decimals on clone attributes (Opera < 10.5/win/non-en)\nconst rect = document.createElementNS(NS.SVG, 'rect');\nrect.setAttribute('x', 0.1);\nconst crect = rect.cloneNode(false);\nconst retValue = (!crect.getAttribute('x').includes(','));\nif (!retValue) {\n  // Todo: i18nize or remove\n  $.alert(\n    'NOTE: This version of Opera is known to contain bugs in SVG-edit.\\n' +\n    'Please upgrade to the <a href=\"http://opera.com\">latest version</a> in which the problems have been fixed.'\n  );\n}\nreturn retValue;\n}());\n\nconst supportsNonScalingStroke_ = (function () {\nconst rect = document.createElementNS(NS.SVG, 'rect');\nrect.setAttribute('style', 'vector-effect:non-scaling-stroke');\nreturn rect.style.vectorEffect === 'non-scaling-stroke';\n}());\n\nlet supportsNativeSVGTransformLists_ = (function () {\nconst rect = document.createElementNS(NS.SVG, 'rect');\nconst rxform = rect.transform.baseVal;\nconst t1 = svg.createSVGTransform();\nrxform.appendItem(t1);\nconst r1 = rxform.getItem(0);\n// Todo: Do frame-independent instance checking\nreturn r1 instanceof SVGTransform && t1 instanceof SVGTransform &&\n  r1.type === t1.type && r1.angle === t1.angle &&\n  r1.matrix.a === t1.matrix.a &&\n  r1.matrix.b === t1.matrix.b &&\n  r1.matrix.c === t1.matrix.c &&\n  r1.matrix.d === t1.matrix.d &&\n  r1.matrix.e === t1.matrix.e &&\n  r1.matrix.f === t1.matrix.f;\n}());\n\n// Public API\n\n/**\n * @function module:browser.isOpera\n * @returns {boolean}\n*/\nexport const isOpera = () => isOpera_;\n/**\n * @function module:browser.isWebkit\n * @returns {boolean}\n*/\nexport const isWebkit = () => isWebkit_;\n/**\n * @function module:browser.isGecko\n * @returns {boolean}\n*/\nexport const isGecko = () => isGecko_;\n/**\n * @function module:browser.isIE\n * @returns {boolean}\n*/\nexport const isIE = () => isIE_;\n/**\n * @function module:browser.isChrome\n * @returns {boolean}\n*/\nexport const isChrome = () => isChrome_;\n/**\n * @function module:browser.isWindows\n * @returns {boolean}\n*/\nexport const isWindows = () => isWindows_;\n/**\n * @function module:browser.isMac\n * @returns {boolean}\n*/\nexport const isMac = () => isMac_;\n/**\n * @function module:browser.isTouch\n * @returns {boolean}\n*/\nexport const isTouch = () => isTouch_;\n\n/**\n * @function module:browser.supportsSelectors\n * @returns {boolean}\n*/\nexport const supportsSelectors = () => supportsSelectors_;\n\n/**\n * @function module:browser.supportsXpath\n * @returns {boolean}\n*/\nexport const supportsXpath = () => supportsXpath_;\n\n/**\n * @function module:browser.supportsPathReplaceItem\n * @returns {boolean}\n*/\nexport const supportsPathReplaceItem = () => supportsPathReplaceItem_;\n\n/**\n * @function module:browser.supportsPathInsertItemBefore\n * @returns {boolean}\n*/\nexport const supportsPathInsertItemBefore = () => supportsPathInsertItemBefore_;\n\n/**\n * @function module:browser.supportsPathBBox\n * @returns {boolean}\n*/\nexport const supportsPathBBox = () => supportsPathBBox_;\n\n/**\n * @function module:browser.supportsHVLineContainerBBox\n * @returns {boolean}\n*/\nexport const supportsHVLineContainerBBox = () => supportsHVLineContainerBBox_;\n\n/**\n * @function module:browser.supportsGoodTextCharPos\n * @returns {boolean}\n*/\nexport const supportsGoodTextCharPos = () => supportsGoodTextCharPos_;\n\n/**\n* @function module:browser.supportsEditableText\n * @returns {boolean}\n*/\nexport const supportsEditableText = () => supportsEditableText_;\n\n/**\n * @function module:browser.supportsGoodDecimals\n * @returns {boolean}\n*/\nexport const supportsGoodDecimals = () => supportsGoodDecimals_;\n\n/**\n* @function module:browser.supportsNonScalingStroke\n* @returns {boolean}\n*/\nexport const supportsNonScalingStroke = () => supportsNonScalingStroke_;\n\n/**\n* @function module:browser.supportsNativeTransformLists\n* @returns {boolean}\n*/\nexport const supportsNativeTransformLists = () => supportsNativeSVGTransformLists_;\n\n/**\n * Set `supportsNativeSVGTransformLists_` to `false` (for unit testing).\n * @function module:browser.disableSupportsNativeTransformLists\n * @returns {undefined}\n*/\nexport const disableSupportsNativeTransformLists = () => {\n  supportsNativeSVGTransformLists_ = false;\n};\n","/**\n * Partial polyfill of `SVGTransformList`\n * @module SVGTransformList\n *\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller\n */\n\nimport {NS} from './namespaces.js';\nimport {supportsNativeTransformLists} from './browser.js';\n\nconst svgroot = document.createElementNS(NS.SVG, 'svg');\n\n/**\n * Helper function to convert `SVGTransform` to a string.\n * @param {SVGTransform} xform\n * @returns {string}\n */\nfunction transformToString (xform) {\n  const m = xform.matrix;\n  let text = '';\n  switch (xform.type) {\n  case 1: // MATRIX\n    text = 'matrix(' + [m.a, m.b, m.c, m.d, m.e, m.f].join(',') + ')';\n    break;\n  case 2: // TRANSLATE\n    text = 'translate(' + m.e + ',' + m.f + ')';\n    break;\n  case 3: // SCALE\n    if (m.a === m.d) {\n      text = 'scale(' + m.a + ')';\n    } else {\n      text = 'scale(' + m.a + ',' + m.d + ')';\n    }\n    break;\n  case 4: { // ROTATE\n    let cx = 0;\n    let cy = 0;\n    // this prevents divide by zero\n    if (xform.angle !== 0) {\n      const K = 1 - m.a;\n      cy = (K * m.f + m.b * m.e) / (K * K + m.b * m.b);\n      cx = (m.e - m.b * cy) / K;\n    }\n    text = 'rotate(' + xform.angle + ' ' + cx + ',' + cy + ')';\n    break;\n  }\n  }\n  return text;\n}\n\n/**\n * Map of SVGTransformList objects.\n */\nlet listMap_ = {};\n\n/**\n* @interface module:SVGTransformList.SVGEditTransformList\n* @property {Integer} numberOfItems unsigned long\n*/\n/**\n* @function module:SVGTransformList.SVGEditTransformList#clear\n* @returns {undefined}\n*/\n/**\n* @function module:SVGTransformList.SVGEditTransformList#initialize\n* @param {SVGTransform} newItem\n* @returns {SVGTransform}\n*/\n/**\n* (DOES NOT THROW DOMException, INDEX_SIZE_ERR)\n* @function module:SVGTransformList.SVGEditTransformList#getItem\n* @param {Integer} index unsigned long\n* @returns {SVGTransform}\n*/\n/**\n* (DOES NOT THROW DOMException, INDEX_SIZE_ERR)\n* @function module:SVGTransformList.SVGEditTransformList#insertItemBefore\n* @param {SVGTransform} newItem\n* @param {Integer} index unsigned long\n* @returns {SVGTransform}\n*/\n/**\n* (DOES NOT THROW DOMException, INDEX_SIZE_ERR)\n* @function module:SVGTransformList.SVGEditTransformList#replaceItem\n* @param {SVGTransform} newItem\n* @param {Integer} index unsigned long\n* @returns {SVGTransform}\n*/\n/**\n* (DOES NOT THROW DOMException, INDEX_SIZE_ERR)\n* @function module:SVGTransformList.SVGEditTransformList#removeItem\n* @param {Integer} index unsigned long\n* @returns {SVGTransform}\n*/\n/**\n* @function module:SVGTransformList.SVGEditTransformList#appendItem\n* @param {SVGTransform} newItem\n* @returns {SVGTransform}\n*/\n/**\n* NOT IMPLEMENTED\n* @ignore\n* @function module:SVGTransformList.SVGEditTransformList#createSVGTransformFromMatrix\n* @param {SVGMatrix} matrix\n* @returns {SVGTransform}\n*/\n/**\n* NOT IMPLEMENTED\n* @ignore\n* @function module:SVGTransformList.SVGEditTransformList#consolidate\n* @returns {SVGTransform}\n*/\n\n/**\n* SVGTransformList implementation for Webkit.\n* These methods do not currently raise any exceptions.\n* These methods also do not check that transforms are being inserted.  This is basically\n* implementing as much of SVGTransformList that we need to get the job done.\n* @implements {module:SVGTransformList.SVGEditTransformList}\n*/\nexport class SVGTransformList {// eslint-disable-line no-shadow\n  /**\n  * @param {Element} elem\n  */\n  constructor (elem) {\n    this._elem = elem || null;\n    this._xforms = [];\n    // TODO: how do we capture the undo-ability in the changed transform list?\n    this._update = function () {\n      let tstr = '';\n      // /* const concatMatrix = */ svgroot.createSVGMatrix();\n      for (let i = 0; i < this.numberOfItems; ++i) {\n        const xform = this._list.getItem(i);\n        tstr += transformToString(xform) + ' ';\n      }\n      this._elem.setAttribute('transform', tstr);\n    };\n    this._list = this;\n    this._init = function () {\n      // Transform attribute parser\n      let str = this._elem.getAttribute('transform');\n      if (!str) { return; }\n\n      // TODO: Add skew support in future\n      const re = /\\s*((scale|matrix|rotate|translate)\\s*\\(.*?\\))\\s*,?\\s*/;\n      let m = true;\n      while (m) {\n        m = str.match(re);\n        str = str.replace(re, '');\n        if (m && m[1]) {\n          const x = m[1];\n          const bits = x.split(/\\s*\\(/);\n          const name = bits[0];\n          const valBits = bits[1].match(/\\s*(.*?)\\s*\\)/);\n          valBits[1] = valBits[1].replace(/(\\d)-/g, '$1 -');\n          const valArr = valBits[1].split(/[, ]+/);\n          const letters = 'abcdef'.split('');\n          const mtx = svgroot.createSVGMatrix();\n          Object.values(valArr).forEach(function (item, i) {\n            valArr[i] = parseFloat(item);\n            if (name === 'matrix') {\n              mtx[letters[i]] = valArr[i];\n            }\n          });\n          const xform = svgroot.createSVGTransform();\n          const fname = 'set' + name.charAt(0).toUpperCase() + name.slice(1);\n          const values = name === 'matrix' ? [mtx] : valArr;\n\n          if (name === 'scale' && values.length === 1) {\n            values.push(values[0]);\n          } else if (name === 'translate' && values.length === 1) {\n            values.push(0);\n          } else if (name === 'rotate' && values.length === 1) {\n            values.push(0, 0);\n          }\n          xform[fname](...values);\n          this._list.appendItem(xform);\n        }\n      }\n    };\n    this._removeFromOtherLists = function (item) {\n      if (item) {\n        // Check if this transform is already in a transformlist, and\n        // remove it if so.\n        Object.values(listMap_).some((tl) => {\n          for (let i = 0, len = tl._xforms.length; i < len; ++i) {\n            if (tl._xforms[i] === item) {\n              tl.removeItem(i);\n              return true;\n            }\n          }\n          return false;\n        });\n      }\n    };\n\n    this.numberOfItems = 0;\n  }\n  /**\n  * @returns {undefined}\n  */\n  clear () {\n    this.numberOfItems = 0;\n    this._xforms = [];\n  }\n\n  /**\n  * @param {SVGTransform} newItem\n  * @returns {SVGTransform}\n  */\n  initialize (newItem) {\n    this.numberOfItems = 1;\n    this._removeFromOtherLists(newItem);\n    this._xforms = [newItem];\n  }\n\n  /**\n  * @param {Integer} index unsigned long\n  * @throws {Error}\n  * @returns {SVGTransform}\n  */\n  getItem (index) {\n    if (index < this.numberOfItems && index >= 0) {\n      return this._xforms[index];\n    }\n    const err = new Error('DOMException with code=INDEX_SIZE_ERR');\n    err.code = 1;\n    throw err;\n  }\n\n  /**\n  * @param {SVGTransform} newItem\n  * @param {Integer} index unsigned long\n  * @returns {SVGTransform}\n  */\n  insertItemBefore (newItem, index) {\n    let retValue = null;\n    if (index >= 0) {\n      if (index < this.numberOfItems) {\n        this._removeFromOtherLists(newItem);\n        const newxforms = new Array(this.numberOfItems + 1);\n        // TODO: use array copying and slicing\n        let i;\n        for (i = 0; i < index; ++i) {\n          newxforms[i] = this._xforms[i];\n        }\n        newxforms[i] = newItem;\n        for (let j = i + 1; i < this.numberOfItems; ++j, ++i) {\n          newxforms[j] = this._xforms[i];\n        }\n        this.numberOfItems++;\n        this._xforms = newxforms;\n        retValue = newItem;\n        this._list._update();\n      } else {\n        retValue = this._list.appendItem(newItem);\n      }\n    }\n    return retValue;\n  }\n\n  /**\n  * @param {SVGTransform} newItem\n  * @param {Integer} index unsigned long\n  * @returns {SVGTransform}\n  */\n  replaceItem (newItem, index) {\n    let retValue = null;\n    if (index < this.numberOfItems && index >= 0) {\n      this._removeFromOtherLists(newItem);\n      this._xforms[index] = newItem;\n      retValue = newItem;\n      this._list._update();\n    }\n    return retValue;\n  }\n\n  /**\n  * @param {Integer} index unsigned long\n  * @throws {Error}\n  * @returns {SVGTransform}\n  */\n  removeItem (index) {\n    if (index < this.numberOfItems && index >= 0) {\n      const retValue = this._xforms[index];\n      const newxforms = new Array(this.numberOfItems - 1);\n      let i;\n      for (i = 0; i < index; ++i) {\n        newxforms[i] = this._xforms[i];\n      }\n      for (let j = i; j < this.numberOfItems - 1; ++j, ++i) {\n        newxforms[j] = this._xforms[i + 1];\n      }\n      this.numberOfItems--;\n      this._xforms = newxforms;\n      this._list._update();\n      return retValue;\n    }\n    const err = new Error('DOMException with code=INDEX_SIZE_ERR');\n    err.code = 1;\n    throw err;\n  }\n\n  /**\n  * @param {SVGTransform} newItem\n  * @returns {SVGTransform}\n  */\n  appendItem (newItem) {\n    this._removeFromOtherLists(newItem);\n    this._xforms.push(newItem);\n    this.numberOfItems++;\n    this._list._update();\n    return newItem;\n  }\n}\n\n/**\n* @function module:SVGTransformList.resetListMap\n* @returns {undefined}\n*/\nexport const resetListMap = function () {\n  listMap_ = {};\n};\n\n/**\n * Removes transforms of the given element from the map.\n * @function module:SVGTransformList.removeElementFromListMap\n * @param {Element} elem - a DOM Element\n * @returns {undefined}\n */\nexport let removeElementFromListMap = function (elem) { // eslint-disable-line import/no-mutable-exports\n  if (elem.id && listMap_[elem.id]) {\n    delete listMap_[elem.id];\n  }\n};\n\n/**\n* Returns an object that behaves like a `SVGTransformList` for the given DOM element.\n* @function module:SVGTransformList.getTransformList\n* @param {Element} elem - DOM element to get a transformlist from\n* @todo The polyfill should have `SVGAnimatedTransformList` and this should use it\n* @returns {SVGAnimatedTransformList|SVGTransformList}\n*/\nexport const getTransformList = function (elem) {\n  if (!supportsNativeTransformLists()) {\n    const id = elem.id || 'temp';\n    let t = listMap_[id];\n    if (!t || id === 'temp') {\n      listMap_[id] = new SVGTransformList(elem);\n      listMap_[id]._init();\n      t = listMap_[id];\n    }\n    return t;\n  }\n  if (elem.transform) {\n    return elem.transform.baseVal;\n  }\n  if (elem.gradientTransform) {\n    return elem.gradientTransform.baseVal;\n  }\n  if (elem.patternTransform) {\n    return elem.patternTransform.baseVal;\n  }\n\n  return null;\n};\n\n/**\n* @callback module:SVGTransformList.removeElementFromListMap\n* @param {Element} elem\n*/\n/**\n* Replace `removeElementFromListMap` for unit-testing.\n* @function module:SVGTransformList.changeRemoveElementFromListMap\n* @param {module:SVGTransformList.removeElementFromListMap} cb Passed a single argument `elem`\n* @returns {undefined}\n*/\n\nexport const changeRemoveElementFromListMap = function (cb) { // eslint-disable-line promise/prefer-await-to-callbacks\n  removeElementFromListMap = cb;\n};\n","/**\n * Tools for working with units\n * @module units\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller\n */\n\nimport {NS} from './namespaces.js';\nimport {isNullish} from './utilities.js';\n\nconst wAttrs = ['x', 'x1', 'cx', 'rx', 'width'];\nconst hAttrs = ['y', 'y1', 'cy', 'ry', 'height'];\nconst unitAttrs = ['r', 'radius', ...wAttrs, ...hAttrs];\n// unused\n/*\nconst unitNumMap = {\n  '%': 2,\n  em: 3,\n  ex: 4,\n  px: 5,\n  cm: 6,\n  mm: 7,\n  in: 8,\n  pt: 9,\n  pc: 10\n};\n*/\n// Container of elements.\nlet elementContainer_;\n\n// Stores mapping of unit type to user coordinates.\nlet typeMap_ = {};\n\n/**\n * @interface module:units.ElementContainer\n */\n/**\n * @function module:units.ElementContainer#getBaseUnit\n * @returns {string} The base unit type of the container ('em')\n */\n/**\n * @function module:units.ElementContainer#getElement\n * @returns {?Element} An element in the container given an id\n */\n/**\n * @function module:units.ElementContainer#getHeight\n * @returns {Float} The container's height\n */\n/**\n * @function module:units.ElementContainer#getWidth\n * @returns {Float} The container's width\n */\n/**\n * @function module:units.ElementContainer#getRoundDigits\n * @returns {Integer} The number of digits number should be rounded to\n */\n\n/**\n * @typedef {PlainObject} module:units.TypeMap\n * @property {Float} em\n * @property {Float} ex\n * @property {Float} in\n * @property {Float} cm\n * @property {Float} mm\n * @property {Float} pt\n * @property {Float} pc\n * @property {Integer} px\n * @property {0} %\n */\n\n/**\n * Initializes this module.\n *\n * @function module:units.init\n * @param {module:units.ElementContainer} elementContainer - An object implementing the ElementContainer interface.\n * @returns {undefined}\n */\nexport const init = function (elementContainer) {\n  elementContainer_ = elementContainer;\n\n  // Get correct em/ex values by creating a temporary SVG.\n  const svg = document.createElementNS(NS.SVG, 'svg');\n  document.body.append(svg);\n  const rect = document.createElementNS(NS.SVG, 'rect');\n  rect.setAttribute('width', '1em');\n  rect.setAttribute('height', '1ex');\n  rect.setAttribute('x', '1in');\n  svg.append(rect);\n  const bb = rect.getBBox();\n  svg.remove();\n\n  const inch = bb.x;\n  typeMap_ = {\n    em: bb.width,\n    ex: bb.height,\n    in: inch,\n    cm: inch / 2.54,\n    mm: inch / 25.4,\n    pt: inch / 72,\n    pc: inch / 6,\n    px: 1,\n    '%': 0\n  };\n};\n\n/**\n* Group: Unit conversion functions\n*/\n\n/**\n * @function module:units.getTypeMap\n * @returns {module:units.TypeMap} The unit object with values for each unit\n*/\nexport const getTypeMap = function () {\n  return typeMap_;\n};\n\n/**\n* @typedef {GenericArray} module:units.CompareNumbers\n* @property {Integer} length 2\n* @property {Float} 0\n* @property {Float} 1\n*/\n\n/**\n* Rounds a given value to a float with number of digits defined in\n* `round_digits` of `saveOptions`\n*\n* @function module:units.shortFloat\n* @param {string|Float|module:units.CompareNumbers} val - The value (or Array of two numbers) to be rounded\n* @returns {Float|string} If a string/number was given, returns a Float. If an array, return a string\n* with comma-separated floats\n*/\nexport const shortFloat = function (val) {\n  const digits = elementContainer_.getRoundDigits();\n  if (!isNaN(val)) {\n    return Number(Number(val).toFixed(digits));\n  }\n  if (Array.isArray(val)) {\n    return shortFloat(val[0]) + ',' + shortFloat(val[1]);\n  }\n  return parseFloat(val).toFixed(digits) - 0;\n};\n\n/**\n* Converts the number to given unit or baseUnit.\n* @function module:units.convertUnit\n* @param {string|Float} val\n* @param {\"em\"|\"ex\"|\"in\"|\"cm\"|\"mm\"|\"pt\"|\"pc\"|\"px\"|\"%\"} [unit]\n* @returns {Float}\n*/\nexport const convertUnit = function (val, unit) {\n  unit = unit || elementContainer_.getBaseUnit();\n  // baseVal.convertToSpecifiedUnits(unitNumMap[unit]);\n  // const val = baseVal.valueInSpecifiedUnits;\n  // baseVal.convertToSpecifiedUnits(1);\n  return shortFloat(val / typeMap_[unit]);\n};\n\n/**\n* Sets an element's attribute based on the unit in its current value.\n*\n* @function module:units.setUnitAttr\n* @param {Element} elem - DOM element to be changed\n* @param {string} attr - Name of the attribute associated with the value\n* @param {string} val - Attribute value to convert\n* @returns {undefined}\n*/\nexport const setUnitAttr = function (elem, attr, val) {\n  //  if (!isNaN(val)) {\n  // New value is a number, so check currently used unit\n  // const oldVal = elem.getAttribute(attr);\n\n  // Enable this for alternate mode\n  // if (oldVal !== null && (isNaN(oldVal) || elementContainer_.getBaseUnit() !== 'px')) {\n  //   // Old value was a number, so get unit, then convert\n  //   let unit;\n  //   if (oldVal.substr(-1) === '%') {\n  //     const res = getResolution();\n  //     unit = '%';\n  //     val *= 100;\n  //     if (wAttrs.includes(attr)) {\n  //       val = val / res.w;\n  //     } else if (hAttrs.includes(attr)) {\n  //       val = val / res.h;\n  //     } else {\n  //       return val / Math.sqrt((res.w*res.w) + (res.h*res.h))/Math.sqrt(2);\n  //     }\n  //   } else {\n  //     if (elementContainer_.getBaseUnit() !== 'px') {\n  //       unit = elementContainer_.getBaseUnit();\n  //     } else {\n  //       unit = oldVal.substr(-2);\n  //     }\n  //     val = val / typeMap_[unit];\n  //   }\n  //\n  // val += unit;\n  // }\n  // }\n  elem.setAttribute(attr, val);\n};\n\nconst attrsToConvert = {\n  line: ['x1', 'x2', 'y1', 'y2'],\n  circle: ['cx', 'cy', 'r'],\n  ellipse: ['cx', 'cy', 'rx', 'ry'],\n  foreignObject: ['x', 'y', 'width', 'height'],\n  rect: ['x', 'y', 'width', 'height'],\n  image: ['x', 'y', 'width', 'height'],\n  use: ['x', 'y', 'width', 'height'],\n  text: ['x', 'y']\n};\n\n/**\n* Converts all applicable attributes to the configured baseUnit.\n* @function module:units.convertAttrs\n* @param {Element} element - A DOM element whose attributes should be converted\n* @returns {undefined}\n*/\nexport const convertAttrs = function (element) {\n  const elName = element.tagName;\n  const unit = elementContainer_.getBaseUnit();\n  const attrs = attrsToConvert[elName];\n  if (!attrs) { return; }\n\n  const len = attrs.length;\n  for (let i = 0; i < len; i++) {\n    const attr = attrs[i];\n    const cur = element.getAttribute(attr);\n    if (cur) {\n      if (!isNaN(cur)) {\n        element.setAttribute(attr, (cur / typeMap_[unit]) + unit);\n      }\n      // else {\n      // Convert existing?\n      // }\n    }\n  }\n};\n\n/**\n* Converts given values to numbers. Attributes must be supplied in\n* case a percentage is given.\n*\n* @function module:units.convertToNum\n* @param {string} attr - Name of the attribute associated with the value\n* @param {string} val - Attribute value to convert\n* @returns {Float} The converted number\n*/\nexport const convertToNum = function (attr, val) {\n  // Return a number if that's what it already is\n  if (!isNaN(val)) { return val - 0; }\n  if (val.substr(-1) === '%') {\n    // Deal with percentage, depends on attribute\n    const num = val.substr(0, val.length - 1) / 100;\n    const width = elementContainer_.getWidth();\n    const height = elementContainer_.getHeight();\n\n    if (wAttrs.includes(attr)) {\n      return num * width;\n    }\n    if (hAttrs.includes(attr)) {\n      return num * height;\n    }\n    return num * Math.sqrt((width * width) + (height * height)) / Math.sqrt(2);\n  }\n  const unit = val.substr(-2);\n  const num = val.substr(0, val.length - 2);\n  // Note that this multiplication turns the string into a number\n  return num * typeMap_[unit];\n};\n\n/**\n* Check if an attribute's value is in a valid format.\n* @function module:units.isValidUnit\n* @param {string} attr - The name of the attribute associated with the value\n* @param {string} val - The attribute value to check\n* @param {Element} selectedElement\n* @returns {boolean} Whether the unit is valid\n*/\nexport const isValidUnit = function (attr, val, selectedElement) {\n  if (unitAttrs.includes(attr)) {\n    // True if it's just a number\n    if (!isNaN(val)) {\n      return true;\n    }\n    // Not a number, check if it has a valid unit\n    val = val.toLowerCase();\n    return Object.keys(typeMap_).some((unit) => {\n      const re = new RegExp('^-?[\\\\d\\\\.]+' + unit + '$');\n      return re.test(val);\n    });\n  }\n  if (attr === 'id') {\n    // if we're trying to change the id, make sure it's not already present in the doc\n    // and the id value is valid.\n\n    let result = false;\n    // because getElem() can throw an exception in the case of an invalid id\n    // (according to https://www.w3.org/TR/xml-id/ IDs must be a NCName)\n    // we wrap it in an exception and only return true if the ID was valid and\n    // not already present\n    try {\n      const elem = elementContainer_.getElement(val);\n      result = (isNullish(elem) || elem === selectedElement);\n    } catch (e) {}\n    return result;\n  }\n  return true;\n};\n","/**\n * For command history tracking and undo functionality\n * @module history\n * @license MIT\n * @copyright 2010 Jeff Schiller\n */\n\nimport {getHref, setHref, getRotationAngle, isNullish} from './utilities.js';\nimport {removeElementFromListMap} from './svgtransformlist.js';\n\n/**\n* Group: Undo/Redo history management\n*/\nexport const HistoryEventTypes = {\n  BEFORE_APPLY: 'before_apply',\n  AFTER_APPLY: 'after_apply',\n  BEFORE_UNAPPLY: 'before_unapply',\n  AFTER_UNAPPLY: 'after_unapply'\n};\n\n// const removedElements = {};\n\n/**\n* Base class for commands.\n*/\nclass Command {\n  /**\n  * @returns {string}\n  */\n  getText () {\n    return this.text;\n  }\n}\n\n// Todo: Figure out why the interface members aren't showing\n//   up (with or without modules applied), despite our apparently following\n//   http://usejsdoc.org/tags-interface.html#virtual-comments\n\n/**\n * An interface that all command objects must implement.\n * @interface module:history.HistoryCommand\n*/\n/**\n * Applies\n *\n * @function module:history.HistoryCommand#apply\n * @param {module:history.HistoryEventHandler}\n * @fires module:history~Command#event:history\n * @returns {undefined|true}\n */\n/**\n *\n * Unapplies\n * @function module:history.HistoryCommand#unapply\n * @param {module:history.HistoryEventHandler}\n * @fires module:history~Command#event:history\n * @returns {undefined|true}\n */\n/**\n * Returns the elements\n * @function module:history.HistoryCommand#elements\n * @returns {Element[]}\n */\n/**\n * Gets the text\n * @function module:history.HistoryCommand#getText\n * @returns {string}\n */\n/**\n * Gives the type\n * @function module:history.HistoryCommand.type\n * @returns {string}\n */\n/**\n * Gives the type\n * @function module:history.HistoryCommand#type\n * @returns {string}\n*/\n\n/**\n * @event module:history~Command#event:history\n * @type {module:history.HistoryCommand}\n */\n\n/**\n * An interface for objects that will handle history events.\n * @interface module:history.HistoryEventHandler\n */\n/**\n *\n * @function module:history.HistoryEventHandler#handleHistoryEvent\n * @param {string} eventType One of the HistoryEvent types\n * @param {module:history~Command#event:history} command\n * @listens module:history~Command#event:history\n * @returns {undefined}\n *\n */\n\n/**\n * History command for an element that had its DOM position changed.\n * @implements {module:history.HistoryCommand}\n * @param {Element} elem - The DOM element that was moved\n * @param {Element} oldNextSibling - The element's next sibling before it was moved\n * @param {Element} oldParent - The element's parent before it was moved\n * @param {string} [text] - An optional string visible to user related to this change\n*/\nexport class MoveElementCommand extends Command {\n  constructor (elem, oldNextSibling, oldParent, text) {\n    super();\n    this.elem = elem;\n    this.text = text ? ('Move ' + elem.tagName + ' to ' + text) : ('Move ' + elem.tagName);\n    this.oldNextSibling = oldNextSibling;\n    this.oldParent = oldParent;\n    this.newNextSibling = elem.nextSibling;\n    this.newParent = elem.parentNode;\n  }\n  type () { // eslint-disable-line class-methods-use-this\n    return 'svgedit.history.MoveElementCommand';\n  }\n\n  /**\n   * Re-positions the element.\n   * @param {module:history.HistoryEventHandler} handler\n   * @fires module:history~Command#event:history\n   * @returns {undefined}\n  */\n  apply (handler) {\n    // TODO(codedread): Refactor this common event code into a base HistoryCommand class.\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);\n    }\n\n    this.elem = this.newParent.insertBefore(this.elem, this.newNextSibling);\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);\n    }\n  }\n\n  /**\n   * Positions the element back to its original location.\n   * @param {module:history.HistoryEventHandler} handler\n   * @fires module:history~Command#event:history\n   * @returns {undefined}\n  */\n  unapply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);\n    }\n\n    this.elem = this.oldParent.insertBefore(this.elem, this.oldNextSibling);\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);\n    }\n  }\n\n  /**\n  * @returns {Element[]} Array with element associated with this command\n  */\n  elements () {\n    return [this.elem];\n  }\n}\nMoveElementCommand.type = MoveElementCommand.prototype.type;\n\n/**\n* History command for an element that was added to the DOM.\n* @implements {module:history.HistoryCommand}\n*\n* @param {Element} elem - The newly added DOM element\n* @param {string} text - An optional string visible to user related to this change\n*/\nexport class InsertElementCommand extends Command {\n  constructor (elem, text) {\n    super();\n    this.elem = elem;\n    this.text = text || ('Create ' + elem.tagName);\n    this.parent = elem.parentNode;\n    this.nextSibling = this.elem.nextSibling;\n  }\n\n  type () { // eslint-disable-line class-methods-use-this\n    return 'svgedit.history.InsertElementCommand';\n  }\n\n  /**\n  * Re-inserts the new element.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {undefined}\n  */\n  apply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);\n    }\n\n    this.elem = this.parent.insertBefore(this.elem, this.nextSibling);\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);\n    }\n  }\n\n  /**\n  * Removes the element.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {undefined}\n  */\n  unapply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);\n    }\n\n    this.parent = this.elem.parentNode;\n    this.elem = this.elem.parentNode.removeChild(this.elem);\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);\n    }\n  }\n\n  /**\n  * @returns {Element[]} Array with element associated with this command\n  */\n  elements () {\n    return [this.elem];\n  }\n}\nInsertElementCommand.type = InsertElementCommand.prototype.type;\n\n/**\n* History command for an element removed from the DOM.\n* @implements {module:history.HistoryCommand}\n* @param {Element} elem - The removed DOM element\n* @param {Node} oldNextSibling - The DOM element's nextSibling when it was in the DOM\n* @param {Element} oldParent - The DOM element's parent\n* @param {string} [text] - An optional string visible to user related to this change\n*/\nexport class RemoveElementCommand extends Command {\n  constructor (elem, oldNextSibling, oldParent, text) {\n    super();\n    this.elem = elem;\n    this.text = text || ('Delete ' + elem.tagName);\n    this.nextSibling = oldNextSibling;\n    this.parent = oldParent;\n\n    // special hack for webkit: remove this element's entry in the svgTransformLists map\n    removeElementFromListMap(elem);\n  }\n  type () { // eslint-disable-line class-methods-use-this\n    return 'svgedit.history.RemoveElementCommand';\n  }\n\n  /**\n  * Re-removes the new element.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {undefined}\n  */\n  apply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);\n    }\n\n    removeElementFromListMap(this.elem);\n    this.parent = this.elem.parentNode;\n    this.elem = this.parent.removeChild(this.elem);\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);\n    }\n  }\n\n  /**\n  * Re-adds the new element.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {undefined}\n  */\n  unapply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);\n    }\n\n    removeElementFromListMap(this.elem);\n    if (isNullish(this.nextSibling)) {\n      if (window.console) {\n        console.log('Error: reference element was lost'); // eslint-disable-line no-console\n      }\n    }\n    this.parent.insertBefore(this.elem, this.nextSibling); // Don't use `before` or `prepend` as `this.nextSibling` may be `null`\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);\n    }\n  }\n\n  /**\n  * @returns {Element[]} Array with element associated with this command\n  */\n  elements () {\n    return [this.elem];\n  }\n}\nRemoveElementCommand.type = RemoveElementCommand.prototype.type;\n\n/**\n* @typedef {\"#text\"|\"#href\"|string} module:history.CommandAttributeName\n*/\n/**\n* @typedef {PlainObject.<module:history.CommandAttributeName, string>} module:history.CommandAttributes\n*/\n\n/**\n* History command to make a change to an element.\n* Usually an attribute change, but can also be textcontent.\n* @implements {module:history.HistoryCommand}\n* @param {Element} elem - The DOM element that was changed\n* @param {module:history.CommandAttributes} attrs - Attributes to be changed with the values they had *before* the change\n* @param {string} text - An optional string visible to user related to this change\n*/\nexport class ChangeElementCommand extends Command {\n  constructor (elem, attrs, text) {\n    super();\n    this.elem = elem;\n    this.text = text ? ('Change ' + elem.tagName + ' ' + text) : ('Change ' + elem.tagName);\n    this.newValues = {};\n    this.oldValues = attrs;\n    for (const attr in attrs) {\n      if (attr === '#text') {\n        this.newValues[attr] = elem.textContent;\n      } else if (attr === '#href') {\n        this.newValues[attr] = getHref(elem);\n      } else {\n        this.newValues[attr] = elem.getAttribute(attr);\n      }\n    }\n  }\n  type () { // eslint-disable-line class-methods-use-this\n    return 'svgedit.history.ChangeElementCommand';\n  }\n\n  /**\n  * Performs the stored change action.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {true}\n  */\n  apply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);\n    }\n\n    let bChangedTransform = false;\n    Object.entries(this.newValues).forEach(([attr, value]) => {\n      if (value) {\n        if (attr === '#text') {\n          this.elem.textContent = value;\n        } else if (attr === '#href') {\n          setHref(this.elem, value);\n        } else {\n          this.elem.setAttribute(attr, value);\n        }\n      } else if (attr === '#text') {\n        this.elem.textContent = '';\n      } else {\n        this.elem.setAttribute(attr, '');\n        this.elem.removeAttribute(attr);\n      }\n\n      if (attr === 'transform') { bChangedTransform = true; }\n    });\n\n    // relocate rotational transform, if necessary\n    if (!bChangedTransform) {\n      const angle = getRotationAngle(this.elem);\n      if (angle) {\n        const bbox = this.elem.getBBox();\n        const cx = bbox.x + bbox.width / 2,\n          cy = bbox.y + bbox.height / 2;\n        const rotate = ['rotate(', angle, ' ', cx, ',', cy, ')'].join('');\n        if (rotate !== this.elem.getAttribute('transform')) {\n          this.elem.setAttribute('transform', rotate);\n        }\n      }\n    }\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);\n    }\n\n    return true;\n  }\n\n  /**\n  * Reverses the stored change action.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {true}\n  */\n  unapply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);\n    }\n\n    let bChangedTransform = false;\n    Object.entries(this.oldValues).forEach(([attr, value]) => {\n      if (value) {\n        if (attr === '#text') {\n          this.elem.textContent = value;\n        } else if (attr === '#href') {\n          setHref(this.elem, value);\n        } else {\n          this.elem.setAttribute(attr, value);\n        }\n      } else if (attr === '#text') {\n        this.elem.textContent = '';\n      } else {\n        this.elem.removeAttribute(attr);\n      }\n      if (attr === 'transform') { bChangedTransform = true; }\n    });\n    // relocate rotational transform, if necessary\n    if (!bChangedTransform) {\n      const angle = getRotationAngle(this.elem);\n      if (angle) {\n        const bbox = this.elem.getBBox();\n        const cx = bbox.x + bbox.width / 2,\n          cy = bbox.y + bbox.height / 2;\n        const rotate = ['rotate(', angle, ' ', cx, ',', cy, ')'].join('');\n        if (rotate !== this.elem.getAttribute('transform')) {\n          this.elem.setAttribute('transform', rotate);\n        }\n      }\n    }\n\n    // Remove transformlist to prevent confusion that causes bugs like 575.\n    removeElementFromListMap(this.elem);\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);\n    }\n\n    return true;\n  }\n\n  /**\n  * @returns {Element[]} Array with element associated with this command\n  */\n  elements () {\n    return [this.elem];\n  }\n}\nChangeElementCommand.type = ChangeElementCommand.prototype.type;\n\n// TODO: create a 'typing' command object that tracks changes in text\n// if a new Typing command is created and the top command on the stack is also a Typing\n// and they both affect the same element, then collapse the two commands into one\n\n/**\n* History command that can contain/execute multiple other commands.\n* @implements {module:history.HistoryCommand}\n*/\nexport class BatchCommand extends Command {\n  /**\n  * @param {string} [text] - An optional string visible to user related to this change\n  */\n  constructor (text) {\n    super();\n    this.text = text || 'Batch Command';\n    this.stack = [];\n  }\n\n  type () { // eslint-disable-line class-methods-use-this\n    return 'svgedit.history.BatchCommand';\n  }\n\n  /**\n  * Runs \"apply\" on all subcommands.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {undefined}\n  */\n  apply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_APPLY, this);\n    }\n\n    const len = this.stack.length;\n    for (let i = 0; i < len; ++i) {\n      this.stack[i].apply(handler);\n    }\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_APPLY, this);\n    }\n  }\n\n  /**\n  * Runs \"unapply\" on all subcommands.\n  * @param {module:history.HistoryEventHandler} handler\n  * @fires module:history~Command#event:history\n  * @returns {undefined}\n  */\n  unapply (handler) {\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.BEFORE_UNAPPLY, this);\n    }\n\n    for (let i = this.stack.length - 1; i >= 0; i--) {\n      this.stack[i].unapply(handler);\n    }\n\n    if (handler) {\n      handler.handleHistoryEvent(HistoryEventTypes.AFTER_UNAPPLY, this);\n    }\n  }\n\n  /**\n  * Iterate through all our subcommands.\n  * @returns {Element[]} All the elements we are changing\n  */\n  elements () {\n    const elems = [];\n    let cmd = this.stack.length;\n    while (cmd--) {\n      const thisElems = this.stack[cmd].elements();\n      let elem = thisElems.length;\n      while (elem--) {\n        if (!elems.includes(thisElems[elem])) { elems.push(thisElems[elem]); }\n      }\n    }\n    return elems;\n  }\n\n  /**\n  * Adds a given command to the history stack.\n  * @param {Command} cmd - The undo command object to add\n  * @returns {undefined}\n  */\n  addSubCommand (cmd) {\n    this.stack.push(cmd);\n  }\n\n  /**\n  * @returns {boolean} Indicates whether or not the batch command is empty\n  */\n  isEmpty () {\n    return !this.stack.length;\n  }\n}\nBatchCommand.type = BatchCommand.prototype.type;\n\n/**\n*\n*/\nexport class UndoManager {\n  /**\n  * @param {module:history.HistoryEventHandler} historyEventHandler\n  */\n  constructor (historyEventHandler) {\n    this.handler_ = historyEventHandler || null;\n    this.undoStackPointer = 0;\n    this.undoStack = [];\n\n    // this is the stack that stores the original values, the elements and\n    // the attribute name for begin/finish\n    this.undoChangeStackPointer = -1;\n    this.undoableChangeStack = [];\n  }\n\n  /**\n  * Resets the undo stack, effectively clearing the undo/redo history.\n  * @returns {undefined}\n  */\n  resetUndoStack () {\n    this.undoStack = [];\n    this.undoStackPointer = 0;\n  }\n\n  /**\n  * @returns {Integer} Current size of the undo history stack\n  */\n  getUndoStackSize () {\n    return this.undoStackPointer;\n  }\n\n  /**\n  * @returns {Integer} Current size of the redo history stack\n  */\n  getRedoStackSize () {\n    return this.undoStack.length - this.undoStackPointer;\n  }\n\n  /**\n  * @returns {string} String associated with the next undo command\n  */\n  getNextUndoCommandText () {\n    return this.undoStackPointer > 0 ? this.undoStack[this.undoStackPointer - 1].getText() : '';\n  }\n\n  /**\n  * @returns {string} String associated with the next redo command\n  */\n  getNextRedoCommandText () {\n    return this.undoStackPointer < this.undoStack.length ? this.undoStack[this.undoStackPointer].getText() : '';\n  }\n\n  /**\n  * Performs an undo step.\n  * @returns {undefined}\n  */\n  undo () {\n    if (this.undoStackPointer > 0) {\n      const cmd = this.undoStack[--this.undoStackPointer];\n      cmd.unapply(this.handler_);\n    }\n  }\n\n  /**\n  * Performs a redo step.\n  * @returns {undefined}\n  */\n  redo () {\n    if (this.undoStackPointer < this.undoStack.length && this.undoStack.length > 0) {\n      const cmd = this.undoStack[this.undoStackPointer++];\n      cmd.apply(this.handler_);\n    }\n  }\n\n  /**\n  * Adds a command object to the undo history stack.\n  * @param {Command} cmd - The command object to add\n  * @returns {undefined}\n  */\n  addCommandToHistory (cmd) {\n    // FIXME: we MUST compress consecutive text changes to the same element\n    // (right now each keystroke is saved as a separate command that includes the\n    // entire text contents of the text element)\n    // TODO: consider limiting the history that we store here (need to do some slicing)\n\n    // if our stack pointer is not at the end, then we have to remove\n    // all commands after the pointer and insert the new command\n    if (this.undoStackPointer < this.undoStack.length && this.undoStack.length > 0) {\n      this.undoStack = this.undoStack.splice(0, this.undoStackPointer);\n    }\n    this.undoStack.push(cmd);\n    this.undoStackPointer = this.undoStack.length;\n  }\n\n  /**\n  * This function tells the canvas to remember the old values of the\n  * `attrName` attribute for each element sent in.  The elements and values\n  * are stored on a stack, so the next call to `finishUndoableChange()` will\n  * pop the elements and old values off the stack, gets the current values\n  * from the DOM and uses all of these to construct the undo-able command.\n  * @param {string} attrName - The name of the attribute being changed\n  * @param {Element[]} elems - Array of DOM elements being changed\n  * @returns {undefined}\n  */\n  beginUndoableChange (attrName, elems) {\n    const p = ++this.undoChangeStackPointer;\n    let i = elems.length;\n    const oldValues = new Array(i), elements = new Array(i);\n    while (i--) {\n      const elem = elems[i];\n      if (isNullish(elem)) { continue; }\n      elements[i] = elem;\n      oldValues[i] = elem.getAttribute(attrName);\n    }\n    this.undoableChangeStack[p] = {\n      attrName,\n      oldValues,\n      elements\n    };\n  }\n\n  /**\n  * This function returns a `BatchCommand` object which summarizes the\n  * change since `beginUndoableChange` was called.  The command can then\n  * be added to the command history.\n  * @returns {BatchCommand} Batch command object with resulting changes\n  */\n  finishUndoableChange () {\n    const p = this.undoChangeStackPointer--;\n    const changeset = this.undoableChangeStack[p];\n    const {attrName} = changeset;\n    const batchCmd = new BatchCommand('Change ' + attrName);\n    let i = changeset.elements.length;\n    while (i--) {\n      const elem = changeset.elements[i];\n      if (isNullish(elem)) { continue; }\n      const changes = {};\n      changes[attrName] = changeset.oldValues[i];\n      if (changes[attrName] !== elem.getAttribute(attrName)) {\n        batchCmd.addSubCommand(new ChangeElementCommand(elem, changes, attrName));\n      }\n    }\n    this.undoableChangeStack[p] = null;\n    return batchCmd;\n  }\n}\n","/**\n * Mathematical utilities\n * @module math\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller\n */\n\n/**\n* @typedef {PlainObject} module:math.AngleCoord45\n* @property {Float} x - The angle-snapped x value\n* @property {Float} y - The angle-snapped y value\n* @property {Integer} a - The angle at which to snap\n*/\n\n/**\n* @typedef {PlainObject} module:math.XYObject\n* @property {Float} x\n* @property {Float} y\n*/\n\nimport {NS} from './namespaces.js';\nimport {getTransformList} from './svgtransformlist.js';\nimport {isNullish} from './utilities.js';\n\n// Constants\nconst NEAR_ZERO = 1e-14;\n\n// Throw away SVGSVGElement used for creating matrices/transforms.\nconst svg = document.createElementNS(NS.SVG, 'svg');\n\n/**\n * A (hopefully) quicker function to transform a point by a matrix\n * (this function avoids any DOM calls and just does the math).\n * @function module:math.transformPoint\n * @param {Float} x - Float representing the x coordinate\n * @param {Float} y - Float representing the y coordinate\n * @param {SVGMatrix} m - Matrix object to transform the point with\n * @returns {module:math.XYObject} An x, y object representing the transformed point\n*/\nexport const transformPoint = function (x, y, m) {\n  return {x: m.a * x + m.c * y + m.e, y: m.b * x + m.d * y + m.f};\n};\n\n/**\n * Helper function to check if the matrix performs no actual transform\n * (i.e. exists for identity purposes).\n * @function module:math.isIdentity\n * @param {SVGMatrix} m - The matrix object to check\n * @returns {boolean} Indicates whether or not the matrix is 1,0,0,1,0,0\n*/\nexport const isIdentity = function (m) {\n  return (m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && m.e === 0 && m.f === 0);\n};\n\n/**\n * This function tries to return a `SVGMatrix` that is the multiplication `m1 * m2`.\n * We also round to zero when it's near zero.\n * @function module:math.matrixMultiply\n * @param {...SVGMatrix} args - Matrix objects to multiply\n * @returns {SVGMatrix} The matrix object resulting from the calculation\n*/\nexport const matrixMultiply = function (...args) {\n  const m = args.reduceRight((prev, m1) => {\n    return m1.multiply(prev);\n  });\n\n  if (Math.abs(m.a) < NEAR_ZERO) { m.a = 0; }\n  if (Math.abs(m.b) < NEAR_ZERO) { m.b = 0; }\n  if (Math.abs(m.c) < NEAR_ZERO) { m.c = 0; }\n  if (Math.abs(m.d) < NEAR_ZERO) { m.d = 0; }\n  if (Math.abs(m.e) < NEAR_ZERO) { m.e = 0; }\n  if (Math.abs(m.f) < NEAR_ZERO) { m.f = 0; }\n\n  return m;\n};\n\n/**\n * See if the given transformlist includes a non-indentity matrix transform.\n * @function module:math.hasMatrixTransform\n * @param {SVGTransformList} [tlist] - The transformlist to check\n * @returns {boolean} Whether or not a matrix transform was found\n*/\nexport const hasMatrixTransform = function (tlist) {\n  if (!tlist) { return false; }\n  let num = tlist.numberOfItems;\n  while (num--) {\n    const xform = tlist.getItem(num);\n    if (xform.type === 1 && !isIdentity(xform.matrix)) { return true; }\n  }\n  return false;\n};\n\n/**\n* @typedef {PlainObject} module:math.TransformedBox An object with the following values\n* @property {module:math.XYObject} tl - The top left coordinate\n* @property {module:math.XYObject} tr - The top right coordinate\n* @property {module:math.XYObject} bl - The bottom left coordinate\n* @property {module:math.XYObject} br - The bottom right coordinate\n* @property {PlainObject} aabox - Object with the following values:\n* @property {Float} aabox.x - Float with the axis-aligned x coordinate\n* @property {Float} aabox.y - Float with the axis-aligned y coordinate\n* @property {Float} aabox.width - Float with the axis-aligned width coordinate\n* @property {Float} aabox.height - Float with the axis-aligned height coordinate\n*/\n\n/**\n * Transforms a rectangle based on the given matrix.\n * @function module:math.transformBox\n * @param {Float} l - Float with the box's left coordinate\n * @param {Float} t - Float with the box's top coordinate\n * @param {Float} w - Float with the box width\n * @param {Float} h - Float with the box height\n * @param {SVGMatrix} m - Matrix object to transform the box by\n * @returns {module:math.TransformedBox}\n*/\nexport const transformBox = function (l, t, w, h, m) {\n  const tl = transformPoint(l, t, m),\n    tr = transformPoint((l + w), t, m),\n    bl = transformPoint(l, (t + h), m),\n    br = transformPoint((l + w), (t + h), m),\n\n    minx = Math.min(tl.x, tr.x, bl.x, br.x),\n    maxx = Math.max(tl.x, tr.x, bl.x, br.x),\n    miny = Math.min(tl.y, tr.y, bl.y, br.y),\n    maxy = Math.max(tl.y, tr.y, bl.y, br.y);\n\n  return {\n    tl,\n    tr,\n    bl,\n    br,\n    aabox: {\n      x: minx,\n      y: miny,\n      width: (maxx - minx),\n      height: (maxy - miny)\n    }\n  };\n};\n\n/**\n * This returns a single matrix Transform for a given Transform List\n * (this is the equivalent of `SVGTransformList.consolidate()` but unlike\n * that method, this one does not modify the actual `SVGTransformList`).\n * This function is very liberal with its `min`, `max` arguments.\n * @function module:math.transformListToTransform\n * @param {SVGTransformList} tlist - The transformlist object\n * @param {Integer} [min=0] - Optional integer indicating start transform position\n * @param {Integer} [max] - Optional integer indicating end transform position;\n *   defaults to one less than the tlist's `numberOfItems`\n * @returns {SVGTransform} A single matrix transform object\n*/\nexport const transformListToTransform = function (tlist, min, max) {\n  if (isNullish(tlist)) {\n    // Or should tlist = null have been prevented before this?\n    return svg.createSVGTransformFromMatrix(svg.createSVGMatrix());\n  }\n  min = min || 0;\n  max = max || (tlist.numberOfItems - 1);\n  min = parseInt(min);\n  max = parseInt(max);\n  if (min > max) { const temp = max; max = min; min = temp; }\n  let m = svg.createSVGMatrix();\n  for (let i = min; i <= max; ++i) {\n    // if our indices are out of range, just use a harmless identity matrix\n    const mtom = (i >= 0 && i < tlist.numberOfItems\n      ? tlist.getItem(i).matrix\n      : svg.createSVGMatrix());\n    m = matrixMultiply(m, mtom);\n  }\n  return svg.createSVGTransformFromMatrix(m);\n};\n\n/**\n * Get the matrix object for a given element.\n * @function module:math.getMatrix\n * @param {Element} elem - The DOM element to check\n * @returns {SVGMatrix} The matrix object associated with the element's transformlist\n*/\nexport const getMatrix = function (elem) {\n  const tlist = getTransformList(elem);\n  return transformListToTransform(tlist).matrix;\n};\n\n/**\n * Returns a 45 degree angle coordinate associated with the two given\n * coordinates.\n * @function module:math.snapToAngle\n * @param {Integer} x1 - First coordinate's x value\n * @param {Integer} y1 - First coordinate's y value\n * @param {Integer} x2 - Second coordinate's x value\n * @param {Integer} y2 - Second coordinate's y value\n * @returns {module:math.AngleCoord45}\n*/\nexport const snapToAngle = function (x1, y1, x2, y2) {\n  const snap = Math.PI / 4; // 45 degrees\n  const dx = x2 - x1;\n  const dy = y2 - y1;\n  const angle = Math.atan2(dy, dx);\n  const dist = Math.sqrt(dx * dx + dy * dy);\n  const snapangle = Math.round(angle / snap) * snap;\n\n  return {\n    x: x1 + dist * Math.cos(snapangle),\n    y: y1 + dist * Math.sin(snapangle),\n    a: snapangle\n  };\n};\n\n/**\n * Check if two rectangles (BBoxes objects) intersect each other.\n * @function module:math.rectsIntersect\n * @param {SVGRect} r1 - The first BBox-like object\n * @param {SVGRect} r2 - The second BBox-like object\n * @returns {boolean} True if rectangles intersect\n */\nexport const rectsIntersect = function (r1, r2) {\n  return r2.x < (r1.x + r1.width) &&\n    (r2.x + r2.width) > r1.x &&\n    r2.y < (r1.y + r1.height) &&\n    (r2.y + r2.height) > r1.y;\n};\n","/* globals jQuery */\n/**\n * Path functionality\n * @module path\n * @license MIT\n *\n * @copyright 2011 Alexis Deveria, 2011 Jeff Schiller\n */\n\nimport './svgpathseg.js';\nimport {NS} from './namespaces.js';\nimport {getTransformList} from './svgtransformlist.js';\nimport {shortFloat} from './units.js';\nimport {ChangeElementCommand, BatchCommand} from './history.js';\nimport {\n  transformPoint, getMatrix, snapToAngle, rectsIntersect,\n  transformListToTransform\n} from './math.js';\nimport {\n  assignAttributes, getElem, getRotationAngle, getBBox,\n  getRefElem, findDefs, snapToGrid, isNullish,\n  getBBox as utilsGetBBox\n} from './utilities.js';\nimport {\n  supportsPathInsertItemBefore, supportsPathReplaceItem, isWebkit\n} from './browser.js';\n\nconst $ = jQuery;\n\nconst segData = {\n  2: ['x', 'y'], // PATHSEG_MOVETO_ABS\n  4: ['x', 'y'], // PATHSEG_LINETO_ABS\n  6: ['x', 'y', 'x1', 'y1', 'x2', 'y2'], // PATHSEG_CURVETO_CUBIC_ABS\n  8: ['x', 'y', 'x1', 'y1'], // PATHSEG_CURVETO_QUADRATIC_ABS\n  10: ['x', 'y', 'r1', 'r2', 'angle', 'largeArcFlag', 'sweepFlag'], // PATHSEG_ARC_ABS\n  12: ['x'], // PATHSEG_LINETO_HORIZONTAL_ABS\n  14: ['y'], // PATHSEG_LINETO_VERTICAL_ABS\n  16: ['x', 'y', 'x2', 'y2'], // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS\n  18: ['x', 'y'] // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS\n};\n\n/**\n * @tutorial LocaleDocs\n * @typedef {module:locale.LocaleStrings|PlainObject} module:path.uiStrings\n * @property {PlainObject.<string, string>} ui\n*/\n\nconst uiStrings = {};\n/**\n* @function module:path.setUiStrings\n* @param {module:path.uiStrings} strs\n* @returns {undefined}\n*/\nexport const setUiStrings = function (strs) {\n  Object.assign(uiStrings, strs.ui);\n};\n\nlet pathFuncs = [];\n\nlet linkControlPts = true;\n\n// Stores references to paths via IDs.\n// TODO: Make this cross-document happy.\nlet pathData = {};\n\n/**\n* @function module:path.setLinkControlPoints\n* @param {boolean} lcp\n* @returns {undefined}\n*/\nexport const setLinkControlPoints = function (lcp) {\n  linkControlPts = lcp;\n};\n\n/**\n * @name module:path.path\n * @type {null|module:path.Path}\n * @memberof module:path\n*/\nexport let path = null; // eslint-disable-line import/no-mutable-exports\n\nlet editorContext_ = null;\n\n/**\n* @external MouseEvent\n*/\n\n/**\n* Object with the following keys/values\n* @typedef {PlainObject} module:path.SVGElementJSON\n* @property {string} element - Tag name of the SVG element to create\n* @property {PlainObject.<string, string>} attr - Has key-value attributes to assign to the new element\n* @property {boolean} [curStyles=false] - Indicates whether current style attributes should be applied first\n* @property {module:path.SVGElementJSON[]} [children] - Data objects to be added recursively as children\n* @property {string} [namespace=\"http://www.w3.org/2000/svg\"] - Indicate a (non-SVG) namespace\n*/\n/**\n * @interface module:path.EditorContext\n * @property {module:select.SelectorManager} selectorManager\n * @property {module:svgcanvas.SvgCanvas} canvas\n */\n/**\n * @function module:path.EditorContext#call\n * @param {\"selected\"|\"changed\"} ev - String with the event name\n * @param {module:svgcanvas.SvgCanvas#event:selected|module:svgcanvas.SvgCanvas#event:changed} arg - Argument to pass through to the callback function. If the event is \"changed\", an array of `Element`s is passed; if \"selected\", a single-item array of `Element` is passed.\n * @returns {undefined}\n */\n/**\n * @function module:path.EditorContext#resetD\n * @param {SVGPathElement} p\n * @returns {undefined}\n*/\n/**\n * Note: This doesn't round to an integer necessarily\n * @function module:path.EditorContext#round\n * @param {Float} val\n * @returns {Float} Rounded value to nearest value based on `currentZoom`\n */\n/**\n * @function module:path.EditorContext#clearSelection\n * @param {boolean} [noCall] - When `true`, does not call the \"selected\" handler\n * @returns {undefined}\n*/\n/**\n * @function module:path.EditorContext#addToSelection\n * @param {Element[]} elemsToAdd - An array of DOM elements to add to the selection\n * @param {boolean} showGrips - Indicates whether the resize grips should be shown\n * @returns {undefined}\n*/\n/**\n * @function module:path.EditorContext#addCommandToHistory\n * @param {Command} cmd\n * @returns {undefined}\n */\n/**\n * @function module:path.EditorContext#remapElement\n * @param {Element} selected - DOM element to be changed\n * @param {PlainObject.<string, string>} changes - Object with changes to be remapped\n * @param {SVGMatrix} m - Matrix object to use for remapping coordinates\n * @returns {undefined}\n */\n/**\n * @function module:path.EditorContext#addSVGElementFromJson\n * @param {module:path.SVGElementJSON} data\n * @returns {Element} The new element\n*/\n/**\n * @function module:path.EditorContext#getGridSnapping\n * @returns {boolean}\n */\n/**\n * @function module:path.EditorContext#getOpacity\n * @returns {Float}\n */\n/**\n * @function module:path.EditorContext#getSelectedElements\n * @returns {Element[]} the array with selected DOM elements\n*/\n/**\n * @function module:path.EditorContext#getContainer\n * @returns {Element}\n */\n/**\n * @function module:path.EditorContext#setStarted\n * @param {boolean} s\n * @returns {undefined}\n */\n/**\n * @function module:path.EditorContext#getRubberBox\n * @returns {SVGRectElement}\n*/\n/**\n * @function module:path.EditorContext#setRubberBox\n * @param {SVGRectElement} rb\n * @returns {SVGRectElement} Same as parameter passed in\n */\n/**\n * @function module:path.EditorContext#addPtsToSelection\n * @param {PlainObject} cfg\n * @param {boolean} cfg.closedSubpath\n * @param {SVGCircleElement[]} cfg.grips\n * @returns {undefined}\n */\n/**\n * @function module:path.EditorContext#endChanges\n * @param {PlainObject} cfg\n * @param {string} cfg.cmd\n * @param {Element} cfg.elem\n * @returns {undefined}\n*/\n/**\n * @function module:path.EditorContext#getCurrentZoom\n * @returns {Float} The current zoom level\n */\n/**\n * Returns the last created DOM element ID string\n * @function module:path.EditorContext#getId\n * @returns {string}\n */\n/**\n * Creates and returns a unique ID string for a DOM element\n * @function module:path.EditorContext#getNextId\n * @returns {string}\n*/\n/**\n * Gets the desired element from a mouse event\n * @function module:path.EditorContext#getMouseTarget\n * @param {external:MouseEvent} evt - Event object from the mouse event\n * @returns {Element} DOM element we want\n */\n/**\n * @function module:path.EditorContext#getCurrentMode\n * @returns {string}\n */\n/**\n * @function module:path.EditorContext#setCurrentMode\n * @param {string} cm The mode\n * @returns {string} The same mode as passed in\n*/\n/**\n * @function module:path.EditorContext#getDrawnPath\n * @returns {SVGPathElement|null}\n */\n/**\n * @function module:path.EditorContext#setDrawnPath\n * @param {SVGPathElement|null} dp\n * @returns {SVGPathElement|null} The same value as passed in\n */\n/**\n * @function module:path.EditorContext#getSVGRoot\n * @returns {SVGSVGElement}\n*/\n\n/**\n* @function module:path.init\n* @param {module:path.EditorContext} editorContext\n* @returns {undefined}\n*/\nexport const init = function (editorContext) {\n  editorContext_ = editorContext;\n\n  pathFuncs = [0, 'ClosePath'];\n  const pathFuncsStrs = [\n    'Moveto', 'Lineto', 'CurvetoCubic', 'CurvetoQuadratic', 'Arc',\n    'LinetoHorizontal', 'LinetoVertical', 'CurvetoCubicSmooth', 'CurvetoQuadraticSmooth'\n  ];\n  $.each(pathFuncsStrs, function (i, s) {\n    pathFuncs.push(s + 'Abs');\n    pathFuncs.push(s + 'Rel');\n  });\n};\n\n/**\n* @function module:path.insertItemBefore\n* @param {Element} elem\n* @param {Segment} newseg\n* @param {Integer} index\n* @returns {undefined}\n*/\nexport const insertItemBefore = function (elem, newseg, index) {\n  // Support insertItemBefore on paths for FF2\n  const list = elem.pathSegList;\n\n  if (supportsPathInsertItemBefore()) {\n    list.insertItemBefore(newseg, index);\n    return;\n  }\n  const len = list.numberOfItems;\n  const arr = [];\n  for (let i = 0; i < len; i++) {\n    const curSeg = list.getItem(i);\n    arr.push(curSeg);\n  }\n  list.clear();\n  for (let i = 0; i < len; i++) {\n    if (i === index) { // index + 1\n      list.appendItem(newseg);\n    }\n    list.appendItem(arr[i]);\n  }\n};\n\n/**\n* @function module:path.ptObjToArr\n* @todo See if this should just live in `replacePathSeg`\n* @param {string} type\n* @param {SVGPathSegMovetoAbs|SVGPathSegLinetoAbs|SVGPathSegCurvetoCubicAbs|SVGPathSegCurvetoQuadraticAbs|SVGPathSegArcAbs|SVGPathSegLinetoHorizontalAbs|SVGPathSegLinetoVerticalAbs|SVGPathSegCurvetoCubicSmoothAbs|SVGPathSegCurvetoQuadraticSmoothAbs} segItem\n* @returns {ArgumentsArray}\n*/\nexport const ptObjToArr = function (type, segItem) {\n  const props = segData[type];\n  return props.map((prop) => {\n    return segItem[prop];\n  });\n};\n\n/**\n* @function module:path.getGripPt\n* @param {Segment} seg\n* @param {module:math.XYObject} altPt\n* @returns {module:math.XYObject}\n*/\nexport const getGripPt = function (seg, altPt) {\n  const {path: pth} = seg;\n  let out = {\n    x: altPt ? altPt.x : seg.item.x,\n    y: altPt ? altPt.y : seg.item.y\n  };\n\n  if (pth.matrix) {\n    const pt = transformPoint(out.x, out.y, pth.matrix);\n    out = pt;\n  }\n\n  const currentZoom = editorContext_.getCurrentZoom();\n  out.x *= currentZoom;\n  out.y *= currentZoom;\n\n  return out;\n};\n\n/**\n* @function module:path.getPointFromGrip\n* @param {module:math.XYObject} pt\n* @param {module:path.Path} pth\n* @returns {module:math.XYObject}\n*/\nexport const getPointFromGrip = function (pt, pth) {\n  const out = {\n    x: pt.x,\n    y: pt.y\n  };\n\n  if (pth.matrix) {\n    pt = transformPoint(out.x, out.y, pth.imatrix);\n    out.x = pt.x;\n    out.y = pt.y;\n  }\n\n  const currentZoom = editorContext_.getCurrentZoom();\n  out.x /= currentZoom;\n  out.y /= currentZoom;\n\n  return out;\n};\n\n/**\n* Requires prior call to `setUiStrings` if `xlink:title`\n*    to be set on the grip.\n* @function module:path.addPointGrip\n* @param {Integer} index\n* @param {Integer} x\n* @param {Integer} y\n* @returns {SVGCircleElement}\n*/\nexport const addPointGrip = function (index, x, y) {\n  // create the container of all the point grips\n  const pointGripContainer = getGripContainer();\n\n  let pointGrip = getElem('pathpointgrip_' + index);\n  // create it\n  if (!pointGrip) {\n    pointGrip = document.createElementNS(NS.SVG, 'circle');\n    const atts = {\n      id: 'pathpointgrip_' + index,\n      display: 'none',\n      r: 4,\n      fill: '#0FF',\n      stroke: '#00F',\n      'stroke-width': 2,\n      cursor: 'move',\n      style: 'pointer-events:all'\n    };\n    if ('pathNodeTooltip' in uiStrings) { // May be empty if running path.js without svg-editor\n      atts['xlink:title'] = uiStrings.pathNodeTooltip;\n    }\n    assignAttributes(pointGrip, atts);\n    pointGrip = pointGripContainer.appendChild(pointGrip);\n\n    const grip = $('#pathpointgrip_' + index);\n    grip.dblclick(function () {\n      if (path) {\n        path.setSegType();\n      }\n    });\n  }\n  if (x && y) {\n    // set up the point grip element and display it\n    assignAttributes(pointGrip, {\n      cx: x,\n      cy: y,\n      display: 'inline'\n    });\n  }\n  return pointGrip;\n};\n\n/**\n* @function module:path.getGripContainer\n* @returns {Element}\n*/\nexport const getGripContainer = function () {\n  let c = getElem('pathpointgrip_container');\n  if (!c) {\n    const parentElement = getElem('selectorParentGroup');\n    c = parentElement.appendChild(document.createElementNS(NS.SVG, 'g'));\n    c.id = 'pathpointgrip_container';\n  }\n  return c;\n};\n\n/**\n* Requires prior call to `setUiStrings` if `xlink:title`\n*    to be set on the grip.\n* @function module:path.addCtrlGrip\n* @param {string} id\n* @returns {SVGCircleElement}\n*/\nexport const addCtrlGrip = function (id) {\n  let pointGrip = getElem('ctrlpointgrip_' + id);\n  if (pointGrip) { return pointGrip; }\n\n  pointGrip = document.createElementNS(NS.SVG, 'circle');\n  const atts = {\n    id: 'ctrlpointgrip_' + id,\n    display: 'none',\n    r: 4,\n    fill: '#0FF',\n    stroke: '#55F',\n    'stroke-width': 1,\n    cursor: 'move',\n    style: 'pointer-events:all'\n  };\n  if ('pathCtrlPtTooltip' in uiStrings) { // May be empty if running path.js without svg-editor\n    atts['xlink:title'] = uiStrings.pathCtrlPtTooltip;\n  }\n  assignAttributes(pointGrip, atts);\n  getGripContainer().append(pointGrip);\n  return pointGrip;\n};\n\n/**\n* @function module:path.getCtrlLine\n* @param {string} id\n* @returns {SVGLineElement}\n*/\nexport const getCtrlLine = function (id) {\n  let ctrlLine = getElem('ctrlLine_' + id);\n  if (ctrlLine) { return ctrlLine; }\n\n  ctrlLine = document.createElementNS(NS.SVG, 'line');\n  assignAttributes(ctrlLine, {\n    id: 'ctrlLine_' + id,\n    stroke: '#555',\n    'stroke-width': 1,\n    style: 'pointer-events:none'\n  });\n  getGripContainer().append(ctrlLine);\n  return ctrlLine;\n};\n\n/**\n* @function module:path.getPointGrip\n* @param {Segment} seg\n* @param {boolean} update\n* @returns {SVGCircleElement}\n*/\nexport const getPointGrip = function (seg, update) {\n  const {index} = seg;\n  const pointGrip = addPointGrip(index);\n\n  if (update) {\n    const pt = getGripPt(seg);\n    assignAttributes(pointGrip, {\n      cx: pt.x,\n      cy: pt.y,\n      display: 'inline'\n    });\n  }\n\n  return pointGrip;\n};\n\n/**\n* @function module:path.getControlPoints\n* @param {Segment} seg\n* @returns {PlainObject.<string, SVGLineElement|SVGCircleElement>}\n*/\nexport const getControlPoints = function (seg) {\n  const {item, index} = seg;\n  if (!('x1' in item) || !('x2' in item)) { return null; }\n  const cpt = {};\n  /* const pointGripContainer = */ getGripContainer();\n\n  // Note that this is intentionally not seg.prev.item\n  const prev = path.segs[index - 1].item;\n\n  const segItems = [prev, item];\n\n  for (let i = 1; i < 3; i++) {\n    const id = index + 'c' + i;\n\n    const ctrlLine = cpt['c' + i + '_line'] = getCtrlLine(id);\n\n    const pt = getGripPt(seg, {x: item['x' + i], y: item['y' + i]});\n    const gpt = getGripPt(seg, {x: segItems[i - 1].x, y: segItems[i - 1].y});\n\n    assignAttributes(ctrlLine, {\n      x1: pt.x,\n      y1: pt.y,\n      x2: gpt.x,\n      y2: gpt.y,\n      display: 'inline'\n    });\n\n    cpt['c' + i + '_line'] = ctrlLine;\n\n    // create it\n    const pointGrip = cpt['c' + i] = addCtrlGrip(id);\n\n    assignAttributes(pointGrip, {\n      cx: pt.x,\n      cy: pt.y,\n      display: 'inline'\n    });\n    cpt['c' + i] = pointGrip;\n  }\n  return cpt;\n};\n\n/**\n* This replaces the segment at the given index. Type is given as number.\n* @function module:path.replacePathSeg\n* @param {Integer} type Possible values set during {@link module:path.init}\n* @param {Integer} index\n* @param {ArgumentsArray} pts\n* @param {SVGPathElement} elem\n* @returns {undefined}\n*/\nexport const replacePathSeg = function (type, index, pts, elem) {\n  const pth = elem || path.elem;\n\n  const func = 'createSVGPathSeg' + pathFuncs[type];\n  const seg = pth[func](...pts);\n\n  if (supportsPathReplaceItem()) {\n    pth.pathSegList.replaceItem(seg, index);\n  } else {\n    const segList = pth.pathSegList;\n    const len = segList.numberOfItems;\n    const arr = [];\n    for (let i = 0; i < len; i++) {\n      const curSeg = segList.getItem(i);\n      arr.push(curSeg);\n    }\n    segList.clear();\n    for (let i = 0; i < len; i++) {\n      if (i === index) {\n        segList.appendItem(seg);\n      } else {\n        segList.appendItem(arr[i]);\n      }\n    }\n  }\n};\n\n/**\n* @function module:path.getSegSelector\n* @param {Segment} seg\n* @param {boolean} update\n* @returns {SVGPathElement}\n*/\nexport const getSegSelector = function (seg, update) {\n  const {index} = seg;\n  let segLine = getElem('segline_' + index);\n  if (!segLine) {\n    const pointGripContainer = getGripContainer();\n    // create segline\n    segLine = document.createElementNS(NS.SVG, 'path');\n    assignAttributes(segLine, {\n      id: 'segline_' + index,\n      display: 'none',\n      fill: 'none',\n      stroke: '#0FF',\n      'stroke-width': 2,\n      style: 'pointer-events:none',\n      d: 'M0,0 0,0'\n    });\n    pointGripContainer.append(segLine);\n  }\n\n  if (update) {\n    const {prev} = seg;\n    if (!prev) {\n      segLine.setAttribute('display', 'none');\n      return segLine;\n    }\n\n    const pt = getGripPt(prev);\n    // Set start point\n    replacePathSeg(2, 0, [pt.x, pt.y], segLine);\n\n    const pts = ptObjToArr(seg.type, seg.item); // , true);\n    for (let i = 0; i < pts.length; i += 2) {\n      const point = getGripPt(seg, {x: pts[i], y: pts[i + 1]});\n      pts[i] = point.x;\n      pts[i + 1] = point.y;\n    }\n\n    replacePathSeg(seg.type, 1, pts, segLine);\n  }\n  return segLine;\n};\n\n/**\n * @typedef {PlainObject} Point\n * @property {Integer} x The x value\n * @property {Integer} y The y value\n */\n\n/**\n* Takes three points and creates a smoother line based on them.\n* @function module:path.smoothControlPoints\n* @param {Point} ct1 - Object with x and y values (first control point)\n* @param {Point} ct2 - Object with x and y values (second control point)\n* @param {Point} pt - Object with x and y values (third point)\n* @returns {Point[]} Array of two \"smoothed\" point objects\n*/\nexport const smoothControlPoints = function (ct1, ct2, pt) {\n  // each point must not be the origin\n  const x1 = ct1.x - pt.x,\n    y1 = ct1.y - pt.y,\n    x2 = ct2.x - pt.x,\n    y2 = ct2.y - pt.y;\n\n  if ((x1 !== 0 || y1 !== 0) && (x2 !== 0 || y2 !== 0)) {\n    const\n      r1 = Math.sqrt(x1 * x1 + y1 * y1),\n      r2 = Math.sqrt(x2 * x2 + y2 * y2),\n      nct1 = editorContext_.getSVGRoot().createSVGPoint(),\n      nct2 = editorContext_.getSVGRoot().createSVGPoint();\n    let anglea = Math.atan2(y1, x1),\n      angleb = Math.atan2(y2, x2);\n    if (anglea < 0) { anglea += 2 * Math.PI; }\n    if (angleb < 0) { angleb += 2 * Math.PI; }\n\n    const angleBetween = Math.abs(anglea - angleb),\n      angleDiff = Math.abs(Math.PI - angleBetween) / 2;\n\n    let newAnglea, newAngleb;\n    if (anglea - angleb > 0) {\n      newAnglea = angleBetween < Math.PI ? (anglea + angleDiff) : (anglea - angleDiff);\n      newAngleb = angleBetween < Math.PI ? (angleb - angleDiff) : (angleb + angleDiff);\n    } else {\n      newAnglea = angleBetween < Math.PI ? (anglea - angleDiff) : (anglea + angleDiff);\n      newAngleb = angleBetween < Math.PI ? (angleb + angleDiff) : (angleb - angleDiff);\n    }\n\n    // rotate the points\n    nct1.x = r1 * Math.cos(newAnglea) + pt.x;\n    nct1.y = r1 * Math.sin(newAnglea) + pt.y;\n    nct2.x = r2 * Math.cos(newAngleb) + pt.x;\n    nct2.y = r2 * Math.sin(newAngleb) + pt.y;\n\n    return [nct1, nct2];\n  }\n  return undefined;\n};\n\n/**\n*\n*/\nexport class Segment {\n  /**\n  * @param {Integer} index\n  * @param {SVGPathSeg} item\n  * @todo Is `item` be more constrained here?\n  */\n  constructor (index, item) {\n    this.selected = false;\n    this.index = index;\n    this.item = item;\n    this.type = item.pathSegType;\n\n    this.ctrlpts = [];\n    this.ptgrip = null;\n    this.segsel = null;\n  }\n\n  /**\n   * @param {boolean} y\n   * @returns {undefined}\n   */\n  showCtrlPts (y) {\n    for (const i in this.ctrlpts) {\n      if ({}.hasOwnProperty.call(this.ctrlpts, i)) {\n        this.ctrlpts[i].setAttribute('display', y ? 'inline' : 'none');\n      }\n    }\n  }\n\n  /**\n   * @param {boolean} y\n   * @returns {undefined}\n   */\n  selectCtrls (y) {\n    $('#ctrlpointgrip_' + this.index + 'c1, #ctrlpointgrip_' + this.index + 'c2')\n      .attr('fill', y ? '#0FF' : '#EEE');\n  }\n\n  /**\n   * @param {boolean} y\n   * @returns {undefined}\n   */\n  show (y) {\n    if (this.ptgrip) {\n      this.ptgrip.setAttribute('display', y ? 'inline' : 'none');\n      this.segsel.setAttribute('display', y ? 'inline' : 'none');\n      // Show/hide all control points if available\n      this.showCtrlPts(y);\n    }\n  }\n\n  /**\n   * @param {boolean} y\n   * @returns {undefined}\n   */\n  select (y) {\n    if (this.ptgrip) {\n      this.ptgrip.setAttribute('stroke', y ? '#0FF' : '#00F');\n      this.segsel.setAttribute('display', y ? 'inline' : 'none');\n      if (this.ctrlpts) {\n        this.selectCtrls(y);\n      }\n      this.selected = y;\n    }\n  }\n\n  /**\n   * @returns {undefined}\n   */\n  addGrip () {\n    this.ptgrip = getPointGrip(this, true);\n    this.ctrlpts = getControlPoints(this); // , true);\n    this.segsel = getSegSelector(this, true);\n  }\n\n  /**\n   * @param {boolean} full\n   * @returns {undefined}\n   */\n  update (full) {\n    if (this.ptgrip) {\n      const pt = getGripPt(this);\n      assignAttributes(this.ptgrip, {\n        cx: pt.x,\n        cy: pt.y\n      });\n\n      getSegSelector(this, true);\n\n      if (this.ctrlpts) {\n        if (full) {\n          this.item = path.elem.pathSegList.getItem(this.index);\n          this.type = this.item.pathSegType;\n        }\n        getControlPoints(this);\n      }\n      // this.segsel.setAttribute('display', y ? 'inline' : 'none');\n    }\n  }\n\n  /**\n   * @param {Integer} dx\n   * @param {Integer} dy\n   * @returns {undefined}\n   */\n  move (dx, dy) {\n    const {item} = this;\n\n    const curPts = this.ctrlpts\n      ? [\n        item.x += dx, item.y += dy,\n        item.x1, item.y1, item.x2 += dx, item.y2 += dy\n      ]\n      : [item.x += dx, item.y += dy];\n\n    replacePathSeg(this.type, this.index, curPts);\n\n    if (this.next && this.next.ctrlpts) {\n      const next = this.next.item;\n      const nextPts = [\n        next.x, next.y,\n        next.x1 += dx, next.y1 += dy, next.x2, next.y2\n      ];\n      replacePathSeg(this.next.type, this.next.index, nextPts);\n    }\n\n    if (this.mate) {\n      // The last point of a closed subpath has a 'mate',\n      // which is the 'M' segment of the subpath\n      const {item: itm} = this.mate;\n      const pts = [itm.x += dx, itm.y += dy];\n      replacePathSeg(this.mate.type, this.mate.index, pts);\n      // Has no grip, so does not need 'updating'?\n    }\n\n    this.update(true);\n    if (this.next) { this.next.update(true); }\n  }\n\n  /**\n   * @param {Integer} num\n   * @returns {undefined}\n   */\n  setLinked (num) {\n    let seg, anum, pt;\n    if (num === 2) {\n      anum = 1;\n      seg = this.next;\n      if (!seg) { return; }\n      pt = this.item;\n    } else {\n      anum = 2;\n      seg = this.prev;\n      if (!seg) { return; }\n      pt = seg.item;\n    }\n\n    const {item} = seg;\n    item['x' + anum] = pt.x + (pt.x - this.item['x' + num]);\n    item['y' + anum] = pt.y + (pt.y - this.item['y' + num]);\n\n    const pts = [\n      item.x, item.y,\n      item.x1, item.y1,\n      item.x2, item.y2\n    ];\n\n    replacePathSeg(seg.type, seg.index, pts);\n    seg.update(true);\n  }\n\n  /**\n   * @param {Integer} num\n   * @param {Integer} dx\n   * @param {Integer} dy\n   * @returns {undefined}\n   */\n  moveCtrl (num, dx, dy) {\n    const {item} = this;\n    item['x' + num] += dx;\n    item['y' + num] += dy;\n\n    const pts = [\n      item.x, item.y,\n      item.x1, item.y1, item.x2, item.y2\n    ];\n\n    replacePathSeg(this.type, this.index, pts);\n    this.update(true);\n  }\n\n  /**\n   * @param {Integer} newType Possible values set during {@link module:path.init}\n   * @param {ArgumentsArray} pts\n   * @returns {undefined}\n   */\n  setType (newType, pts) {\n    replacePathSeg(newType, this.index, pts);\n    this.type = newType;\n    this.item = path.elem.pathSegList.getItem(this.index);\n    this.showCtrlPts(newType === 6);\n    this.ctrlpts = getControlPoints(this);\n    this.update(true);\n  }\n}\n\n/**\n*\n*/\nexport class Path {\n  /**\n  * @param {SVGPathElement} elem\n  * @throws {Error} If constructed without a path element\n  */\n  constructor (elem) {\n    if (!elem || elem.tagName !== 'path') {\n      throw new Error('svgedit.path.Path constructed without a <path> element');\n    }\n\n    this.elem = elem;\n    this.segs = [];\n    this.selected_pts = [];\n    path = this; // eslint-disable-line consistent-this\n\n    this.init();\n  }\n\n  /**\n  * Reset path data.\n  * @returns {module:path.Path}\n  */\n  init () {\n    // Hide all grips, etc\n\n    // fixed, needed to work on all found elements, not just first\n    $(getGripContainer()).find('*').each(function () {\n      $(this).attr('display', 'none');\n    });\n\n    const segList = this.elem.pathSegList;\n    const len = segList.numberOfItems;\n    this.segs = [];\n    this.selected_pts = [];\n    this.first_seg = null;\n\n    // Set up segs array\n    for (let i = 0; i < len; i++) {\n      const item = segList.getItem(i);\n      const segment = new Segment(i, item);\n      segment.path = this;\n      this.segs.push(segment);\n    }\n\n    const {segs} = this;\n\n    let startI = null;\n    for (let i = 0; i < len; i++) {\n      const seg = segs[i];\n      const nextSeg = (i + 1) >= len ? null : segs[i + 1];\n      const prevSeg = (i - 1) < 0 ? null : segs[i - 1];\n      if (seg.type === 2) {\n        if (prevSeg && prevSeg.type !== 1) {\n          // New sub-path, last one is open,\n          // so add a grip to last sub-path's first point\n          const startSeg = segs[startI];\n          startSeg.next = segs[startI + 1];\n          startSeg.next.prev = startSeg;\n          startSeg.addGrip();\n        }\n        // Remember that this is a starter seg\n        startI = i;\n      } else if (nextSeg && nextSeg.type === 1) {\n        // This is the last real segment of a closed sub-path\n        // Next is first seg after \"M\"\n        seg.next = segs[startI + 1];\n\n        // First seg after \"M\"'s prev is this\n        seg.next.prev = seg;\n        seg.mate = segs[startI];\n        seg.addGrip();\n        if (isNullish(this.first_seg)) {\n          this.first_seg = seg;\n        }\n      } else if (!nextSeg) {\n        if (seg.type !== 1) {\n          // Last seg, doesn't close so add a grip\n          // to last sub-path's first point\n          const startSeg = segs[startI];\n          startSeg.next = segs[startI + 1];\n          startSeg.next.prev = startSeg;\n          startSeg.addGrip();\n          seg.addGrip();\n\n          if (!this.first_seg) {\n            // Open path, so set first as real first and add grip\n            this.first_seg = segs[startI];\n          }\n        }\n      } else if (seg.type !== 1) {\n        // Regular segment, so add grip and its \"next\"\n        seg.addGrip();\n\n        // Don't set its \"next\" if it's an \"M\"\n        if (nextSeg && nextSeg.type !== 2) {\n          seg.next = nextSeg;\n          seg.next.prev = seg;\n        }\n      }\n    }\n    return this;\n  }\n\n  /**\n  * @callback module:path.PathEachSegCallback\n  * @this module:path.Segment\n  * @param {Integer} i The index of the seg being iterated\n  * @returns {boolean|undefined} Will stop execution of `eachSeg` if returns `false`\n  */\n  /**\n  * @param {module:path.PathEachSegCallback} fn\n  * @returns {undefined}\n  */\n  eachSeg (fn) {\n    const len = this.segs.length;\n    for (let i = 0; i < len; i++) {\n      const ret = fn.call(this.segs[i], i);\n      if (ret === false) { break; }\n    }\n  }\n\n  /**\n  * @param {Integer} index\n  * @returns {undefined}\n  */\n  addSeg (index) {\n    // Adds a new segment\n    const seg = this.segs[index];\n    if (!seg.prev) { return; }\n\n    const {prev} = seg;\n    let newseg, newX, newY;\n    switch (seg.item.pathSegType) {\n    case 4: {\n      newX = (seg.item.x + prev.item.x) / 2;\n      newY = (seg.item.y + prev.item.y) / 2;\n      newseg = this.elem.createSVGPathSegLinetoAbs(newX, newY);\n      break;\n    } case 6: { // make it a curved segment to preserve the shape (WRS)\n      // https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm#Geometric_interpretation\n      const p0x = (prev.item.x + seg.item.x1) / 2;\n      const p1x = (seg.item.x1 + seg.item.x2) / 2;\n      const p2x = (seg.item.x2 + seg.item.x) / 2;\n      const p01x = (p0x + p1x) / 2;\n      const p12x = (p1x + p2x) / 2;\n      newX = (p01x + p12x) / 2;\n      const p0y = (prev.item.y + seg.item.y1) / 2;\n      const p1y = (seg.item.y1 + seg.item.y2) / 2;\n      const p2y = (seg.item.y2 + seg.item.y) / 2;\n      const p01y = (p0y + p1y) / 2;\n      const p12y = (p1y + p2y) / 2;\n      newY = (p01y + p12y) / 2;\n      newseg = this.elem.createSVGPathSegCurvetoCubicAbs(newX, newY, p0x, p0y, p01x, p01y);\n      const pts = [seg.item.x, seg.item.y, p12x, p12y, p2x, p2y];\n      replacePathSeg(seg.type, index, pts);\n      break;\n    }\n    }\n\n    insertItemBefore(this.elem, newseg, index);\n  }\n\n  /**\n  * @param {Integer} index\n  * @returns {undefined}\n  */\n  deleteSeg (index) {\n    const seg = this.segs[index];\n    const list = this.elem.pathSegList;\n\n    seg.show(false);\n    const {next} = seg;\n    if (seg.mate) {\n      // Make the next point be the \"M\" point\n      const pt = [next.item.x, next.item.y];\n      replacePathSeg(2, next.index, pt);\n\n      // Reposition last node\n      replacePathSeg(4, seg.index, pt);\n\n      list.removeItem(seg.mate.index);\n    } else if (!seg.prev) {\n      // First node of open path, make next point the M\n      // const {item} = seg;\n      const pt = [next.item.x, next.item.y];\n      replacePathSeg(2, seg.next.index, pt);\n      list.removeItem(index);\n    } else {\n      list.removeItem(index);\n    }\n  }\n\n  /**\n  * @param {Integer} index\n  * @returns {undefined}\n  */\n  removePtFromSelection (index) {\n    const pos = this.selected_pts.indexOf(index);\n    if (pos === -1) {\n      return;\n    }\n    this.segs[index].select(false);\n    this.selected_pts.splice(pos, 1);\n  }\n\n  /**\n  * @returns {undefined}\n  */\n  clearSelection () {\n    this.eachSeg(function () {\n      // 'this' is the segment here\n      this.select(false);\n    });\n    this.selected_pts = [];\n  }\n\n  /**\n  * @returns {undefined}\n  */\n  storeD () {\n    this.last_d = this.elem.getAttribute('d');\n  }\n\n  /**\n  * @param {Integer} y\n  * @returns {undefined}\n  */\n  show (y) {\n    // Shows this path's segment grips\n    this.eachSeg(function () {\n      // 'this' is the segment here\n      this.show(y);\n    });\n    if (y) {\n      this.selectPt(this.first_seg.index);\n    }\n    return this;\n  }\n\n  /**\n  * Move selected points.\n  * @param {Integer} dx\n  * @param {Integer} dy\n  * @returns {undefined}\n  */\n  movePts (dx, dy) {\n    let i = this.selected_pts.length;\n    while (i--) {\n      const seg = this.segs[this.selected_pts[i]];\n      seg.move(dx, dy);\n    }\n  }\n\n  /**\n  * @param {Integer} dx\n  * @param {Integer} dy\n  * @returns {undefined}\n  */\n  moveCtrl (dx, dy) {\n    const seg = this.segs[this.selected_pts[0]];\n    seg.moveCtrl(this.dragctrl, dx, dy);\n    if (linkControlPts) {\n      seg.setLinked(this.dragctrl);\n    }\n  }\n\n  /**\n  * @param {?Integer} newType See {@link https://www.w3.org/TR/SVG/single-page.html#paths-InterfaceSVGPathSeg}\n  * @returns {undefined}\n  */\n  setSegType (newType) {\n    this.storeD();\n    let i = this.selected_pts.length;\n    let text;\n    while (i--) {\n      const selPt = this.selected_pts[i];\n\n      // Selected seg\n      const cur = this.segs[selPt];\n      const {prev} = cur;\n      if (!prev) { continue; }\n\n      if (!newType) { // double-click, so just toggle\n        text = 'Toggle Path Segment Type';\n\n        // Toggle segment to curve/straight line\n        const oldType = cur.type;\n\n        newType = (oldType === 6) ? 4 : 6;\n      }\n\n      newType = Number(newType);\n\n      const curX = cur.item.x;\n      const curY = cur.item.y;\n      const prevX = prev.item.x;\n      const prevY = prev.item.y;\n      let points;\n      switch (newType) {\n      case 6: {\n        if (cur.olditem) {\n          const old = cur.olditem;\n          points = [curX, curY, old.x1, old.y1, old.x2, old.y2];\n        } else {\n          const diffX = curX - prevX;\n          const diffY = curY - prevY;\n          // get control points from straight line segment\n          /*\n          const ct1x = (prevX + (diffY/2));\n          const ct1y = (prevY - (diffX/2));\n          const ct2x = (curX + (diffY/2));\n          const ct2y = (curY - (diffX/2));\n          */\n          // create control points on the line to preserve the shape (WRS)\n          const ct1x = (prevX + (diffX / 3));\n          const ct1y = (prevY + (diffY / 3));\n          const ct2x = (curX - (diffX / 3));\n          const ct2y = (curY - (diffY / 3));\n          points = [curX, curY, ct1x, ct1y, ct2x, ct2y];\n        }\n        break;\n      } case 4: {\n        points = [curX, curY];\n\n        // Store original prevve segment nums\n        cur.olditem = cur.item;\n        break;\n      }\n      }\n\n      cur.setType(newType, points);\n    }\n    path.endChanges(text);\n  }\n\n  /**\n  * @param {Integer} pt\n  * @param {Integer} ctrlNum\n  * @returns {undefined}\n  */\n  selectPt (pt, ctrlNum) {\n    this.clearSelection();\n    if (isNullish(pt)) {\n      this.eachSeg(function (i) {\n        // 'this' is the segment here.\n        if (this.prev) {\n          pt = i;\n        }\n      });\n    }\n    this.addPtsToSelection(pt);\n    if (ctrlNum) {\n      this.dragctrl = ctrlNum;\n\n      if (linkControlPts) {\n        this.segs[pt].setLinked(ctrlNum);\n      }\n    }\n  }\n\n  /**\n  * Update position of all points.\n  * @returns {Path}\n  */\n  update () {\n    const {elem} = this;\n    if (getRotationAngle(elem)) {\n      this.matrix = getMatrix(elem);\n      this.imatrix = this.matrix.inverse();\n    } else {\n      this.matrix = null;\n      this.imatrix = null;\n    }\n\n    this.eachSeg(function (i) {\n      this.item = elem.pathSegList.getItem(i);\n      this.update();\n    });\n\n    return this;\n  }\n\n  /**\n  * @param {string} text\n  * @returns {undefined}\n  */\n  endChanges (text) {\n    if (isWebkit()) { editorContext_.resetD(this.elem); }\n    const cmd = new ChangeElementCommand(this.elem, {d: this.last_d}, text);\n    editorContext_.endChanges({cmd, elem: this.elem});\n  }\n\n  /**\n  * @param {Integer|Integer[]} indexes\n  * @returns {undefined}\n  */\n  addPtsToSelection (indexes) {\n    if (!Array.isArray(indexes)) { indexes = [indexes]; }\n    for (let i = 0; i < indexes.length; i++) {\n      const index = indexes[i];\n      const seg = this.segs[index];\n      if (seg.ptgrip) {\n        if (!this.selected_pts.includes(index) && index >= 0) {\n          this.selected_pts.push(index);\n        }\n      }\n    }\n    this.selected_pts.sort();\n    let i = this.selected_pts.length;\n    const grips = [];\n    grips.length = i;\n    // Loop through points to be selected and highlight each\n    while (i--) {\n      const pt = this.selected_pts[i];\n      const seg = this.segs[pt];\n      seg.select(true);\n      grips[i] = seg.ptgrip;\n    }\n\n    const closedSubpath = Path.subpathIsClosed(this.selected_pts[0]);\n    editorContext_.addPtsToSelection({grips, closedSubpath});\n  }\n}\n\n/**\n* @param {Integer} index\n* @returns {boolean}\n*/\nPath.subpathIsClosed = function (index) {\n  let clsd = false;\n  // Check if subpath is already open\n  path.eachSeg(function (i) {\n    if (i <= index) { return true; }\n    if (this.type === 2) {\n      // Found M first, so open\n      return false;\n    }\n    if (this.type === 1) {\n      // Found Z first, so closed\n      clsd = true;\n      return false;\n    }\n    return true;\n  });\n\n  return clsd;\n};\n\n/**\n* @function module:path.getPath_\n* @param {SVGPathElement} elem\n* @returns {module:path.Path}\n*/\nexport const getPath_ = function (elem) {\n  let p = pathData[elem.id];\n  if (!p) {\n    p = pathData[elem.id] = new Path(elem);\n  }\n  return p;\n};\n\n/**\n* @function module:path.removePath_\n* @param {string} id\n* @returns {undefined}\n*/\nexport const removePath_ = function (id) {\n  if (id in pathData) { delete pathData[id]; }\n};\n\nlet newcx, newcy, oldcx, oldcy, angle;\n\nconst getRotVals = function (x, y) {\n  let dx = x - oldcx;\n  let dy = y - oldcy;\n\n  // rotate the point around the old center\n  let r = Math.sqrt(dx * dx + dy * dy);\n  let theta = Math.atan2(dy, dx) + angle;\n  dx = r * Math.cos(theta) + oldcx;\n  dy = r * Math.sin(theta) + oldcy;\n\n  // dx,dy should now hold the actual coordinates of each\n  // point after being rotated\n\n  // now we want to rotate them around the new center in the reverse direction\n  dx -= newcx;\n  dy -= newcy;\n\n  r = Math.sqrt(dx * dx + dy * dy);\n  theta = Math.atan2(dy, dx) - angle;\n\n  return {x: r * Math.cos(theta) + newcx,\n    y: r * Math.sin(theta) + newcy};\n};\n\n// If the path was rotated, we must now pay the piper:\n// Every path point must be rotated into the rotated coordinate system of\n// its old center, then determine the new center, then rotate it back\n// This is because we want the path to remember its rotation\n\n/**\n* @function module:path.recalcRotatedPath\n* @todo This is still using ye olde transform methods, can probably\n* be optimized or even taken care of by `recalculateDimensions`\n* @returns {undefined}\n*/\nexport const recalcRotatedPath = function () {\n  const currentPath = path.elem;\n  angle = getRotationAngle(currentPath, true);\n  if (!angle) { return; }\n  // selectedBBoxes[0] = path.oldbbox;\n  const oldbox = path.oldbbox; // selectedBBoxes[0],\n  oldcx = oldbox.x + oldbox.width / 2;\n  oldcy = oldbox.y + oldbox.height / 2;\n  const box = getBBox(currentPath);\n  newcx = box.x + box.width / 2;\n  newcy = box.y + box.height / 2;\n\n  // un-rotate the new center to the proper position\n  const dx = newcx - oldcx,\n    dy = newcy - oldcy,\n    r = Math.sqrt(dx * dx + dy * dy),\n    theta = Math.atan2(dy, dx) + angle;\n\n  newcx = r * Math.cos(theta) + oldcx;\n  newcy = r * Math.sin(theta) + oldcy;\n\n  const list = currentPath.pathSegList;\n\n  let i = list.numberOfItems;\n  while (i) {\n    i -= 1;\n    const seg = list.getItem(i),\n      type = seg.pathSegType;\n    if (type === 1) { continue; }\n\n    const rvals = getRotVals(seg.x, seg.y),\n      points = [rvals.x, rvals.y];\n    if (!isNullish(seg.x1) && !isNullish(seg.x2)) {\n      const cVals1 = getRotVals(seg.x1, seg.y1);\n      const cVals2 = getRotVals(seg.x2, seg.y2);\n      points.splice(points.length, 0, cVals1.x, cVals1.y, cVals2.x, cVals2.y);\n    }\n    replacePathSeg(type, i, points);\n  } // loop for each point\n\n  /* box = */ getBBox(currentPath);\n  // selectedBBoxes[0].x = box.x; selectedBBoxes[0].y = box.y;\n  // selectedBBoxes[0].width = box.width; selectedBBoxes[0].height = box.height;\n\n  // now we must set the new transform to be rotated around the new center\n  const Rnc = editorContext_.getSVGRoot().createSVGTransform(),\n    tlist = getTransformList(currentPath);\n  Rnc.setRotate((angle * 180.0 / Math.PI), newcx, newcy);\n  tlist.replaceItem(Rnc, 0);\n};\n\n// ====================================\n// Public API starts here\n\n/**\n* @function module:path.clearData\n* @returns {undefined}\n*/\nexport const clearData = function () {\n  pathData = {};\n};\n\n// Making public for mocking\n/**\n* @function module:path.reorientGrads\n* @param {Element} elem\n* @param {SVGMatrix} m\n* @returns {undefined}\n*/\nexport const reorientGrads = function (elem, m) {\n  const bb = utilsGetBBox(elem);\n  for (let i = 0; i < 2; i++) {\n    const type = i === 0 ? 'fill' : 'stroke';\n    const attrVal = elem.getAttribute(type);\n    if (attrVal && attrVal.startsWith('url(')) {\n      const grad = getRefElem(attrVal);\n      if (grad.tagName === 'linearGradient') {\n        let x1 = grad.getAttribute('x1') || 0;\n        let y1 = grad.getAttribute('y1') || 0;\n        let x2 = grad.getAttribute('x2') || 1;\n        let y2 = grad.getAttribute('y2') || 0;\n\n        // Convert to USOU points\n        x1 = (bb.width * x1) + bb.x;\n        y1 = (bb.height * y1) + bb.y;\n        x2 = (bb.width * x2) + bb.x;\n        y2 = (bb.height * y2) + bb.y;\n\n        // Transform those points\n        const pt1 = transformPoint(x1, y1, m);\n        const pt2 = transformPoint(x2, y2, m);\n\n        // Convert back to BB points\n        const gCoords = {};\n\n        gCoords.x1 = (pt1.x - bb.x) / bb.width;\n        gCoords.y1 = (pt1.y - bb.y) / bb.height;\n        gCoords.x2 = (pt2.x - bb.x) / bb.width;\n        gCoords.y2 = (pt2.y - bb.y) / bb.height;\n\n        const newgrad = grad.cloneNode(true);\n        $(newgrad).attr(gCoords);\n\n        newgrad.id = editorContext_.getNextId();\n        findDefs().append(newgrad);\n        elem.setAttribute(type, 'url(#' + newgrad.id + ')');\n      }\n    }\n  }\n};\n\n/**\n* This is how we map paths to our preferred relative segment types\n* @name module:path.pathMap\n* @type {GenericArray}\n*/\nconst pathMap = [\n  0, 'z', 'M', 'm', 'L', 'l', 'C', 'c', 'Q', 'q', 'A', 'a',\n  'H', 'h', 'V', 'v', 'S', 's', 'T', 't'\n];\n\n/**\n * Convert a path to one with only absolute or relative values.\n * @todo move to pathActions.js\n * @function module:path.convertPath\n * @param {SVGPathElement} pth - the path to convert\n * @param {boolean} toRel - true of convert to relative\n * @returns {string}\n */\nexport const convertPath = function (pth, toRel) {\n  const {pathSegList} = pth;\n  const len = pathSegList.numberOfItems;\n  let curx = 0, cury = 0;\n  let d = '';\n  let lastM = null;\n\n  for (let i = 0; i < len; ++i) {\n    const seg = pathSegList.getItem(i);\n    // if these properties are not in the segment, set them to zero\n    let x = seg.x || 0,\n      y = seg.y || 0,\n      x1 = seg.x1 || 0,\n      y1 = seg.y1 || 0,\n      x2 = seg.x2 || 0,\n      y2 = seg.y2 || 0;\n\n    const type = seg.pathSegType;\n    let letter = pathMap[type]['to' + (toRel ? 'Lower' : 'Upper') + 'Case']();\n\n    switch (type) {\n    case 1: // z,Z closepath (Z/z)\n      d += 'z';\n      if (lastM && !toRel) {\n        curx = lastM[0];\n        cury = lastM[1];\n      }\n      break;\n    case 12: // absolute horizontal line (H)\n      x -= curx;\n      // Fallthrough\n    case 13: // relative horizontal line (h)\n      if (toRel) {\n        curx += x;\n        letter = 'l';\n      } else {\n        x += curx;\n        curx = x;\n        letter = 'L';\n      }\n      // Convert to \"line\" for easier editing\n      d += pathDSegment(letter, [[x, cury]]);\n      break;\n    case 14: // absolute vertical line (V)\n      y -= cury;\n      // Fallthrough\n    case 15: // relative vertical line (v)\n      if (toRel) {\n        cury += y;\n        letter = 'l';\n      } else {\n        y += cury;\n        cury = y;\n        letter = 'L';\n      }\n      // Convert to \"line\" for easier editing\n      d += pathDSegment(letter, [[curx, y]]);\n      break;\n    case 2: // absolute move (M)\n    case 4: // absolute line (L)\n    case 18: // absolute smooth quad (T)\n      x -= curx;\n      y -= cury;\n      // Fallthrough\n    case 5: // relative line (l)\n    case 3: // relative move (m)\n    case 19: // relative smooth quad (t)\n      if (toRel) {\n        curx += x;\n        cury += y;\n      } else {\n        x += curx;\n        y += cury;\n        curx = x;\n        cury = y;\n      }\n      if (type === 2 || type === 3) { lastM = [curx, cury]; }\n\n      d += pathDSegment(letter, [[x, y]]);\n      break;\n    case 6: // absolute cubic (C)\n      x -= curx; x1 -= curx; x2 -= curx;\n      y -= cury; y1 -= cury; y2 -= cury;\n      // Fallthrough\n    case 7: // relative cubic (c)\n      if (toRel) {\n        curx += x;\n        cury += y;\n      } else {\n        x += curx; x1 += curx; x2 += curx;\n        y += cury; y1 += cury; y2 += cury;\n        curx = x;\n        cury = y;\n      }\n      d += pathDSegment(letter, [[x1, y1], [x2, y2], [x, y]]);\n      break;\n    case 8: // absolute quad (Q)\n      x -= curx; x1 -= curx;\n      y -= cury; y1 -= cury;\n      // Fallthrough\n    case 9: // relative quad (q)\n      if (toRel) {\n        curx += x;\n        cury += y;\n      } else {\n        x += curx; x1 += curx;\n        y += cury; y1 += cury;\n        curx = x;\n        cury = y;\n      }\n      d += pathDSegment(letter, [[x1, y1], [x, y]]);\n      break;\n    case 10: // absolute elliptical arc (A)\n      x -= curx;\n      y -= cury;\n      // Fallthrough\n    case 11: // relative elliptical arc (a)\n      if (toRel) {\n        curx += x;\n        cury += y;\n      } else {\n        x += curx;\n        y += cury;\n        curx = x;\n        cury = y;\n      }\n      d += pathDSegment(letter, [[seg.r1, seg.r2]], [\n        seg.angle,\n        (seg.largeArcFlag ? 1 : 0),\n        (seg.sweepFlag ? 1 : 0)\n      ], [x, y]);\n      break;\n    case 16: // absolute smooth cubic (S)\n      x -= curx; x2 -= curx;\n      y -= cury; y2 -= cury;\n      // Fallthrough\n    case 17: // relative smooth cubic (s)\n      if (toRel) {\n        curx += x;\n        cury += y;\n      } else {\n        x += curx; x2 += curx;\n        y += cury; y2 += cury;\n        curx = x;\n        cury = y;\n      }\n      d += pathDSegment(letter, [[x2, y2], [x, y]]);\n      break;\n    } // switch on path segment type\n  } // for each segment\n  return d;\n};\n\n/**\n * TODO: refactor callers in `convertPath` to use `getPathDFromSegments` instead of this function.\n * Legacy code refactored from `svgcanvas.pathActions.convertPath`.\n * @param {string} letter - path segment command (letter in potentially either case from {@link module:path.pathMap}; see [SVGPathSeg#pathSegTypeAsLetter]{@link https://www.w3.org/TR/SVG/single-page.html#paths-__svg__SVGPathSeg__pathSegTypeAsLetter})\n * @param {GenericArray<GenericArray<Integer>>} points - x,y points\n * @param {GenericArray<GenericArray<Integer>>} [morePoints] - x,y points\n * @param {Integer[]} [lastPoint] - x,y point\n * @returns {string}\n */\nfunction pathDSegment (letter, points, morePoints, lastPoint) {\n  $.each(points, function (i, pnt) {\n    points[i] = shortFloat(pnt);\n  });\n  let segment = letter + points.join(' ');\n  if (morePoints) {\n    segment += ' ' + morePoints.join(' ');\n  }\n  if (lastPoint) {\n    segment += ' ' + shortFloat(lastPoint);\n  }\n  return segment;\n}\n\n/**\n* Group: Path edit functions\n* Functions relating to editing path elements\n* @namespace {PlainObject} pathActions\n* @memberof module:path\n*/\nexport const pathActions = (function () {\n  let subpath = false;\n  let newPoint, firstCtrl;\n\n  let currentPath = null;\n  let hasMoved = false;\n  // No `editorContext_` yet but should be ok as is `null` by default\n  // editorContext_.setDrawnPath(null);\n\n  /**\n  * This function converts a polyline (created by the fh_path tool) into\n  * a path element and coverts every three line segments into a single bezier\n  * curve in an attempt to smooth out the free-hand.\n  * @function smoothPolylineIntoPath\n  * @param {Element} element\n  * @returns {Element}\n  */\n  const smoothPolylineIntoPath = function (element) {\n    let i;\n    const {points} = element;\n    const N = points.numberOfItems;\n    if (N >= 4) {\n      // loop through every 3 points and convert to a cubic bezier curve segment\n      //\n      // NOTE: this is cheating, it means that every 3 points has the potential to\n      // be a corner instead of treating each point in an equal manner. In general,\n      // this technique does not look that good.\n      //\n      // I am open to better ideas!\n      //\n      // Reading:\n      // - http://www.efg2.com/Lab/Graphics/Jean-YvesQueinecBezierCurves.htm\n      // - https://www.codeproject.com/KB/graphics/BezierSpline.aspx?msg=2956963\n      // - https://www.ian-ko.com/ET_GeoWizards/UserGuide/smooth.htm\n      // - https://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/Bezier/bezier-der.html\n      let curpos = points.getItem(0), prevCtlPt = null;\n      let d = [];\n      d.push(['M', curpos.x, ',', curpos.y, ' C'].join(''));\n      for (i = 1; i <= (N - 4); i += 3) {\n        let ct1 = points.getItem(i);\n        const ct2 = points.getItem(i + 1);\n        const end = points.getItem(i + 2);\n\n        // if the previous segment had a control point, we want to smooth out\n        // the control points on both sides\n        if (prevCtlPt) {\n          const newpts = smoothControlPoints(prevCtlPt, ct1, curpos);\n          if (newpts && newpts.length === 2) {\n            const prevArr = d[d.length - 1].split(',');\n            prevArr[2] = newpts[0].x;\n            prevArr[3] = newpts[0].y;\n            d[d.length - 1] = prevArr.join(',');\n            ct1 = newpts[1];\n          }\n        }\n\n        d.push([ct1.x, ct1.y, ct2.x, ct2.y, end.x, end.y].join(','));\n\n        curpos = end;\n        prevCtlPt = ct2;\n      }\n      // handle remaining line segments\n      d.push('L');\n      while (i < N) {\n        const pt = points.getItem(i);\n        d.push([pt.x, pt.y].join(','));\n        i++;\n      }\n      d = d.join(' ');\n\n      // create new path element\n      element = editorContext_.addSVGElementFromJson({\n        element: 'path',\n        curStyles: true,\n        attr: {\n          id: editorContext_.getId(),\n          d,\n          fill: 'none'\n        }\n      });\n      // No need to call \"changed\", as this is already done under mouseUp\n    }\n    return element;\n  };\n\n  return (/** @lends module:path.pathActions */ {\n    /**\n    * @param {MouseEvent} evt\n    * @param {Element} mouseTarget\n    * @param {Float} startX\n    * @param {Float} startY\n    * @returns {boolean|undefined}\n    */\n    mouseDown (evt, mouseTarget, startX, startY) {\n      let id;\n      if (editorContext_.getCurrentMode() === 'path') {\n        let mouseX = startX; // Was this meant to work with the other `mouseX`? (was defined globally so adding `let` to at least avoid a global)\n        let mouseY = startY; // Was this meant to work with the other `mouseY`? (was defined globally so adding `let` to at least avoid a global)\n\n        const currentZoom = editorContext_.getCurrentZoom();\n        let x = mouseX / currentZoom,\n          y = mouseY / currentZoom,\n          stretchy = getElem('path_stretch_line');\n        newPoint = [x, y];\n\n        if (editorContext_.getGridSnapping()) {\n          x = snapToGrid(x);\n          y = snapToGrid(y);\n          mouseX = snapToGrid(mouseX);\n          mouseY = snapToGrid(mouseY);\n        }\n\n        if (!stretchy) {\n          stretchy = document.createElementNS(NS.SVG, 'path');\n          assignAttributes(stretchy, {\n            id: 'path_stretch_line',\n            stroke: '#22C',\n            'stroke-width': '0.5',\n            fill: 'none'\n          });\n          stretchy = getElem('selectorParentGroup').appendChild(stretchy);\n        }\n        stretchy.setAttribute('display', 'inline');\n\n        let keep = null;\n        let index;\n        // if pts array is empty, create path element with M at current point\n        const drawnPath = editorContext_.getDrawnPath();\n        if (!drawnPath) {\n          const dAttr = 'M' + x + ',' + y + ' '; // Was this meant to work with the other `dAttr`? (was defined globally so adding `var` to at least avoid a global)\n          /* drawnPath = */ editorContext_.setDrawnPath(editorContext_.addSVGElementFromJson({\n            element: 'path',\n            curStyles: true,\n            attr: {\n              d: dAttr,\n              id: editorContext_.getNextId(),\n              opacity: editorContext_.getOpacity() / 2\n            }\n          }));\n          // set stretchy line to first point\n          stretchy.setAttribute('d', ['M', mouseX, mouseY, mouseX, mouseY].join(' '));\n          index = subpath ? path.segs.length : 0;\n          addPointGrip(index, mouseX, mouseY);\n        } else {\n          // determine if we clicked on an existing point\n          const seglist = drawnPath.pathSegList;\n          let i = seglist.numberOfItems;\n          const FUZZ = 6 / currentZoom;\n          let clickOnPoint = false;\n          while (i) {\n            i--;\n            const item = seglist.getItem(i);\n            const px = item.x, py = item.y;\n            // found a matching point\n            if (x >= (px - FUZZ) && x <= (px + FUZZ) &&\n              y >= (py - FUZZ) && y <= (py + FUZZ)\n            ) {\n              clickOnPoint = true;\n              break;\n            }\n          }\n\n          // get path element that we are in the process of creating\n          id = editorContext_.getId();\n\n          // Remove previous path object if previously created\n          removePath_(id);\n\n          const newpath = getElem(id);\n          let newseg;\n          let sSeg;\n          const len = seglist.numberOfItems;\n          // if we clicked on an existing point, then we are done this path, commit it\n          // (i, i+1) are the x,y that were clicked on\n          if (clickOnPoint) {\n            // if clicked on any other point but the first OR\n            // the first point was clicked on and there are less than 3 points\n            // then leave the path open\n            // otherwise, close the path\n            if (i <= 1 && len >= 2) {\n              // Create end segment\n              const absX = seglist.getItem(0).x;\n              const absY = seglist.getItem(0).y;\n\n              sSeg = stretchy.pathSegList.getItem(1);\n              if (sSeg.pathSegType === 4) {\n                newseg = drawnPath.createSVGPathSegLinetoAbs(absX, absY);\n              } else {\n                newseg = drawnPath.createSVGPathSegCurvetoCubicAbs(\n                  absX,\n                  absY,\n                  sSeg.x1 / currentZoom,\n                  sSeg.y1 / currentZoom,\n                  absX,\n                  absY\n                );\n              }\n\n              const endseg = drawnPath.createSVGPathSegClosePath();\n              seglist.appendItem(newseg);\n              seglist.appendItem(endseg);\n            } else if (len < 3) {\n              keep = false;\n              return keep;\n            }\n            $(stretchy).remove();\n\n            // This will signal to commit the path\n            // const element = newpath; // Other event handlers define own `element`, so this was probably not meant to interact with them or one which shares state (as there were none); I therefore adding a missing `var` to avoid a global\n            /* drawnPath = */ editorContext_.setDrawnPath(null);\n            editorContext_.setStarted(false);\n\n            if (subpath) {\n              if (path.matrix) {\n                editorContext_.remapElement(newpath, {}, path.matrix.inverse());\n              }\n\n              const newD = newpath.getAttribute('d');\n              const origD = $(path.elem).attr('d');\n              $(path.elem).attr('d', origD + newD);\n              $(newpath).remove();\n              if (path.matrix) {\n                recalcRotatedPath();\n              }\n              init();\n              pathActions.toEditMode(path.elem);\n              path.selectPt();\n              return false;\n            }\n          // else, create a new point, update path element\n          } else {\n            // Checks if current target or parents are #svgcontent\n            if (!$.contains(\n              editorContext_.getContainer(),\n              editorContext_.getMouseTarget(evt)\n            )) {\n              // Clicked outside canvas, so don't make point\n              // console.log('Clicked outside canvas');\n              return false;\n            }\n\n            const num = drawnPath.pathSegList.numberOfItems;\n            const last = drawnPath.pathSegList.getItem(num - 1);\n            const lastx = last.x, lasty = last.y;\n\n            if (evt.shiftKey) {\n              const xya = snapToAngle(lastx, lasty, x, y);\n              ({x, y} = xya);\n            }\n\n            // Use the segment defined by stretchy\n            sSeg = stretchy.pathSegList.getItem(1);\n            if (sSeg.pathSegType === 4) {\n              newseg = drawnPath.createSVGPathSegLinetoAbs(\n                editorContext_.round(x),\n                editorContext_.round(y)\n              );\n            } else {\n              newseg = drawnPath.createSVGPathSegCurvetoCubicAbs(\n                editorContext_.round(x),\n                editorContext_.round(y),\n                sSeg.x1 / currentZoom,\n                sSeg.y1 / currentZoom,\n                sSeg.x2 / currentZoom,\n                sSeg.y2 / currentZoom\n              );\n            }\n\n            drawnPath.pathSegList.appendItem(newseg);\n\n            x *= currentZoom;\n            y *= currentZoom;\n\n            // set stretchy line to latest point\n            stretchy.setAttribute('d', ['M', x, y, x, y].join(' '));\n            index = num;\n            if (subpath) { index += path.segs.length; }\n            addPointGrip(index, x, y);\n          }\n          // keep = true;\n        }\n\n        return undefined;\n      }\n\n      // TODO: Make sure currentPath isn't null at this point\n      if (!path) { return undefined; }\n\n      path.storeD();\n\n      ({id} = evt.target);\n      let curPt;\n      if (id.substr(0, 14) === 'pathpointgrip_') {\n        // Select this point\n        curPt = path.cur_pt = parseInt(id.substr(14));\n        path.dragging = [startX, startY];\n        const seg = path.segs[curPt];\n\n        // only clear selection if shift is not pressed (otherwise, add\n        // node to selection)\n        if (!evt.shiftKey) {\n          if (path.selected_pts.length <= 1 || !seg.selected) {\n            path.clearSelection();\n          }\n          path.addPtsToSelection(curPt);\n        } else if (seg.selected) {\n          path.removePtFromSelection(curPt);\n        } else {\n          path.addPtsToSelection(curPt);\n        }\n      } else if (id.startsWith('ctrlpointgrip_')) {\n        path.dragging = [startX, startY];\n\n        const parts = id.split('_')[1].split('c');\n        curPt = Number(parts[0]);\n        const ctrlNum = Number(parts[1]);\n        path.selectPt(curPt, ctrlNum);\n      }\n\n      // Start selection box\n      if (!path.dragging) {\n        let rubberBox = editorContext_.getRubberBox();\n        if (isNullish(rubberBox)) {\n          rubberBox = editorContext_.setRubberBox(\n            editorContext_.selectorManager.getRubberBandBox()\n          );\n        }\n        const currentZoom = editorContext_.getCurrentZoom();\n        assignAttributes(rubberBox, {\n          x: startX * currentZoom,\n          y: startY * currentZoom,\n          width: 0,\n          height: 0,\n          display: 'inline'\n        }, 100);\n      }\n      return undefined;\n    },\n    /**\n    * @param {Float} mouseX\n    * @param {Float} mouseY\n    * @returns {undefined}\n    */\n    mouseMove (mouseX, mouseY) {\n      const currentZoom = editorContext_.getCurrentZoom();\n      hasMoved = true;\n      const drawnPath = editorContext_.getDrawnPath();\n      if (editorContext_.getCurrentMode() === 'path') {\n        if (!drawnPath) { return; }\n        const seglist = drawnPath.pathSegList;\n        const index = seglist.numberOfItems - 1;\n\n        if (newPoint) {\n          // First point\n          // if (!index) { return; }\n\n          // Set control points\n          const pointGrip1 = addCtrlGrip('1c1');\n          const pointGrip2 = addCtrlGrip('0c2');\n\n          // dragging pointGrip1\n          pointGrip1.setAttribute('cx', mouseX);\n          pointGrip1.setAttribute('cy', mouseY);\n          pointGrip1.setAttribute('display', 'inline');\n\n          const ptX = newPoint[0];\n          const ptY = newPoint[1];\n\n          // set curve\n          // const seg = seglist.getItem(index);\n          const curX = mouseX / currentZoom;\n          const curY = mouseY / currentZoom;\n          const altX = (ptX + (ptX - curX));\n          const altY = (ptY + (ptY - curY));\n\n          pointGrip2.setAttribute('cx', altX * currentZoom);\n          pointGrip2.setAttribute('cy', altY * currentZoom);\n          pointGrip2.setAttribute('display', 'inline');\n\n          const ctrlLine = getCtrlLine(1);\n          assignAttributes(ctrlLine, {\n            x1: mouseX,\n            y1: mouseY,\n            x2: altX * currentZoom,\n            y2: altY * currentZoom,\n            display: 'inline'\n          });\n\n          if (index === 0) {\n            firstCtrl = [mouseX, mouseY];\n          } else {\n            const last = seglist.getItem(index - 1);\n            let lastX = last.x;\n            let lastY = last.y;\n\n            if (last.pathSegType === 6) {\n              lastX += (lastX - last.x2);\n              lastY += (lastY - last.y2);\n            } else if (firstCtrl) {\n              lastX = firstCtrl[0] / currentZoom;\n              lastY = firstCtrl[1] / currentZoom;\n            }\n            replacePathSeg(6, index, [ptX, ptY, lastX, lastY, altX, altY], drawnPath);\n          }\n        } else {\n          const stretchy = getElem('path_stretch_line');\n          if (stretchy) {\n            const prev = seglist.getItem(index);\n            if (prev.pathSegType === 6) {\n              const prevX = prev.x + (prev.x - prev.x2);\n              const prevY = prev.y + (prev.y - prev.y2);\n              replacePathSeg(6, 1, [mouseX, mouseY, prevX * currentZoom, prevY * currentZoom, mouseX, mouseY], stretchy);\n            } else if (firstCtrl) {\n              replacePathSeg(6, 1, [mouseX, mouseY, firstCtrl[0], firstCtrl[1], mouseX, mouseY], stretchy);\n            } else {\n              replacePathSeg(4, 1, [mouseX, mouseY], stretchy);\n            }\n          }\n        }\n        return;\n      }\n      // if we are dragging a point, let's move it\n      if (path.dragging) {\n        const pt = getPointFromGrip({\n          x: path.dragging[0],\n          y: path.dragging[1]\n        }, path);\n        const mpt = getPointFromGrip({\n          x: mouseX,\n          y: mouseY\n        }, path);\n        const diffX = mpt.x - pt.x;\n        const diffY = mpt.y - pt.y;\n        path.dragging = [mouseX, mouseY];\n\n        if (path.dragctrl) {\n          path.moveCtrl(diffX, diffY);\n        } else {\n          path.movePts(diffX, diffY);\n        }\n      } else {\n        path.selected_pts = [];\n        path.eachSeg(function (i) {\n          const seg = this; // eslint-disable-line consistent-this\n          if (!seg.next && !seg.prev) { return; }\n\n          // const {item} = seg;\n          const rubberBox = editorContext_.getRubberBox();\n          const rbb = rubberBox.getBBox();\n\n          const pt = getGripPt(seg);\n          const ptBb = {\n            x: pt.x,\n            y: pt.y,\n            width: 0,\n            height: 0\n          };\n\n          const sel = rectsIntersect(rbb, ptBb);\n\n          this.select(sel);\n          // Note that addPtsToSelection is not being run\n          if (sel) { path.selected_pts.push(seg.index); }\n        });\n      }\n    },\n    /**\n     * @typedef module:path.keepElement\n     * @type {PlainObject}\n     * @property {boolean} keep\n     * @property {Element} element\n     */\n    /**\n    * @param {Event} evt\n    * @param {Element} element\n    * @param {Float} mouseX\n    * @param {Float} mouseY\n    * @returns {module:path.keepElement|undefined}\n    */\n    mouseUp (evt, element, mouseX, mouseY) {\n      const drawnPath = editorContext_.getDrawnPath();\n      // Create mode\n      if (editorContext_.getCurrentMode() === 'path') {\n        newPoint = null;\n        if (!drawnPath) {\n          element = getElem(editorContext_.getId());\n          editorContext_.setStarted(false);\n          firstCtrl = null;\n        }\n\n        return {\n          keep: true,\n          element\n        };\n      }\n\n      // Edit mode\n      const rubberBox = editorContext_.getRubberBox();\n      if (path.dragging) {\n        const lastPt = path.cur_pt;\n\n        path.dragging = false;\n        path.dragctrl = false;\n        path.update();\n\n        if (hasMoved) {\n          path.endChanges('Move path point(s)');\n        }\n\n        if (!evt.shiftKey && !hasMoved) {\n          path.selectPt(lastPt);\n        }\n      } else if (rubberBox && rubberBox.getAttribute('display') !== 'none') {\n        // Done with multi-node-select\n        rubberBox.setAttribute('display', 'none');\n\n        if (rubberBox.getAttribute('width') <= 2 && rubberBox.getAttribute('height') <= 2) {\n          pathActions.toSelectMode(evt.target);\n        }\n\n      // else, move back to select mode\n      } else {\n        pathActions.toSelectMode(evt.target);\n      }\n      hasMoved = false;\n      return undefined;\n    },\n    /**\n    * @param {Element} element\n    * @returns {undefined}\n    */\n    toEditMode (element) {\n      path = getPath_(element);\n      editorContext_.setCurrentMode('pathedit');\n      editorContext_.clearSelection();\n      path.show(true).update();\n      path.oldbbox = utilsGetBBox(path.elem);\n      subpath = false;\n    },\n    /**\n    * @param {Element} elem\n    * @fires module:svgcanvas.SvgCanvas#event:selected\n    * @returns {undefined}\n    */\n    toSelectMode (elem) {\n      const selPath = (elem === path.elem);\n      editorContext_.setCurrentMode('select');\n      path.show(false);\n      currentPath = false;\n      editorContext_.clearSelection();\n\n      if (path.matrix) {\n        // Rotated, so may need to re-calculate the center\n        recalcRotatedPath();\n      }\n\n      if (selPath) {\n        editorContext_.call('selected', [elem]);\n        editorContext_.addToSelection([elem], true);\n      }\n    },\n    /**\n    * @param {boolean} on\n    * @returns {undefined}\n    */\n    addSubPath (on) {\n      if (on) {\n        // Internally we go into \"path\" mode, but in the UI it will\n        // still appear as if in \"pathedit\" mode.\n        editorContext_.setCurrentMode('path');\n        subpath = true;\n      } else {\n        pathActions.clear(true);\n        pathActions.toEditMode(path.elem);\n      }\n    },\n    /**\n    * @param {Element} target\n    * @returns {undefined}\n    */\n    select (target) {\n      if (currentPath === target) {\n        pathActions.toEditMode(target);\n        editorContext_.setCurrentMode('pathedit');\n      // going into pathedit mode\n      } else {\n        currentPath = target;\n      }\n    },\n    /**\n    * @fires module:svgcanvas.SvgCanvas#event:changed\n    * @returns {undefined}\n    */\n    reorient () {\n      const elem = editorContext_.getSelectedElements()[0];\n      if (!elem) { return; }\n      const angl = getRotationAngle(elem);\n      if (angl === 0) { return; }\n\n      const batchCmd = new BatchCommand('Reorient path');\n      const changes = {\n        d: elem.getAttribute('d'),\n        transform: elem.getAttribute('transform')\n      };\n      batchCmd.addSubCommand(new ChangeElementCommand(elem, changes));\n      editorContext_.clearSelection();\n      this.resetOrientation(elem);\n\n      editorContext_.addCommandToHistory(batchCmd);\n\n      // Set matrix to null\n      getPath_(elem).show(false).matrix = null;\n\n      this.clear();\n\n      editorContext_.addToSelection([elem], true);\n      editorContext_.call('changed', editorContext_.getSelectedElements());\n    },\n\n    /**\n    * @param {boolean} remove Not in use\n    * @returns {undefined}\n    */\n    clear (remove) {\n      const drawnPath = editorContext_.getDrawnPath();\n      currentPath = null;\n      if (drawnPath) {\n        const elem = getElem(editorContext_.getId());\n        $(getElem('path_stretch_line')).remove();\n        $(elem).remove();\n        $(getElem('pathpointgrip_container')).find('*').attr('display', 'none');\n        firstCtrl = null;\n        editorContext_.setDrawnPath(null);\n        editorContext_.setStarted(false);\n      } else if (editorContext_.getCurrentMode() === 'pathedit') {\n        this.toSelectMode();\n      }\n      if (path) { path.init().show(false); }\n    },\n    /**\n    * @param {?(Element|SVGPathElement)} pth\n    * @returns {false|undefined}\n    */\n    resetOrientation (pth) {\n      if (isNullish(pth) || pth.nodeName !== 'path') { return false; }\n      const tlist = getTransformList(pth);\n      const m = transformListToTransform(tlist).matrix;\n      tlist.clear();\n      pth.removeAttribute('transform');\n      const segList = pth.pathSegList;\n\n      // Opera/win/non-EN throws an error here.\n      // TODO: Find out why!\n      // Presumed fixed in Opera 10.5, so commented out for now\n\n      // try {\n      const len = segList.numberOfItems;\n      // } catch(err) {\n      //   const fixed_d = pathActions.convertPath(pth);\n      //   pth.setAttribute('d', fixed_d);\n      //   segList = pth.pathSegList;\n      //   const len = segList.numberOfItems;\n      // }\n      // let lastX, lastY;\n      for (let i = 0; i < len; ++i) {\n        const seg = segList.getItem(i);\n        const type = seg.pathSegType;\n        if (type === 1) { continue; }\n        const pts = [];\n        $.each(['', 1, 2], function (j, n) {\n          const x = seg['x' + n], y = seg['y' + n];\n          if (x !== undefined && y !== undefined) {\n            const pt = transformPoint(x, y, m);\n            pts.splice(pts.length, 0, pt.x, pt.y);\n          }\n        });\n        replacePathSeg(type, i, pts, pth);\n      }\n\n      reorientGrads(pth, m);\n      return undefined;\n    },\n    /**\n    * @returns {undefined}\n    */\n    zoomChange () {\n      if (editorContext_.getCurrentMode() === 'pathedit') {\n        path.update();\n      }\n    },\n    /**\n    * @typedef {PlainObject} module:path.NodePoint\n    * @property {Float} x\n    * @property {Float} y\n    * @property {Integer} type\n    */\n    /**\n    * @returns {module:path.NodePoint}\n    */\n    getNodePoint () {\n      const selPt = path.selected_pts.length ? path.selected_pts[0] : 1;\n\n      const seg = path.segs[selPt];\n      return {\n        x: seg.item.x,\n        y: seg.item.y,\n        type: seg.type\n      };\n    },\n    /**\n    * @param {boolean} linkPoints\n    * @returns {undefined}\n    */\n    linkControlPoints (linkPoints) {\n      setLinkControlPoints(linkPoints);\n    },\n    /**\n    * @returns {undefined}\n    */\n    clonePathNode () {\n      path.storeD();\n\n      const selPts = path.selected_pts;\n      // const {segs} = path;\n\n      let i = selPts.length;\n      const nums = [];\n\n      while (i--) {\n        const pt = selPts[i];\n        path.addSeg(pt);\n\n        nums.push(pt + i);\n        nums.push(pt + i + 1);\n      }\n      path.init().addPtsToSelection(nums);\n\n      path.endChanges('Clone path node(s)');\n    },\n    /**\n    * @returns {undefined}\n    */\n    opencloseSubPath () {\n      const selPts = path.selected_pts;\n      // Only allow one selected node for now\n      if (selPts.length !== 1) { return; }\n\n      const {elem} = path;\n      const list = elem.pathSegList;\n\n      // const len = list.numberOfItems;\n\n      const index = selPts[0];\n\n      let openPt = null;\n      let startItem = null;\n\n      // Check if subpath is already open\n      path.eachSeg(function (i) {\n        if (this.type === 2 && i <= index) {\n          startItem = this.item;\n        }\n        if (i <= index) { return true; }\n        if (this.type === 2) {\n          // Found M first, so open\n          openPt = i;\n          return false;\n        }\n        if (this.type === 1) {\n          // Found Z first, so closed\n          openPt = false;\n          return false;\n        }\n        return true;\n      });\n\n      if (isNullish(openPt)) {\n        // Single path, so close last seg\n        openPt = path.segs.length - 1;\n      }\n\n      if (openPt !== false) {\n        // Close this path\n\n        // Create a line going to the previous \"M\"\n        const newseg = elem.createSVGPathSegLinetoAbs(startItem.x, startItem.y);\n\n        const closer = elem.createSVGPathSegClosePath();\n        if (openPt === path.segs.length - 1) {\n          list.appendItem(newseg);\n          list.appendItem(closer);\n        } else {\n          insertItemBefore(elem, closer, openPt);\n          insertItemBefore(elem, newseg, openPt);\n        }\n\n        path.init().selectPt(openPt + 1);\n        return;\n      }\n\n      // M 1,1 L 2,2 L 3,3 L 1,1 z // open at 2,2\n      // M 2,2 L 3,3 L 1,1\n\n      // M 1,1 L 2,2 L 1,1 z M 4,4 L 5,5 L6,6 L 5,5 z\n      // M 1,1 L 2,2 L 1,1 z [M 4,4] L 5,5 L(M)6,6 L 5,5 z\n\n      const seg = path.segs[index];\n\n      if (seg.mate) {\n        list.removeItem(index); // Removes last \"L\"\n        list.removeItem(index); // Removes the \"Z\"\n        path.init().selectPt(index - 1);\n        return;\n      }\n\n      let lastM, zSeg;\n\n      // Find this sub-path's closing point and remove\n      for (let i = 0; i < list.numberOfItems; i++) {\n        const item = list.getItem(i);\n\n        if (item.pathSegType === 2) {\n          // Find the preceding M\n          lastM = i;\n        } else if (i === index) {\n          // Remove it\n          list.removeItem(lastM);\n          // index--;\n        } else if (item.pathSegType === 1 && index < i) {\n          // Remove the closing seg of this subpath\n          zSeg = i - 1;\n          list.removeItem(i);\n          break;\n        }\n      }\n\n      let num = (index - lastM) - 1;\n\n      while (num--) {\n        insertItemBefore(elem, list.getItem(lastM), zSeg);\n      }\n\n      const pt = list.getItem(lastM);\n\n      // Make this point the new \"M\"\n      replacePathSeg(2, lastM, [pt.x, pt.y]);\n\n      // i = index; // i is local here, so has no effect; what was the intent for this?\n\n      path.init().selectPt(0);\n    },\n    /**\n    * @returns {undefined}\n    */\n    deletePathNode () {\n      if (!pathActions.canDeleteNodes) { return; }\n      path.storeD();\n\n      const selPts = path.selected_pts;\n\n      let i = selPts.length;\n      while (i--) {\n        const pt = selPts[i];\n        path.deleteSeg(pt);\n      }\n\n      // Cleanup\n      const cleanup = function () {\n        const segList = path.elem.pathSegList;\n        let len = segList.numberOfItems;\n\n        const remItems = function (pos, count) {\n          while (count--) {\n            segList.removeItem(pos);\n          }\n        };\n\n        if (len <= 1) { return true; }\n\n        while (len--) {\n          const item = segList.getItem(len);\n          if (item.pathSegType === 1) {\n            const prev = segList.getItem(len - 1);\n            const nprev = segList.getItem(len - 2);\n            if (prev.pathSegType === 2) {\n              remItems(len - 1, 2);\n              cleanup();\n              break;\n            } else if (nprev.pathSegType === 2) {\n              remItems(len - 2, 3);\n              cleanup();\n              break;\n            }\n          } else if (item.pathSegType === 2) {\n            if (len > 0) {\n              const prevType = segList.getItem(len - 1).pathSegType;\n              // Path has M M\n              if (prevType === 2) {\n                remItems(len - 1, 1);\n                cleanup();\n                break;\n              // Entire path ends with Z M\n              } else if (prevType === 1 && segList.numberOfItems - 1 === len) {\n                remItems(len, 1);\n                cleanup();\n                break;\n              }\n            }\n          }\n        }\n        return false;\n      };\n\n      cleanup();\n\n      // Completely delete a path with 1 or 0 segments\n      if (path.elem.pathSegList.numberOfItems <= 1) {\n        pathActions.toSelectMode(path.elem);\n        editorContext_.canvas.deleteSelectedElements();\n        return;\n      }\n\n      path.init();\n      path.clearSelection();\n\n      // TODO: Find right way to select point now\n      // path.selectPt(selPt);\n      if (window.opera) { // Opera repaints incorrectly\n        const cp = $(path.elem);\n        cp.attr('d', cp.attr('d'));\n      }\n      path.endChanges('Delete path node(s)');\n    },\n    // Can't seem to use `@borrows` here, so using `@see`\n    /**\n    * Smooth polyline into path\n    * @function module:path.pathActions.smoothPolylineIntoPath\n    * @see module:path~smoothPolylineIntoPath\n    */\n    smoothPolylineIntoPath,\n    /**\n    * @param {?Integer} v See {@link https://www.w3.org/TR/SVG/single-page.html#paths-InterfaceSVGPathSeg}\n    * @returns {undefined}\n    */\n    setSegType (v) {\n      path.setSegType(v);\n    },\n    /**\n    * @param {string} attr\n    * @param {Float} newValue\n    * @returns {undefined}\n    */\n    moveNode (attr, newValue) {\n      const selPts = path.selected_pts;\n      if (!selPts.length) { return; }\n\n      path.storeD();\n\n      // Get first selected point\n      const seg = path.segs[selPts[0]];\n      const diff = {x: 0, y: 0};\n      diff[attr] = newValue - seg.item[attr];\n\n      seg.move(diff.x, diff.y);\n      path.endChanges('Move path point');\n    },\n    /**\n    * @param {Element} elem\n    * @returns {undefined}\n    */\n    fixEnd (elem) {\n      // Adds an extra segment if the last seg before a Z doesn't end\n      // at its M point\n      // M0,0 L0,100 L100,100 z\n      const segList = elem.pathSegList;\n      const len = segList.numberOfItems;\n      let lastM;\n      for (let i = 0; i < len; ++i) {\n        const item = segList.getItem(i);\n        if (item.pathSegType === 2) {\n          lastM = item;\n        }\n\n        if (item.pathSegType === 1) {\n          const prev = segList.getItem(i - 1);\n          if (prev.x !== lastM.x || prev.y !== lastM.y) {\n            // Add an L segment here\n            const newseg = elem.createSVGPathSegLinetoAbs(lastM.x, lastM.y);\n            insertItemBefore(elem, newseg, i);\n            // Can this be done better?\n            pathActions.fixEnd(elem);\n            break;\n          }\n        }\n      }\n      if (isWebkit()) { editorContext_.resetD(elem); }\n    },\n    // Can't seem to use `@borrows` here, so using `@see`\n    /**\n    * Convert a path to one with only absolute or relative values\n    * @function module:path.pathActions.convertPath\n    * @see module:path.convertPath\n    */\n    convertPath\n  });\n})();\n// end pathActions\n","/* globals jQuery */\n/**\n * Miscellaneous utilities\n * @module utilities\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller\n */\n\nimport './svgpathseg.js';\nimport jQueryPluginSVG from './jQuery.attr.js'; // Needed for SVG attribute setting and array form with `attr`\nimport {NS} from './namespaces.js';\nimport {getTransformList} from './svgtransformlist.js';\nimport {setUnitAttr, getTypeMap} from './units.js';\nimport {convertPath} from './path.js';\nimport {\n  hasMatrixTransform, transformListToTransform, transformBox\n} from './math.js';\nimport {\n  isWebkit, supportsHVLineContainerBBox, supportsPathBBox, supportsXpath,\n  supportsSelectors\n} from './browser.js';\n\n// Constants\nconst $ = jQueryPluginSVG(jQuery);\n\n// String used to encode base64.\nconst KEYSTR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n// Much faster than running getBBox() every time\nconst visElems = 'a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use';\nconst visElemsArr = visElems.split(',');\n// const hidElems = 'clipPath,defs,desc,feGaussianBlur,filter,linearGradient,marker,mask,metadata,pattern,radialGradient,stop,switch,symbol,title,textPath';\n\nlet editorContext_ = null;\nlet domdoc_ = null;\nlet domcontainer_ = null;\nlet svgroot_ = null;\n\n/**\n* Object with the following keys/values\n* @typedef {PlainObject} module:utilities.SVGElementJSON\n* @property {string} element - Tag name of the SVG element to create\n* @property {PlainObject.<string, string>} attr - Has key-value attributes to assign to the new element\n* @property {boolean} [curStyles=false] - Indicates whether current style attributes should be applied first\n* @property {module:utilities.SVGElementJSON[]} [children] - Data objects to be added recursively as children\n* @property {string} [namespace=\"http://www.w3.org/2000/svg\"] - Indicate a (non-SVG) namespace\n*/\n\n/**\n * An object that creates SVG elements for the canvas.\n *\n * @interface module:utilities.EditorContext\n * @property {module:path.pathActions} pathActions\n */\n/**\n * @function module:utilities.EditorContext#getSVGContent\n * @returns {SVGSVGElement}\n */\n/**\n * Create a new SVG element based on the given object keys/values and add it\n * to the current layer.\n * The element will be run through `cleanupElement` before being returned\n * @function module:utilities.EditorContext#addSVGElementFromJson\n * @param {module:utilities.SVGElementJSON} data\n * @returns {Element} The new element\n*/\n/**\n * @function module:utilities.EditorContext#getSelectedElements\n * @returns {Element[]} the array with selected DOM elements\n*/\n/**\n * @function module:utilities.EditorContext#getDOMDocument\n * @returns {HTMLDocument}\n*/\n/**\n * @function module:utilities.EditorContext#getDOMContainer\n * @returns {HTMLElement}\n*/\n/**\n * @function module:utilities.EditorContext#getSVGRoot\n * @returns {SVGSVGElement}\n*/\n/**\n * @function module:utilities.EditorContext#getBaseUnit\n * @returns {string}\n*/\n/**\n * @function module:utilities.EditorContext#getSnappingStep\n * @returns {Float|string}\n*/\n\n/**\n* @function module:utilities.init\n* @param {module:utilities.EditorContext} editorContext\n* @returns {undefined}\n*/\nexport const init = function (editorContext) {\n  editorContext_ = editorContext;\n  domdoc_ = editorContext.getDOMDocument();\n  domcontainer_ = editorContext.getDOMContainer();\n  svgroot_ = editorContext.getSVGRoot();\n};\n\n/**\n * Used to prevent the [Billion laughs attack]{@link https://en.wikipedia.org/wiki/Billion_laughs_attack}.\n * @function module:utilities.dropXMLInteralSubset\n * @param {string} str String to be processed\n * @returns {string} The string with entity declarations in the internal subset removed\n * @todo This might be needed in other places `parseFromString` is used even without LGTM flagging\n */\nexport const dropXMLInteralSubset = (str) => {\n  return str.replace(/(<!DOCTYPE\\s+\\w*\\s*\\[).*(\\?\\]>)/, '$1$2');\n};\n\n/**\n* Converts characters in a string to XML-friendly entities.\n* @function module:utilities.toXml\n* @example `&` becomes `&amp;`\n* @param {string} str - The string to be converted\n* @returns {string} The converted string\n*/\nexport const toXml = function (str) {\n  // &apos; is ok in XML, but not HTML\n  // &gt; does not normally need escaping, though it can if within a CDATA expression (and preceded by \"]]\")\n  return str\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n    .replace(/'/g, '&#x27;'); // Note: `&apos;` is XML only\n};\n\n/**\n* Converts XML entities in a string to single characters.\n* @function module:utilities.fromXml\n* @example `&amp;` becomes `&`\n* @param {string} str - The string to be converted\n* @returns {string} The converted string\n*/\nexport function fromXml (str) {\n  return $('<p/>').html(str).text();\n}\n\n// This code was written by Tyler Akins and has been placed in the\n// public domain.  It would be nice if you left this header intact.\n// Base64 code from Tyler Akins -- http://rumkin.com\n\n// schiller: Removed string concatenation in favour of Array.join() optimization,\n//        also precalculate the size of the array needed.\n\n/**\n* Converts a string to base64.\n* @function module:utilities.encode64\n* @param {string} input\n* @returns {string} Base64 output\n*/\nexport function encode64 (input) {\n  // base64 strings are 4/3 larger than the original string\n  input = encodeUTF8(input); // convert non-ASCII characters\n  // input = convertToXMLReferences(input);\n  if (window.btoa) {\n    return window.btoa(input); // Use native if available\n  }\n  const output = new Array(Math.floor((input.length + 2) / 3) * 4);\n\n  let i = 0,\n    p = 0;\n  do {\n    const chr1 = input.charCodeAt(i++);\n    const chr2 = input.charCodeAt(i++);\n    const chr3 = input.charCodeAt(i++);\n\n    /* eslint-disable no-bitwise */\n    const enc1 = chr1 >> 2;\n    const enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);\n\n    let enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);\n    let enc4 = chr3 & 63;\n    /* eslint-enable no-bitwise */\n\n    if (isNaN(chr2)) {\n      enc3 = 64;\n      enc4 = 64;\n    } else if (isNaN(chr3)) {\n      enc4 = 64;\n    }\n\n    output[p++] = KEYSTR.charAt(enc1);\n    output[p++] = KEYSTR.charAt(enc2);\n    output[p++] = KEYSTR.charAt(enc3);\n    output[p++] = KEYSTR.charAt(enc4);\n  } while (i < input.length);\n\n  return output.join('');\n}\n\n/**\n* Converts a string from base64.\n* @function module:utilities.decode64\n* @param {string} input Base64-encoded input\n* @returns {string} Decoded output\n*/\nexport function decode64 (input) {\n  if (window.atob) {\n    return decodeUTF8(window.atob(input));\n  }\n\n  // remove all characters that are not A-Z, a-z, 0-9, +, /, or =\n  input = input.replace(/[^A-Za-z0-9+/=]/g, '');\n\n  let output = '';\n  let i = 0;\n\n  do {\n    const enc1 = KEYSTR.indexOf(input.charAt(i++));\n    const enc2 = KEYSTR.indexOf(input.charAt(i++));\n    const enc3 = KEYSTR.indexOf(input.charAt(i++));\n    const enc4 = KEYSTR.indexOf(input.charAt(i++));\n\n    /* eslint-disable no-bitwise */\n    const chr1 = (enc1 << 2) | (enc2 >> 4);\n    const chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);\n    const chr3 = ((enc3 & 3) << 6) | enc4;\n    /* eslint-enable no-bitwise */\n\n    output += String.fromCharCode(chr1);\n\n    if (enc3 !== 64) {\n      output += String.fromCharCode(chr2);\n    }\n    if (enc4 !== 64) {\n      output += String.fromCharCode(chr3);\n    }\n  } while (i < input.length);\n  return decodeUTF8(output);\n}\n\n/**\n* @function module:utilities.decodeUTF8\n* @param {string} argString\n* @returns {string}\n*/\nexport function decodeUTF8 (argString) {\n  return decodeURIComponent(escape(argString));\n}\n\n// codedread:does not seem to work with webkit-based browsers on OSX // Brettz9: please test again as function upgraded\n/**\n* @function module:utilities.encodeUTF8\n* @param {string} argString\n* @returns {string}\n*/\nexport const encodeUTF8 = function (argString) {\n  return unescape(encodeURIComponent(argString));\n};\n\n/**\n * Convert dataURL to object URL.\n * @function module:utilities.dataURLToObjectURL\n * @param {string} dataurl\n * @returns {string} object URL or empty string\n */\nexport const dataURLToObjectURL = function (dataurl) {\n  if (typeof Uint8Array === 'undefined' || typeof Blob === 'undefined' || typeof URL === 'undefined' || !URL.createObjectURL) {\n    return '';\n  }\n  const arr = dataurl.split(','),\n    mime = arr[0].match(/:(.*?);/)[1],\n    bstr = atob(arr[1]);\n  let n = bstr.length;\n  const u8arr = new Uint8Array(n);\n  while (n--) {\n    u8arr[n] = bstr.charCodeAt(n);\n  }\n  const blob = new Blob([u8arr], {type: mime});\n  return URL.createObjectURL(blob);\n};\n\n/**\n * Get object URL for a blob object.\n * @function module:utilities.createObjectURL\n * @param {Blob} blob A Blob object or File object\n * @returns {string} object URL or empty string\n */\nexport const createObjectURL = function (blob) {\n  if (!blob || typeof URL === 'undefined' || !URL.createObjectURL) {\n    return '';\n  }\n  return URL.createObjectURL(blob);\n};\n\n/**\n * @property {string} blankPageObjectURL\n */\nexport const blankPageObjectURL = (function () {\n  if (typeof Blob === 'undefined') {\n    return '';\n  }\n  const blob = new Blob(['<html><head><title>SVG-edit</title></head><body>&nbsp;</body></html>'], {type: 'text/html'});\n  return createObjectURL(blob);\n})();\n\n/**\n* Converts a string to use XML references (for non-ASCII).\n* @function module:utilities.convertToXMLReferences\n* @param {string} input\n* @returns {string} Decimal numeric character references\n*/\nexport const convertToXMLReferences = function (input) {\n  let output = '';\n  [...input].forEach((ch) => {\n    const c = ch.charCodeAt();\n    if (c <= 127) {\n      output += ch;\n    } else {\n      output += `&#${c};`;\n    }\n  });\n  return output;\n};\n\n/**\n* Cross-browser compatible method of converting a string to an XML tree.\n* Found this function [here]{@link http://groups.google.com/group/jquery-dev/browse_thread/thread/c6d11387c580a77f}.\n* @function module:utilities.text2xml\n* @param {string} sXML\n* @throws {Error}\n* @returns {XMLDocument}\n*/\nexport const text2xml = function (sXML) {\n  if (sXML.includes('<svg:svg')) {\n    sXML = sXML.replace(/<(\\/?)svg:/g, '<$1').replace('xmlns:svg', 'xmlns');\n  }\n\n  let out, dXML;\n  try {\n    dXML = (window.DOMParser) ? new DOMParser() : new window.ActiveXObject('Microsoft.XMLDOM');\n    dXML.async = false;\n  } catch (e) {\n    throw new Error('XML Parser could not be instantiated');\n  }\n  try {\n    if (dXML.loadXML) {\n      out = (dXML.loadXML(sXML)) ? dXML : false;\n    } else {\n      out = dXML.parseFromString(sXML, 'text/xml');\n    }\n  } catch (e2) { throw new Error('Error parsing XML string'); }\n  return out;\n};\n\n/**\n* @typedef {PlainObject} module:utilities.BBoxObject (like `DOMRect`)\n* @property {Float} x\n* @property {Float} y\n* @property {Float} width\n* @property {Float} height\n*/\n\n/**\n* Converts a `SVGRect` into an object.\n* @function module:utilities.bboxToObj\n* @param {SVGRect} bbox - a SVGRect\n* @returns {module:utilities.BBoxObject} An object with properties names x, y, width, height.\n*/\nexport const bboxToObj = function ({x, y, width, height}) {\n  return {x, y, width, height};\n};\n\n/**\n* @callback module:utilities.TreeWalker\n* @param {Element} elem - DOM element being traversed\n* @returns {undefined}\n*/\n\n/**\n* Walks the tree and executes the callback on each element in a top-down fashion.\n* @function module:utilities.walkTree\n* @param {Element} elem - DOM element to traverse\n* @param {module:utilities.TreeWalker} cbFn - Callback function to run on each element\n* @returns {undefined}\n*/\nexport const walkTree = function (elem, cbFn) {\n  if (elem && elem.nodeType === 1) {\n    cbFn(elem);\n    let i = elem.childNodes.length;\n    while (i--) {\n      walkTree(elem.childNodes.item(i), cbFn);\n    }\n  }\n};\n\n/**\n* Walks the tree and executes the callback on each element in a depth-first fashion.\n* @function module:utilities.walkTreePost\n* @todo FIXME: Shouldn't this be calling walkTreePost?\n* @param {Element} elem - DOM element to traverse\n* @param {module:utilities.TreeWalker} cbFn - Callback function to run on each element\n* @returns {undefined}\n*/\nexport const walkTreePost = function (elem, cbFn) {\n  if (elem && elem.nodeType === 1) {\n    let i = elem.childNodes.length;\n    while (i--) {\n      walkTree(elem.childNodes.item(i), cbFn);\n    }\n    cbFn(elem);\n  }\n};\n\n/**\n* Extracts the URL from the `url(...)` syntax of some attributes.\n* Three variants:\n*  - `<circle fill=\"url(someFile.svg#foo)\" />`\n*  - `<circle fill=\"url('someFile.svg#foo')\" />`\n*  - `<circle fill='url(\"someFile.svg#foo\")' />`\n* @function module:utilities.getUrlFromAttr\n* @param {string} attrVal The attribute value as a string\n* @returns {string} String with just the URL, like \"someFile.svg#foo\"\n*/\nexport const getUrlFromAttr = function (attrVal) {\n  if (attrVal) {\n    // url('#somegrad')\n    if (attrVal.startsWith('url(\"')) {\n      return attrVal.substring(5, attrVal.indexOf('\"', 6));\n    }\n    // url('#somegrad')\n    if (attrVal.startsWith(\"url('\")) {\n      return attrVal.substring(5, attrVal.indexOf(\"'\", 6));\n    }\n    if (attrVal.startsWith('url(')) {\n      return attrVal.substring(4, attrVal.indexOf(')'));\n    }\n  }\n  return null;\n};\n\n/**\n* @function module:utilities.getHref\n* @param {Element} elem\n* @returns {string} The given element's `xlink:href` value\n*/\nexport let getHref = function (elem) { // eslint-disable-line import/no-mutable-exports\n  return elem.getAttributeNS(NS.XLINK, 'href');\n};\n\n/**\n* Sets the given element's `xlink:href` value.\n* @function module:utilities.setHref\n* @param {Element} elem\n* @param {string} val\n* @returns {undefined}\n*/\nexport let setHref = function (elem, val) { // eslint-disable-line import/no-mutable-exports\n  elem.setAttributeNS(NS.XLINK, 'xlink:href', val);\n};\n\n/**\n* @function module:utilities.findDefs\n* @returns {SVGDefsElement} The document's `<defs>` element, creating it first if necessary\n*/\nexport const findDefs = function () {\n  const svgElement = editorContext_.getSVGContent();\n  let defs = svgElement.getElementsByTagNameNS(NS.SVG, 'defs');\n  if (defs.length > 0) {\n    defs = defs[0];\n  } else {\n    defs = svgElement.ownerDocument.createElementNS(NS.SVG, 'defs');\n    if (svgElement.firstChild) {\n      // first child is a comment, so call nextSibling\n      svgElement.insertBefore(defs, svgElement.firstChild.nextSibling);\n      // svgElement.firstChild.nextSibling.before(defs); // Not safe\n    } else {\n      svgElement.append(defs);\n    }\n  }\n  return defs;\n};\n\n// TODO(codedread): Consider moving the next to functions to bbox.js\n\n/**\n* Get correct BBox for a path in Webkit.\n* Converted from code found [here]{@link http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html}.\n* @function module:utilities.getPathBBox\n* @param {SVGPathElement} path - The path DOM element to get the BBox for\n* @returns {module:utilities.BBoxObject} A BBox-like object\n*/\nexport const getPathBBox = function (path) {\n  const seglist = path.pathSegList;\n  const tot = seglist.numberOfItems;\n\n  const bounds = [[], []];\n  const start = seglist.getItem(0);\n  let P0 = [start.x, start.y];\n\n  const getCalc = function (j, P1, P2, P3) {\n    return function (t) {\n      return 1 - (t ** 3) * P0[j] +\n        3 * 1 - (t ** 2) * t * P1[j] +\n        3 * (1 - t) * (t ** 2) * P2[j] +\n        (t ** 3) * P3[j];\n    };\n  };\n\n  for (let i = 0; i < tot; i++) {\n    const seg = seglist.getItem(i);\n\n    if (seg.x === undefined) { continue; }\n\n    // Add actual points to limits\n    bounds[0].push(P0[0]);\n    bounds[1].push(P0[1]);\n\n    if (seg.x1) {\n      const P1 = [seg.x1, seg.y1],\n        P2 = [seg.x2, seg.y2],\n        P3 = [seg.x, seg.y];\n\n      for (let j = 0; j < 2; j++) {\n        const calc = getCalc(j, P1, P2, P3);\n\n        const b = 6 * P0[j] - 12 * P1[j] + 6 * P2[j];\n        const a = -3 * P0[j] + 9 * P1[j] - 9 * P2[j] + 3 * P3[j];\n        const c = 3 * P1[j] - 3 * P0[j];\n\n        if (a === 0) {\n          if (b === 0) { continue; }\n          const t = -c / b;\n          if (t > 0 && t < 1) {\n            bounds[j].push(calc(t));\n          }\n          continue;\n        }\n        const b2ac = (b ** 2) - 4 * c * a;\n        if (b2ac < 0) { continue; }\n        const t1 = (-b + Math.sqrt(b2ac)) / (2 * a);\n        if (t1 > 0 && t1 < 1) { bounds[j].push(calc(t1)); }\n        const t2 = (-b - Math.sqrt(b2ac)) / (2 * a);\n        if (t2 > 0 && t2 < 1) { bounds[j].push(calc(t2)); }\n      }\n      P0 = P3;\n    } else {\n      bounds[0].push(seg.x);\n      bounds[1].push(seg.y);\n    }\n  }\n\n  const x = Math.min.apply(null, bounds[0]);\n  const w = Math.max.apply(null, bounds[0]) - x;\n  const y = Math.min.apply(null, bounds[1]);\n  const h = Math.max.apply(null, bounds[1]) - y;\n  return {\n    x,\n    y,\n    width: w,\n    height: h\n  };\n};\n\n/**\n* Get the given/selected element's bounding box object, checking for\n* horizontal/vertical lines (see issue 717)\n* Note that performance is currently terrible, so some way to improve would\n* be great.\n* @param {Element} selected - Container or `<use>` DOM element\n* @returns {DOMRect} Bounding box object\n*/\nfunction groupBBFix (selected) {\n  if (supportsHVLineContainerBBox()) {\n    try { return selected.getBBox(); } catch (e) {}\n  }\n  const ref = $.data(selected, 'ref');\n  let matched = null;\n  let ret, copy;\n\n  if (ref) {\n    copy = $(ref).children().clone().attr('visibility', 'hidden');\n    $(svgroot_).append(copy);\n    matched = copy.filter('line, path');\n  } else {\n    matched = $(selected).find('line, path');\n  }\n\n  let issue = false;\n  if (matched.length) {\n    matched.each(function () {\n      const bb = this.getBBox();\n      if (!bb.width || !bb.height) {\n        issue = true;\n      }\n    });\n    if (issue) {\n      const elems = ref ? copy : $(selected).children();\n      ret = getStrokedBBox(elems);\n    } else {\n      ret = selected.getBBox();\n    }\n  } else {\n    ret = selected.getBBox();\n  }\n  if (ref) {\n    copy.remove();\n  }\n  return ret;\n}\n\n/**\n* Get the given/selected element's bounding box object, convert it to be more\n* usable when necessary.\n* @function module:utilities.getBBox\n* @param {Element} elem - Optional DOM element to get the BBox for\n* @returns {module:utilities.BBoxObject} Bounding box object\n*/\nexport const getBBox = function (elem) {\n  const selected = elem || editorContext_.geSelectedElements()[0];\n  if (elem.nodeType !== 1) { return null; }\n  const elname = selected.nodeName;\n\n  let ret = null;\n  switch (elname) {\n  case 'text':\n    if (selected.textContent === '') {\n      selected.textContent = 'a'; // Some character needed for the selector to use.\n      ret = selected.getBBox();\n      selected.textContent = '';\n    } else if (selected.getBBox) {\n      ret = selected.getBBox();\n    }\n    break;\n  case 'path':\n    if (!supportsPathBBox()) {\n      ret = getPathBBox(selected);\n    } else if (selected.getBBox) {\n      ret = selected.getBBox();\n    }\n    break;\n  case 'g':\n  case 'a':\n    ret = groupBBFix(selected);\n    break;\n  default:\n\n    if (elname === 'use') {\n      ret = groupBBFix(selected); // , true);\n    }\n    if (elname === 'use' || (elname === 'foreignObject' && isWebkit())) {\n      if (!ret) { ret = selected.getBBox(); }\n      // This is resolved in later versions of webkit, perhaps we should\n      // have a featured detection for correct 'use' behavior?\n      // ——————————\n      if (!isWebkit()) {\n        const bb = {};\n        bb.width = ret.width;\n        bb.height = ret.height;\n        bb.x = ret.x + parseFloat(selected.getAttribute('x') || 0);\n        bb.y = ret.y + parseFloat(selected.getAttribute('y') || 0);\n        ret = bb;\n      }\n    } else if (visElemsArr.includes(elname)) {\n      if (selected) {\n        try {\n          ret = selected.getBBox();\n        } catch (err) {\n          // tspan (and textPath apparently) have no `getBBox` in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=937268\n          // Re: Chrome returning bbox for containing text element, see: https://bugs.chromium.org/p/chromium/issues/detail?id=349835\n          const extent = selected.getExtentOfChar(0); // pos+dimensions of the first glyph\n          const width = selected.getComputedTextLength(); // width of the tspan\n          ret = {\n            x: extent.x,\n            y: extent.y,\n            width,\n            height: extent.height\n          };\n        }\n      } else {\n        // Check if element is child of a foreignObject\n        const fo = $(selected).closest('foreignObject');\n        if (fo.length) {\n          if (fo[0].getBBox) {\n            ret = fo[0].getBBox();\n          }\n        }\n      }\n    }\n  }\n  if (ret) {\n    ret = bboxToObj(ret);\n  }\n\n  // get the bounding box from the DOM (which is in that element's coordinate system)\n  return ret;\n};\n\n/**\n* @typedef {GenericArray} module:utilities.PathSegmentArray\n* @property {Integer} length 2\n* @property {\"M\"|\"L\"|\"C\"|\"Z\"} 0\n* @property {Float[]} 1\n*/\n\n/**\n* Create a path 'd' attribute from path segments.\n* Each segment is an array of the form: `[singleChar, [x,y, x,y, ...]]`\n* @function module:utilities.getPathDFromSegments\n* @param {module:utilities.PathSegmentArray[]} pathSegments - An array of path segments to be converted\n* @returns {string} The converted path d attribute.\n*/\nexport const getPathDFromSegments = function (pathSegments) {\n  let d = '';\n\n  $.each(pathSegments, function (j, [singleChar, pts]) {\n    d += singleChar;\n    for (let i = 0; i < pts.length; i += 2) {\n      d += (pts[i] + ',' + pts[i + 1]) + ' ';\n    }\n  });\n\n  return d;\n};\n\n/**\n* Make a path 'd' attribute from a simple SVG element shape.\n* @function module:utilities.getPathDFromElement\n* @param {Element} elem - The element to be converted\n* @returns {string} The path d attribute or `undefined` if the element type is unknown.\n*/\nexport const getPathDFromElement = function (elem) {\n  // Possibly the cubed root of 6, but 1.81 works best\n  let num = 1.81;\n  let d, a, rx, ry;\n  switch (elem.tagName) {\n  case 'ellipse':\n  case 'circle': {\n    a = $(elem).attr(['rx', 'ry', 'cx', 'cy']);\n    const {cx, cy} = a;\n    ({rx, ry} = a);\n    if (elem.tagName === 'circle') {\n      ry = $(elem).attr('r');\n      rx = ry;\n    }\n\n    d = getPathDFromSegments([\n      ['M', [(cx - rx), (cy)]],\n      ['C', [(cx - rx), (cy - ry / num), (cx - rx / num), (cy - ry), (cx), (cy - ry)]],\n      ['C', [(cx + rx / num), (cy - ry), (cx + rx), (cy - ry / num), (cx + rx), (cy)]],\n      ['C', [(cx + rx), (cy + ry / num), (cx + rx / num), (cy + ry), (cx), (cy + ry)]],\n      ['C', [(cx - rx / num), (cy + ry), (cx - rx), (cy + ry / num), (cx - rx), (cy)]],\n      ['Z', []]\n    ]);\n    break;\n  } case 'path':\n    d = elem.getAttribute('d');\n    break;\n  case 'line':\n    a = $(elem).attr(['x1', 'y1', 'x2', 'y2']);\n    d = 'M' + a.x1 + ',' + a.y1 + 'L' + a.x2 + ',' + a.y2;\n    break;\n  case 'polyline':\n    d = 'M' + elem.getAttribute('points');\n    break;\n  case 'polygon':\n    d = 'M' + elem.getAttribute('points') + ' Z';\n    break;\n  case 'rect': {\n    const r = $(elem).attr(['rx', 'ry']);\n    ({rx, ry} = r);\n    const b = elem.getBBox();\n    const {x, y} = b,\n      w = b.width,\n      h = b.height;\n    num = 4 - num; // Why? Because!\n\n    if (!rx && !ry) {\n      // Regular rect\n      d = getPathDFromSegments([\n        ['M', [x, y]],\n        ['L', [x + w, y]],\n        ['L', [x + w, y + h]],\n        ['L', [x, y + h]],\n        ['L', [x, y]],\n        ['Z', []]\n      ]);\n    } else {\n      d = getPathDFromSegments([\n        ['M', [x, y + ry]],\n        ['C', [x, y + ry / num, x + rx / num, y, x + rx, y]],\n        ['L', [x + w - rx, y]],\n        ['C', [x + w - rx / num, y, x + w, y + ry / num, x + w, y + ry]],\n        ['L', [x + w, y + h - ry]],\n        ['C', [x + w, y + h - ry / num, x + w - rx / num, y + h, x + w - rx, y + h]],\n        ['L', [x + rx, y + h]],\n        ['C', [x + rx / num, y + h, x, y + h - ry / num, x, y + h - ry]],\n        ['L', [x, y + ry]],\n        ['Z', []]\n      ]);\n    }\n    break;\n  } default:\n    break;\n  }\n\n  return d;\n};\n\n/**\n* Get a set of attributes from an element that is useful for convertToPath.\n* @function module:utilities.getExtraAttributesForConvertToPath\n* @param {Element} elem - The element to be probed\n* @returns {PlainObject.<\"marker-start\"|\"marker-end\"|\"marker-mid\"|\"filter\"|\"clip-path\", string>} An object with attributes.\n*/\nexport const getExtraAttributesForConvertToPath = function (elem) {\n  const attrs = {};\n  // TODO: make this list global so that we can properly maintain it\n  // TODO: what about @transform, @clip-rule, @fill-rule, etc?\n  $.each(['marker-start', 'marker-end', 'marker-mid', 'filter', 'clip-path'], function () {\n    const a = elem.getAttribute(this);\n    if (a) {\n      attrs[this] = a;\n    }\n  });\n  return attrs;\n};\n\n/**\n* Get the BBox of an element-as-path.\n* @function module:utilities.getBBoxOfElementAsPath\n* @param {Element} elem - The DOM element to be probed\n* @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson\n* @param {module:path.pathActions} pathActions - If a transform exists, `pathActions.resetOrientation()` is used. See: canvas.pathActions.\n* @returns {DOMRect|false} The resulting path's bounding box object.\n*/\nexport const getBBoxOfElementAsPath = function (elem, addSVGElementFromJson, pathActions) {\n  const path = addSVGElementFromJson({\n    element: 'path',\n    attr: getExtraAttributesForConvertToPath(elem)\n  });\n\n  const eltrans = elem.getAttribute('transform');\n  if (eltrans) {\n    path.setAttribute('transform', eltrans);\n  }\n\n  const {parentNode} = elem;\n  if (elem.nextSibling) {\n    elem.before(path);\n  } else {\n    parentNode.append(path);\n  }\n\n  const d = getPathDFromElement(elem);\n  if (d) {\n    path.setAttribute('d', d);\n  } else {\n    path.remove();\n  }\n\n  // Get the correct BBox of the new path, then discard it\n  pathActions.resetOrientation(path);\n  let bb = false;\n  try {\n    bb = path.getBBox();\n  } catch (e) {\n    // Firefox fails\n  }\n  path.remove();\n  return bb;\n};\n\n/**\n* Convert selected element to a path.\n* @function module:utilities.convertToPath\n* @param {Element} elem - The DOM element to be converted\n* @param {module:utilities.SVGElementJSON} attrs - Apply attributes to new path. see canvas.convertToPath\n* @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson\n* @param {module:path.pathActions} pathActions - If a transform exists, pathActions.resetOrientation() is used. See: canvas.pathActions.\n* @param {module:draw.DrawCanvasInit#clearSelection|module:path.EditorContext#clearSelection} clearSelection - see [canvas.clearSelection]{@link module:svgcanvas.SvgCanvas#clearSelection}\n* @param {module:path.EditorContext#addToSelection} addToSelection - see [canvas.addToSelection]{@link module:svgcanvas.SvgCanvas#addToSelection}\n* @param {module:history} hstry - see history module\n* @param {module:path.EditorContext#addCommandToHistory|module:draw.DrawCanvasInit#addCommandToHistory} addCommandToHistory - see [canvas.addCommandToHistory]{@link module:svgcanvas~addCommandToHistory}\n* @returns {SVGPathElement|null} The converted path element or null if the DOM element was not recognized.\n*/\nexport const convertToPath = function (elem, attrs, addSVGElementFromJson, pathActions, clearSelection, addToSelection, hstry, addCommandToHistory) {\n  const batchCmd = new hstry.BatchCommand('Convert element to Path');\n\n  // Any attribute on the element not covered by the passed-in attributes\n  attrs = $.extend({}, attrs, getExtraAttributesForConvertToPath(elem));\n\n  const path = addSVGElementFromJson({\n    element: 'path',\n    attr: attrs\n  });\n\n  const eltrans = elem.getAttribute('transform');\n  if (eltrans) {\n    path.setAttribute('transform', eltrans);\n  }\n\n  const {id} = elem;\n  const {parentNode} = elem;\n  if (elem.nextSibling) {\n    elem.before(path);\n  } else {\n    parentNode.append(path);\n  }\n\n  const d = getPathDFromElement(elem);\n  if (d) {\n    path.setAttribute('d', d);\n\n    // Replace the current element with the converted one\n\n    // Reorient if it has a matrix\n    if (eltrans) {\n      const tlist = getTransformList(path);\n      if (hasMatrixTransform(tlist)) {\n        pathActions.resetOrientation(path);\n      }\n    }\n\n    const {nextSibling} = elem;\n    batchCmd.addSubCommand(new hstry.RemoveElementCommand(elem, nextSibling, parent));\n    batchCmd.addSubCommand(new hstry.InsertElementCommand(path));\n\n    clearSelection();\n    elem.remove();\n    path.setAttribute('id', id);\n    path.removeAttribute('visibility');\n    addToSelection([path], true);\n\n    addCommandToHistory(batchCmd);\n\n    return path;\n  }\n  // the elem.tagName was not recognized, so no \"d\" attribute. Remove it, so we've haven't changed anything.\n  path.remove();\n  return null;\n};\n\n/**\n* Can the bbox be optimized over the native getBBox? The optimized bbox is the same as the native getBBox when\n* the rotation angle is a multiple of 90 degrees and there are no complex transforms.\n* Getting an optimized bbox can be dramatically slower, so we want to make sure it's worth it.\n*\n* The best example for this is a circle rotate 45 degrees. The circle doesn't get wider or taller when rotated\n* about it's center.\n*\n* The standard, unoptimized technique gets the native bbox of the circle, rotates the box 45 degrees, uses\n* that width and height, and applies any transforms to get the final bbox. This means the calculated bbox\n* is much wider than the original circle. If the angle had been 0, 90, 180, etc. both techniques render the\n* same bbox.\n*\n* The optimization is not needed if the rotation is a multiple 90 degrees. The default technique is to call\n* getBBox then apply the angle and any transforms.\n*\n* @param {Float} angle - The rotation angle in degrees\n* @param {boolean} hasAMatrixTransform - True if there is a matrix transform\n* @returns {boolean} True if the bbox can be optimized.\n*/\nfunction bBoxCanBeOptimizedOverNativeGetBBox (angle, hasAMatrixTransform) {\n  const angleModulo90 = angle % 90;\n  const closeTo90 = angleModulo90 < -89.99 || angleModulo90 > 89.99;\n  const closeTo0 = angleModulo90 > -0.001 && angleModulo90 < 0.001;\n  return hasAMatrixTransform || !(closeTo0 || closeTo90);\n}\n\n/**\n* Get bounding box that includes any transforms.\n* @function module:utilities.getBBoxWithTransform\n* @param {Element} elem - The DOM element to be converted\n* @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson\n* @param {module:path.pathActions} pathActions - If a transform exists, pathActions.resetOrientation() is used. See: canvas.pathActions.\n* @returns {module:utilities.BBoxObject|module:math.TransformedBox|DOMRect} A single bounding box object\n*/\nexport const getBBoxWithTransform = function (elem, addSVGElementFromJson, pathActions) {\n  // TODO: Fix issue with rotated groups. Currently they work\n  // fine in FF, but not in other browsers (same problem mentioned\n  // in Issue 339 comment #2).\n\n  let bb = getBBox(elem);\n\n  if (!bb) {\n    return null;\n  }\n\n  const tlist = getTransformList(elem);\n  const angle = getRotationAngleFromTransformList(tlist);\n  const hasMatrixXForm = hasMatrixTransform(tlist);\n\n  if (angle || hasMatrixXForm) {\n    let goodBb = false;\n    if (bBoxCanBeOptimizedOverNativeGetBBox(angle, hasMatrixXForm)) {\n      // Get the BBox from the raw path for these elements\n      // TODO: why ellipse and not circle\n      const elemNames = ['ellipse', 'path', 'line', 'polyline', 'polygon'];\n      if (elemNames.includes(elem.tagName)) {\n        goodBb = getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions);\n        bb = goodBb;\n      } else if (elem.tagName === 'rect') {\n        // Look for radius\n        const rx = elem.getAttribute('rx');\n        const ry = elem.getAttribute('ry');\n        if (rx || ry) {\n          goodBb = getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions);\n          bb = goodBb;\n        }\n      }\n    }\n\n    if (!goodBb) {\n      const {matrix} = transformListToTransform(tlist);\n      bb = transformBox(bb.x, bb.y, bb.width, bb.height, matrix).aabox;\n\n      // Old technique that was exceedingly slow with large documents.\n      //\n      // Accurate way to get BBox of rotated element in Firefox:\n      // Put element in group and get its BBox\n      //\n      // Must use clone else FF freaks out\n      // const clone = elem.cloneNode(true);\n      // const g = document.createElementNS(NS.SVG, 'g');\n      // const parent = elem.parentNode;\n      // parent.append(g);\n      // g.append(clone);\n      // const bb2 = bboxToObj(g.getBBox());\n      // g.remove();\n    }\n  }\n  return bb;\n};\n\n/**\n * @param {Element} elem\n * @returns {Float}\n * @todo This is problematic with large stroke-width and, for example, a single\n * horizontal line. The calculated BBox extends way beyond left and right sides.\n */\nfunction getStrokeOffsetForBBox (elem) {\n  const sw = elem.getAttribute('stroke-width');\n  return (!isNaN(sw) && elem.getAttribute('stroke') !== 'none') ? sw / 2 : 0;\n}\n\n/**\n * @typedef {PlainObject} BBox\n * @property {Integer} x The x value\n * @property {Integer} y The y value\n * @property {Float} width\n * @property {Float} height\n */\n\n/**\n* Get the bounding box for one or more stroked and/or transformed elements.\n* @function module:utilities.getStrokedBBox\n* @param {Element[]} elems - Array with DOM elements to check\n* @param {module:utilities.EditorContext#addSVGElementFromJson} addSVGElementFromJson - Function to add the path element to the current layer. See canvas.addSVGElementFromJson\n* @param {module:path.pathActions} pathActions - If a transform exists, pathActions.resetOrientation() is used. See: canvas.pathActions.\n* @returns {module:utilities.BBoxObject|module:math.TransformedBox|DOMRect} A single bounding box object\n*/\nexport const getStrokedBBox = function (elems, addSVGElementFromJson, pathActions) {\n  if (!elems || !elems.length) { return false; }\n\n  let fullBb;\n  $.each(elems, function () {\n    if (fullBb) { return; }\n    if (!this.parentNode) { return; }\n    fullBb = getBBoxWithTransform(this, addSVGElementFromJson, pathActions);\n  });\n\n  // This shouldn't ever happen...\n  if (fullBb === undefined) { return null; }\n\n  // fullBb doesn't include the stoke, so this does no good!\n  // if (elems.length == 1) return fullBb;\n\n  let maxX = fullBb.x + fullBb.width;\n  let maxY = fullBb.y + fullBb.height;\n  let minX = fullBb.x;\n  let minY = fullBb.y;\n\n  // If only one elem, don't call the potentially slow getBBoxWithTransform method again.\n  if (elems.length === 1) {\n    const offset = getStrokeOffsetForBBox(elems[0]);\n    minX -= offset;\n    minY -= offset;\n    maxX += offset;\n    maxY += offset;\n  } else {\n    $.each(elems, function (i, elem) {\n      const curBb = getBBoxWithTransform(elem, addSVGElementFromJson, pathActions);\n      if (curBb) {\n        const offset = getStrokeOffsetForBBox(elem);\n        minX = Math.min(minX, curBb.x - offset);\n        minY = Math.min(minY, curBb.y - offset);\n        // TODO: The old code had this test for max, but not min. I suspect this test should be for both min and max\n        if (elem.nodeType === 1) {\n          maxX = Math.max(maxX, curBb.x + curBb.width + offset);\n          maxY = Math.max(maxY, curBb.y + curBb.height + offset);\n        }\n      }\n    });\n  }\n\n  fullBb.x = minX;\n  fullBb.y = minY;\n  fullBb.width = maxX - minX;\n  fullBb.height = maxY - minY;\n  return fullBb;\n};\n\n/**\n* Get all elements that have a BBox (excludes `<defs>`, `<title>`, etc).\n* Note that 0-opacity, off-screen etc elements are still considered \"visible\"\n* for this function.\n* @function module:utilities.getVisibleElements\n* @param {Element} parentElement - The parent DOM element to search within\n* @returns {Element[]} All \"visible\" elements.\n*/\nexport const getVisibleElements = function (parentElement) {\n  if (!parentElement) {\n    parentElement = $(editorContext_.getSVGContent()).children(); // Prevent layers from being included\n  }\n\n  const contentElems = [];\n  $(parentElement).children().each(function (i, elem) {\n    if (elem.getBBox) {\n      contentElems.push(elem);\n    }\n  });\n  return contentElems.reverse();\n};\n\n/**\n* Get the bounding box for one or more stroked and/or transformed elements.\n* @function module:utilities.getStrokedBBoxDefaultVisible\n* @param {Element[]} elems - Array with DOM elements to check\n* @returns {module:utilities.BBoxObject} A single bounding box object\n*/\nexport const getStrokedBBoxDefaultVisible = function (elems) {\n  if (!elems) { elems = getVisibleElements(); }\n  return getStrokedBBox(\n    elems,\n    editorContext_.addSVGElementFromJson,\n    editorContext_.pathActions\n  );\n};\n\n/**\n* Get the rotation angle of the given transform list.\n* @function module:utilities.getRotationAngleFromTransformList\n* @param {SVGTransformList} tlist - List of transforms\n* @param {boolean} toRad - When true returns the value in radians rather than degrees\n* @returns {Float} The angle in degrees or radians\n*/\nexport const getRotationAngleFromTransformList = function (tlist, toRad) {\n  if (!tlist) { return 0; } // <svg> elements have no tlist\n  const N = tlist.numberOfItems;\n  for (let i = 0; i < N; ++i) {\n    const xform = tlist.getItem(i);\n    if (xform.type === 4) {\n      return toRad ? xform.angle * Math.PI / 180.0 : xform.angle;\n    }\n  }\n  return 0.0;\n};\n\n/**\n* Get the rotation angle of the given/selected DOM element.\n* @function module:utilities.getRotationAngle\n* @param {Element} [elem] - DOM element to get the angle for. Default to first of selected elements.\n* @param {boolean} [toRad=false] - When true returns the value in radians rather than degrees\n* @returns {Float} The angle in degrees or radians\n*/\nexport let getRotationAngle = function (elem, toRad) { // eslint-disable-line import/no-mutable-exports\n  const selected = elem || editorContext_.getSelectedElements()[0];\n  // find the rotation transform (if any) and set it\n  const tlist = getTransformList(selected);\n  return getRotationAngleFromTransformList(tlist, toRad);\n};\n\n/**\n* Get the reference element associated with the given attribute value.\n* @function module:utilities.getRefElem\n* @param {string} attrVal - The attribute value as a string\n* @returns {Element} Reference element\n*/\nexport const getRefElem = function (attrVal) {\n  return getElem(getUrlFromAttr(attrVal).substr(1));\n};\n\n/**\n* Get a DOM element by ID within the SVG root element.\n* @function module:utilities.getElem\n* @param {string} id - String with the element's new ID\n* @returns {?Element}\n*/\nexport const getElem = (supportsSelectors())\n  ? function (id) {\n    // querySelector lookup\n    return svgroot_.querySelector('#' + id);\n  }\n  : supportsXpath()\n    ? function (id) {\n      // xpath lookup\n      return domdoc_.evaluate(\n        'svg:svg[@id=\"svgroot\"]//svg:*[@id=\"' + id + '\"]',\n        domcontainer_,\n        function () { return NS.SVG; },\n        9,\n        null\n      ).singleNodeValue;\n    }\n    : function (id) {\n      // jQuery lookup: twice as slow as xpath in FF\n      return $(svgroot_).find('[id=' + id + ']')[0];\n    };\n\n/**\n* Assigns multiple attributes to an element.\n* @function module:utilities.assignAttributes\n* @param {Element} elem - DOM element to apply new attribute values to\n* @param {PlainObject.<string, string>} attrs - Object with attribute keys/values\n* @param {Integer} [suspendLength] - Milliseconds to suspend redraw\n* @param {boolean} [unitCheck=false] - Boolean to indicate the need to use units.setUnitAttr\n* @returns {undefined}\n*/\nexport const assignAttributes = function (elem, attrs, suspendLength, unitCheck) {\n  for (const [key, value] of Object.entries(attrs)) {\n    const ns = (key.substr(0, 4) === 'xml:'\n      ? NS.XML\n      : key.substr(0, 6) === 'xlink:' ? NS.XLINK : null);\n\n    if (ns) {\n      elem.setAttributeNS(ns, key, value);\n    } else if (!unitCheck) {\n      elem.setAttribute(key, value);\n    } else {\n      setUnitAttr(elem, key, value);\n    }\n  }\n};\n\n/**\n* Remove unneeded (default) attributes, making resulting SVG smaller.\n* @function module:utilities.cleanupElement\n* @param {Element} element - DOM element to clean up\n* @returns {undefined}\n*/\nexport const cleanupElement = function (element) {\n  const defaults = {\n    'fill-opacity': 1,\n    'stop-opacity': 1,\n    opacity: 1,\n    stroke: 'none',\n    'stroke-dasharray': 'none',\n    'stroke-linejoin': 'miter',\n    'stroke-linecap': 'butt',\n    'stroke-opacity': 1,\n    'stroke-width': 1,\n    rx: 0,\n    ry: 0\n  };\n\n  if (element.nodeName === 'ellipse') {\n    // Ellipse elements require rx and ry attributes\n    delete defaults.rx;\n    delete defaults.ry;\n  }\n\n  Object.entries(defaults).forEach(([attr, val]) => {\n    if (element.getAttribute(attr) === String(val)) {\n      element.removeAttribute(attr);\n    }\n  });\n};\n\n/**\n* Round value to for snapping.\n* @function module:utilities.snapToGrid\n* @param {Float} value\n* @returns {Integer}\n*/\nexport const snapToGrid = function (value) {\n  const unit = editorContext_.getBaseUnit();\n  let stepSize = editorContext_.getSnappingStep();\n  if (unit !== 'px') {\n    stepSize *= getTypeMap()[unit];\n  }\n  value = Math.round(value / stepSize) * stepSize;\n  return value;\n};\n\n/**\n* Escapes special characters in a regular expression.\n* @function module:utilities.regexEscape\n* @param {string} str\n* @returns {string}\n*/\nexport const regexEscape = function (str) {\n  // From: http://phpjs.org/functions\n  return String(str).replace(new RegExp('[.\\\\\\\\+*?\\\\[\\\\^\\\\]$(){}=!<>|:\\\\-]', 'g'), '\\\\$&');\n};\n\n/**\n * Prevents default browser click behaviour on the given element.\n * @function module:utilities.preventClickDefault\n * @param {Element} img - The DOM element to prevent the click on\n * @returns {undefined}\n */\nexport const preventClickDefault = function (img) {\n  $(img).click(function (e) { e.preventDefault(); });\n};\n\n/**\n * @callback module:utilities.GetNextID\n * @returns {string} The ID\n */\n/**\n * Create a clone of an element, updating its ID and its children's IDs when needed.\n * @function module:utilities.copyElem\n * @param {Element} el - DOM element to clone\n * @param {module:utilities.GetNextID} getNextId - The getter of the next unique ID.\n * @returns {Element} The cloned element\n */\nexport const copyElem = function (el, getNextId) {\n  // manually create a copy of the element\n  const newEl = document.createElementNS(el.namespaceURI, el.nodeName);\n  $.each(el.attributes, function (i, attr) {\n    if (attr.localName !== '-moz-math-font-style') {\n      newEl.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value);\n    }\n  });\n  // set the copied element's new id\n  newEl.removeAttribute('id');\n  newEl.id = getNextId();\n\n  // Opera's \"d\" value needs to be reset for Opera/Win/non-EN\n  // Also needed for webkit (else does not keep curved segments on clone)\n  if (isWebkit() && el.nodeName === 'path') {\n    const fixedD = convertPath(el);\n    newEl.setAttribute('d', fixedD);\n  }\n\n  // now create copies of all children\n  $.each(el.childNodes, function (i, child) {\n    switch (child.nodeType) {\n    case 1: // element node\n      newEl.append(copyElem(child, getNextId));\n      break;\n    case 3: // text node\n      newEl.textContent = child.nodeValue;\n      break;\n    default:\n      break;\n    }\n  });\n\n  if ($(el).data('gsvg')) {\n    $(newEl).data('gsvg', newEl.firstChild);\n  } else if ($(el).data('symbol')) {\n    const ref = $(el).data('symbol');\n    $(newEl).data('ref', ref).data('symbol', ref);\n  } else if (newEl.tagName === 'image') {\n    preventClickDefault(newEl);\n  }\n\n  return newEl;\n};\n\n/**\n * Whether a value is `null` or `undefined`.\n * @param {Any} val\n * @returns {boolean}\n */\nexport const isNullish = (val) => {\n  return val === null || val === undefined;\n};\n\n/**\n* Overwrite methods for unit testing.\n* @function module:utilities.mock\n* @param {PlainObject} mockMethods\n* @returns {undefined}\n*/\nexport const mock = ({\n  getHref: getHrefUser, setHref: setHrefUser, getRotationAngle: getRotationAngleUser\n}) => {\n  getHref = getHrefUser;\n  setHref = setHrefUser;\n  getRotationAngle = getRotationAngleUser;\n};\n","/* globals jQuery */\n/**\n * Provides tools for the layer concept\n * @module layer\n * @license MIT\n *\n * @copyright 2011 Jeff Schiller, 2016 Flint O'Brien\n */\n\nimport {NS} from './namespaces.js';\nimport {toXml, walkTree, isNullish} from './utilities.js';\n\nconst $ = jQuery;\n\n/**\n * This class encapsulates the concept of a layer in the drawing. It can be constructed with\n * an existing group element or, with three parameters, will create a new layer group element.\n *\n * @example\n * new Layer('name', group);          // Use the existing group for this layer.\n * new Layer('name', group, svgElem); // Create a new group and add it to the DOM after group.\n * new Layer('name', null, svgElem);  // Create a new group and add it to the DOM as the last layer.\n * @memberof module:layer\n */\nclass Layer {\n  /**\n  * @param {string} name - Layer name\n  * @param {SVGGElement|null} group - An existing SVG group element or null.\n  *     If group and no svgElem, use group for this layer.\n  *     If group and svgElem, create a new group element and insert it in the DOM after group.\n  *     If no group and svgElem, create a new group element and insert it in the DOM as the last layer.\n  * @param {SVGGElement=} svgElem - The SVG DOM element. If defined, use this to add\n  *     a new layer to the document.\n  */\n  constructor (name, group, svgElem) {\n    this.name_ = name;\n    this.group_ = svgElem ? null : group;\n\n    if (svgElem) {\n      // Create a group element with title and add it to the DOM.\n      const svgdoc = svgElem.ownerDocument;\n      this.group_ = svgdoc.createElementNS(NS.SVG, 'g');\n      const layerTitle = svgdoc.createElementNS(NS.SVG, 'title');\n      layerTitle.textContent = name;\n      this.group_.append(layerTitle);\n      if (group) {\n        $(group).after(this.group_);\n      } else {\n        svgElem.append(this.group_);\n      }\n    }\n\n    addLayerClass(this.group_);\n    walkTree(this.group_, function (e) {\n      e.setAttribute('style', 'pointer-events:inherit');\n    });\n\n    this.group_.setAttribute('style', svgElem ? 'pointer-events:all' : 'pointer-events:none');\n  }\n\n  /**\n   * Get the layer's name.\n   * @returns {string} The layer name\n   */\n  getName () {\n    return this.name_;\n  }\n\n  /**\n   * Get the group element for this layer.\n   * @returns {SVGGElement} The layer SVG group\n   */\n  getGroup () {\n    return this.group_;\n  }\n\n  /**\n   * Active this layer so it takes pointer events.\n   * @returns {undefined}\n   */\n  activate () {\n    this.group_.setAttribute('style', 'pointer-events:all');\n  }\n\n  /**\n   * Deactive this layer so it does NOT take pointer events.\n   * @returns {undefined}\n   */\n  deactivate () {\n    this.group_.setAttribute('style', 'pointer-events:none');\n  }\n\n  /**\n   * Set this layer visible or hidden based on 'visible' parameter.\n   * @param {boolean} visible - If true, make visible; otherwise, hide it.\n   * @returns {undefined}\n   */\n  setVisible (visible) {\n    const expected = visible === undefined || visible ? 'inline' : 'none';\n    const oldDisplay = this.group_.getAttribute('display');\n    if (oldDisplay !== expected) {\n      this.group_.setAttribute('display', expected);\n    }\n  }\n\n  /**\n   * Is this layer visible?\n   * @returns {boolean} True if visible.\n   */\n  isVisible () {\n    return this.group_.getAttribute('display') !== 'none';\n  }\n\n  /**\n   * Get layer opacity.\n   * @returns {Float} Opacity value.\n   */\n  getOpacity () {\n    const opacity = this.group_.getAttribute('opacity');\n    if (isNullish(opacity)) {\n      return 1;\n    }\n    return parseFloat(opacity);\n  }\n\n  /**\n   * Sets the opacity of this layer. If opacity is not a value between 0.0 and 1.0,\n   * nothing happens.\n   * @param {Float} opacity - A float value in the range 0.0-1.0\n   * @returns {undefined}\n   */\n  setOpacity (opacity) {\n    if (typeof opacity === 'number' && opacity >= 0.0 && opacity <= 1.0) {\n      this.group_.setAttribute('opacity', opacity);\n    }\n  }\n\n  /**\n   * Append children to this layer.\n   * @param {SVGGElement} children - The children to append to this layer.\n   * @returns {undefined}\n   */\n  appendChildren (children) {\n    for (let i = 0; i < children.length; ++i) {\n      this.group_.append(children[i]);\n    }\n  }\n\n  /**\n  * @returns {SVGTitleElement|null}\n  */\n  getTitleElement () {\n    const len = this.group_.childNodes.length;\n    for (let i = 0; i < len; ++i) {\n      const child = this.group_.childNodes.item(i);\n      if (child && child.tagName === 'title') {\n        return child;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Set the name of this layer.\n   * @param {string} name - The new name.\n   * @param {module:history.HistoryRecordingService} hrService - History recording service\n   * @returns {string|null} The new name if changed; otherwise, null.\n   */\n  setName (name, hrService) {\n    const previousName = this.name_;\n    name = toXml(name);\n    // now change the underlying title element contents\n    const title = this.getTitleElement();\n    if (title) {\n      $(title).empty();\n      title.textContent = name;\n      this.name_ = name;\n      if (hrService) {\n        hrService.changeElement(title, {'#text': previousName});\n      }\n      return this.name_;\n    }\n    return null;\n  }\n\n  /**\n   * Remove this layer's group from the DOM. No more functions on group can be called after this.\n   * @returns {SVGGElement} The layer SVG group that was just removed.\n   */\n  removeGroup () {\n    const parent = this.group_.parentNode;\n    const group = parent.removeChild(this.group_);\n    this.group_ = undefined;\n    return group;\n  }\n}\n/**\n * @property {string} CLASS_NAME - class attribute assigned to all layer groups.\n */\nLayer.CLASS_NAME = 'layer';\n\n/**\n * @property {RegExp} CLASS_REGEX - Used to test presence of class Layer.CLASS_NAME\n */\nLayer.CLASS_REGEX = new RegExp('(\\\\s|^)' + Layer.CLASS_NAME + '(\\\\s|$)');\n\n/**\n * Add class `Layer.CLASS_NAME` to the element (usually `class='layer'`).\n *\n * @param {SVGGElement} elem - The SVG element to update\n * @returns {undefined}\n */\nfunction addLayerClass (elem) {\n  const classes = elem.getAttribute('class');\n  if (isNullish(classes) || !classes.length) {\n    elem.setAttribute('class', Layer.CLASS_NAME);\n  } else if (!Layer.CLASS_REGEX.test(classes)) {\n    elem.setAttribute('class', classes + ' ' + Layer.CLASS_NAME);\n  }\n}\n\nexport default Layer;\n","/**\n * HistoryRecordingService component of history\n * @module history\n * @license MIT\n * @copyright 2016 Flint O'Brien\n */\n\nimport {\n  BatchCommand, MoveElementCommand, InsertElementCommand, RemoveElementCommand,\n  ChangeElementCommand\n} from './history.js';\n\n/**\n * History recording service.\n *\n * A self-contained service interface for recording history. Once injected, no other dependencies\n * or globals are required (example: UndoManager, command types, etc.). Easy to mock for unit tests.\n * Built on top of history classes in history.js.\n *\n * There is a simple start/end interface for batch commands.\n *\n * HistoryRecordingService.NO_HISTORY is a singleton that can be passed in to functions\n * that record history. This helps when the caller requires that no history be recorded.\n *\n * The following will record history: insert, batch, insert.\n * @example\n * hrService = new history.HistoryRecordingService(this.undoMgr);\n * hrService.insertElement(elem, text);         // add simple command to history.\n * hrService.startBatchCommand('create two elements');\n * hrService.changeElement(elem, attrs, text);  // add to batchCommand\n * hrService.changeElement(elem, attrs2, text); // add to batchCommand\n * hrService.endBatchCommand();                  // add batch command with two change commands to history.\n * hrService.insertElement(elem, text);         // add simple command to history.\n *\n * @example\n * // Note that all functions return this, so commands can be chained, like so:\n * hrService\n *   .startBatchCommand('create two elements')\n *   .insertElement(elem, text)\n *   .changeElement(elem, attrs, text)\n *   .endBatchCommand();\n *\n * @memberof module:history\n */\nclass HistoryRecordingService {\n  /**\n  * @param {history.UndoManager|null} undoManager - The undo manager.\n  *     A value of `null` is valid for cases where no history recording is required.\n  *     See singleton: {@link module:history.HistoryRecordingService.HistoryRecordingService.NO_HISTORY}\n  */\n  constructor (undoManager) {\n    this.undoManager_ = undoManager;\n    this.currentBatchCommand_ = null;\n    this.batchCommandStack_ = [];\n  }\n\n  /**\n   * Start a batch command so multiple commands can recorded as a single history command.\n   * Requires a corresponding call to endBatchCommand. Start and end commands can be nested.\n   *\n   * @param {string} text - Optional string describing the batch command.\n   * @returns {module:history.HistoryRecordingService}\n   */\n  startBatchCommand (text) {\n    if (!this.undoManager_) { return this; }\n    this.currentBatchCommand_ = new BatchCommand(text);\n    this.batchCommandStack_.push(this.currentBatchCommand_);\n    return this;\n  }\n\n  /**\n   * End a batch command and add it to the history or a parent batch command.\n   * @returns {module:history.HistoryRecordingService}\n   */\n  endBatchCommand () {\n    if (!this.undoManager_) { return this; }\n    if (this.currentBatchCommand_) {\n      const batchCommand = this.currentBatchCommand_;\n      this.batchCommandStack_.pop();\n      const {length: len} = this.batchCommandStack_;\n      this.currentBatchCommand_ = len ? this.batchCommandStack_[len - 1] : null;\n      this.addCommand_(batchCommand);\n    }\n    return this;\n  }\n\n  /**\n   * Add a `MoveElementCommand` to the history or current batch command.\n   * @param {Element} elem - The DOM element that was moved\n   * @param {Element} oldNextSibling - The element's next sibling before it was moved\n   * @param {Element} oldParent - The element's parent before it was moved\n   * @param {string} [text] - An optional string visible to user related to this change\n   * @returns {module:history.HistoryRecordingService}\n   */\n  moveElement (elem, oldNextSibling, oldParent, text) {\n    if (!this.undoManager_) { return this; }\n    this.addCommand_(new MoveElementCommand(elem, oldNextSibling, oldParent, text));\n    return this;\n  }\n\n  /**\n   * Add an `InsertElementCommand` to the history or current batch command.\n   * @param {Element} elem - The DOM element that was added\n   * @param {string} [text] - An optional string visible to user related to this change\n   * @returns {module:history.HistoryRecordingService}\n   */\n  insertElement (elem, text) {\n    if (!this.undoManager_) { return this; }\n    this.addCommand_(new InsertElementCommand(elem, text));\n    return this;\n  }\n\n  /**\n   * Add a `RemoveElementCommand` to the history or current batch command.\n   * @param {Element} elem - The DOM element that was removed\n   * @param {Element} oldNextSibling - The element's next sibling before it was removed\n   * @param {Element} oldParent - The element's parent before it was removed\n   * @param {string} [text] - An optional string visible to user related to this change\n   * @returns {module:history.HistoryRecordingService}\n   */\n  removeElement (elem, oldNextSibling, oldParent, text) {\n    if (!this.undoManager_) { return this; }\n    this.addCommand_(new RemoveElementCommand(elem, oldNextSibling, oldParent, text));\n    return this;\n  }\n\n  /**\n   * Add a `ChangeElementCommand` to the history or current batch command.\n   * @param {Element} elem - The DOM element that was changed\n   * @param {module:history.CommandAttributes} attrs - An object with the attributes to be changed and the values they had *before* the change\n   * @param {string} [text] - An optional string visible to user related to this change\n   * @returns {module:history.HistoryRecordingService}\n   */\n  changeElement (elem, attrs, text) {\n    if (!this.undoManager_) { return this; }\n    this.addCommand_(new ChangeElementCommand(elem, attrs, text));\n    return this;\n  }\n\n  /**\n   * Private function to add a command to the history or current batch command.\n   * @private\n   * @param {Command} cmd\n   * @returns {module:history.HistoryRecordingService|undefined}\n   */\n  addCommand_ (cmd) {\n    if (!this.undoManager_) { return this; }\n    if (this.currentBatchCommand_) {\n      this.currentBatchCommand_.addSubCommand(cmd);\n    } else {\n      this.undoManager_.addCommandToHistory(cmd);\n    }\n    return undefined;\n  }\n}\n/**\n * @memberof module:history.HistoryRecordingService\n * @property {module:history.HistoryRecordingService} NO_HISTORY - Singleton that can be passed to functions that record history, but the caller requires that no history be recorded.\n */\nHistoryRecordingService.NO_HISTORY = new HistoryRecordingService();\nexport default HistoryRecordingService;\n","/* globals jQuery */\n/**\n * Tools for drawing\n * @module draw\n * @license MIT\n * @copyright 2011 Jeff Schiller\n */\n\nimport Layer from './layer.js';\nimport HistoryRecordingService from './historyrecording.js';\n\nimport {NS} from './namespaces.js';\nimport {isOpera} from './browser.js';\nimport {\n  toXml, getElem,\n  copyElem as utilCopyElem\n} from './utilities.js';\nimport {\n  BatchCommand, RemoveElementCommand, MoveElementCommand, ChangeElementCommand\n} from './history.js';\n\nconst $ = jQuery;\n\nconst visElems = 'a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use'.split(',');\n\nconst RandomizeModes = {\n  LET_DOCUMENT_DECIDE: 0,\n  ALWAYS_RANDOMIZE: 1,\n  NEVER_RANDOMIZE: 2\n};\nlet randIds = RandomizeModes.LET_DOCUMENT_DECIDE;\n// Array with current disabled elements (for in-group editing)\nlet disabledElems = [];\n\n/**\n * Get a HistoryRecordingService.\n * @param {module:history.HistoryRecordingService} [hrService] - if exists, return it instead of creating a new service.\n * @returns {module:history.HistoryRecordingService}\n */\nfunction historyRecordingService (hrService) {\n  return hrService || new HistoryRecordingService(canvas_.undoMgr);\n}\n\n/**\n * Find the layer name in a group element.\n * @param {Element} group The group element to search in.\n * @returns {string} The layer name or empty string.\n */\nfunction findLayerNameInGroup (group) {\n  return $('title', group).text() ||\n    (isOpera() && group.querySelectorAll\n      // Hack for Opera 10.60\n      ? $(group.querySelectorAll('title')).text()\n      : '');\n}\n\n/**\n * Given a set of names, return a new unique name.\n * @param {string[]} existingLayerNames - Existing layer names.\n * @returns {string} - The new name.\n */\nfunction getNewLayerName (existingLayerNames) {\n  let i = 1;\n  // TODO(codedread): What about internationalization of \"Layer\"?\n  while (existingLayerNames.includes(('Layer ' + i))) { i++; }\n  return 'Layer ' + i;\n}\n\n/**\n * This class encapsulates the concept of a SVG-edit drawing.\n */\nexport class Drawing {\n  /**\n  * @param {SVGSVGElement} svgElem - The SVG DOM Element that this JS object\n  *     encapsulates.  If the svgElem has a se:nonce attribute on it, then\n  *     IDs will use the nonce as they are generated.\n  * @param {string} [optIdPrefix=svg_] - The ID prefix to use.\n  * @throws {Error} If not initialized with an SVG element\n  */\n  constructor (svgElem, optIdPrefix) {\n    if (!svgElem || !svgElem.tagName || !svgElem.namespaceURI ||\n      svgElem.tagName !== 'svg' || svgElem.namespaceURI !== NS.SVG) {\n      throw new Error('Error: svgedit.draw.Drawing instance initialized without a <svg> element');\n    }\n\n    /**\n    * The SVG DOM Element that represents this drawing.\n    * @type {SVGSVGElement}\n    */\n    this.svgElem_ = svgElem;\n\n    /**\n    * The latest object number used in this drawing.\n    * @type {Integer}\n    */\n    this.obj_num = 0;\n\n    /**\n    * The prefix to prepend to each element id in the drawing.\n    * @type {string}\n    */\n    this.idPrefix = optIdPrefix || 'svg_';\n\n    /**\n    * An array of released element ids to immediately reuse.\n    * @type {Integer[]}\n    */\n    this.releasedNums = [];\n\n    /**\n    * The z-ordered array of Layer objects. Each layer has a name\n    * and group element.\n    * The first layer is the one at the bottom of the rendering.\n    * @type {Layer[]}\n    */\n    this.all_layers = [];\n\n    /**\n    * Map of all_layers by name.\n    *\n    * Note: Layers are ordered, but referenced externally by name; so, we need both container\n    * types depending on which function is called (i.e. all_layers and layer_map).\n    *\n    * @type {PlainObject.<string, Layer>}\n    */\n    this.layer_map = {};\n\n    /**\n    * The current layer being used.\n    * @type {Layer}\n    */\n    this.current_layer = null;\n\n    /**\n    * The nonce to use to uniquely identify elements across drawings.\n    * @type {!String}\n    */\n    this.nonce_ = '';\n    const n = this.svgElem_.getAttributeNS(NS.SE, 'nonce');\n    // If already set in the DOM, use the nonce throughout the document\n    // else, if randomizeIds(true) has been called, create and set the nonce.\n    if (n && randIds !== RandomizeModes.NEVER_RANDOMIZE) {\n      this.nonce_ = n;\n    } else if (randIds === RandomizeModes.ALWAYS_RANDOMIZE) {\n      this.setNonce(Math.floor(Math.random() * 100001));\n    }\n  }\n\n  /**\n   * @param {string} id Element ID to retrieve\n   * @returns {Element} SVG element within the root SVGSVGElement\n  */\n  getElem_ (id) {\n    if (this.svgElem_.querySelector) {\n      // querySelector lookup\n      return this.svgElem_.querySelector('#' + id);\n    }\n    // jQuery lookup: twice as slow as xpath in FF\n    return $(this.svgElem_).find('[id=' + id + ']')[0];\n  }\n\n  /**\n   * @returns {SVGSVGElement}\n   */\n  getSvgElem () {\n    return this.svgElem_;\n  }\n\n  /**\n   * @returns {!(string|Integer)} The previously set nonce\n   */\n  getNonce () {\n    return this.nonce_;\n  }\n\n  /**\n   * @param {!(string|Integer)} n The nonce to set\n   * @returns {undefined}\n   */\n  setNonce (n) {\n    this.svgElem_.setAttributeNS(NS.XMLNS, 'xmlns:se', NS.SE);\n    this.svgElem_.setAttributeNS(NS.SE, 'se:nonce', n);\n    this.nonce_ = n;\n  }\n\n  /**\n   * Clears any previously set nonce.\n   * @returns {undefined}\n   */\n  clearNonce () {\n    // We deliberately leave any se:nonce attributes alone,\n    // we just don't use it to randomize ids.\n    this.nonce_ = '';\n  }\n\n  /**\n   * Returns the latest object id as a string.\n   * @returns {string} The latest object Id.\n   */\n  getId () {\n    return this.nonce_\n      ? this.idPrefix + this.nonce_ + '_' + this.obj_num\n      : this.idPrefix + this.obj_num;\n  }\n\n  /**\n   * Returns the next object Id as a string.\n   * @returns {string} The next object Id to use.\n   */\n  getNextId () {\n    const oldObjNum = this.obj_num;\n    let restoreOldObjNum = false;\n\n    // If there are any released numbers in the release stack,\n    // use the last one instead of the next obj_num.\n    // We need to temporarily use obj_num as that is what getId() depends on.\n    if (this.releasedNums.length > 0) {\n      this.obj_num = this.releasedNums.pop();\n      restoreOldObjNum = true;\n    } else {\n      // If we are not using a released id, then increment the obj_num.\n      this.obj_num++;\n    }\n\n    // Ensure the ID does not exist.\n    let id = this.getId();\n    while (this.getElem_(id)) {\n      if (restoreOldObjNum) {\n        this.obj_num = oldObjNum;\n        restoreOldObjNum = false;\n      }\n      this.obj_num++;\n      id = this.getId();\n    }\n    // Restore the old object number if required.\n    if (restoreOldObjNum) {\n      this.obj_num = oldObjNum;\n    }\n    return id;\n  }\n\n  /**\n   * Releases the object Id, letting it be used as the next id in getNextId().\n   * This method DOES NOT remove any elements from the DOM, it is expected\n   * that client code will do this.\n   * @param {string} id - The id to release.\n   * @returns {boolean} True if the id was valid to be released, false otherwise.\n  */\n  releaseId (id) {\n    // confirm if this is a valid id for this Document, else return false\n    const front = this.idPrefix + (this.nonce_ ? this.nonce_ + '_' : '');\n    if (typeof id !== 'string' || !id.startsWith(front)) {\n      return false;\n    }\n    // extract the obj_num of this id\n    const num = parseInt(id.substr(front.length));\n\n    // if we didn't get a positive number or we already released this number\n    // then return false.\n    if (typeof num !== 'number' || num <= 0 || this.releasedNums.includes(num)) {\n      return false;\n    }\n\n    // push the released number into the released queue\n    this.releasedNums.push(num);\n\n    return true;\n  }\n\n  /**\n   * Returns the number of layers in the current drawing.\n   * @returns {Integer} The number of layers in the current drawing.\n  */\n  getNumLayers () {\n    return this.all_layers.length;\n  }\n\n  /**\n   * Check if layer with given name already exists.\n   * @param {string} name - The layer name to check\n   * @returns {boolean}\n  */\n  hasLayer (name) {\n    return this.layer_map[name] !== undefined;\n  }\n\n  /**\n   * Returns the name of the ith layer. If the index is out of range, an empty string is returned.\n   * @param {Integer} i - The zero-based index of the layer you are querying.\n   * @returns {string} The name of the ith layer (or the empty string if none found)\n  */\n  getLayerName (i) {\n    return i >= 0 && i < this.getNumLayers() ? this.all_layers[i].getName() : '';\n  }\n\n  /**\n   * @returns {SVGGElement|null} The SVGGElement representing the current layer.\n   */\n  getCurrentLayer () {\n    return this.current_layer ? this.current_layer.getGroup() : null;\n  }\n\n  /**\n   * Get a layer by name.\n   * @param {string} name\n   * @returns {SVGGElement} The SVGGElement representing the named layer or null.\n   */\n  getLayerByName (name) {\n    const layer = this.layer_map[name];\n    return layer ? layer.getGroup() : null;\n  }\n\n  /**\n   * Returns the name of the currently selected layer. If an error occurs, an empty string\n   * is returned.\n   * @returns {string} The name of the currently active layer (or the empty string if none found).\n  */\n  getCurrentLayerName () {\n    return this.current_layer ? this.current_layer.getName() : '';\n  }\n\n  /**\n   * Set the current layer's name.\n   * @param {string} name - The new name.\n   * @param {module:history.HistoryRecordingService} hrService - History recording service\n   * @returns {string|null} The new name if changed; otherwise, null.\n   */\n  setCurrentLayerName (name, hrService) {\n    let finalName = null;\n    if (this.current_layer) {\n      const oldName = this.current_layer.getName();\n      finalName = this.current_layer.setName(name, hrService);\n      if (finalName) {\n        delete this.layer_map[oldName];\n        this.layer_map[finalName] = this.current_layer;\n      }\n    }\n    return finalName;\n  }\n\n  /**\n   * Set the current layer's position.\n   * @param {Integer} newpos - The zero-based index of the new position of the layer. Range should be 0 to layers-1\n   * @returns {{title: SVGGElement, previousName: string}|null} If the name was changed, returns {title:SVGGElement, previousName:string}; otherwise null.\n   */\n  setCurrentLayerPosition (newpos) {\n    const layerCount = this.getNumLayers();\n    if (!this.current_layer || newpos < 0 || newpos >= layerCount) {\n      return null;\n    }\n\n    let oldpos;\n    for (oldpos = 0; oldpos < layerCount; ++oldpos) {\n      if (this.all_layers[oldpos] === this.current_layer) { break; }\n    }\n    // some unknown error condition (current_layer not in all_layers)\n    if (oldpos === layerCount) { return null; }\n\n    if (oldpos !== newpos) {\n      // if our new position is below us, we need to insert before the node after newpos\n      const currentGroup = this.current_layer.getGroup();\n      const oldNextSibling = currentGroup.nextSibling;\n\n      let refGroup = null;\n      if (newpos > oldpos) {\n        if (newpos < layerCount - 1) {\n          refGroup = this.all_layers[newpos + 1].getGroup();\n        }\n      // if our new position is above us, we need to insert before the node at newpos\n      } else {\n        refGroup = this.all_layers[newpos].getGroup();\n      }\n      this.svgElem_.insertBefore(currentGroup, refGroup); // Ok to replace with `refGroup.before(currentGroup);`?\n\n      this.identifyLayers();\n      this.setCurrentLayer(this.getLayerName(newpos));\n\n      return {\n        currentGroup,\n        oldNextSibling\n      };\n    }\n    return null;\n  }\n\n  /**\n  * @param {module:history.HistoryRecordingService} hrService\n  * @returns {undefined}\n  */\n  mergeLayer (hrService) {\n    const currentGroup = this.current_layer.getGroup();\n    const prevGroup = $(currentGroup).prev()[0];\n    if (!prevGroup) { return; }\n\n    hrService.startBatchCommand('Merge Layer');\n\n    const layerNextSibling = currentGroup.nextSibling;\n    hrService.removeElement(currentGroup, layerNextSibling, this.svgElem_);\n\n    while (currentGroup.firstChild) {\n      const child = currentGroup.firstChild;\n      if (child.localName === 'title') {\n        hrService.removeElement(child, child.nextSibling, currentGroup);\n        child.remove();\n        continue;\n      }\n      const oldNextSibling = child.nextSibling;\n      prevGroup.append(child);\n      hrService.moveElement(child, oldNextSibling, currentGroup);\n    }\n\n    // Remove current layer's group\n    this.current_layer.removeGroup();\n    // Remove the current layer and set the previous layer as the new current layer\n    const index = this.all_layers.indexOf(this.current_layer);\n    if (index > 0) {\n      const name = this.current_layer.getName();\n      this.current_layer = this.all_layers[index - 1];\n      this.all_layers.splice(index, 1);\n      delete this.layer_map[name];\n    }\n\n    hrService.endBatchCommand();\n  }\n\n  /**\n  * @param {module:history.HistoryRecordingService} hrService\n  * @returns {undefined}\n  */\n  mergeAllLayers (hrService) {\n    // Set the current layer to the last layer.\n    this.current_layer = this.all_layers[this.all_layers.length - 1];\n\n    hrService.startBatchCommand('Merge all Layers');\n    while (this.all_layers.length > 1) {\n      this.mergeLayer(hrService);\n    }\n    hrService.endBatchCommand();\n  }\n\n  /**\n   * Sets the current layer. If the name is not a valid layer name, then this\n   * function returns `false`. Otherwise it returns `true`. This is not an\n   * undo-able action.\n   * @param {string} name - The name of the layer you want to switch to.\n   * @returns {boolean} `true` if the current layer was switched, otherwise `false`\n   */\n  setCurrentLayer (name) {\n    const layer = this.layer_map[name];\n    if (layer) {\n      if (this.current_layer) {\n        this.current_layer.deactivate();\n      }\n      this.current_layer = layer;\n      this.current_layer.activate();\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Deletes the current layer from the drawing and then clears the selection.\n   * This function then calls the 'changed' handler.  This is an undoable action.\n   * @todo Does this actually call the 'changed' handler?\n   * @returns {SVGGElement} The SVGGElement of the layer removed or null.\n   */\n  deleteCurrentLayer () {\n    if (this.current_layer && this.getNumLayers() > 1) {\n      const oldLayerGroup = this.current_layer.removeGroup();\n      this.identifyLayers();\n      return oldLayerGroup;\n    }\n    return null;\n  }\n\n  /**\n   * Updates layer system and sets the current layer to the\n   * top-most layer (last `<g>` child of this drawing).\n   * @returns {undefined}\n  */\n  identifyLayers () {\n    this.all_layers = [];\n    this.layer_map = {};\n    const numchildren = this.svgElem_.childNodes.length;\n    // loop through all children of SVG element\n    const orphans = [], layernames = [];\n    let layer = null;\n    let childgroups = false;\n    for (let i = 0; i < numchildren; ++i) {\n      const child = this.svgElem_.childNodes.item(i);\n      // for each g, find its layer name\n      if (child && child.nodeType === 1) {\n        if (child.tagName === 'g') {\n          childgroups = true;\n          const name = findLayerNameInGroup(child);\n          if (name) {\n            layernames.push(name);\n            layer = new Layer(name, child);\n            this.all_layers.push(layer);\n            this.layer_map[name] = layer;\n          } else {\n            // if group did not have a name, it is an orphan\n            orphans.push(child);\n          }\n        } else if (visElems.includes(child.nodeName)) {\n          // Child is \"visible\" (i.e. not a <title> or <defs> element), so it is an orphan\n          orphans.push(child);\n        }\n      }\n    }\n\n    // If orphans or no layers found, create a new layer and add all the orphans to it\n    if (orphans.length > 0 || !childgroups) {\n      layer = new Layer(getNewLayerName(layernames), null, this.svgElem_);\n      layer.appendChildren(orphans);\n      this.all_layers.push(layer);\n      this.layer_map[name] = layer;\n    } else {\n      layer.activate();\n    }\n    this.current_layer = layer;\n  }\n\n  /**\n   * Creates a new top-level layer in the drawing with the given name and\n   * makes it the current layer.\n   * @param {string} name - The given name. If the layer name exists, a new name will be generated.\n   * @param {module:history.HistoryRecordingService} hrService - History recording service\n   * @returns {SVGGElement} The SVGGElement of the new layer, which is\n   *     also the current layer of this drawing.\n  */\n  createLayer (name, hrService) {\n    if (this.current_layer) {\n      this.current_layer.deactivate();\n    }\n    // Check for duplicate name.\n    if (name === undefined || name === null || name === '' || this.layer_map[name]) {\n      name = getNewLayerName(Object.keys(this.layer_map));\n    }\n\n    // Crate new layer and add to DOM as last layer\n    const layer = new Layer(name, null, this.svgElem_);\n    // Like to assume hrService exists, but this is backwards compatible with old version of createLayer.\n    if (hrService) {\n      hrService.startBatchCommand('Create Layer');\n      hrService.insertElement(layer.getGroup());\n      hrService.endBatchCommand();\n    }\n\n    this.all_layers.push(layer);\n    this.layer_map[name] = layer;\n    this.current_layer = layer;\n    return layer.getGroup();\n  }\n\n  /**\n   * Creates a copy of the current layer with the given name and makes it the current layer.\n   * @param {string} name - The given name. If the layer name exists, a new name will be generated.\n   * @param {module:history.HistoryRecordingService} hrService - History recording service\n   * @returns {SVGGElement} The SVGGElement of the new layer, which is\n   *     also the current layer of this drawing.\n  */\n  cloneLayer (name, hrService) {\n    if (!this.current_layer) { return null; }\n    this.current_layer.deactivate();\n    // Check for duplicate name.\n    if (name === undefined || name === null || name === '' || this.layer_map[name]) {\n      name = getNewLayerName(Object.keys(this.layer_map));\n    }\n\n    // Create new group and add to DOM just after current_layer\n    const currentGroup = this.current_layer.getGroup();\n    const layer = new Layer(name, currentGroup, this.svgElem_);\n    const group = layer.getGroup();\n\n    // Clone children\n    const children = currentGroup.childNodes;\n    for (let index = 0; index < children.length; index++) {\n      const ch = children[index];\n      if (ch.localName === 'title') { continue; }\n      group.append(this.copyElem(ch));\n    }\n\n    if (hrService) {\n      hrService.startBatchCommand('Duplicate Layer');\n      hrService.insertElement(group);\n      hrService.endBatchCommand();\n    }\n\n    // Update layer containers and current_layer.\n    const index = this.all_layers.indexOf(this.current_layer);\n    if (index >= 0) {\n      this.all_layers.splice(index + 1, 0, layer);\n    } else {\n      this.all_layers.push(layer);\n    }\n    this.layer_map[name] = layer;\n    this.current_layer = layer;\n    return group;\n  }\n\n  /**\n   * Returns whether the layer is visible.  If the layer name is not valid,\n   * then this function returns `false`.\n   * @param {string} layerName - The name of the layer which you want to query.\n   * @returns {boolean} The visibility state of the layer, or `false` if the layer name was invalid.\n  */\n  getLayerVisibility (layerName) {\n    const layer = this.layer_map[layerName];\n    return layer ? layer.isVisible() : false;\n  }\n\n  /**\n   * Sets the visibility of the layer. If the layer name is not valid, this\n   * function returns `null`, otherwise it returns the `SVGElement` representing\n   * the layer. This is an undo-able action.\n   * @param {string} layerName - The name of the layer to change the visibility\n   * @param {boolean} bVisible - Whether the layer should be visible\n   * @returns {?SVGGElement} The SVGGElement representing the layer if the\n   *   `layerName` was valid, otherwise `null`.\n  */\n  setLayerVisibility (layerName, bVisible) {\n    if (typeof bVisible !== 'boolean') {\n      return null;\n    }\n    const layer = this.layer_map[layerName];\n    if (!layer) { return null; }\n    layer.setVisible(bVisible);\n    return layer.getGroup();\n  }\n\n  /**\n   * Returns the opacity of the given layer.  If the input name is not a layer, `null` is returned.\n   * @param {string} layerName - name of the layer on which to get the opacity\n   * @returns {?Float} The opacity value of the given layer.  This will be a value between 0.0 and 1.0, or `null`\n   * if `layerName` is not a valid layer\n  */\n  getLayerOpacity (layerName) {\n    const layer = this.layer_map[layerName];\n    if (!layer) { return null; }\n    return layer.getOpacity();\n  }\n\n  /**\n   * Sets the opacity of the given layer.  If the input name is not a layer,\n   * nothing happens. If opacity is not a value between 0.0 and 1.0, then\n   * nothing happens.\n   * NOTE: this function exists solely to apply a highlighting/de-emphasis\n   * effect to a layer. When it is possible for a user to affect the opacity\n   * of a layer, we will need to allow this function to produce an undo-able\n   * action.\n   * @param {string} layerName - Name of the layer on which to set the opacity\n   * @param {Float} opacity - A float value in the range 0.0-1.0\n   * @returns {undefined}\n  */\n  setLayerOpacity (layerName, opacity) {\n    if (typeof opacity !== 'number' || opacity < 0.0 || opacity > 1.0) {\n      return;\n    }\n    const layer = this.layer_map[layerName];\n    if (layer) {\n      layer.setOpacity(opacity);\n    }\n  }\n\n  /**\n   * Create a clone of an element, updating its ID and its children's IDs when needed.\n   * @param {Element} el - DOM element to clone\n   * @returns {Element}\n   */\n  copyElem (el) {\n    const that = this;\n    const getNextIdClosure = function () { return that.getNextId(); };\n    return utilCopyElem(el, getNextIdClosure);\n  }\n}\n\n/**\n * Called to ensure that drawings will or will not have randomized ids.\n * The currentDrawing will have its nonce set if it doesn't already.\n * @function module:draw.randomizeIds\n * @param {boolean} enableRandomization - flag indicating if documents should have randomized ids\n * @param {draw.Drawing} currentDrawing\n * @returns {undefined}\n */\nexport const randomizeIds = function (enableRandomization, currentDrawing) {\n  randIds = enableRandomization === false\n    ? RandomizeModes.NEVER_RANDOMIZE\n    : RandomizeModes.ALWAYS_RANDOMIZE;\n\n  if (randIds === RandomizeModes.ALWAYS_RANDOMIZE && !currentDrawing.getNonce()) {\n    currentDrawing.setNonce(Math.floor(Math.random() * 100001));\n  } else if (randIds === RandomizeModes.NEVER_RANDOMIZE && currentDrawing.getNonce()) {\n    currentDrawing.clearNonce();\n  }\n};\n\n// Layer API Functions\n\n/**\n* Group: Layers\n*/\n\n/**\n * @see {@link https://api.jquery.com/jQuery.data/}\n * @name external:jQuery.data\n */\n\n/**\n * @interface module:draw.DrawCanvasInit\n * @property {module:path.pathActions} pathActions\n * @property {external:jQuery.data} elData\n * @property {module:history.UndoManager} undoMgr\n */\n/**\n * @function module:draw.DrawCanvasInit#getCurrentGroup\n * @returns {Element}\n */\n/**\n * @function module:draw.DrawCanvasInit#setCurrentGroup\n * @param {Element} cg\n * @returns {undefined}\n*/\n/**\n * @function module:draw.DrawCanvasInit#getSelectedElements\n * @returns {Element[]} the array with selected DOM elements\n*/\n/**\n * @function module:draw.DrawCanvasInit#getSVGContent\n * @returns {SVGSVGElement}\n */\n/**\n * @function module:draw.DrawCanvasInit#getCurrentDrawing\n * @returns {module:draw.Drawing}\n */\n/**\n * @function module:draw.DrawCanvasInit#clearSelection\n * @param {boolean} [noCall] - When `true`, does not call the \"selected\" handler\n * @returns {undefined}\n*/\n/**\n * Run the callback function associated with the given event\n * @function module:draw.DrawCanvasInit#call\n * @param {\"changed\"|\"contextset\"} ev - String with the event name\n * @param {module:svgcanvas.SvgCanvas#event:changed|module:svgcanvas.SvgCanvas#event:contextset} arg - Argument to pass through to the callback\n * function. If the event is \"changed\", a (single-item) array of `Element`s is\n * passed. If the event is \"contextset\", the arg is `null` or `Element`.\n * @returns {undefined}\n */\n/**\n * @function module:draw.DrawCanvasInit#addCommandToHistory\n * @param {Command} cmd\n * @returns {undefined}\n*/\n/**\n * @function module:draw.DrawCanvasInit#changeSVGContent\n * @returns {undefined}\n */\n\nlet canvas_;\n/**\n* @function module:draw.init\n* @param {module:draw.DrawCanvasInit} canvas\n* @returns {undefined}\n*/\nexport const init = function (canvas) {\n  canvas_ = canvas;\n};\n\n/**\n* Updates layer system.\n* @function module:draw.identifyLayers\n* @returns {undefined}\n*/\nexport const identifyLayers = function () {\n  leaveContext();\n  canvas_.getCurrentDrawing().identifyLayers();\n};\n\n/**\n* Creates a new top-level layer in the drawing with the given name, sets the current layer\n* to it, and then clears the selection. This function then calls the 'changed' handler.\n* This is an undoable action.\n* @function module:draw.createLayer\n* @param {string} name - The given name\n* @param {module:history.HistoryRecordingService} hrService\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nexport const createLayer = function (name, hrService) {\n  const newLayer = canvas_.getCurrentDrawing().createLayer(\n    name,\n    historyRecordingService(hrService)\n  );\n  canvas_.clearSelection();\n  canvas_.call('changed', [newLayer]);\n};\n\n/**\n * Creates a new top-level layer in the drawing with the given name, copies all the current layer's contents\n * to it, and then clears the selection. This function then calls the 'changed' handler.\n * This is an undoable action.\n * @function module:draw.cloneLayer\n * @param {string} name - The given name. If the layer name exists, a new name will be generated.\n * @param {module:history.HistoryRecordingService} hrService - History recording service\n * @fires module:svgcanvas.SvgCanvas#event:changed\n * @returns {undefined}\n */\nexport const cloneLayer = function (name, hrService) {\n  // Clone the current layer and make the cloned layer the new current layer\n  const newLayer = canvas_.getCurrentDrawing().cloneLayer(name, historyRecordingService(hrService));\n\n  canvas_.clearSelection();\n  leaveContext();\n  canvas_.call('changed', [newLayer]);\n};\n\n/**\n* Deletes the current layer from the drawing and then clears the selection. This function\n* then calls the 'changed' handler. This is an undoable action.\n* @function module:draw.deleteCurrentLayer\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {boolean} `true` if an old layer group was found to delete\n*/\nexport const deleteCurrentLayer = function () {\n  let currentLayer = canvas_.getCurrentDrawing().getCurrentLayer();\n  const {nextSibling} = currentLayer;\n  const parent = currentLayer.parentNode;\n  currentLayer = canvas_.getCurrentDrawing().deleteCurrentLayer();\n  if (currentLayer) {\n    const batchCmd = new BatchCommand('Delete Layer');\n    // store in our Undo History\n    batchCmd.addSubCommand(new RemoveElementCommand(currentLayer, nextSibling, parent));\n    canvas_.addCommandToHistory(batchCmd);\n    canvas_.clearSelection();\n    canvas_.call('changed', [parent]);\n    return true;\n  }\n  return false;\n};\n\n/**\n* Sets the current layer. If the name is not a valid layer name, then this function returns\n* false. Otherwise it returns true. This is not an undo-able action.\n* @function module:draw.setCurrentLayer\n* @param {string} name - The name of the layer you want to switch to.\n* @returns {boolean} true if the current layer was switched, otherwise false\n*/\nexport const setCurrentLayer = function (name) {\n  const result = canvas_.getCurrentDrawing().setCurrentLayer(toXml(name));\n  if (result) {\n    canvas_.clearSelection();\n  }\n  return result;\n};\n\n/**\n* Renames the current layer. If the layer name is not valid (i.e. unique), then this function\n* does nothing and returns `false`, otherwise it returns `true`. This is an undo-able action.\n* @function module:draw.renameCurrentLayer\n* @param {string} newName - the new name you want to give the current layer. This name must\n* be unique among all layer names.\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {boolean} Whether the rename succeeded\n*/\nexport const renameCurrentLayer = function (newName) {\n  const drawing = canvas_.getCurrentDrawing();\n  const layer = drawing.getCurrentLayer();\n  if (layer) {\n    const result = drawing.setCurrentLayerName(newName, historyRecordingService());\n    if (result) {\n      canvas_.call('changed', [layer]);\n      return true;\n    }\n  }\n  return false;\n};\n\n/**\n* Changes the position of the current layer to the new value. If the new index is not valid,\n* this function does nothing and returns false, otherwise it returns true. This is an\n* undo-able action.\n* @function module:draw.setCurrentLayerPosition\n* @param {Integer} newPos - The zero-based index of the new position of the layer. This should be between\n* 0 and (number of layers - 1)\n* @returns {boolean} `true` if the current layer position was changed, `false` otherwise.\n*/\nexport const setCurrentLayerPosition = function (newPos) {\n  const drawing = canvas_.getCurrentDrawing();\n  const result = drawing.setCurrentLayerPosition(newPos);\n  if (result) {\n    canvas_.addCommandToHistory(new MoveElementCommand(result.currentGroup, result.oldNextSibling, canvas_.getSVGContent()));\n    return true;\n  }\n  return false;\n};\n\n/**\n* Sets the visibility of the layer. If the layer name is not valid, this function return\n* `false`, otherwise it returns `true`. This is an undo-able action.\n* @function module:draw.setLayerVisibility\n* @param {string} layerName - The name of the layer to change the visibility\n* @param {boolean} bVisible - Whether the layer should be visible\n* @returns {boolean} true if the layer's visibility was set, false otherwise\n*/\nexport const setLayerVisibility = function (layerName, bVisible) {\n  const drawing = canvas_.getCurrentDrawing();\n  const prevVisibility = drawing.getLayerVisibility(layerName);\n  const layer = drawing.setLayerVisibility(layerName, bVisible);\n  if (layer) {\n    const oldDisplay = prevVisibility ? 'inline' : 'none';\n    canvas_.addCommandToHistory(new ChangeElementCommand(layer, {display: oldDisplay}, 'Layer Visibility'));\n  } else {\n    return false;\n  }\n\n  if (layer === drawing.getCurrentLayer()) {\n    canvas_.clearSelection();\n    canvas_.pathActions.clear();\n  }\n  // call('changed', [selected]);\n  return true;\n};\n\n/**\n* Moves the selected elements to layerName. If the name is not a valid layer name, then `false`\n* is returned. Otherwise it returns `true`. This is an undo-able action.\n* @function module:draw.moveSelectedToLayer\n* @param {string} layerName - The name of the layer you want to which you want to move the selected elements\n* @returns {boolean} Whether the selected elements were moved to the layer.\n*/\nexport const moveSelectedToLayer = function (layerName) {\n  // find the layer\n  const drawing = canvas_.getCurrentDrawing();\n  const layer = drawing.getLayerByName(layerName);\n  if (!layer) { return false; }\n\n  const batchCmd = new BatchCommand('Move Elements to Layer');\n\n  // loop for each selected element and move it\n  const selElems = canvas_.getSelectedElements();\n  let i = selElems.length;\n  while (i--) {\n    const elem = selElems[i];\n    if (!elem) { continue; }\n    const oldNextSibling = elem.nextSibling;\n    // TODO: this is pretty brittle!\n    const oldLayer = elem.parentNode;\n    layer.append(elem);\n    batchCmd.addSubCommand(new MoveElementCommand(elem, oldNextSibling, oldLayer));\n  }\n\n  canvas_.addCommandToHistory(batchCmd);\n\n  return true;\n};\n\n/**\n* @function module:draw.mergeLayer\n* @param {module:history.HistoryRecordingService} hrService\n* @returns {undefined}\n*/\nexport const mergeLayer = function (hrService) {\n  canvas_.getCurrentDrawing().mergeLayer(historyRecordingService(hrService));\n  canvas_.clearSelection();\n  leaveContext();\n  canvas_.changeSVGContent();\n};\n\n/**\n* @function module:draw.mergeAllLayers\n* @param {module:history.HistoryRecordingService} hrService\n* @returns {undefined}\n*/\nexport const mergeAllLayers = function (hrService) {\n  canvas_.getCurrentDrawing().mergeAllLayers(historyRecordingService(hrService));\n  canvas_.clearSelection();\n  leaveContext();\n  canvas_.changeSVGContent();\n};\n\n/**\n* Return from a group context to the regular kind, make any previously\n* disabled elements enabled again.\n* @function module:draw.leaveContext\n* @fires module:svgcanvas.SvgCanvas#event:contextset\n* @returns {undefined}\n*/\nexport const leaveContext = function () {\n  const len = disabledElems.length;\n  if (len) {\n    for (let i = 0; i < len; i++) {\n      const elem = disabledElems[i];\n      const orig = canvas_.elData(elem, 'orig_opac');\n      if (orig !== 1) {\n        elem.setAttribute('opacity', orig);\n      } else {\n        elem.removeAttribute('opacity');\n      }\n      elem.setAttribute('style', 'pointer-events: inherit');\n    }\n    disabledElems = [];\n    canvas_.clearSelection(true);\n    canvas_.call('contextset', null);\n  }\n  canvas_.setCurrentGroup(null);\n};\n\n/**\n* Set the current context (for in-group editing).\n* @function module:draw.setContext\n* @param {Element} elem\n* @fires module:svgcanvas.SvgCanvas#event:contextset\n* @returns {undefined}\n*/\nexport const setContext = function (elem) {\n  leaveContext();\n  if (typeof elem === 'string') {\n    elem = getElem(elem);\n  }\n\n  // Edit inside this group\n  canvas_.setCurrentGroup(elem);\n\n  // Disable other elements\n  $(elem).parentsUntil('#svgcontent').andSelf().siblings().each(function () {\n    const opac = this.getAttribute('opacity') || 1;\n    // Store the original's opacity\n    canvas_.elData(this, 'orig_opac', opac);\n    this.setAttribute('opacity', opac * 0.33);\n    this.setAttribute('style', 'pointer-events: none');\n    disabledElems.push(this);\n  });\n\n  canvas_.clearSelection();\n  canvas_.call('contextset', canvas_.getCurrentGroup());\n};\n\n/**\n* @memberof module:draw\n* @class Layer\n* @see {@link module:layer.Layer}\n*/\nexport {Layer};\n","/**\n * Tools for SVG sanitization\n * @module sanitize\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller\n */\n\nimport {getReverseNS, NS} from './namespaces.js';\nimport {isGecko} from './browser.js';\nimport {getHref, setHref, getUrlFromAttr} from './utilities.js';\n\nconst REVERSE_NS = getReverseNS();\n\n// this defines which elements and attributes that we support\nconst svgWhiteList_ = {\n  // SVG Elements\n  a: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'mask', 'opacity', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'xlink:href', 'xlink:title'],\n  circle: ['class', 'clip-path', 'clip-rule', 'cx', 'cy', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'mask', 'opacity', 'r', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],\n  clipPath: ['class', 'clipPathUnits', 'id'],\n  defs: [],\n  style: ['type'],\n  desc: [],\n  ellipse: ['class', 'clip-path', 'clip-rule', 'cx', 'cy', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'mask', 'opacity', 'requiredFeatures', 'rx', 'ry', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],\n  feGaussianBlur: ['class', 'color-interpolation-filters', 'id', 'requiredFeatures', 'stdDeviation'],\n  filter: ['class', 'color-interpolation-filters', 'filterRes', 'filterUnits', 'height', 'id', 'primitiveUnits', 'requiredFeatures', 'width', 'x', 'xlink:href', 'y'],\n  foreignObject: ['class', 'font-size', 'height', 'id', 'opacity', 'requiredFeatures', 'style', 'transform', 'width', 'x', 'y'],\n  g: ['class', 'clip-path', 'clip-rule', 'id', 'display', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'font-family', 'font-size', 'font-style', 'font-weight', 'text-anchor'],\n  image: ['class', 'clip-path', 'clip-rule', 'filter', 'height', 'id', 'mask', 'opacity', 'requiredFeatures', 'style', 'systemLanguage', 'transform', 'width', 'x', 'xlink:href', 'xlink:title', 'y'],\n  line: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'x1', 'x2', 'y1', 'y2'],\n  linearGradient: ['class', 'id', 'gradientTransform', 'gradientUnits', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'x1', 'x2', 'xlink:href', 'y1', 'y2'],\n  marker: ['id', 'class', 'markerHeight', 'markerUnits', 'markerWidth', 'orient', 'preserveAspectRatio', 'refX', 'refY', 'systemLanguage', 'viewBox'],\n  mask: ['class', 'height', 'id', 'maskContentUnits', 'maskUnits', 'width', 'x', 'y'],\n  metadata: ['class', 'id'],\n  path: ['class', 'clip-path', 'clip-rule', 'd', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],\n  pattern: ['class', 'height', 'id', 'patternContentUnits', 'patternTransform', 'patternUnits', 'requiredFeatures', 'style', 'systemLanguage', 'viewBox', 'width', 'x', 'xlink:href', 'y'],\n  polygon: ['class', 'clip-path', 'clip-rule', 'id', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'id', 'class', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'points', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],\n  polyline: ['class', 'clip-path', 'clip-rule', 'id', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'points', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform'],\n  radialGradient: ['class', 'cx', 'cy', 'fx', 'fy', 'gradientTransform', 'gradientUnits', 'id', 'r', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'xlink:href'],\n  rect: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'id', 'mask', 'opacity', 'requiredFeatures', 'rx', 'ry', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'width', 'x', 'y'],\n  stop: ['class', 'id', 'offset', 'requiredFeatures', 'stop-color', 'stop-opacity', 'style', 'systemLanguage'],\n  svg: ['class', 'clip-path', 'clip-rule', 'filter', 'id', 'height', 'mask', 'preserveAspectRatio', 'requiredFeatures', 'style', 'systemLanguage', 'viewBox', 'width', 'x', 'xmlns', 'xmlns:se', 'xmlns:xlink', 'y'],\n  switch: ['class', 'id', 'requiredFeatures', 'systemLanguage'],\n  symbol: ['class', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'id', 'opacity', 'preserveAspectRatio', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'transform', 'viewBox'],\n  text: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'id', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'text-anchor', 'transform', 'x', 'xml:space', 'y'],\n  textPath: ['class', 'id', 'method', 'requiredFeatures', 'spacing', 'startOffset', 'style', 'systemLanguage', 'transform', 'xlink:href'],\n  title: [],\n  tspan: ['class', 'clip-path', 'clip-rule', 'dx', 'dy', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'id', 'mask', 'opacity', 'requiredFeatures', 'rotate', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'systemLanguage', 'text-anchor', 'textLength', 'transform', 'x', 'xml:space', 'y'],\n  use: ['class', 'clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'id', 'mask', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'style', 'transform', 'width', 'x', 'xlink:href', 'y'],\n\n  // MathML Elements\n  annotation: ['encoding'],\n  'annotation-xml': ['encoding'],\n  maction: ['actiontype', 'other', 'selection'],\n  math: ['class', 'id', 'display', 'xmlns'],\n  menclose: ['notation'],\n  merror: [],\n  mfrac: ['linethickness'],\n  mi: ['mathvariant'],\n  mmultiscripts: [],\n  mn: [],\n  mo: ['fence', 'lspace', 'maxsize', 'minsize', 'rspace', 'stretchy'],\n  mover: [],\n  mpadded: ['lspace', 'width', 'height', 'depth', 'voffset'],\n  mphantom: [],\n  mprescripts: [],\n  mroot: [],\n  mrow: ['xlink:href', 'xlink:type', 'xmlns:xlink'],\n  mspace: ['depth', 'height', 'width'],\n  msqrt: [],\n  mstyle: ['displaystyle', 'mathbackground', 'mathcolor', 'mathvariant', 'scriptlevel'],\n  msub: [],\n  msubsup: [],\n  msup: [],\n  mtable: ['align', 'columnalign', 'columnlines', 'columnspacing', 'displaystyle', 'equalcolumns', 'equalrows', 'frame', 'rowalign', 'rowlines', 'rowspacing', 'width'],\n  mtd: ['columnalign', 'columnspan', 'rowalign', 'rowspan'],\n  mtext: [],\n  mtr: ['columnalign', 'rowalign'],\n  munder: [],\n  munderover: [],\n  none: [],\n  semantics: []\n};\n\n// Produce a Namespace-aware version of svgWhitelist\nconst svgWhiteListNS_ = {};\nObject.entries(svgWhiteList_).forEach(function ([elt, atts]) {\n  const attNS = {};\n  Object.entries(atts).forEach(function ([i, att]) {\n    if (att.includes(':')) {\n      const v = att.split(':');\n      attNS[v[1]] = NS[(v[0]).toUpperCase()];\n    } else {\n      attNS[att] = att === 'xmlns' ? NS.XMLNS : null;\n    }\n  });\n  svgWhiteListNS_[elt] = attNS;\n});\n\n/**\n* Sanitizes the input node and its children.\n* It only keeps what is allowed from our whitelist defined above.\n* @function module:sanitize.sanitizeSvg\n* @param {Text|Element} node - The DOM element to be checked (we'll also check its children) or text node to be cleaned up\n* @returns {undefined}\n*/\nexport const sanitizeSvg = function (node) {\n  // Cleanup text nodes\n  if (node.nodeType === 3) { // 3 === TEXT_NODE\n    // Trim whitespace\n    node.nodeValue = node.nodeValue.replace(/^\\s+|\\s+$/g, '');\n    // Remove if empty\n    if (!node.nodeValue.length) {\n      node.remove();\n    }\n  }\n\n  // We only care about element nodes.\n  // Automatically return for all non-element nodes, such as comments, etc.\n  if (node.nodeType !== 1) { // 1 == ELEMENT_NODE\n    return;\n  }\n\n  const doc = node.ownerDocument;\n  const parent = node.parentNode;\n  // can parent ever be null here?  I think the root node's parent is the document...\n  if (!doc || !parent) {\n    return;\n  }\n\n  const allowedAttrs = svgWhiteList_[node.nodeName];\n  const allowedAttrsNS = svgWhiteListNS_[node.nodeName];\n  // if this element is supported, sanitize it\n  if (typeof allowedAttrs !== 'undefined') {\n    const seAttrs = [];\n    let i = node.attributes.length;\n    while (i--) {\n      // if the attribute is not in our whitelist, then remove it\n      // could use jQuery's inArray(), but I don't know if that's any better\n      const attr = node.attributes.item(i);\n      const attrName = attr.nodeName;\n      const attrLocalName = attr.localName;\n      const attrNsURI = attr.namespaceURI;\n      // Check that an attribute with the correct localName in the correct namespace is on\n      // our whitelist or is a namespace declaration for one of our allowed namespaces\n      if (!({}.hasOwnProperty.call(allowedAttrsNS, attrLocalName) && attrNsURI === allowedAttrsNS[attrLocalName] && attrNsURI !== NS.XMLNS) &&\n        !(attrNsURI === NS.XMLNS && REVERSE_NS[attr.value])) {\n        // TODO(codedread): Programmatically add the se: attributes to the NS-aware whitelist.\n        // Bypassing the whitelist to allow se: prefixes.\n        // Is there a more appropriate way to do this?\n        if (attrName.startsWith('se:') || attrName.startsWith('data-')) {\n          seAttrs.push([attrName, attr.value]);\n        }\n        node.removeAttributeNS(attrNsURI, attrLocalName);\n      }\n\n      // Add spaces before negative signs where necessary\n      if (isGecko()) {\n        switch (attrName) {\n        case 'transform':\n        case 'gradientTransform':\n        case 'patternTransform': {\n          const val = attr.value.replace(/(\\d)-/g, '$1 -');\n          node.setAttribute(attrName, val);\n          break;\n        }\n        }\n      }\n\n      // For the style attribute, rewrite it in terms of XML presentational attributes\n      if (attrName === 'style') {\n        const props = attr.value.split(';');\n        let p = props.length;\n        while (p--) {\n          const [name, val] = props[p].split(':');\n          const styleAttrName = (name || '').trim();\n          const styleAttrVal = (val || '').trim();\n          // Now check that this attribute is supported\n          if (allowedAttrs.includes(styleAttrName)) {\n            node.setAttribute(styleAttrName, styleAttrVal);\n          }\n        }\n        node.removeAttribute('style');\n      }\n    }\n\n    Object.values(seAttrs).forEach(([att, val]) => {\n      node.setAttributeNS(NS.SE, att, val);\n    });\n\n    // for some elements that have a xlink:href, ensure the URI refers to a local element\n    // (but not for links)\n    const href = getHref(node);\n    if (href &&\n      ['filter', 'linearGradient', 'pattern',\n        'radialGradient', 'textPath', 'use'].includes(node.nodeName)) {\n      // TODO: we simply check if the first character is a #, is this bullet-proof?\n      if (href[0] !== '#') {\n        // remove the attribute (but keep the element)\n        setHref(node, '');\n        node.removeAttributeNS(NS.XLINK, 'href');\n      }\n    }\n\n    // Safari crashes on a <use> without a xlink:href, so we just remove the node here\n    if (node.nodeName === 'use' && !getHref(node)) {\n      node.remove();\n      return;\n    }\n    // if the element has attributes pointing to a non-local reference,\n    // need to remove the attribute\n    Object.values(['clip-path', 'fill', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'stroke'], function (attr) {\n      let val = node.getAttribute(attr);\n      if (val) {\n        val = getUrlFromAttr(val);\n        // simply check for first character being a '#'\n        if (val && val[0] !== '#') {\n          node.setAttribute(attr, '');\n          node.removeAttribute(attr);\n        }\n      }\n    });\n\n    // recurse to children\n    i = node.childNodes.length;\n    while (i--) { sanitizeSvg(node.childNodes.item(i)); }\n  // else (element not supported), remove it\n  } else {\n    // remove all children from this node and insert them before this node\n    // FIXME: in the case of animation elements this will hardly ever be correct\n    const children = [];\n    while (node.hasChildNodes()) {\n      children.push(parent.insertBefore(node.firstChild, node));\n    }\n\n    // remove this node from the document altogether\n    node.remove();\n\n    // call sanitizeSvg on each of those children\n    let i = children.length;\n    while (i--) { sanitizeSvg(children[i]); }\n  }\n};\n","// MIT License\n// From: https://github.com/uupaa/dynamic-import-polyfill/blob/master/importModule.js\n\n/**\n * @module importModule\n */\n\n/**\n * Converts a possible relative URL into an absolute one.\n * @param {string} url\n * @returns {string}\n */\nfunction toAbsoluteURL (url) {\n  const a = document.createElement('a');\n  a.setAttribute('href', url); // <a href=\"hoge.html\">\n  return a.cloneNode(false).href; // -> \"http://example.com/hoge.html\"\n}\n\n/**\n * Add any of the whitelisted attributes to the script tag.\n * @param {HTMLScriptElement} script\n * @param {PlainObject.<string, string>} atts\n * @returns {undefined}\n */\nfunction addScriptAtts (script, atts) {\n  ['id', 'class', 'type'].forEach((prop) => {\n    if (prop in atts) {\n      script[prop] = atts[prop];\n    }\n  });\n}\n\n// Additions by Brett\n/**\n* @typedef {PlainObject} module:importModule.ImportConfig\n* @property {string} global The variable name to set on `window` (when not using the modular version)\n* @property {boolean} [returnDefault=false]\n*/\n/**\n* @function module:importModule.importSetGlobalDefault\n* @param {string|string[]} url\n* @param {module:importModule.ImportConfig} config\n* @returns {Promise} The value to which it resolves depends on the export of the targeted module.\n*/\nexport function importSetGlobalDefault (url, config) {\n  return importSetGlobal(url, {...config, returnDefault: true});\n}\n/**\n* @function module:importModule.importSetGlobal\n* @param {string|string[]} url\n* @param {module:importModule.ImportConfig} config\n* @returns {Promise} The promise resolves to either an `ArbitraryModule` or\n*   any other value depends on the export of the targeted module.\n*/\nexport async function importSetGlobal (url, {global: glob, returnDefault}) {\n  // Todo: Replace calls to this function with `import()` when supported\n  const modularVersion = !('svgEditor' in window) ||\n    !window.svgEditor ||\n    window.svgEditor.modules !== false;\n  if (modularVersion) {\n    return importModule(url, undefined, {returnDefault});\n  }\n  await importScript(url);\n  return window[glob];\n}\n/**\n *\n * @author Brett Zamir (other items are from `dynamic-import-polyfill`)\n * @param {string|string[]} url\n * @param {PlainObject} [atts={}]\n * @returns {Promise} Resolves to `undefined` or rejects with an `Error` upon a\n *   script loading error\n */\nexport function importScript (url, atts = {}) {\n  if (Array.isArray(url)) {\n    return Promise.all(url.map((u) => {\n      return importScript(u, atts);\n    }));\n  }\n  return new Promise((resolve, reject) => { // eslint-disable-line promise/avoid-new\n    const script = document.createElement('script');\n    /**\n     *\n     * @returns {undefined}\n     */\n    function scriptOnError () {\n      reject(new Error(`Failed to import: ${url}`));\n      destructor();\n    }\n    /**\n     *\n     * @returns {undefined}\n     */\n    function scriptOnLoad () {\n      resolve();\n      destructor();\n    }\n    const destructor = () => {\n      script.removeEventListener('error', scriptOnError);\n      script.removeEventListener('load', scriptOnLoad);\n      script.remove();\n      script.src = '';\n    };\n    script.defer = 'defer';\n    addScriptAtts(script, atts);\n    script.addEventListener('error', scriptOnError);\n    script.addEventListener('load', scriptOnLoad);\n    script.src = url;\n\n    document.head.append(script);\n  });\n}\n\n/**\n *\n * @param {string|string[]} url\n * @param {PlainObject} [atts={}]\n * @param {PlainObject} opts\n * @param {boolean} [opts.returnDefault=false} = {}]\n * @returns {Promise} Resolves to value of loading module or rejects with\n *   `Error` upon a script loading error.\n */\nexport function importModule (url, atts = {}, {returnDefault = false} = {}) {\n  if (Array.isArray(url)) {\n    return Promise.all(url.map((u) => {\n      return importModule(u, atts);\n    }));\n  }\n  return new Promise((resolve, reject) => { // eslint-disable-line promise/avoid-new\n    const vector = '$importModule$' + Math.random().toString(32).slice(2);\n    const script = document.createElement('script');\n    /**\n     *\n     * @returns {undefined}\n     */\n    function scriptOnError () {\n      reject(new Error(`Failed to import: ${url}`));\n      destructor();\n    }\n    /**\n     *\n     * @returns {undefined}\n     */\n    function scriptOnLoad () {\n      resolve(window[vector]);\n      destructor();\n    }\n    const destructor = () => {\n      delete window[vector];\n      script.removeEventListener('error', scriptOnError);\n      script.removeEventListener('load', scriptOnLoad);\n      script.remove();\n      URL.revokeObjectURL(script.src);\n      script.src = '';\n    };\n    addScriptAtts(script, atts);\n    script.defer = 'defer';\n    script.type = 'module';\n    script.addEventListener('error', scriptOnError);\n    script.addEventListener('load', scriptOnLoad);\n    const absURL = toAbsoluteURL(url);\n    const loader = `import * as m from '${absURL.replace(/'/g, \"\\\\'\")}'; window.${vector} = ${returnDefault ? 'm.default || ' : ''}m;`; // export Module\n    const blob = new Blob([loader], {type: 'text/javascript'});\n    script.src = URL.createObjectURL(blob);\n\n    document.head.append(script);\n  });\n}\n\nexport default importModule;\n","/* globals jQuery */\n/**\n * Manipulating coordinates\n * @module coords\n * @license MIT\n */\n\nimport './svgpathseg.js';\nimport {\n  snapToGrid, assignAttributes, getBBox, getRefElem, findDefs\n} from './utilities.js';\nimport {\n  transformPoint, transformListToTransform, matrixMultiply, transformBox\n} from './math.js';\nimport {getTransformList} from './svgtransformlist.js';\n\nconst $ = jQuery;\n\n// this is how we map paths to our preferred relative segment types\nconst pathMap = [\n  0, 'z', 'M', 'm', 'L', 'l', 'C', 'c', 'Q', 'q', 'A', 'a',\n  'H', 'h', 'V', 'v', 'S', 's', 'T', 't'\n];\n\n/**\n * @interface module:coords.EditorContext\n */\n/**\n * @function module:coords.EditorContext#getGridSnapping\n * @returns {boolean}\n */\n/**\n * @function module:coords.EditorContext#getDrawing\n * @returns {module:draw.Drawing}\n*/\n/**\n * @function module:coords.EditorContext#getSVGRoot\n * @returns {SVGSVGElement}\n*/\n\nlet editorContext_ = null;\n\n/**\n* @function module:coords.init\n* @param {module:coords.EditorContext} editorContext\n* @returns {undefined}\n*/\nexport const init = function (editorContext) {\n  editorContext_ = editorContext;\n};\n\n/**\n * Applies coordinate changes to an element based on the given matrix.\n * @function module:coords.remapElement\n * @implements {module:path.EditorContext#remapElement}\n*/\nexport const remapElement = function (selected, changes, m) {\n  const remap = function (x, y) { return transformPoint(x, y, m); },\n    scalew = function (w) { return m.a * w; },\n    scaleh = function (h) { return m.d * h; },\n    doSnapping = editorContext_.getGridSnapping() && selected.parentNode.parentNode.localName === 'svg',\n    finishUp = function () {\n      if (doSnapping) {\n        Object.entries(changes).forEach(([o, value]) => {\n          changes[o] = snapToGrid(value);\n        });\n      }\n      assignAttributes(selected, changes, 1000, true);\n    },\n    box = getBBox(selected);\n\n  for (let i = 0; i < 2; i++) {\n    const type = i === 0 ? 'fill' : 'stroke';\n    const attrVal = selected.getAttribute(type);\n    if (attrVal && attrVal.startsWith('url(')) {\n      if (m.a < 0 || m.d < 0) {\n        const grad = getRefElem(attrVal);\n        const newgrad = grad.cloneNode(true);\n        if (m.a < 0) {\n          // flip x\n          const x1 = newgrad.getAttribute('x1');\n          const x2 = newgrad.getAttribute('x2');\n          newgrad.setAttribute('x1', -(x1 - 1));\n          newgrad.setAttribute('x2', -(x2 - 1));\n        }\n\n        if (m.d < 0) {\n          // flip y\n          const y1 = newgrad.getAttribute('y1');\n          const y2 = newgrad.getAttribute('y2');\n          newgrad.setAttribute('y1', -(y1 - 1));\n          newgrad.setAttribute('y2', -(y2 - 1));\n        }\n        newgrad.id = editorContext_.getDrawing().getNextId();\n        findDefs().append(newgrad);\n        selected.setAttribute(type, 'url(#' + newgrad.id + ')');\n      }\n\n      // Not really working :(\n      // if (selected.tagName === 'path') {\n      //   reorientGrads(selected, m);\n      // }\n    }\n  }\n\n  const elName = selected.tagName;\n  if (elName === 'g' || elName === 'text' || elName === 'tspan' || elName === 'use') {\n    // if it was a translate, then just update x,y\n    if (m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && (m.e !== 0 || m.f !== 0)) {\n      // [T][M] = [M][T']\n      // therefore [T'] = [M_inv][T][M]\n      const existing = transformListToTransform(selected).matrix,\n        tNew = matrixMultiply(existing.inverse(), m, existing);\n      changes.x = parseFloat(changes.x) + tNew.e;\n      changes.y = parseFloat(changes.y) + tNew.f;\n    } else {\n      // we just absorb all matrices into the element and don't do any remapping\n      const chlist = getTransformList(selected);\n      const mt = editorContext_.getSVGRoot().createSVGTransform();\n      mt.setMatrix(matrixMultiply(transformListToTransform(chlist).matrix, m));\n      chlist.clear();\n      chlist.appendItem(mt);\n    }\n  }\n\n  // now we have a set of changes and an applied reduced transform list\n  // we apply the changes directly to the DOM\n  switch (elName) {\n  case 'foreignObject':\n  case 'rect':\n  case 'image': {\n    // Allow images to be inverted (give them matrix when flipped)\n    if (elName === 'image' && (m.a < 0 || m.d < 0)) {\n      // Convert to matrix\n      const chlist = getTransformList(selected);\n      const mt = editorContext_.getSVGRoot().createSVGTransform();\n      mt.setMatrix(matrixMultiply(transformListToTransform(chlist).matrix, m));\n      chlist.clear();\n      chlist.appendItem(mt);\n    } else {\n      const pt1 = remap(changes.x, changes.y);\n      changes.width = scalew(changes.width);\n      changes.height = scaleh(changes.height);\n      changes.x = pt1.x + Math.min(0, changes.width);\n      changes.y = pt1.y + Math.min(0, changes.height);\n      changes.width = Math.abs(changes.width);\n      changes.height = Math.abs(changes.height);\n    }\n    finishUp();\n    break;\n  } case 'ellipse': {\n    const c = remap(changes.cx, changes.cy);\n    changes.cx = c.x;\n    changes.cy = c.y;\n    changes.rx = scalew(changes.rx);\n    changes.ry = scaleh(changes.ry);\n    changes.rx = Math.abs(changes.rx);\n    changes.ry = Math.abs(changes.ry);\n    finishUp();\n    break;\n  } case 'circle': {\n    const c = remap(changes.cx, changes.cy);\n    changes.cx = c.x;\n    changes.cy = c.y;\n    // take the minimum of the new selected box's dimensions for the new circle radius\n    const tbox = transformBox(box.x, box.y, box.width, box.height, m);\n    const w = tbox.tr.x - tbox.tl.x, h = tbox.bl.y - tbox.tl.y;\n    changes.r = Math.min(w / 2, h / 2);\n\n    if (changes.r) { changes.r = Math.abs(changes.r); }\n    finishUp();\n    break;\n  } case 'line': {\n    const pt1 = remap(changes.x1, changes.y1);\n    const pt2 = remap(changes.x2, changes.y2);\n    changes.x1 = pt1.x;\n    changes.y1 = pt1.y;\n    changes.x2 = pt2.x;\n    changes.y2 = pt2.y;\n  } // Fallthrough\n  case 'text':\n  case 'tspan':\n  case 'use': {\n    finishUp();\n    break;\n  } case 'g': {\n    const gsvg = $(selected).data('gsvg');\n    if (gsvg) {\n      assignAttributes(gsvg, changes, 1000, true);\n    }\n    break;\n  } case 'polyline':\n  case 'polygon': {\n    const len = changes.points.length;\n    for (let i = 0; i < len; ++i) {\n      const pt = changes.points[i];\n      const {x, y} = remap(pt.x, pt.y);\n      changes.points[i].x = x;\n      changes.points[i].y = y;\n    }\n\n    // const len = changes.points.length;\n    let pstr = '';\n    for (let i = 0; i < len; ++i) {\n      const pt = changes.points[i];\n      pstr += pt.x + ',' + pt.y + ' ';\n    }\n    selected.setAttribute('points', pstr);\n    break;\n  } case 'path': {\n    const segList = selected.pathSegList;\n    let len = segList.numberOfItems;\n    changes.d = [];\n    for (let i = 0; i < len; ++i) {\n      const seg = segList.getItem(i);\n      changes.d[i] = {\n        type: seg.pathSegType,\n        x: seg.x,\n        y: seg.y,\n        x1: seg.x1,\n        y1: seg.y1,\n        x2: seg.x2,\n        y2: seg.y2,\n        r1: seg.r1,\n        r2: seg.r2,\n        angle: seg.angle,\n        largeArcFlag: seg.largeArcFlag,\n        sweepFlag: seg.sweepFlag\n      };\n    }\n\n    len = changes.d.length;\n    const firstseg = changes.d[0],\n      currentpt = remap(firstseg.x, firstseg.y);\n    changes.d[0].x = currentpt.x;\n    changes.d[0].y = currentpt.y;\n    for (let i = 1; i < len; ++i) {\n      const seg = changes.d[i];\n      const {type} = seg;\n      // if absolute or first segment, we want to remap x, y, x1, y1, x2, y2\n      // if relative, we want to scalew, scaleh\n      if (type % 2 === 0) { // absolute\n        const thisx = (seg.x !== undefined) ? seg.x : currentpt.x, // for V commands\n          thisy = (seg.y !== undefined) ? seg.y : currentpt.y; // for H commands\n        const pt = remap(thisx, thisy);\n        const pt1 = remap(seg.x1, seg.y1);\n        const pt2 = remap(seg.x2, seg.y2);\n        seg.x = pt.x;\n        seg.y = pt.y;\n        seg.x1 = pt1.x;\n        seg.y1 = pt1.y;\n        seg.x2 = pt2.x;\n        seg.y2 = pt2.y;\n        seg.r1 = scalew(seg.r1);\n        seg.r2 = scaleh(seg.r2);\n      } else { // relative\n        seg.x = scalew(seg.x);\n        seg.y = scaleh(seg.y);\n        seg.x1 = scalew(seg.x1);\n        seg.y1 = scaleh(seg.y1);\n        seg.x2 = scalew(seg.x2);\n        seg.y2 = scaleh(seg.y2);\n        seg.r1 = scalew(seg.r1);\n        seg.r2 = scaleh(seg.r2);\n      }\n    } // for each segment\n\n    let dstr = '';\n    len = changes.d.length;\n    for (let i = 0; i < len; ++i) {\n      const seg = changes.d[i];\n      const {type} = seg;\n      dstr += pathMap[type];\n      switch (type) {\n      case 13: // relative horizontal line (h)\n      case 12: // absolute horizontal line (H)\n        dstr += seg.x + ' ';\n        break;\n      case 15: // relative vertical line (v)\n      case 14: // absolute vertical line (V)\n        dstr += seg.y + ' ';\n        break;\n      case 3: // relative move (m)\n      case 5: // relative line (l)\n      case 19: // relative smooth quad (t)\n      case 2: // absolute move (M)\n      case 4: // absolute line (L)\n      case 18: // absolute smooth quad (T)\n        dstr += seg.x + ',' + seg.y + ' ';\n        break;\n      case 7: // relative cubic (c)\n      case 6: // absolute cubic (C)\n        dstr += seg.x1 + ',' + seg.y1 + ' ' + seg.x2 + ',' + seg.y2 + ' ' +\n          seg.x + ',' + seg.y + ' ';\n        break;\n      case 9: // relative quad (q)\n      case 8: // absolute quad (Q)\n        dstr += seg.x1 + ',' + seg.y1 + ' ' + seg.x + ',' + seg.y + ' ';\n        break;\n      case 11: // relative elliptical arc (a)\n      case 10: // absolute elliptical arc (A)\n        dstr += seg.r1 + ',' + seg.r2 + ' ' + seg.angle + ' ' + Number(seg.largeArcFlag) +\n          ' ' + Number(seg.sweepFlag) + ' ' + seg.x + ',' + seg.y + ' ';\n        break;\n      case 17: // relative smooth cubic (s)\n      case 16: // absolute smooth cubic (S)\n        dstr += seg.x2 + ',' + seg.y2 + ' ' + seg.x + ',' + seg.y + ' ';\n        break;\n      }\n    }\n\n    selected.setAttribute('d', dstr);\n    break;\n  }\n  }\n};\n","/* globals jQuery */\n/**\n * Recalculate.\n * @module recalculate\n * @license MIT\n */\n\nimport jQueryPluginSVG from './jQuery.attr.js'; // Needed for SVG attribute setting and array form with `attr`\nimport {NS} from './namespaces.js';\nimport {convertToNum} from './units.js';\nimport {isWebkit} from './browser.js';\nimport {getTransformList} from './svgtransformlist.js';\nimport {getRotationAngle, getHref, getBBox, getRefElem, isNullish} from './utilities.js';\nimport {BatchCommand, ChangeElementCommand} from './history.js';\nimport {remapElement} from './coords.js';\nimport {\n  isIdentity, matrixMultiply, transformPoint, transformListToTransform,\n  hasMatrixTransform\n} from './math.js';\n\nconst $ = jQueryPluginSVG(jQuery);\n\nlet context_;\n\n/**\n* @interface module:recalculate.EditorContext\n*/\n/**\n * @function module:recalculate.EditorContext#getSVGRoot\n * @returns {SVGSVGElement} The root DOM element\n */\n/**\n * @function module:recalculate.EditorContext#getStartTransform\n * @returns {string}\n*/\n/**\n * @function module:recalculate.EditorContext#setStartTransform\n * @param {string} transform\n * @returns {undefined}\n */\n\n/**\n* @function module:recalculate.init\n* @param {module:recalculate.EditorContext} editorContext\n* @returns {undefined}\n*/\nexport const init = function (editorContext) {\n  context_ = editorContext;\n};\n\n/**\n* Updates a `<clipPath>`s values based on the given translation of an element.\n* @function module:recalculate.updateClipPath\n* @param {string} attr - The clip-path attribute value with the clipPath's ID\n* @param {Float} tx - The translation's x value\n* @param {Float} ty - The translation's y value\n* @returns {undefined}\n*/\nexport const updateClipPath = function (attr, tx, ty) {\n  const path = getRefElem(attr).firstChild;\n  const cpXform = getTransformList(path);\n  const newxlate = context_.getSVGRoot().createSVGTransform();\n  newxlate.setTranslate(tx, ty);\n\n  cpXform.appendItem(newxlate);\n\n  // Update clipPath's dimensions\n  recalculateDimensions(path);\n};\n\n/**\n* Decides the course of action based on the element's transform list.\n* @function module:recalculate.recalculateDimensions\n* @param {Element} selected - The DOM element to recalculate\n* @returns {Command} Undo command object with the resulting change\n*/\nexport const recalculateDimensions = function (selected) {\n  if (isNullish(selected)) { return null; }\n\n  // Firefox Issue - 1081\n  if (selected.nodeName === 'svg' && navigator.userAgent.includes('Firefox/20')) {\n    return null;\n  }\n\n  const svgroot = context_.getSVGRoot();\n  const tlist = getTransformList(selected);\n\n  // remove any unnecessary transforms\n  if (tlist && tlist.numberOfItems > 0) {\n    let k = tlist.numberOfItems;\n    const noi = k;\n    while (k--) {\n      const xform = tlist.getItem(k);\n      if (xform.type === 0) {\n        tlist.removeItem(k);\n      // remove identity matrices\n      } else if (xform.type === 1) {\n        if (isIdentity(xform.matrix)) {\n          if (noi === 1) {\n            // Overcome Chrome bug (though only when noi is 1) with\n            //    `removeItem` preventing `removeAttribute` from\n            //    subsequently working\n            // See https://bugs.chromium.org/p/chromium/issues/detail?id=843901\n            selected.removeAttribute('transform');\n            return null;\n          }\n          tlist.removeItem(k);\n        }\n      // remove zero-degree rotations\n      } else if (xform.type === 4) {\n        if (xform.angle === 0) {\n          tlist.removeItem(k);\n        }\n      }\n    }\n    // End here if all it has is a rotation\n    if (tlist.numberOfItems === 1 &&\n        getRotationAngle(selected)) { return null; }\n  }\n\n  // if this element had no transforms, we are done\n  if (!tlist || tlist.numberOfItems === 0) {\n    // Chrome apparently had a bug that requires clearing the attribute first.\n    selected.setAttribute('transform', '');\n    // However, this still next line currently doesn't work at all in Chrome\n    selected.removeAttribute('transform');\n    // selected.transform.baseVal.clear(); // Didn't help for Chrome bug\n    return null;\n  }\n\n  // TODO: Make this work for more than 2\n  if (tlist) {\n    let mxs = [];\n    let k = tlist.numberOfItems;\n    while (k--) {\n      const xform = tlist.getItem(k);\n      if (xform.type === 1) {\n        mxs.push([xform.matrix, k]);\n      } else if (mxs.length) {\n        mxs = [];\n      }\n    }\n    if (mxs.length === 2) {\n      const mNew = svgroot.createSVGTransformFromMatrix(matrixMultiply(mxs[1][0], mxs[0][0]));\n      tlist.removeItem(mxs[0][1]);\n      tlist.removeItem(mxs[1][1]);\n      tlist.insertItemBefore(mNew, mxs[1][1]);\n    }\n\n    // combine matrix + translate\n    k = tlist.numberOfItems;\n    if (k >= 2 && tlist.getItem(k - 2).type === 1 && tlist.getItem(k - 1).type === 2) {\n      const mt = svgroot.createSVGTransform();\n\n      const m = matrixMultiply(\n        tlist.getItem(k - 2).matrix,\n        tlist.getItem(k - 1).matrix\n      );\n      mt.setMatrix(m);\n      tlist.removeItem(k - 2);\n      tlist.removeItem(k - 2);\n      tlist.appendItem(mt);\n    }\n  }\n\n  // If it still has a single [M] or [R][M], return null too (prevents BatchCommand from being returned).\n  switch (selected.tagName) {\n  // Ignore these elements, as they can absorb the [M]\n  case 'line':\n  case 'polyline':\n  case 'polygon':\n  case 'path':\n    break;\n  default:\n    if ((tlist.numberOfItems === 1 && tlist.getItem(0).type === 1) ||\n        (tlist.numberOfItems === 2 && tlist.getItem(0).type === 1 && tlist.getItem(0).type === 4)) {\n      return null;\n    }\n  }\n\n  // Grouped SVG element\n  const gsvg = $(selected).data('gsvg');\n\n  // we know we have some transforms, so set up return variable\n  const batchCmd = new BatchCommand('Transform');\n\n  // store initial values that will be affected by reducing the transform list\n  let changes = {};\n  let initial = null;\n  let attrs = [];\n  switch (selected.tagName) {\n  case 'line':\n    attrs = ['x1', 'y1', 'x2', 'y2'];\n    break;\n  case 'circle':\n    attrs = ['cx', 'cy', 'r'];\n    break;\n  case 'ellipse':\n    attrs = ['cx', 'cy', 'rx', 'ry'];\n    break;\n  case 'foreignObject':\n  case 'rect':\n  case 'image':\n    attrs = ['width', 'height', 'x', 'y'];\n    break;\n  case 'use':\n  case 'text':\n  case 'tspan':\n    attrs = ['x', 'y'];\n    break;\n  case 'polygon':\n  case 'polyline': {\n    initial = {};\n    initial.points = selected.getAttribute('points');\n    const list = selected.points;\n    const len = list.numberOfItems;\n    changes.points = new Array(len);\n    for (let i = 0; i < len; ++i) {\n      const pt = list.getItem(i);\n      changes.points[i] = {x: pt.x, y: pt.y};\n    }\n    break;\n  } case 'path':\n    initial = {};\n    initial.d = selected.getAttribute('d');\n    changes.d = selected.getAttribute('d');\n    break;\n  } // switch on element type to get initial values\n\n  if (attrs.length) {\n    changes = $(selected).attr(attrs);\n    $.each(changes, function (attr, val) {\n      changes[attr] = convertToNum(attr, val);\n    });\n  } else if (gsvg) {\n    // GSVG exception\n    changes = {\n      x: $(gsvg).attr('x') || 0,\n      y: $(gsvg).attr('y') || 0\n    };\n  }\n\n  // if we haven't created an initial array in polygon/polyline/path, then\n  // make a copy of initial values and include the transform\n  if (isNullish(initial)) {\n    initial = $.extend(true, {}, changes);\n    $.each(initial, function (attr, val) {\n      initial[attr] = convertToNum(attr, val);\n    });\n  }\n  // save the start transform value too\n  initial.transform = context_.getStartTransform() || '';\n\n  let oldcenter, newcenter;\n\n  // if it's a regular group, we have special processing to flatten transforms\n  if ((selected.tagName === 'g' && !gsvg) || selected.tagName === 'a') {\n    const box = getBBox(selected);\n\n    oldcenter = {x: box.x + box.width / 2, y: box.y + box.height / 2};\n    newcenter = transformPoint(\n      box.x + box.width / 2,\n      box.y + box.height / 2,\n      transformListToTransform(tlist).matrix\n    );\n    // let m = svgroot.createSVGMatrix();\n\n    // temporarily strip off the rotate and save the old center\n    const gangle = getRotationAngle(selected);\n    if (gangle) {\n      const a = gangle * Math.PI / 180;\n      let s;\n      if (Math.abs(a) > (1.0e-10)) {\n        s = Math.sin(a) / (1 - Math.cos(a));\n      } else {\n        // FIXME: This blows up if the angle is exactly 0!\n        s = 2 / a;\n      }\n      for (let i = 0; i < tlist.numberOfItems; ++i) {\n        const xform = tlist.getItem(i);\n        if (xform.type === 4) {\n          // extract old center through mystical arts\n          const rm = xform.matrix;\n          oldcenter.y = (s * rm.e + rm.f) / 2;\n          oldcenter.x = (rm.e - s * rm.f) / 2;\n          tlist.removeItem(i);\n          break;\n        }\n      }\n    }\n    const N = tlist.numberOfItems;\n    let tx = 0, ty = 0, operation = 0;\n\n    let firstM;\n    if (N) {\n      firstM = tlist.getItem(0).matrix;\n    }\n\n    let oldStartTransform;\n    // first, if it was a scale then the second-last transform will be it\n    if (N >= 3 && tlist.getItem(N - 2).type === 3 &&\n      tlist.getItem(N - 3).type === 2 && tlist.getItem(N - 1).type === 2) {\n      operation = 3; // scale\n\n      // if the children are unrotated, pass the scale down directly\n      // otherwise pass the equivalent matrix() down directly\n      const tm = tlist.getItem(N - 3).matrix,\n        sm = tlist.getItem(N - 2).matrix,\n        tmn = tlist.getItem(N - 1).matrix;\n\n      const children = selected.childNodes;\n      let c = children.length;\n      while (c--) {\n        const child = children.item(c);\n        tx = 0;\n        ty = 0;\n        if (child.nodeType === 1) {\n          const childTlist = getTransformList(child);\n\n          // some children might not have a transform (<metadata>, <defs>, etc)\n          if (!childTlist) { continue; }\n\n          const m = transformListToTransform(childTlist).matrix;\n\n          // Convert a matrix to a scale if applicable\n          // if (hasMatrixTransform(childTlist) && childTlist.numberOfItems == 1) {\n          //   if (m.b==0 && m.c==0 && m.e==0 && m.f==0) {\n          //     childTlist.removeItem(0);\n          //     const translateOrigin = svgroot.createSVGTransform(),\n          //       scale = svgroot.createSVGTransform(),\n          //       translateBack = svgroot.createSVGTransform();\n          //     translateOrigin.setTranslate(0, 0);\n          //     scale.setScale(m.a, m.d);\n          //     translateBack.setTranslate(0, 0);\n          //     childTlist.appendItem(translateBack);\n          //     childTlist.appendItem(scale);\n          //     childTlist.appendItem(translateOrigin);\n          //   }\n          // }\n\n          const angle = getRotationAngle(child);\n          oldStartTransform = context_.getStartTransform();\n          const childxforms = [];\n          context_.setStartTransform(child.getAttribute('transform'));\n          if (angle || hasMatrixTransform(childTlist)) {\n            const e2t = svgroot.createSVGTransform();\n            e2t.setMatrix(matrixMultiply(tm, sm, tmn, m));\n            childTlist.clear();\n            childTlist.appendItem(e2t);\n            childxforms.push(e2t);\n          // if not rotated or skewed, push the [T][S][-T] down to the child\n          } else {\n            // update the transform list with translate,scale,translate\n\n            // slide the [T][S][-T] from the front to the back\n            // [T][S][-T][M] = [M][T2][S2][-T2]\n\n            // (only bringing [-T] to the right of [M])\n            // [T][S][-T][M] = [T][S][M][-T2]\n            // [-T2] = [M_inv][-T][M]\n            const t2n = matrixMultiply(m.inverse(), tmn, m);\n            // [T2] is always negative translation of [-T2]\n            const t2 = svgroot.createSVGMatrix();\n            t2.e = -t2n.e;\n            t2.f = -t2n.f;\n\n            // [T][S][-T][M] = [M][T2][S2][-T2]\n            // [S2] = [T2_inv][M_inv][T][S][-T][M][-T2_inv]\n            const s2 = matrixMultiply(t2.inverse(), m.inverse(), tm, sm, tmn, m, t2n.inverse());\n\n            const translateOrigin = svgroot.createSVGTransform(),\n              scale = svgroot.createSVGTransform(),\n              translateBack = svgroot.createSVGTransform();\n            translateOrigin.setTranslate(t2n.e, t2n.f);\n            scale.setScale(s2.a, s2.d);\n            translateBack.setTranslate(t2.e, t2.f);\n            childTlist.appendItem(translateBack);\n            childTlist.appendItem(scale);\n            childTlist.appendItem(translateOrigin);\n            childxforms.push(translateBack);\n            childxforms.push(scale);\n            childxforms.push(translateOrigin);\n            // logMatrix(translateBack.matrix);\n            // logMatrix(scale.matrix);\n          } // not rotated\n          batchCmd.addSubCommand(recalculateDimensions(child));\n          // TODO: If any <use> have this group as a parent and are\n          // referencing this child, then we need to impose a reverse\n          // scale on it so that when it won't get double-translated\n          // const uses = selected.getElementsByTagNameNS(NS.SVG, 'use');\n          // const href = '#' + child.id;\n          // let u = uses.length;\n          // while (u--) {\n          //   const useElem = uses.item(u);\n          //   if (href == getHref(useElem)) {\n          //     const usexlate = svgroot.createSVGTransform();\n          //     usexlate.setTranslate(-tx,-ty);\n          //     getTransformList(useElem).insertItemBefore(usexlate,0);\n          //     batchCmd.addSubCommand( recalculateDimensions(useElem) );\n          //   }\n          // }\n          context_.setStartTransform(oldStartTransform);\n        } // element\n      } // for each child\n      // Remove these transforms from group\n      tlist.removeItem(N - 1);\n      tlist.removeItem(N - 2);\n      tlist.removeItem(N - 3);\n    } else if (N >= 3 && tlist.getItem(N - 1).type === 1) {\n      operation = 3; // scale\n      const m = transformListToTransform(tlist).matrix;\n      const e2t = svgroot.createSVGTransform();\n      e2t.setMatrix(m);\n      tlist.clear();\n      tlist.appendItem(e2t);\n    // next, check if the first transform was a translate\n    // if we had [ T1 ] [ M ] we want to transform this into [ M ] [ T2 ]\n    // therefore [ T2 ] = [ M_inv ] [ T1 ] [ M ]\n    } else if ((N === 1 || (N > 1 && tlist.getItem(1).type !== 3)) &&\n      tlist.getItem(0).type === 2) {\n      operation = 2; // translate\n      const T_M = transformListToTransform(tlist).matrix;\n      tlist.removeItem(0);\n      const mInv = transformListToTransform(tlist).matrix.inverse();\n      const M2 = matrixMultiply(mInv, T_M);\n\n      tx = M2.e;\n      ty = M2.f;\n\n      if (tx !== 0 || ty !== 0) {\n        // we pass the translates down to the individual children\n        const children = selected.childNodes;\n        let c = children.length;\n\n        const clipPathsDone = [];\n        while (c--) {\n          const child = children.item(c);\n          if (child.nodeType === 1) {\n            // Check if child has clip-path\n            if (child.getAttribute('clip-path')) {\n              // tx, ty\n              const attr = child.getAttribute('clip-path');\n              if (!clipPathsDone.includes(attr)) {\n                updateClipPath(attr, tx, ty);\n                clipPathsDone.push(attr);\n              }\n            }\n\n            oldStartTransform = context_.getStartTransform();\n            context_.setStartTransform(child.getAttribute('transform'));\n\n            const childTlist = getTransformList(child);\n            // some children might not have a transform (<metadata>, <defs>, etc)\n            if (childTlist) {\n              const newxlate = svgroot.createSVGTransform();\n              newxlate.setTranslate(tx, ty);\n              if (childTlist.numberOfItems) {\n                childTlist.insertItemBefore(newxlate, 0);\n              } else {\n                childTlist.appendItem(newxlate);\n              }\n              batchCmd.addSubCommand(recalculateDimensions(child));\n              // If any <use> have this group as a parent and are\n              // referencing this child, then impose a reverse translate on it\n              // so that when it won't get double-translated\n              const uses = selected.getElementsByTagNameNS(NS.SVG, 'use');\n              const href = '#' + child.id;\n              let u = uses.length;\n              while (u--) {\n                const useElem = uses.item(u);\n                if (href === getHref(useElem)) {\n                  const usexlate = svgroot.createSVGTransform();\n                  usexlate.setTranslate(-tx, -ty);\n                  getTransformList(useElem).insertItemBefore(usexlate, 0);\n                  batchCmd.addSubCommand(recalculateDimensions(useElem));\n                }\n              }\n              context_.setStartTransform(oldStartTransform);\n            }\n          }\n        }\n        context_.setStartTransform(oldStartTransform);\n      }\n    // else, a matrix imposition from a parent group\n    // keep pushing it down to the children\n    } else if (N === 1 && tlist.getItem(0).type === 1 && !gangle) {\n      operation = 1;\n      const m = tlist.getItem(0).matrix,\n        children = selected.childNodes;\n      let c = children.length;\n      while (c--) {\n        const child = children.item(c);\n        if (child.nodeType === 1) {\n          oldStartTransform = context_.getStartTransform();\n          context_.setStartTransform(child.getAttribute('transform'));\n          const childTlist = getTransformList(child);\n\n          if (!childTlist) { continue; }\n\n          const em = matrixMultiply(m, transformListToTransform(childTlist).matrix);\n          const e2m = svgroot.createSVGTransform();\n          e2m.setMatrix(em);\n          childTlist.clear();\n          childTlist.appendItem(e2m, 0);\n\n          batchCmd.addSubCommand(recalculateDimensions(child));\n          context_.setStartTransform(oldStartTransform);\n\n          // Convert stroke\n          // TODO: Find out if this should actually happen somewhere else\n          const sw = child.getAttribute('stroke-width');\n          if (child.getAttribute('stroke') !== 'none' && !isNaN(sw)) {\n            const avg = (Math.abs(em.a) + Math.abs(em.d)) / 2;\n            child.setAttribute('stroke-width', sw * avg);\n          }\n        }\n      }\n      tlist.clear();\n    // else it was just a rotate\n    } else {\n      if (gangle) {\n        const newRot = svgroot.createSVGTransform();\n        newRot.setRotate(gangle, newcenter.x, newcenter.y);\n        if (tlist.numberOfItems) {\n          tlist.insertItemBefore(newRot, 0);\n        } else {\n          tlist.appendItem(newRot);\n        }\n      }\n      if (tlist.numberOfItems === 0) {\n        selected.removeAttribute('transform');\n      }\n      return null;\n    }\n\n    // if it was a translate, put back the rotate at the new center\n    if (operation === 2) {\n      if (gangle) {\n        newcenter = {\n          x: oldcenter.x + firstM.e,\n          y: oldcenter.y + firstM.f\n        };\n\n        const newRot = svgroot.createSVGTransform();\n        newRot.setRotate(gangle, newcenter.x, newcenter.y);\n        if (tlist.numberOfItems) {\n          tlist.insertItemBefore(newRot, 0);\n        } else {\n          tlist.appendItem(newRot);\n        }\n      }\n    // if it was a resize\n    } else if (operation === 3) {\n      const m = transformListToTransform(tlist).matrix;\n      const roldt = svgroot.createSVGTransform();\n      roldt.setRotate(gangle, oldcenter.x, oldcenter.y);\n      const rold = roldt.matrix;\n      const rnew = svgroot.createSVGTransform();\n      rnew.setRotate(gangle, newcenter.x, newcenter.y);\n      const rnewInv = rnew.matrix.inverse(),\n        mInv = m.inverse(),\n        extrat = matrixMultiply(mInv, rnewInv, rold, m);\n\n      tx = extrat.e;\n      ty = extrat.f;\n\n      if (tx !== 0 || ty !== 0) {\n        // now push this transform down to the children\n        // we pass the translates down to the individual children\n        const children = selected.childNodes;\n        let c = children.length;\n        while (c--) {\n          const child = children.item(c);\n          if (child.nodeType === 1) {\n            oldStartTransform = context_.getStartTransform();\n            context_.setStartTransform(child.getAttribute('transform'));\n            const childTlist = getTransformList(child);\n            const newxlate = svgroot.createSVGTransform();\n            newxlate.setTranslate(tx, ty);\n            if (childTlist.numberOfItems) {\n              childTlist.insertItemBefore(newxlate, 0);\n            } else {\n              childTlist.appendItem(newxlate);\n            }\n\n            batchCmd.addSubCommand(recalculateDimensions(child));\n            context_.setStartTransform(oldStartTransform);\n          }\n        }\n      }\n\n      if (gangle) {\n        if (tlist.numberOfItems) {\n          tlist.insertItemBefore(rnew, 0);\n        } else {\n          tlist.appendItem(rnew);\n        }\n      }\n    }\n  // else, it's a non-group\n  } else {\n    // FIXME: box might be null for some elements (<metadata> etc), need to handle this\n    const box = getBBox(selected);\n\n    // Paths (and possbly other shapes) will have no BBox while still in <defs>,\n    // but we still may need to recalculate them (see issue 595).\n    // TODO: Figure out how to get BBox from these elements in case they\n    // have a rotation transform\n\n    if (!box && selected.tagName !== 'path') return null;\n\n    let m; // = svgroot.createSVGMatrix();\n    // temporarily strip off the rotate and save the old center\n    const angle = getRotationAngle(selected);\n    if (angle) {\n      oldcenter = {x: box.x + box.width / 2, y: box.y + box.height / 2};\n      newcenter = transformPoint(\n        box.x + box.width / 2,\n        box.y + box.height / 2,\n        transformListToTransform(tlist).matrix\n      );\n\n      const a = angle * Math.PI / 180;\n      const s = (Math.abs(a) > (1.0e-10))\n        ? Math.sin(a) / (1 - Math.cos(a))\n        // FIXME: This blows up if the angle is exactly 0!\n        : 2 / a;\n\n      for (let i = 0; i < tlist.numberOfItems; ++i) {\n        const xform = tlist.getItem(i);\n        if (xform.type === 4) {\n          // extract old center through mystical arts\n          const rm = xform.matrix;\n          oldcenter.y = (s * rm.e + rm.f) / 2;\n          oldcenter.x = (rm.e - s * rm.f) / 2;\n          tlist.removeItem(i);\n          break;\n        }\n      }\n    }\n\n    // 2 = translate, 3 = scale, 4 = rotate, 1 = matrix imposition\n    let operation = 0;\n    const N = tlist.numberOfItems;\n\n    // Check if it has a gradient with userSpaceOnUse, in which case\n    // adjust it by recalculating the matrix transform.\n    // TODO: Make this work in Webkit using transformlist.SVGTransformList\n    if (!isWebkit()) {\n      const fill = selected.getAttribute('fill');\n      if (fill && fill.startsWith('url(')) {\n        const paint = getRefElem(fill);\n        let type = 'pattern';\n        if (paint.tagName !== type) type = 'gradient';\n        const attrVal = paint.getAttribute(type + 'Units');\n        if (attrVal === 'userSpaceOnUse') {\n          // Update the userSpaceOnUse element\n          m = transformListToTransform(tlist).matrix;\n          const gtlist = getTransformList(paint);\n          const gmatrix = transformListToTransform(gtlist).matrix;\n          m = matrixMultiply(m, gmatrix);\n          const mStr = 'matrix(' + [m.a, m.b, m.c, m.d, m.e, m.f].join(',') + ')';\n          paint.setAttribute(type + 'Transform', mStr);\n        }\n      }\n    }\n\n    // first, if it was a scale of a non-skewed element, then the second-last\n    // transform will be the [S]\n    // if we had [M][T][S][T] we want to extract the matrix equivalent of\n    // [T][S][T] and push it down to the element\n    if (N >= 3 && tlist.getItem(N - 2).type === 3 &&\n      tlist.getItem(N - 3).type === 2 && tlist.getItem(N - 1).type === 2) {\n      // Removed this so a <use> with a given [T][S][T] would convert to a matrix.\n      // Is that bad?\n      //  && selected.nodeName != 'use'\n      operation = 3; // scale\n      m = transformListToTransform(tlist, N - 3, N - 1).matrix;\n      tlist.removeItem(N - 1);\n      tlist.removeItem(N - 2);\n      tlist.removeItem(N - 3);\n    // if we had [T][S][-T][M], then this was a skewed element being resized\n    // Thus, we simply combine it all into one matrix\n    } else if (N === 4 && tlist.getItem(N - 1).type === 1) {\n      operation = 3; // scale\n      m = transformListToTransform(tlist).matrix;\n      const e2t = svgroot.createSVGTransform();\n      e2t.setMatrix(m);\n      tlist.clear();\n      tlist.appendItem(e2t);\n      // reset the matrix so that the element is not re-mapped\n      m = svgroot.createSVGMatrix();\n    // if we had [R][T][S][-T][M], then this was a rotated matrix-element\n    // if we had [T1][M] we want to transform this into [M][T2]\n    // therefore [ T2 ] = [ M_inv ] [ T1 ] [ M ] and we can push [T2]\n    // down to the element\n    } else if ((N === 1 || (N > 1 && tlist.getItem(1).type !== 3)) &&\n      tlist.getItem(0).type === 2) {\n      operation = 2; // translate\n      const oldxlate = tlist.getItem(0).matrix,\n        meq = transformListToTransform(tlist, 1).matrix,\n        meqInv = meq.inverse();\n      m = matrixMultiply(meqInv, oldxlate, meq);\n      tlist.removeItem(0);\n    // else if this child now has a matrix imposition (from a parent group)\n    // we might be able to simplify\n    } else if (N === 1 && tlist.getItem(0).type === 1 && !angle) {\n      // Remap all point-based elements\n      m = transformListToTransform(tlist).matrix;\n      switch (selected.tagName) {\n      case 'line':\n        changes = $(selected).attr(['x1', 'y1', 'x2', 'y2']);\n        // Fallthrough\n      case 'polyline':\n      case 'polygon':\n        changes.points = selected.getAttribute('points');\n        if (changes.points) {\n          const list = selected.points;\n          const len = list.numberOfItems;\n          changes.points = new Array(len);\n          for (let i = 0; i < len; ++i) {\n            const pt = list.getItem(i);\n            changes.points[i] = {x: pt.x, y: pt.y};\n          }\n        }\n        // Fallthrough\n      case 'path':\n        changes.d = selected.getAttribute('d');\n        operation = 1;\n        tlist.clear();\n        break;\n      default:\n        break;\n      }\n    // if it was a rotation, put the rotate back and return without a command\n    // (this function has zero work to do for a rotate())\n    } else {\n      // operation = 4; // rotation\n      if (angle) {\n        const newRot = svgroot.createSVGTransform();\n        newRot.setRotate(angle, newcenter.x, newcenter.y);\n\n        if (tlist.numberOfItems) {\n          tlist.insertItemBefore(newRot, 0);\n        } else {\n          tlist.appendItem(newRot);\n        }\n      }\n      if (tlist.numberOfItems === 0) {\n        selected.removeAttribute('transform');\n      }\n      return null;\n    }\n\n    // if it was a translate or resize, we need to remap the element and absorb the xform\n    if (operation === 1 || operation === 2 || operation === 3) {\n      remapElement(selected, changes, m);\n    } // if we are remapping\n\n    // if it was a translate, put back the rotate at the new center\n    if (operation === 2) {\n      if (angle) {\n        if (!hasMatrixTransform(tlist)) {\n          newcenter = {\n            x: oldcenter.x + m.e,\n            y: oldcenter.y + m.f\n          };\n        }\n        const newRot = svgroot.createSVGTransform();\n        newRot.setRotate(angle, newcenter.x, newcenter.y);\n        if (tlist.numberOfItems) {\n          tlist.insertItemBefore(newRot, 0);\n        } else {\n          tlist.appendItem(newRot);\n        }\n      }\n      // We have special processing for tspans:  Tspans are not transformable\n      // but they can have x,y coordinates (sigh).  Thus, if this was a translate,\n      // on a text element, also translate any tspan children.\n      if (selected.tagName === 'text') {\n        const children = selected.childNodes;\n        let c = children.length;\n        while (c--) {\n          const child = children.item(c);\n          if (child.tagName === 'tspan') {\n            const tspanChanges = {\n              x: $(child).attr('x') || 0,\n              y: $(child).attr('y') || 0\n            };\n            remapElement(child, tspanChanges, m);\n          }\n        }\n      }\n    // [Rold][M][T][S][-T] became [Rold][M]\n    // we want it to be [Rnew][M][Tr] where Tr is the\n    // translation required to re-center it\n    // Therefore, [Tr] = [M_inv][Rnew_inv][Rold][M]\n    } else if (operation === 3 && angle) {\n      const {matrix} = transformListToTransform(tlist);\n      const roldt = svgroot.createSVGTransform();\n      roldt.setRotate(angle, oldcenter.x, oldcenter.y);\n      const rold = roldt.matrix;\n      const rnew = svgroot.createSVGTransform();\n      rnew.setRotate(angle, newcenter.x, newcenter.y);\n      const rnewInv = rnew.matrix.inverse();\n      const mInv = matrix.inverse();\n      const extrat = matrixMultiply(mInv, rnewInv, rold, matrix);\n\n      remapElement(selected, changes, extrat);\n      if (angle) {\n        if (tlist.numberOfItems) {\n          tlist.insertItemBefore(rnew, 0);\n        } else {\n          tlist.appendItem(rnew);\n        }\n      }\n    }\n  } // a non-group\n\n  // if the transform list has been emptied, remove it\n  if (tlist.numberOfItems === 0) {\n    selected.removeAttribute('transform');\n  }\n\n  batchCmd.addSubCommand(new ChangeElementCommand(selected, initial));\n\n  return batchCmd;\n};\n","/* globals jQuery */\n/**\n * DOM element selection box tools\n * @module select\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Jeff Schiller\n */\n\nimport {isTouch, isWebkit} from './browser.js'; // , isOpera\nimport {getRotationAngle, getBBox, getStrokedBBox, isNullish} from './utilities.js';\nimport {transformListToTransform, transformBox, transformPoint} from './math.js';\nimport {getTransformList} from './svgtransformlist.js';\n\nconst $ = jQuery;\n\nlet svgFactory_;\nlet config_;\nlet selectorManager_; // A Singleton\nconst gripRadius = isTouch() ? 10 : 4;\n\n/**\n* Private class for DOM element selection boxes.\n*/\nexport class Selector {\n  /**\n  * @param {Integer} id - Internally identify the selector\n  * @param {Element} elem - DOM element associated with this selector\n  * @param {module:utilities.BBoxObject} [bbox] - Optional bbox to use for initialization (prevents duplicate `getBBox` call).\n  */\n  constructor (id, elem, bbox) {\n    // this is the selector's unique number\n    this.id = id;\n\n    // this holds a reference to the element for which this selector is being used\n    this.selectedElement = elem;\n\n    // this is a flag used internally to track whether the selector is being used or not\n    this.locked = true;\n\n    // this holds a reference to the <g> element that holds all visual elements of the selector\n    this.selectorGroup = svgFactory_.createSVGElement({\n      element: 'g',\n      attr: {id: ('selectorGroup' + this.id)}\n    });\n\n    // this holds a reference to the path rect\n    this.selectorRect = this.selectorGroup.appendChild(\n      svgFactory_.createSVGElement({\n        element: 'path',\n        attr: {\n          id: ('selectedBox' + this.id),\n          fill: 'none',\n          stroke: '#22C',\n          'stroke-width': '1',\n          'stroke-dasharray': '5,5',\n          // need to specify this so that the rect is not selectable\n          style: 'pointer-events:none'\n        }\n      })\n    );\n\n    // this holds a reference to the grip coordinates for this selector\n    this.gripCoords = {\n      nw: null,\n      n: null,\n      ne: null,\n      e: null,\n      se: null,\n      s: null,\n      sw: null,\n      w: null\n    };\n\n    this.reset(this.selectedElement, bbox);\n  }\n\n  /**\n  * Used to reset the id and element that the selector is attached to.\n  * @param {Element} e - DOM element associated with this selector\n  * @param {module:utilities.BBoxObject} bbox - Optional bbox to use for reset (prevents duplicate getBBox call).\n  * @returns {undefined}\n  */\n  reset (e, bbox) {\n    this.locked = true;\n    this.selectedElement = e;\n    this.resize(bbox);\n    this.selectorGroup.setAttribute('display', 'inline');\n  }\n\n  /**\n  * Show the resize grips of this selector.\n  * @param {boolean} show - Indicates whether grips should be shown or not\n  * @returns {undefined}\n  */\n  showGrips (show) {\n    const bShow = show ? 'inline' : 'none';\n    selectorManager_.selectorGripsGroup.setAttribute('display', bShow);\n    const elem = this.selectedElement;\n    this.hasGrips = show;\n    if (elem && show) {\n      this.selectorGroup.append(selectorManager_.selectorGripsGroup);\n      Selector.updateGripCursors(getRotationAngle(elem));\n    }\n  }\n\n  /**\n  * Updates the selector to match the element's size.\n  * @param {module:utilities.BBoxObject} [bbox] - BBox to use for resize (prevents duplicate getBBox call).\n  * @returns {undefined}\n  */\n  resize (bbox) {\n    const selectedBox = this.selectorRect,\n      mgr = selectorManager_,\n      selectedGrips = mgr.selectorGrips,\n      selected = this.selectedElement,\n      sw = selected.getAttribute('stroke-width'),\n      currentZoom = svgFactory_.getCurrentZoom();\n    let offset = 1 / currentZoom;\n    if (selected.getAttribute('stroke') !== 'none' && !isNaN(sw)) {\n      offset += (sw / 2);\n    }\n\n    const {tagName} = selected;\n    if (tagName === 'text') {\n      offset += 2 / currentZoom;\n    }\n\n    // loop and transform our bounding box until we reach our first rotation\n    const tlist = getTransformList(selected);\n    const m = transformListToTransform(tlist).matrix;\n\n    // This should probably be handled somewhere else, but for now\n    // it keeps the selection box correctly positioned when zoomed\n    m.e *= currentZoom;\n    m.f *= currentZoom;\n\n    if (!bbox) {\n      bbox = getBBox(selected);\n    }\n    // TODO: getBBox (previous line) already knows to call getStrokedBBox when tagName === 'g'. Remove this?\n    // TODO: getBBox doesn't exclude 'gsvg' and calls getStrokedBBox for any 'g'. Should getBBox be updated?\n    if (tagName === 'g' && !$.data(selected, 'gsvg')) {\n      // The bbox for a group does not include stroke vals, so we\n      // get the bbox based on its children.\n      const strokedBbox = getStrokedBBox([selected.childNodes]);\n      if (strokedBbox) {\n        bbox = strokedBbox;\n      }\n    }\n\n    // apply the transforms\n    const l = bbox.x, t = bbox.y, w = bbox.width, h = bbox.height;\n    // bbox = {x: l, y: t, width: w, height: h}; // Not in use\n\n    // we need to handle temporary transforms too\n    // if skewed, get its transformed box, then find its axis-aligned bbox\n\n    // *\n    offset *= currentZoom;\n\n    const nbox = transformBox(l * currentZoom, t * currentZoom, w * currentZoom, h * currentZoom, m),\n      {aabox} = nbox;\n    let nbax = aabox.x - offset,\n      nbay = aabox.y - offset,\n      nbaw = aabox.width + (offset * 2),\n      nbah = aabox.height + (offset * 2);\n\n    // now if the shape is rotated, un-rotate it\n    const cx = nbax + nbaw / 2,\n      cy = nbay + nbah / 2;\n\n    const angle = getRotationAngle(selected);\n    if (angle) {\n      const rot = svgFactory_.svgRoot().createSVGTransform();\n      rot.setRotate(-angle, cx, cy);\n      const rotm = rot.matrix;\n      nbox.tl = transformPoint(nbox.tl.x, nbox.tl.y, rotm);\n      nbox.tr = transformPoint(nbox.tr.x, nbox.tr.y, rotm);\n      nbox.bl = transformPoint(nbox.bl.x, nbox.bl.y, rotm);\n      nbox.br = transformPoint(nbox.br.x, nbox.br.y, rotm);\n\n      // calculate the axis-aligned bbox\n      const {tl} = nbox;\n      let minx = tl.x,\n        miny = tl.y,\n        maxx = tl.x,\n        maxy = tl.y;\n\n      const {min, max} = Math;\n\n      minx = min(minx, min(nbox.tr.x, min(nbox.bl.x, nbox.br.x))) - offset;\n      miny = min(miny, min(nbox.tr.y, min(nbox.bl.y, nbox.br.y))) - offset;\n      maxx = max(maxx, max(nbox.tr.x, max(nbox.bl.x, nbox.br.x))) + offset;\n      maxy = max(maxy, max(nbox.tr.y, max(nbox.bl.y, nbox.br.y))) + offset;\n\n      nbax = minx;\n      nbay = miny;\n      nbaw = (maxx - minx);\n      nbah = (maxy - miny);\n    }\n\n    const dstr = 'M' + nbax + ',' + nbay +\n      ' L' + (nbax + nbaw) + ',' + nbay +\n      ' ' + (nbax + nbaw) + ',' + (nbay + nbah) +\n      ' ' + nbax + ',' + (nbay + nbah) + 'z';\n    selectedBox.setAttribute('d', dstr);\n\n    const xform = angle ? 'rotate(' + [angle, cx, cy].join(',') + ')' : '';\n    this.selectorGroup.setAttribute('transform', xform);\n\n    // TODO(codedread): Is this needed?\n    //  if (selected === selectedElements[0]) {\n    this.gripCoords = {\n      nw: [nbax, nbay],\n      ne: [nbax + nbaw, nbay],\n      sw: [nbax, nbay + nbah],\n      se: [nbax + nbaw, nbay + nbah],\n      n: [nbax + (nbaw) / 2, nbay],\n      w: [nbax, nbay + (nbah) / 2],\n      e: [nbax + nbaw, nbay + (nbah) / 2],\n      s: [nbax + (nbaw) / 2, nbay + nbah]\n    };\n    Object.entries(this.gripCoords).forEach(([dir, coords]) => {\n      selectedGrips[dir].setAttribute('cx', coords[0]);\n      selectedGrips[dir].setAttribute('cy', coords[1]);\n    });\n\n    // we want to go 20 pixels in the negative transformed y direction, ignoring scale\n    mgr.rotateGripConnector.setAttribute('x1', nbax + (nbaw) / 2);\n    mgr.rotateGripConnector.setAttribute('y1', nbay);\n    mgr.rotateGripConnector.setAttribute('x2', nbax + (nbaw) / 2);\n    mgr.rotateGripConnector.setAttribute('y2', nbay - (gripRadius * 5));\n\n    mgr.rotateGrip.setAttribute('cx', nbax + (nbaw) / 2);\n    mgr.rotateGrip.setAttribute('cy', nbay - (gripRadius * 5));\n    // }\n  }\n}\n/**\n* Updates cursors for corner grips on rotation so arrows point the right way.\n* @param {Float} angle - Current rotation angle in degrees\n* @returns {undefined}\n*/\nSelector.updateGripCursors = function (angle) {\n  const dirArr = Object.keys(selectorManager_.selectorGrips);\n  let steps = Math.round(angle / 45);\n  if (steps < 0) { steps += 8; }\n  while (steps > 0) {\n    dirArr.push(dirArr.shift());\n    steps--;\n  }\n  Object.values(selectorManager_.selectorGrips).forEach((gripElement, i) => {\n    gripElement.setAttribute('style', ('cursor:' + dirArr[i] + '-resize'));\n  });\n};\n\n/**\n* Manage all selector objects (selection boxes).\n*/\nexport class SelectorManager {\n  constructor () {\n    // this will hold the <g> element that contains all selector rects/grips\n    this.selectorParentGroup = null;\n\n    // this is a special rect that is used for multi-select\n    this.rubberBandBox = null;\n\n    // this will hold objects of type Selector (see above)\n    this.selectors = [];\n\n    // this holds a map of SVG elements to their Selector object\n    this.selectorMap = {};\n\n    // this holds a reference to the grip elements\n    this.selectorGrips = {\n      nw: null,\n      n: null,\n      ne: null,\n      e: null,\n      se: null,\n      s: null,\n      sw: null,\n      w: null\n    };\n\n    this.selectorGripsGroup = null;\n    this.rotateGripConnector = null;\n    this.rotateGrip = null;\n\n    this.initGroup();\n  }\n\n  /**\n  * Resets the parent selector group element.\n  * @returns {undefined}\n  */\n  initGroup () {\n    // remove old selector parent group if it existed\n    if (this.selectorParentGroup && this.selectorParentGroup.parentNode) {\n      this.selectorParentGroup.remove();\n    }\n\n    // create parent selector group and add it to svgroot\n    this.selectorParentGroup = svgFactory_.createSVGElement({\n      element: 'g',\n      attr: {id: 'selectorParentGroup'}\n    });\n    this.selectorGripsGroup = svgFactory_.createSVGElement({\n      element: 'g',\n      attr: {display: 'none'}\n    });\n    this.selectorParentGroup.append(this.selectorGripsGroup);\n    svgFactory_.svgRoot().append(this.selectorParentGroup);\n\n    this.selectorMap = {};\n    this.selectors = [];\n    this.rubberBandBox = null;\n\n    // add the corner grips\n    Object.keys(this.selectorGrips).forEach((dir) => {\n      const grip = svgFactory_.createSVGElement({\n        element: 'circle',\n        attr: {\n          id: ('selectorGrip_resize_' + dir),\n          fill: '#22C',\n          r: gripRadius,\n          style: ('cursor:' + dir + '-resize'),\n          // This expands the mouse-able area of the grips making them\n          // easier to grab with the mouse.\n          // This works in Opera and WebKit, but does not work in Firefox\n          // see https://bugzilla.mozilla.org/show_bug.cgi?id=500174\n          'stroke-width': 2,\n          'pointer-events': 'all'\n        }\n      });\n\n      $.data(grip, 'dir', dir);\n      $.data(grip, 'type', 'resize');\n      this.selectorGrips[dir] = this.selectorGripsGroup.appendChild(grip);\n    });\n\n    // add rotator elems\n    this.rotateGripConnector = this.selectorGripsGroup.appendChild(\n      svgFactory_.createSVGElement({\n        element: 'line',\n        attr: {\n          id: ('selectorGrip_rotateconnector'),\n          stroke: '#22C',\n          'stroke-width': '1'\n        }\n      })\n    );\n\n    this.rotateGrip = this.selectorGripsGroup.appendChild(\n      svgFactory_.createSVGElement({\n        element: 'circle',\n        attr: {\n          id: 'selectorGrip_rotate',\n          fill: 'lime',\n          r: gripRadius,\n          stroke: '#22C',\n          'stroke-width': 2,\n          style: 'cursor:url(' + config_.imgPath + 'rotate.png) 12 12, auto;'\n        }\n      })\n    );\n    $.data(this.rotateGrip, 'type', 'rotate');\n\n    if ($('#canvasBackground').length) { return; }\n\n    const [width, height] = config_.dimensions;\n    const canvasbg = svgFactory_.createSVGElement({\n      element: 'svg',\n      attr: {\n        id: 'canvasBackground',\n        width,\n        height,\n        x: 0,\n        y: 0,\n        overflow: (isWebkit() ? 'none' : 'visible'), // Chrome 7 has a problem with this when zooming out\n        style: 'pointer-events:none'\n      }\n    });\n\n    const rect = svgFactory_.createSVGElement({\n      element: 'rect',\n      attr: {\n        width: '100%',\n        height: '100%',\n        x: 0,\n        y: 0,\n        'stroke-width': 1,\n        stroke: '#000',\n        fill: '#FFF',\n        style: 'pointer-events:none'\n      }\n    });\n\n    // Both Firefox and WebKit are too slow with this filter region (especially at higher\n    // zoom levels) and Opera has at least one bug\n    // if (!isOpera()) rect.setAttribute('filter', 'url(#canvashadow)');\n    canvasbg.append(rect);\n    svgFactory_.svgRoot().insertBefore(canvasbg, svgFactory_.svgContent());\n    // Ok to replace above with `svgFactory_.svgContent().before(canvasbg);`?\n  }\n\n  /**\n  *\n  * @param {Element} elem - DOM element to get the selector for\n  * @param {module:utilities.BBoxObject} [bbox] - Optional bbox to use for reset (prevents duplicate getBBox call).\n  * @returns {Selector} The selector based on the given element\n  */\n  requestSelector (elem, bbox) {\n    if (isNullish(elem)) { return null; }\n\n    const N = this.selectors.length;\n    // If we've already acquired one for this element, return it.\n    if (typeof this.selectorMap[elem.id] === 'object') {\n      this.selectorMap[elem.id].locked = true;\n      return this.selectorMap[elem.id];\n    }\n    for (let i = 0; i < N; ++i) {\n      if (this.selectors[i] && !this.selectors[i].locked) {\n        this.selectors[i].locked = true;\n        this.selectors[i].reset(elem, bbox);\n        this.selectorMap[elem.id] = this.selectors[i];\n        return this.selectors[i];\n      }\n    }\n    // if we reached here, no available selectors were found, we create one\n    this.selectors[N] = new Selector(N, elem, bbox);\n    this.selectorParentGroup.append(this.selectors[N].selectorGroup);\n    this.selectorMap[elem.id] = this.selectors[N];\n    return this.selectors[N];\n  }\n\n  /**\n  * Removes the selector of the given element (hides selection box).\n  *\n  * @param {Element} elem - DOM element to remove the selector for\n  * @returns {undefined}\n  */\n  releaseSelector (elem) {\n    if (isNullish(elem)) { return; }\n    const N = this.selectors.length,\n      sel = this.selectorMap[elem.id];\n    if (!sel.locked) {\n      // TODO(codedread): Ensure this exists in this module.\n      console.log('WARNING! selector was released but was already unlocked'); // eslint-disable-line no-console\n    }\n    for (let i = 0; i < N; ++i) {\n      if (this.selectors[i] && this.selectors[i] === sel) {\n        delete this.selectorMap[elem.id];\n        sel.locked = false;\n        sel.selectedElement = null;\n        sel.showGrips(false);\n\n        // remove from DOM and store reference in JS but only if it exists in the DOM\n        try {\n          sel.selectorGroup.setAttribute('display', 'none');\n        } catch (e) {}\n\n        break;\n      }\n    }\n  }\n\n  /**\n  * @returns {SVGRectElement} The rubberBandBox DOM element. This is the rectangle drawn by\n  * the user for selecting/zooming\n  */\n  getRubberBandBox () {\n    if (!this.rubberBandBox) {\n      this.rubberBandBox = this.selectorParentGroup.appendChild(\n        svgFactory_.createSVGElement({\n          element: 'rect',\n          attr: {\n            id: 'selectorRubberBand',\n            fill: '#22C',\n            'fill-opacity': 0.15,\n            stroke: '#22C',\n            'stroke-width': 0.5,\n            display: 'none',\n            style: 'pointer-events:none'\n          }\n        })\n      );\n    }\n    return this.rubberBandBox;\n  }\n}\n\n/**\n * An object that creates SVG elements for the canvas.\n *\n * @interface module:select.SVGFactory\n */\n/**\n * @function module:select.SVGFactory#createSVGElement\n * @param {module:utilities.EditorContext#addSVGElementFromJson} jsonMap\n * @returns {SVGElement}\n */\n/**\n * @function module:select.SVGFactory#svgRoot\n * @returns {SVGSVGElement}\n */\n/**\n * @function module:select.SVGFactory#svgContent\n * @returns {SVGSVGElement}\n */\n/**\n * @function module:select.SVGFactory#getCurrentZoom\n * @returns {Float}\n */\n\n/**\n * @typedef {GenericArray} module:select.Dimensions\n * @property {Integer} length 2\n * @property {Float} 0 Width\n * @property {Float} 1 Height\n */\n/**\n * @typedef {PlainObject} module:select.Config\n * @property {string} imgPath\n * @property {module:select.Dimensions} dimensions\n */\n\n/**\n * Initializes this module.\n * @function module:select.init\n * @param {module:select.Config} config - An object containing configurable parameters (imgPath)\n * @param {module:select.SVGFactory} svgFactory - An object implementing the SVGFactory interface.\n * @returns {undefined}\n */\nexport const init = function (config, svgFactory) {\n  config_ = config;\n  svgFactory_ = svgFactory;\n  selectorManager_ = new SelectorManager();\n};\n\n/**\n * @function module:select.getSelectorManager\n * @returns {module:select.SelectorManager} The SelectorManager instance.\n */\nexport const getSelectorManager = () => selectorManager_;\n","/* eslint-disable indent, unicorn/no-fn-reference-in-iterator */\n/* globals jQuery, jsPDF */\n/**\n * Numerous tools for working with the editor's \"canvas\"\n * @module svgcanvas\n *\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria, 2010 Pavol Rusnak, 2010 Jeff Schiller\n *\n */\n\n/* Dependencies:\n1. Also expects jQuery UI for `svgCanvasToString` and\n`convertToGroup` use of `:data()` selector\n*/\n\n// Todo: Obtain/adapt latest jsPDF to utilize ES Module for `jsPDF`/avoid global\n\nimport './svgpathseg.js';\nimport jQueryPluginSVG from './jQuery.attr.js'; // Needed for SVG attribute setting and array form with `attr`\nimport jQueryPluginDBox from './dbox.js';\nimport * as draw from './draw.js'; // eslint-disable-line import/no-duplicates\nimport { // eslint-disable-line no-duplicate-imports\n  identifyLayers, createLayer, cloneLayer, deleteCurrentLayer,\n  setCurrentLayer, renameCurrentLayer, setCurrentLayerPosition,\n  setLayerVisibility, moveSelectedToLayer, mergeLayer, mergeAllLayers,\n  leaveContext, setContext\n} from './draw.js'; // eslint-disable-line import/no-duplicates\nimport * as pathModule from './path.js';\nimport {sanitizeSvg} from './sanitize.js';\nimport {getReverseNS, NS} from './namespaces.js';\nimport {importSetGlobal, importScript} from './external/dynamic-import-polyfill/importModule.js';\nimport {\n  text2xml, assignAttributes, cleanupElement, getElem, getUrlFromAttr,\n  findDefs, getHref, setHref, getRefElem, getRotationAngle, getPathBBox,\n  preventClickDefault, snapToGrid, walkTree, walkTreePost,\n  getBBoxOfElementAsPath, convertToPath, toXml, encode64, decode64,\n  dataURLToObjectURL, createObjectURL,\n  getVisibleElements, dropXMLInteralSubset,\n  init as utilsInit, getBBox as utilsGetBBox, getStrokedBBoxDefaultVisible,\n  isNullish\n} from './utilities.js';\nimport * as hstry from './history.js';\nimport {\n  transformPoint, matrixMultiply, hasMatrixTransform, transformListToTransform,\n  getMatrix, snapToAngle, isIdentity, rectsIntersect, transformBox\n} from './math.js';\nimport {\n  convertToNum, convertAttrs, convertUnit, shortFloat, getTypeMap,\n  init as unitsInit\n} from './units.js';\nimport {\n  isGecko, isChrome, isIE, isWebkit, supportsNonScalingStroke, supportsGoodTextCharPos\n} from './browser.js'; // , supportsEditableText\nimport {\n  getTransformList, resetListMap,\n  SVGTransformList as SVGEditTransformList\n} from './svgtransformlist.js';\nimport {\n  remapElement,\n  init as coordsInit\n} from './coords.js';\nimport {\n  recalculateDimensions,\n  init as recalculateInit\n} from './recalculate.js';\nimport {\n  getSelectorManager,\n  Selector,\n  init as selectInit\n} from './select.js';\n\nlet $ = jQueryPluginSVG(jQuery);\nconst {\n  MoveElementCommand, InsertElementCommand, RemoveElementCommand,\n  ChangeElementCommand, BatchCommand, UndoManager, HistoryEventTypes\n} = hstry;\n\nif (!window.console) {\n  window.console = {};\n  window.console.log = function (str) { /* */ };\n  window.console.dir = function (str) { /* */ };\n}\n\nif (window.opera) {\n  window.console.log = function (str) { window.opera.postError(str); };\n  window.console.dir = function (str) { /* */ };\n}\n\n/**\n* The main SvgCanvas class that manages all SVG-related functions.\n* @memberof module:svgcanvas\n*\n* @borrows module:coords.remapElement as #remapElement\n* @borrows module:recalculate.recalculateDimensions as #recalculateDimensions\n*\n* @borrows module:utilities.cleanupElement as #cleanupElement\n* @borrows module:utilities.getStrokedBBoxDefaultVisible as #getStrokedBBox\n* @borrows module:utilities.getVisibleElements as #getVisibleElements\n* @borrows module:utilities.findDefs as #findDefs\n* @borrows module:utilities.getUrlFromAttr as #getUrlFromAttr\n* @borrows module:utilities.getHref as #getHref\n* @borrows module:utilities.setHref as #setHref\n* @borrows module:utilities.getRotationAngle as #getRotationAngle\n* @borrows module:utilities.getBBox as #getBBox\n* @borrows module:utilities.getElem as #getElem\n* @borrows module:utilities.getRefElem as #getRefElem\n* @borrows module:utilities.assignAttributes as #assignAttributes\n*\n* @borrows module:SVGTransformList.getTransformList as #getTransformList\n* @borrows module:math.matrixMultiply as #matrixMultiply\n* @borrows module:math.hasMatrixTransform as #hasMatrixTransform\n* @borrows module:math.transformListToTransform as #transformListToTransform\n* @borrows module:units.convertToNum as #convertToNum\n* @borrows module:sanitize.sanitizeSvg as #sanitizeSvg\n* @borrows module:path.pathActions.linkControlPoints as #linkControlPoints\n*/\nclass SvgCanvas {\n  /**\n  * @param {HTMLElement} container - The container HTML element that should hold the SVG root element\n  * @param {module:SVGEditor.curConfig} config - An object that contains configuration data\n  */\n  constructor (container, config) {\n// Alias Namespace constants\n\n// Default configuration options\nconst curConfig = {\n  show_outside_canvas: true,\n  selectNew: true,\n  dimensions: [640, 480]\n};\n\n// Update config with new one if given\nif (config) {\n  $.extend(curConfig, config);\n}\n\n// Array with width/height of canvas\nconst {dimensions} = curConfig;\n\nconst canvas = this; // eslint-disable-line consistent-this\n\n// \"document\" element associated with the container (same as window.document using default svg-editor.js)\n// NOTE: This is not actually a SVG document, but an HTML document.\nconst svgdoc = container.ownerDocument;\n\n// This is a container for the document being edited, not the document itself.\n/**\n * @name module:svgcanvas~svgroot\n * @type {SVGSVGElement}\n */\nconst svgroot = svgdoc.importNode(\n  text2xml(\n    '<svg id=\"svgroot\" xmlns=\"' + NS.SVG + '\" xlinkns=\"' + NS.XLINK + '\" ' +\n      'width=\"' + dimensions[0] + '\" height=\"' + dimensions[1] + '\" x=\"' + dimensions[0] + '\" y=\"' + dimensions[1] + '\" overflow=\"visible\">' +\n      '<defs>' +\n        '<filter id=\"canvashadow\" filterUnits=\"objectBoundingBox\">' +\n          '<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"4\" result=\"blur\"/>' +\n          '<feOffset in=\"blur\" dx=\"5\" dy=\"5\" result=\"offsetBlur\"/>' +\n          '<feMerge>' +\n            '<feMergeNode in=\"offsetBlur\"/>' +\n            '<feMergeNode in=\"SourceGraphic\"/>' +\n          '</feMerge>' +\n        '</filter>' +\n      '</defs>' +\n    '</svg>'\n  ).documentElement,\n  true\n);\ncontainer.append(svgroot);\n\n/**\n * The actual element that represents the final output SVG element\n * @name module:svgcanvas~svgcontent\n * @type {SVGSVGElement}\n */\nlet svgcontent = svgdoc.createElementNS(NS.SVG, 'svg');\n\n/**\n* This function resets the svgcontent element while keeping it in the DOM.\n* @function module:svgcanvas.SvgCanvas#clearSvgContentElement\n* @returns {undefined}\n*/\nconst clearSvgContentElement = canvas.clearSvgContentElement = function () {\n  $(svgcontent).empty();\n\n  // TODO: Clear out all other attributes first?\n  $(svgcontent).attr({\n    id: 'svgcontent',\n    width: dimensions[0],\n    height: dimensions[1],\n    x: dimensions[0],\n    y: dimensions[1],\n    overflow: curConfig.show_outside_canvas ? 'visible' : 'hidden',\n    xmlns: NS.SVG,\n    'xmlns:se': NS.SE,\n    'xmlns:xlink': NS.XLINK\n  }).appendTo(svgroot);\n\n  // TODO: make this string optional and set by the client\n  const comment = svgdoc.createComment(' Created with SVG-edit - https://github.com/SVG-Edit/svgedit');\n  svgcontent.append(comment);\n};\nclearSvgContentElement();\n\n// Prefix string for element IDs\nlet idprefix = 'svg_';\n\n/**\n* Changes the ID prefix to the given value.\n* @function module:svgcanvas.SvgCanvas#setIdPrefix\n* @param {string} p - String with the new prefix\n* @returns {undefined}\n*/\ncanvas.setIdPrefix = function (p) {\n  idprefix = p;\n};\n\n/**\n* Current draw.Drawing object\n* @type {module:draw.Drawing}\n* @name module:svgcanvas.SvgCanvas#current_drawing_\n*/\ncanvas.current_drawing_ = new draw.Drawing(svgcontent, idprefix);\n\n/**\n* Returns the current Drawing.\n* @function module:svgcanvas.SvgCanvas#getCurrentDrawing\n* @implements {module:draw.DrawCanvasInit#getCurrentDrawing}\n*/\nconst getCurrentDrawing = canvas.getCurrentDrawing = function () {\n  return canvas.current_drawing_;\n};\n\n/**\n* Float displaying the current zoom level (1 = 100%, .5 = 50%, etc)\n* @type {Float}\n*/\nlet currentZoom = 1;\n\n// pointer to current group (for in-group editing)\nlet currentGroup = null;\n\n// Object containing data for the currently selected styles\nconst allProperties = {\n  shape: {\n    fill: (curConfig.initFill.color === 'none' ? '' : '#') + curConfig.initFill.color,\n    fill_paint: null,\n    fill_opacity: curConfig.initFill.opacity,\n    stroke: '#' + curConfig.initStroke.color,\n    stroke_paint: null,\n    stroke_opacity: curConfig.initStroke.opacity,\n    stroke_width: curConfig.initStroke.width,\n    stroke_dasharray: 'none',\n    stroke_linejoin: 'miter',\n    stroke_linecap: 'butt',\n    opacity: curConfig.initOpacity\n  }\n};\n\nallProperties.text = $.extend(true, {}, allProperties.shape);\n$.extend(allProperties.text, {\n  fill: '#000000',\n  stroke_width: curConfig.text && curConfig.text.stroke_width,\n  font_size: curConfig.text && curConfig.text.font_size,\n  font_family: curConfig.text && curConfig.text.font_family\n});\n\n// Current shape style properties\nconst curShape = allProperties.shape;\n\n// Array with all the currently selected elements\n// default size of 1 until it needs to grow bigger\nlet selectedElements = [];\n\n/**\n* @typedef {PlainObject} module:svgcanvas.SVGAsJSON\n* @property {string} element\n* @property {PlainObject.<string, string>} attr\n* @property {module:svgcanvas.SVGAsJSON[]} children\n*/\n\n/**\n* @function module:svgcanvas.SvgCanvas#getContentElem\n* @param {Text|Element} data\n* @returns {module:svgcanvas.SVGAsJSON}\n*/\nconst getJsonFromSvgElement = this.getJsonFromSvgElement = function (data) {\n  // Text node\n  if (data.nodeType === 3) return data.nodeValue;\n\n  const retval = {\n    element: data.tagName,\n    // namespace: nsMap[data.namespaceURI],\n    attr: {},\n    children: []\n  };\n\n  // Iterate attributes\n  for (let i = 0, attr; (attr = data.attributes[i]); i++) {\n    retval.attr[attr.name] = attr.value;\n  }\n\n  // Iterate children\n  for (let i = 0, node; (node = data.childNodes[i]); i++) {\n    retval.children[i] = getJsonFromSvgElement(node);\n  }\n\n  return retval;\n};\n\n/**\n* This should really be an intersection implementing all rather than a union.\n* @function module:svgcanvas.SvgCanvas#addSVGElementFromJson\n* @implements {module:utilities.EditorContext#addSVGElementFromJson|module:path.EditorContext#addSVGElementFromJson}\n*/\nconst addSVGElementFromJson = this.addSVGElementFromJson = function (data) {\n  if (typeof data === 'string') return svgdoc.createTextNode(data);\n\n  let shape = getElem(data.attr.id);\n  // if shape is a path but we need to create a rect/ellipse, then remove the path\n  const currentLayer = getCurrentDrawing().getCurrentLayer();\n  if (shape && data.element !== shape.tagName) {\n    shape.remove();\n    shape = null;\n  }\n  if (!shape) {\n    const ns = data.namespace || NS.SVG;\n    shape = svgdoc.createElementNS(ns, data.element);\n    if (currentLayer) {\n      (currentGroup || currentLayer).append(shape);\n    }\n  }\n  if (data.curStyles) {\n    assignAttributes(shape, {\n      fill: curShape.fill,\n      stroke: curShape.stroke,\n      'stroke-width': curShape.stroke_width,\n      'stroke-dasharray': curShape.stroke_dasharray,\n      'stroke-linejoin': curShape.stroke_linejoin,\n      'stroke-linecap': curShape.stroke_linecap,\n      'stroke-opacity': curShape.stroke_opacity,\n      'fill-opacity': curShape.fill_opacity,\n      opacity: curShape.opacity / 2,\n      style: 'pointer-events:inherit'\n    }, 100);\n  }\n  assignAttributes(shape, data.attr, 100);\n  cleanupElement(shape);\n\n  // Children\n  if (data.children) {\n    data.children.forEach((child) => {\n      shape.append(addSVGElementFromJson(child));\n    });\n  }\n\n  return shape;\n};\n\ncanvas.getTransformList = getTransformList;\n\ncanvas.matrixMultiply = matrixMultiply;\ncanvas.hasMatrixTransform = hasMatrixTransform;\ncanvas.transformListToTransform = transformListToTransform;\n\n/**\n* @implements {module:utilities.EditorContext#getBaseUnit}\n*/\nconst getBaseUnit = () => { return curConfig.baseUnit; };\n\n/**\n* initialize from units.js.\n* Send in an object implementing the ElementContainer interface (see units.js)\n*/\nunitsInit(\n  /**\n  * @implements {module:units.ElementContainer}\n  */\n  {\n    getBaseUnit,\n    getElement: getElem,\n    getHeight () { return svgcontent.getAttribute('height') / currentZoom; },\n    getWidth () { return svgcontent.getAttribute('width') / currentZoom; },\n    getRoundDigits () { return saveOptions.round_digits; }\n  }\n);\n\ncanvas.convertToNum = convertToNum;\n\n/**\n* This should really be an intersection implementing all rather than a union.\n* @implements {module:draw.DrawCanvasInit#getSVGContent|module:utilities.EditorContext#getSVGContent}\n*/\nconst getSVGContent = () => { return svgcontent; };\n\n/**\n* Should really be an intersection with all needing to apply rather than a union.\n* @function module:svgcanvas.SvgCanvas#getSelectedElements\n* @implements {module:utilities.EditorContext#getSelectedElements|module:draw.DrawCanvasInit#getSelectedElements|module:path.EditorContext#getSelectedElements}\n*/\nconst getSelectedElements = this.getSelectedElems = function () {\n  return selectedElements;\n};\n\nconst {pathActions} = pathModule;\n\n/**\n* This should actually be an intersection as all interfaces should be met.\n* @implements {module:utilities.EditorContext#getSVGRoot|module:recalculate.EditorContext#getSVGRoot|module:coords.EditorContext#getSVGRoot|module:path.EditorContext#getSVGRoot}\n*/\nconst getSVGRoot = () => svgroot;\n\nutilsInit(\n  /**\n  * @implements {module:utilities.EditorContext}\n  */\n  {\n    pathActions, // Ok since not modifying\n    getSVGContent,\n    addSVGElementFromJson,\n    getSelectedElements,\n    getDOMDocument () { return svgdoc; },\n    getDOMContainer () { return container; },\n    getSVGRoot,\n    // TODO: replace this mostly with a way to get the current drawing.\n    getBaseUnit,\n    getSnappingStep () { return curConfig.snappingStep; }\n  }\n);\n\ncanvas.findDefs = findDefs;\ncanvas.getUrlFromAttr = getUrlFromAttr;\ncanvas.getHref = getHref;\ncanvas.setHref = setHref;\n/* const getBBox = */ canvas.getBBox = utilsGetBBox;\ncanvas.getRotationAngle = getRotationAngle;\ncanvas.getElem = getElem;\ncanvas.getRefElem = getRefElem;\ncanvas.assignAttributes = assignAttributes;\n\nthis.cleanupElement = cleanupElement;\n\n/**\n* This should actually be an intersection not a union as all should apply.\n* @implements {module:coords.EditorContext|module:path.EditorContext}\n*/\nconst getGridSnapping = () => { return curConfig.gridSnapping; };\n\ncoordsInit(\n  /**\n  * @implements {module:coords.EditorContext}\n  */\n  {\n    getDrawing () { return getCurrentDrawing(); },\n    getSVGRoot,\n    getGridSnapping\n  }\n);\nthis.remapElement = remapElement;\n\nrecalculateInit(\n  /**\n  * @implements {module:recalculate.EditorContext}\n  */\n  {\n    getSVGRoot,\n    getStartTransform () { return startTransform; },\n    setStartTransform (transform) { startTransform = transform; }\n  }\n);\nthis.recalculateDimensions = recalculateDimensions;\n\n// import from sanitize.js\nconst nsMap = getReverseNS();\ncanvas.sanitizeSvg = sanitizeSvg;\n\n/**\n* @name undoMgr\n* @memberof module:svgcanvas.SvgCanvas#\n* @type {module:history.HistoryEventHandler}\n*/\nconst undoMgr = canvas.undoMgr = new UndoManager({\n  /**\n   * @param {string} eventType One of the HistoryEvent types\n   * @param {module:history.HistoryCommand} cmd Fulfills the HistoryCommand interface\n   * @fires module:svgcanvas.SvgCanvas#event:changed\n   * @returns {undefined}\n   */\n  handleHistoryEvent (eventType, cmd) {\n    const EventTypes = HistoryEventTypes;\n    // TODO: handle setBlurOffsets.\n    if (eventType === EventTypes.BEFORE_UNAPPLY || eventType === EventTypes.BEFORE_APPLY) {\n      canvas.clearSelection();\n    } else if (eventType === EventTypes.AFTER_APPLY || eventType === EventTypes.AFTER_UNAPPLY) {\n      const elems = cmd.elements();\n      canvas.pathActions.clear();\n      call('changed', elems);\n      const cmdType = cmd.type();\n      const isApply = (eventType === EventTypes.AFTER_APPLY);\n      if (cmdType === MoveElementCommand.type()) {\n        const parent = isApply ? cmd.newParent : cmd.oldParent;\n        if (parent === svgcontent) {\n          draw.identifyLayers();\n        }\n      } else if (cmdType === InsertElementCommand.type() ||\n          cmdType === RemoveElementCommand.type()) {\n        if (cmd.parent === svgcontent) {\n          draw.identifyLayers();\n        }\n        if (cmdType === InsertElementCommand.type()) {\n          if (isApply) { restoreRefElems(cmd.elem); }\n        } else if (!isApply) {\n          restoreRefElems(cmd.elem);\n        }\n        if (cmd.elem.tagName === 'use') {\n          setUseData(cmd.elem);\n        }\n      } else if (cmdType === ChangeElementCommand.type()) {\n        // if we are changing layer names, re-identify all layers\n        if (cmd.elem.tagName === 'title' &&\n          cmd.elem.parentNode.parentNode === svgcontent\n        ) {\n          draw.identifyLayers();\n        }\n        const values = isApply ? cmd.newValues : cmd.oldValues;\n        // If stdDeviation was changed, update the blur.\n        if (values.stdDeviation) {\n          canvas.setBlurOffsets(cmd.elem.parentNode, values.stdDeviation);\n        }\n        // This is resolved in later versions of webkit, perhaps we should\n        // have a featured detection for correct 'use' behavior?\n        // ——————————\n        // Remove & Re-add hack for Webkit (issue 775)\n        // if (cmd.elem.tagName === 'use' && isWebkit()) {\n        //  const {elem} = cmd;\n        //  if (!elem.getAttribute('x') && !elem.getAttribute('y')) {\n        //    const parent = elem.parentNode;\n        //    const sib = elem.nextSibling;\n        //    elem.remove();\n        //    parent.insertBefore(elem, sib);\n        //    // Ok to replace above with this? `sib.before(elem);`\n        //  }\n        // }\n      }\n    }\n  }\n});\n\n/**\n* This should really be an intersection applying to all types rather than a union.\n* @function module:svgcanvas~addCommandToHistory\n* @implements {module:path.EditorContext#addCommandToHistory|module:draw.DrawCanvasInit#addCommandToHistory}\n*/\nconst addCommandToHistory = function (cmd) {\n  canvas.undoMgr.addCommandToHistory(cmd);\n};\n\n/**\n* This should really be an intersection applying to all types rather than a union.\n* @function module:svgcanvas.SvgCanvas#getZoom\n* @implements {module:path.EditorContext#getCurrentZoom|module:select.SVGFactory#getCurrentZoom}\n*/\nconst getCurrentZoom = this.getZoom = function () { return currentZoom; };\n\n/**\n* This method rounds the incoming value to the nearest value based on the `currentZoom`\n* @function module:svgcanvas.SvgCanvas#round\n* @implements {module:path.EditorContext#round}\n*/\nconst round = this.round = function (val) {\n  return parseInt(val * currentZoom) / currentZoom;\n};\n\nselectInit(\n  curConfig,\n  /**\n  * Export to select.js\n  * @implements {module:select.SVGFactory}\n  */\n  {\n    createSVGElement (jsonMap) { return canvas.addSVGElementFromJson(jsonMap); },\n    svgRoot () { return svgroot; },\n    svgContent () { return svgcontent; },\n    getCurrentZoom\n  }\n);\n/**\n* This object manages selectors for us\n* @name module:svgcanvas.SvgCanvas#selectorManager\n* @type {module:select.SelectorManager}\n*/\nconst selectorManager = this.selectorManager = getSelectorManager();\n\n/**\n* @function module:svgcanvas.SvgCanvas#getNextId\n* @implements {module:path.EditorContext#getNextId}\n*/\nconst getNextId = canvas.getNextId = function () {\n  return getCurrentDrawing().getNextId();\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getId\n* @implements {module:path.EditorContext#getId}\n*/\nconst getId = canvas.getId = function () {\n  return getCurrentDrawing().getId();\n};\n\n/**\n* The \"implements\" should really be an intersection applying to all types rather than a union.\n* @function module:svgcanvas.SvgCanvas#call\n* @implements {module:draw.DrawCanvasInit#call|module:path.EditorContext#call}\n* @param {\"selected\"|\"changed\"|\"contextset\"|\"pointsAdded\"|\"extension_added\"|\"extensions_added\"|\"message\"|\"transition\"|\"zoomed\"|\"updateCanvas\"|\"zoomDone\"|\"saved\"|\"exported\"|\"exportedPDF\"|\"setnonce\"|\"unsetnonce\"|\"cleared\"} ev - String with the event name\n* @param {module:svgcanvas.SvgCanvas#event:GenericCanvasEvent} arg - Argument to pass through to the callback function.\n* @returns {module:svgcanvas.EventHandlerReturn|undefined}\n*/\nconst call = function (ev, arg) {\n  if (events[ev]) {\n    return events[ev](window, arg);\n  }\n  return undefined;\n};\n\n/**\n* Clears the selection. The 'selected' handler is then optionally called.\n* This should really be an intersection applying to all types rather than a union.\n* @function module:svgcanvas.SvgCanvas#clearSelection\n* @implements {module:draw.DrawCanvasInit#clearSelection|module:path.EditorContext#clearSelection}\n* @fires module:svgcanvas.SvgCanvas#event:selected\n*/\nconst clearSelection = this.clearSelection = function (noCall) {\n  selectedElements.forEach((elem) => {\n    if (isNullish(elem)) {\n      return;\n    }\n    selectorManager.releaseSelector(elem);\n  });\n  selectedElements = [];\n\n  if (!noCall) { call('selected', selectedElements); }\n};\n\n/**\n* Adds a list of elements to the selection. The 'selected' handler is then called.\n* @function module:svgcanvas.SvgCanvas#addToSelection\n* @implements {module:path.EditorContext#addToSelection}\n* @fires module:svgcanvas.SvgCanvas#event:selected\n*/\nconst addToSelection = this.addToSelection = function (elemsToAdd, showGrips) {\n  if (!elemsToAdd.length) { return; }\n  // find the first null in our selectedElements array\n\n  let j = 0;\n  while (j < selectedElements.length) {\n    if (isNullish(selectedElements[j])) {\n      break;\n    }\n    ++j;\n  }\n\n  // now add each element consecutively\n  let i = elemsToAdd.length;\n  while (i--) {\n    let elem = elemsToAdd[i];\n    if (!elem) { continue; }\n    const bbox = utilsGetBBox(elem);\n    if (!bbox) { continue; }\n\n    if (elem.tagName === 'a' && elem.childNodes.length === 1) {\n      // Make \"a\" element's child be the selected element\n      elem = elem.firstChild;\n    }\n\n    // if it's not already there, add it\n    if (!selectedElements.includes(elem)) {\n      selectedElements[j] = elem;\n\n      // only the first selectedBBoxes element is ever used in the codebase these days\n      // if (j === 0) selectedBBoxes[0] = utilsGetBBox(elem);\n      j++;\n      const sel = selectorManager.requestSelector(elem, bbox);\n\n      if (selectedElements.length > 1) {\n        sel.showGrips(false);\n      }\n    }\n  }\n  call('selected', selectedElements);\n\n  if (showGrips || selectedElements.length === 1) {\n    selectorManager.requestSelector(selectedElements[0]).showGrips(true);\n  } else {\n    selectorManager.requestSelector(selectedElements[0]).showGrips(false);\n  }\n\n  // make sure the elements are in the correct order\n  // See: https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-compareDocumentPosition\n\n  selectedElements.sort(function (a, b) {\n    if (a && b && a.compareDocumentPosition) {\n      return 3 - (b.compareDocumentPosition(a) & 6); // eslint-disable-line no-bitwise\n    }\n    if (isNullish(a)) {\n      return 1;\n    }\n    return 0;\n  });\n\n  // Make sure first elements are not null\n  while (isNullish(selectedElements[0])) {\n    selectedElements.shift(0);\n  }\n};\n\n/**\n* @implements {module:path.EditorContext#getOpacity}\n*/\nconst getOpacity = function () {\n  return curShape.opacity;\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getMouseTarget\n* @implements {module:path.EditorContext#getMouseTarget}\n*/\nconst getMouseTarget = this.getMouseTarget = function (evt) {\n  if (isNullish(evt)) {\n    return null;\n  }\n  let mouseTarget = evt.target;\n\n  // if it was a <use>, Opera and WebKit return the SVGElementInstance\n  if (mouseTarget.correspondingUseElement) { mouseTarget = mouseTarget.correspondingUseElement; }\n\n  // for foreign content, go up until we find the foreignObject\n  // WebKit browsers set the mouse target to the svgcanvas div\n  if ([NS.MATH, NS.HTML].includes(mouseTarget.namespaceURI) &&\n    mouseTarget.id !== 'svgcanvas'\n  ) {\n    while (mouseTarget.nodeName !== 'foreignObject') {\n      mouseTarget = mouseTarget.parentNode;\n      if (!mouseTarget) { return svgroot; }\n    }\n  }\n\n  // Get the desired mouseTarget with jQuery selector-fu\n  // If it's root-like, select the root\n  const currentLayer = getCurrentDrawing().getCurrentLayer();\n  if ([svgroot, container, svgcontent, currentLayer].includes(mouseTarget)) {\n    return svgroot;\n  }\n\n  const $target = $(mouseTarget);\n\n  // If it's a selection grip, return the grip parent\n  if ($target.closest('#selectorParentGroup').length) {\n    // While we could instead have just returned mouseTarget,\n    // this makes it easier to indentify as being a selector grip\n    return selectorManager.selectorParentGroup;\n  }\n\n  while (mouseTarget.parentNode !== (currentGroup || currentLayer)) {\n    mouseTarget = mouseTarget.parentNode;\n  }\n\n  //\n  // // go up until we hit a child of a layer\n  // while (mouseTarget.parentNode.parentNode.tagName == 'g') {\n  //   mouseTarget = mouseTarget.parentNode;\n  // }\n  // Webkit bubbles the mouse event all the way up to the div, so we\n  // set the mouseTarget to the svgroot like the other browsers\n  // if (mouseTarget.nodeName.toLowerCase() == 'div') {\n  //   mouseTarget = svgroot;\n  // }\n\n  return mouseTarget;\n};\n\n/**\n* @namespace {module:path.pathActions} pathActions\n* @memberof module:svgcanvas.SvgCanvas#\n* @see module:path.pathActions\n*/\ncanvas.pathActions = pathActions;\n/**\n* @implements {module:path.EditorContext#resetD}\n*/\nfunction resetD (p) {\n  p.setAttribute('d', pathActions.convertPath(p));\n}\npathModule.init(\n  /**\n  * @implements {module:path.EditorContext}\n  */\n  {\n    selectorManager, // Ok since not changing\n    canvas, // Ok since not changing\n    call,\n    resetD,\n    round,\n    clearSelection,\n    addToSelection,\n    addCommandToHistory,\n    remapElement,\n    addSVGElementFromJson,\n    getGridSnapping,\n    getOpacity,\n    getSelectedElements,\n    getContainer () {\n      return container;\n    },\n    setStarted (s) {\n      started = s;\n    },\n    getRubberBox () {\n      return rubberBox;\n    },\n    setRubberBox (rb) {\n      rubberBox = rb;\n      return rubberBox;\n    },\n    /**\n     * @param {PlainObject} ptsInfo\n     * @param {boolean} ptsInfo.closedSubpath\n     * @param {SVGCircleElement[]} ptsInfo.grips\n     * @fires module:svgcanvas.SvgCanvas#event:pointsAdded\n     * @fires module:svgcanvas.SvgCanvas#event:selected\n     * @returns {undefined}\n     */\n    addPtsToSelection ({closedSubpath, grips}) {\n      // TODO: Correct this:\n      pathActions.canDeleteNodes = true;\n      pathActions.closed_subpath = closedSubpath;\n      call('pointsAdded', {closedSubpath, grips});\n      call('selected', grips);\n    },\n    /**\n     * @param {PlainObject} changes\n     * @param {ChangeElementCommand} changes.cmd\n     * @param {SVGPathElement} changes.elem\n     * @fires module:svgcanvas.SvgCanvas#event:changed\n     * @returns {undefined}\n     */\n    endChanges ({cmd, elem}) {\n      addCommandToHistory(cmd);\n      call('changed', [elem]);\n    },\n    getCurrentZoom,\n    getId,\n    getNextId,\n    getMouseTarget,\n    getCurrentMode () {\n      return currentMode;\n    },\n    setCurrentMode (cm) {\n      currentMode = cm;\n      return currentMode;\n    },\n    getDrawnPath () {\n      return drawnPath;\n    },\n    setDrawnPath (dp) {\n      drawnPath = dp;\n      return drawnPath;\n    },\n    getSVGRoot\n  }\n);\n\n// Interface strings, usually for title elements\nconst uiStrings = {};\n\nconst visElems = 'a,circle,ellipse,foreignObject,g,image,line,path,polygon,polyline,rect,svg,text,tspan,use';\nconst refAttrs = ['clip-path', 'fill', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'stroke'];\n\nconst elData = $.data;\n\n// Animation element to change the opacity of any newly created element\nconst opacAni = document.createElementNS(NS.SVG, 'animate');\n$(opacAni).attr({\n  attributeName: 'opacity',\n  begin: 'indefinite',\n  dur: 1,\n  fill: 'freeze'\n}).appendTo(svgroot);\n\nconst restoreRefElems = function (elem) {\n  // Look for missing reference elements, restore any found\n  const attrs = $(elem).attr(refAttrs);\n  Object.values(attrs).forEach((val) => {\n    if (val && val.startsWith('url(')) {\n      const id = getUrlFromAttr(val).substr(1);\n      const ref = getElem(id);\n      if (!ref) {\n        findDefs().append(removedElements[id]);\n        delete removedElements[id];\n      }\n    }\n  });\n\n  const childs = elem.getElementsByTagName('*');\n\n  if (childs.length) {\n    for (let i = 0, l = childs.length; i < l; i++) {\n      restoreRefElems(childs[i]);\n    }\n  }\n};\n\n// (function () {\n// TODO For Issue 208: this is a start on a thumbnail\n//  const svgthumb = svgdoc.createElementNS(NS.SVG, 'use');\n//  svgthumb.setAttribute('width', '100');\n//  svgthumb.setAttribute('height', '100');\n//  setHref(svgthumb, '#svgcontent');\n//  svgroot.append(svgthumb);\n// }());\n\n/**\n * @typedef {PlainObject} module:svgcanvas.SaveOptions\n * @property {boolean} apply\n * @property {\"embed\"} [image]\n * @property {Integer} round_digits\n */\n\n// Object to contain image data for raster images that were found encodable\nconst encodableImages = {},\n\n  // Object with save options\n  /**\n   * @type {module:svgcanvas.SaveOptions}\n   */\n  saveOptions = {round_digits: 5},\n\n  // Object with IDs for imported files, to see if one was already added\n  importIds = {},\n\n  // Current text style properties\n  curText = allProperties.text,\n\n  // Object to contain all included extensions\n  extensions = {},\n\n  // Map of deleted reference elements\n  removedElements = {};\n\nlet\n  // String with image URL of last loadable image\n  lastGoodImgUrl = curConfig.imgPath + 'logo.png',\n\n  // Boolean indicating whether or not a draw action has been started\n  started = false,\n\n  // String with an element's initial transform attribute value\n  startTransform = null,\n\n  // String indicating the current editor mode\n  currentMode = 'select',\n\n  // String with the current direction in which an element is being resized\n  currentResizeMode = 'none',\n\n  // Current general properties\n  curProperties = curShape,\n\n  // Array with selected elements' Bounding box object\n  // selectedBBoxes = new Array(1),\n\n  // The DOM element that was just selected\n  justSelected = null,\n\n  // DOM element for selection rectangle drawn by the user\n  rubberBox = null,\n\n  // Array of current BBoxes, used in getIntersectionList().\n  curBBoxes = [],\n\n  // Canvas point for the most recent right click\n  lastClickPoint = null;\n\nthis.runExtension = function (name, action, vars) {\n  return this.runExtensions(action, vars, false, (n) => n === name);\n};\n/**\n* @typedef {module:svgcanvas.ExtensionMouseDownStatus|module:svgcanvas.ExtensionMouseUpStatus|module:svgcanvas.ExtensionIDsUpdatedStatus|module:locale.ExtensionLocaleData[]|undefined} module:svgcanvas.ExtensionStatus\n* @tutorial ExtensionDocs\n*/\n/**\n* @callback module:svgcanvas.ExtensionVarBuilder\n* @param {string} name The name of the extension\n* @returns {module:svgcanvas.SvgCanvas#event:ext-addLangData}\n*/\n/**\n* @callback module:svgcanvas.ExtensionNameFilter\n* @param {string} name\n* @returns {boolean}\n*/\n/**\n* @todo Consider: Should this return an array by default, so extension results aren't overwritten?\n* @todo Would be easier to document if passing in object with key of action and vars as value; could then define an interface which tied both together\n* @function module:svgcanvas.SvgCanvas#runExtensions\n* @param {\"mouseDown\"|\"mouseMove\"|\"mouseUp\"|\"zoomChanged\"|\"IDsUpdated\"|\"canvasUpdated\"|\"toolButtonStateUpdate\"|\"selectedChanged\"|\"elementTransition\"|\"elementChanged\"|\"langReady\"|\"langChanged\"|\"addLangData\"|\"onNewDocument\"|\"workareaResized\"} action\n* @param {module:svgcanvas.SvgCanvas#event:ext-mouseDown|module:svgcanvas.SvgCanvas#event:ext-mouseMove|module:svgcanvas.SvgCanvas#event:ext-mouseUp|module:svgcanvas.SvgCanvas#event:ext-zoomChanged|module:svgcanvas.SvgCanvas#event:ext-IDsUpdated|module:svgcanvas.SvgCanvas#event:ext-canvasUpdated|module:svgcanvas.SvgCanvas#event:ext-toolButtonStateUpdate|module:svgcanvas.SvgCanvas#event:ext-selectedChanged|module:svgcanvas.SvgCanvas#event:ext-elementTransition|module:svgcanvas.SvgCanvas#event:ext-elementChanged|module:svgcanvas.SvgCanvas#event:ext-langReady|module:svgcanvas.SvgCanvas#event:ext-langChanged|module:svgcanvas.SvgCanvas#event:ext-addLangData|module:svgcanvas.SvgCanvas#event:ext-onNewDocument|module:svgcanvas.SvgCanvas#event:ext-workareaResized|module:svgcanvas.ExtensionVarBuilder} [vars]\n* @param {boolean} [returnArray]\n* @param {module:svgcanvas.ExtensionNameFilter} nameFilter\n* @returns {GenericArray.<module:svgcanvas.ExtensionStatus>|module:svgcanvas.ExtensionStatus|false} See {@tutorial ExtensionDocs} on the ExtensionStatus.\n*/\nconst runExtensions = this.runExtensions = function (action, vars, returnArray, nameFilter) {\n  let result = returnArray ? [] : false;\n  $.each(extensions, function (name, ext) {\n    if (nameFilter && !nameFilter(name)) {\n      return;\n    }\n    if (ext && action in ext) {\n      if (typeof vars === 'function') {\n        vars = vars(name); // ext, action\n      }\n      if (returnArray) {\n        result.push(ext[action](vars));\n      } else {\n        result = ext[action](vars);\n      }\n    }\n  });\n  return result;\n};\n\n/**\n* @typedef {PlainObject} module:svgcanvas.ExtensionMouseDownStatus\n* @property {boolean} started Indicates that creating/editing has started\n*/\n/**\n* @typedef {PlainObject} module:svgcanvas.ExtensionMouseUpStatus\n* @property {boolean} keep Indicates if the current element should be kept\n* @property {boolean} started Indicates if editing should still be considered as \"started\"\n* @property {Element} element The element being affected\n*/\n/**\n* @typedef {PlainObject} module:svgcanvas.ExtensionIDsUpdatedStatus\n* @property {string[]} remove Contains string IDs (used by `ext-connector.js`)\n*/\n\n/**\n * @interface module:svgcanvas.ExtensionInitResponse\n * @property {module:SVGEditor.ContextTool[]|PlainObject.<string, module:SVGEditor.ContextTool>} [context_tools]\n * @property {module:SVGEditor.Button[]|PlainObject.<Integer, module:SVGEditor.Button>} [buttons]\n * @property {string} [svgicons] The location of a local SVG or SVGz file\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#mouseDown\n * @param {module:svgcanvas.SvgCanvas#event:ext-mouseDown} arg\n * @returns {undefined|module:svgcanvas.ExtensionMouseDownStatus}\n */\n/**\n * @function module:svgcanvas.ExtensionInitResponse#mouseMove\n * @param {module:svgcanvas.SvgCanvas#event:ext-mouseMove} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#mouseUp\n * @param {module:svgcanvas.SvgCanvas#event:ext-mouseUp} arg\n * @returns {module:svgcanvas.ExtensionMouseUpStatus}\n */\n/**\n * @function module:svgcanvas.ExtensionInitResponse#zoomChanged\n * @param {module:svgcanvas.SvgCanvas#event:ext-zoomChanged} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#IDsUpdated\n * @param {module:svgcanvas.SvgCanvas#event:ext-IDsUpdated} arg\n * @returns {module:svgcanvas.ExtensionIDsUpdatedStatus}\n */\n/**\n * @function module:svgcanvas.ExtensionInitResponse#canvasUpdated\n * @param {module:svgcanvas.SvgCanvas#event:ext-canvasUpdated} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#toolButtonStateUpdate\n * @param {module:svgcanvas.SvgCanvas#event:ext-toolButtonStateUpdate} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#selectedChanged\n * @param {module:svgcanvas.SvgCanvas#event:ext-selectedChanged} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#elementTransition\n * @param {module:svgcanvas.SvgCanvas#event:ext-elementTransition} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#elementChanged\n * @param {module:svgcanvas.SvgCanvas#event:ext-elementChanged} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#langReady\n * @param {module:svgcanvas.SvgCanvas#event:ext-langReady} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#langChanged\n * @param {module:svgcanvas.SvgCanvas#event:ext-langChanged} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#addLangData\n * @param {module:svgcanvas.SvgCanvas#event:ext-addLangData} arg\n * @returns {Promise} Resolves to {@link module:locale.ExtensionLocaleData}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#onNewDocument\n * @param {module:svgcanvas.SvgCanvas#event:ext-onNewDocument} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#workareaResized\n * @param {module:svgcanvas.SvgCanvas#event:ext-workareaResized} arg\n * @returns {undefined}\n*/\n/**\n * @function module:svgcanvas.ExtensionInitResponse#callback\n * @this module:SVGEditor\n * @param {module:svgcanvas.SvgCanvas#event:ext-callback} arg\n * @returns {undefined}\n*/\n\n/**\n* @callback module:svgcanvas.ExtensionInitCallback\n* @this module:SVGEditor\n* @param {module:svgcanvas.ExtensionArgumentObject} arg\n* @returns {Promise} Resolves to [ExtensionInitResponse]{@link module:svgcanvas.ExtensionInitResponse} or `undefined`\n*/\n/**\n* @typedef {PlainObject} module:svgcanvas.ExtensionInitArgs\n* @param {external:jQuery} initArgs.$\n* @param {module:SVGEditor~ImportLocale} initArgs.importLocale\n*/\n/**\n* Add an extension to the editor.\n* @function module:svgcanvas.SvgCanvas#addExtension\n* @param {string} name - String with the ID of the extension. Used internally; no need for i18n.\n* @param {module:svgcanvas.ExtensionInitCallback} [extInitFunc] - Function supplied by the extension with its data\n* @param {module:svgcanvas.ExtensionInitArgs} initArgs\n* @fires module:svgcanvas.SvgCanvas#event:extension_added\n* @throws {TypeError|Error} `TypeError` if `extInitFunc` is not a function, `Error`\n*   if extension of supplied name already exists\n* @returns {Promise} Resolves to `undefined`\n*/\nthis.addExtension = async function (name, extInitFunc, {$: jq, importLocale}) {\n  if (typeof extInitFunc !== 'function') {\n    throw new TypeError('Function argument expected for `svgcanvas.addExtension`');\n  }\n  if (name in extensions) {\n    throw new Error('Cannot add extension \"' + name + '\", an extension by that name already exists.');\n  }\n  // Provide private vars/funcs here. Is there a better way to do this?\n  /**\n   * @typedef {module:svgcanvas.PrivateMethods} module:svgcanvas.ExtensionArgumentObject\n   * @property {SVGSVGElement} svgroot See {@link module:svgcanvas~svgroot}\n   * @property {SVGSVGElement} svgcontent See {@link module:svgcanvas~svgcontent}\n   * @property {!(string|Integer)} nonce See {@link module:draw.Drawing#getNonce}\n   * @property {module:select.SelectorManager} selectorManager\n   * @property {module:SVGEditor~ImportLocale} importLocale\n   */\n  /**\n   * @type {module:svgcanvas.ExtensionArgumentObject}\n   * @see {@link module:svgcanvas.PrivateMethods} source for the other methods/properties\n   */\n  const argObj = $.extend(canvas.getPrivateMethods(), {\n    $: jq,\n    importLocale,\n    svgroot,\n    svgcontent,\n    nonce: getCurrentDrawing().getNonce(),\n    selectorManager\n  });\n  const extObj = await extInitFunc(argObj);\n  if (extObj) {\n    extObj.name = name;\n  }\n\n  extensions[name] = extObj;\n  return call('extension_added', extObj);\n};\n\n/**\n* This method sends back an array or a NodeList full of elements that\n* intersect the multi-select rubber-band-box on the currentLayer only.\n*\n* We brute-force `getIntersectionList` for browsers that do not support it (Firefox).\n*\n* Reference:\n* Firefox does not implement `getIntersectionList()`, see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=501421}.\n* @function module:svgcanvas.SvgCanvas#getIntersectionList\n* @param {SVGRect} rect\n* @returns {Element[]|NodeList} Bbox elements\n*/\nconst getIntersectionList = this.getIntersectionList = function (rect) {\n  if (isNullish(rubberBox)) { return null; }\n\n  const parent = currentGroup || getCurrentDrawing().getCurrentLayer();\n\n  let rubberBBox;\n  if (!rect) {\n    rubberBBox = rubberBox.getBBox();\n    const bb = svgcontent.createSVGRect();\n\n    ['x', 'y', 'width', 'height', 'top', 'right', 'bottom', 'left'].forEach((o) => {\n      bb[o] = rubberBBox[o] / currentZoom;\n    });\n    rubberBBox = bb;\n  } else {\n    rubberBBox = svgcontent.createSVGRect();\n    rubberBBox.x = rect.x;\n    rubberBBox.y = rect.y;\n    rubberBBox.width = rect.width;\n    rubberBBox.height = rect.height;\n  }\n\n  let resultList = null;\n  if (!isIE) {\n    if (typeof svgroot.getIntersectionList === 'function') {\n      // Offset the bbox of the rubber box by the offset of the svgcontent element.\n      rubberBBox.x += parseInt(svgcontent.getAttribute('x'));\n      rubberBBox.y += parseInt(svgcontent.getAttribute('y'));\n\n      resultList = svgroot.getIntersectionList(rubberBBox, parent);\n    }\n  }\n\n  if (isNullish(resultList) || typeof resultList.item !== 'function') {\n    resultList = [];\n\n    if (!curBBoxes.length) {\n      // Cache all bboxes\n      curBBoxes = getVisibleElementsAndBBoxes(parent);\n    }\n    let i = curBBoxes.length;\n    while (i--) {\n      if (!rubberBBox.width) { continue; }\n      if (rectsIntersect(rubberBBox, curBBoxes[i].bbox)) {\n        resultList.push(curBBoxes[i].elem);\n      }\n    }\n  }\n\n  // addToSelection expects an array, but it's ok to pass a NodeList\n  // because using square-bracket notation is allowed:\n  // https://www.w3.org/TR/DOM-Level-2-Core/ecma-script-binding.html\n  return resultList;\n};\n\nthis.getStrokedBBox = getStrokedBBoxDefaultVisible;\n\nthis.getVisibleElements = getVisibleElements;\n\n/**\n* @typedef {PlainObject} ElementAndBBox\n* @property {Element} elem - The element\n* @property {module:utilities.BBoxObject} bbox - The element's BBox as retrieved from `getStrokedBBoxDefaultVisible`\n*/\n\n/**\n* Get all elements that have a BBox (excludes `<defs>`, `<title>`, etc).\n* Note that 0-opacity, off-screen etc elements are still considered \"visible\"\n* for this function.\n* @function module:svgcanvas.SvgCanvas#getVisibleElementsAndBBoxes\n* @param {Element} parent - The parent DOM element to search within\n* @returns {ElementAndBBox[]} An array with objects that include:\n*/\nconst getVisibleElementsAndBBoxes = this.getVisibleElementsAndBBoxes = function (parent) {\n  if (!parent) {\n    parent = $(svgcontent).children(); // Prevent layers from being included\n  }\n  const contentElems = [];\n  $(parent).children().each(function (i, elem) {\n    if (elem.getBBox) {\n      contentElems.push({elem, bbox: getStrokedBBoxDefaultVisible([elem])});\n    }\n  });\n  return contentElems.reverse();\n};\n\n/**\n* Wrap an SVG element into a group element, mark the group as 'gsvg'.\n* @function module:svgcanvas.SvgCanvas#groupSvgElem\n* @param {Element} elem - SVG element to wrap\n* @returns {undefined}\n*/\nconst groupSvgElem = this.groupSvgElem = function (elem) {\n  const g = document.createElementNS(NS.SVG, 'g');\n  elem.replaceWith(g);\n  $(g).append(elem).data('gsvg', elem)[0].id = getNextId();\n};\n\n// Set scope for these functions\n\n// Object to contain editor event names and callback functions\nconst events = {};\n\ncanvas.call = call;\n/**\n * Array of what was changed (elements, layers)\n * @event module:svgcanvas.SvgCanvas#event:changed\n * @type {Element[]}\n */\n/**\n * Array of selected elements\n * @event module:svgcanvas.SvgCanvas#event:selected\n * @type {Element[]}\n */\n/**\n * Array of selected elements\n * @event module:svgcanvas.SvgCanvas#event:transition\n * @type {Element[]}\n */\n/**\n * The Element is always `SVGGElement`?\n * If not `null`, will be the set current group element\n * @event module:svgcanvas.SvgCanvas#event:contextset\n * @type {null|Element}\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:pointsAdded\n * @type {PlainObject}\n * @property {boolean} closedSubpath\n * @property {SVGCircleElement[]} grips Grips elements\n */\n\n/**\n * @event module:svgcanvas.SvgCanvas#event:zoomed\n * @type {PlainObject}\n * @property {Float} x\n * @property {Float} y\n * @property {Float} width\n * @property {Float} height\n * @property {0.5|2} factor\n * @see module:SVGEditor.BBoxObjectWithFactor\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:updateCanvas\n * @type {PlainObject}\n * @property {false} center\n * @property {module:math.XYObject} newCtr\n */\n/**\n * @typedef {PlainObject} module:svgcanvas.ExtensionInitResponsePlusName\n * @implements {module:svgcanvas.ExtensionInitResponse}\n * @property {string} name The extension's resolved ID (whether explicit or based on file name)\n */\n/**\n * Generalized extension object response of\n * [`init()`]{@link module:svgcanvas.ExtensionInitCallback}\n * along with the name of the extension.\n * @event module:svgcanvas.SvgCanvas#event:extension_added\n * @type {module:svgcanvas.ExtensionInitResponsePlusName|undefined}\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:extensions_added\n * @type {undefined}\n*/\n/**\n * @typedef {PlainObject} module:svgcanvas.Message\n * @property {Any} data The data\n * @property {string} origin The origin\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:message\n * @type {module:svgcanvas.Message}\n */\n/**\n * SVG canvas converted to string\n * @event module:svgcanvas.SvgCanvas#event:saved\n * @type {string}\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:setnonce\n * @type {!(string|Integer)}\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:unsetnonce\n * @type {undefined}\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:zoomDone\n * @type {undefined}\n*/\n/**\n * @event module:svgcanvas.SvgCanvas#event:cleared\n * @type {undefined}\n*/\n\n/**\n * @event module:svgcanvas.SvgCanvas#event:exported\n * @type {module:svgcanvas.ImageExportedResults}\n */\n/**\n * @event module:svgcanvas.SvgCanvas#event:exportedPDF\n * @type {module:svgcanvas.PDFExportedResults}\n */\n/**\n * Creating a cover-all class until {@link https://github.com/jsdoc3/jsdoc/issues/1545} may be supported.\n * `undefined` may be returned by {@link module:svgcanvas.SvgCanvas#event:extension_added} if the extension's `init` returns `undefined` It is also the type for the following events \"zoomDone\", \"unsetnonce\", \"cleared\", and \"extensions_added\".\n * @event module:svgcanvas.SvgCanvas#event:GenericCanvasEvent\n * @type {module:svgcanvas.SvgCanvas#event:selected|module:svgcanvas.SvgCanvas#event:changed|module:svgcanvas.SvgCanvas#event:contextset|module:svgcanvas.SvgCanvas#event:pointsAdded|module:svgcanvas.SvgCanvas#event:extension_added|module:svgcanvas.SvgCanvas#event:extensions_added|module:svgcanvas.SvgCanvas#event:message|module:svgcanvas.SvgCanvas#event:transition|module:svgcanvas.SvgCanvas#event:zoomed|module:svgcanvas.SvgCanvas#event:updateCanvas|module:svgcanvas.SvgCanvas#event:saved|module:svgcanvas.SvgCanvas#event:exported|module:svgcanvas.SvgCanvas#event:exportedPDF|module:svgcanvas.SvgCanvas#event:setnonce|module:svgcanvas.SvgCanvas#event:unsetnonce|undefined}\n */\n\n/**\n * The promise return, if present, resolves to `undefined`\n *  (`extension_added`, `exported`, `saved`)\n * @typedef {Promise|undefined} module:svgcanvas.EventHandlerReturn\n*/\n\n/**\n* @callback module:svgcanvas.EventHandler\n* @param {external:Window} win\n* @param {module:svgcanvas.SvgCanvas#event:GenericCanvasEvent} arg\n* @listens module:svgcanvas.SvgCanvas#event:GenericCanvasEvent\n* @returns {module:svgcanvas.EventHandlerReturn}\n*/\n\n/**\n* Attaches a callback function to an event.\n* @function module:svgcanvas.SvgCanvas#bind\n* @param {\"changed\"|\"contextset\"|\"selected\"|\"pointsAdded\"|\"extension_added\"|\"extensions_added\"|\"message\"|\"transition\"|\"zoomed\"|\"updateCanvas\"|\"zoomDone\"|\"saved\"|\"exported\"|\"exportedPDF\"|\"setnonce\"|\"unsetnonce\"|\"cleared\"} ev - String indicating the name of the event\n* @param {module:svgcanvas.EventHandler} f - The callback function to bind to the event\n* @returns {module:svgcanvas.EventHandler} The previous event\n*/\ncanvas.bind = function (ev, f) {\n  const old = events[ev];\n  events[ev] = f;\n  return old;\n};\n\n/**\n* Runs the SVG Document through the sanitizer and then updates its paths.\n* @function module:svgcanvas.SvgCanvas#prepareSvg\n* @param {XMLDocument} newDoc - The SVG DOM document\n* @returns {undefined}\n*/\nthis.prepareSvg = function (newDoc) {\n  this.sanitizeSvg(newDoc.documentElement);\n\n  // convert paths into absolute commands\n  const paths = [...newDoc.getElementsByTagNameNS(NS.SVG, 'path')];\n  paths.forEach((path) => {\n    path.setAttribute('d', pathActions.convertPath(path));\n    pathActions.fixEnd(path);\n  });\n};\n\n/**\n* Hack for Firefox bugs where text element features aren't updated or get\n* messed up. See issue 136 and issue 137.\n* This function clones the element and re-selects it.\n* @function module:svgcanvas~ffClone\n* @todo Test for this bug on load and add it to \"support\" object instead of\n* browser sniffing\n* @param {Element} elem - The (text) DOM element to clone\n* @returns {Element} Cloned element\n*/\nconst ffClone = function (elem) {\n  if (!isGecko()) { return elem; }\n  const clone = elem.cloneNode(true);\n  elem.before(clone);\n  elem.remove();\n  selectorManager.releaseSelector(elem);\n  selectedElements[0] = clone;\n  selectorManager.requestSelector(clone).showGrips(true);\n  return clone;\n};\n\n// `this.each` is deprecated, if any extension used this it can be recreated by doing this:\n// * @example $(canvas.getRootElem()).children().each(...)\n// * @function module:svgcanvas.SvgCanvas#each\n// this.each = function (cb) {\n//  $(svgroot).children().each(cb);\n// };\n\n/**\n* Removes any old rotations if present, prepends a new rotation at the\n* transformed center.\n* @function module:svgcanvas.SvgCanvas#setRotationAngle\n* @param {string|Float} val - The new rotation angle in degrees\n* @param {boolean} preventUndo - Indicates whether the action should be undoable or not\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.setRotationAngle = function (val, preventUndo) {\n  // ensure val is the proper type\n  val = parseFloat(val);\n  const elem = selectedElements[0];\n  const oldTransform = elem.getAttribute('transform');\n  const bbox = utilsGetBBox(elem);\n  const cx = bbox.x + bbox.width / 2, cy = bbox.y + bbox.height / 2;\n  const tlist = getTransformList(elem);\n\n  // only remove the real rotational transform if present (i.e. at index=0)\n  if (tlist.numberOfItems > 0) {\n    const xform = tlist.getItem(0);\n    if (xform.type === 4) {\n      tlist.removeItem(0);\n    }\n  }\n  // find Rnc and insert it\n  if (val !== 0) {\n    const center = transformPoint(cx, cy, transformListToTransform(tlist).matrix);\n    const Rnc = svgroot.createSVGTransform();\n    Rnc.setRotate(val, center.x, center.y);\n    if (tlist.numberOfItems) {\n      tlist.insertItemBefore(Rnc, 0);\n    } else {\n      tlist.appendItem(Rnc);\n    }\n  } else if (tlist.numberOfItems === 0) {\n    elem.removeAttribute('transform');\n  }\n\n  if (!preventUndo) {\n    // we need to undo it, then redo it so it can be undo-able! :)\n    // TODO: figure out how to make changes to transform list undo-able cross-browser?\n    const newTransform = elem.getAttribute('transform');\n    elem.setAttribute('transform', oldTransform);\n    changeSelectedAttribute('transform', newTransform, selectedElements);\n    call('changed', selectedElements);\n  }\n  // const pointGripContainer = getElem('pathpointgrip_container');\n  // if (elem.nodeName === 'path' && pointGripContainer) {\n  //   pathActions.setPointContainerTransform(elem.getAttribute('transform'));\n  // }\n  const selector = selectorManager.requestSelector(selectedElements[0]);\n  selector.resize();\n  Selector.updateGripCursors(val);\n};\n\n/**\n* Runs `recalculateDimensions` on the selected elements,\n* adding the changes to a single batch command.\n* @function module:svgcanvas.SvgCanvas#recalculateAllSelectedDimensions\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nconst recalculateAllSelectedDimensions = this.recalculateAllSelectedDimensions = function () {\n  const text = (currentResizeMode === 'none' ? 'position' : 'size');\n  const batchCmd = new BatchCommand(text);\n\n  let i = selectedElements.length;\n  while (i--) {\n    const elem = selectedElements[i];\n    // if (getRotationAngle(elem) && !hasMatrixTransform(getTransformList(elem))) { continue; }\n    const cmd = recalculateDimensions(elem);\n    if (cmd) {\n      batchCmd.addSubCommand(cmd);\n    }\n  }\n\n  if (!batchCmd.isEmpty()) {\n    addCommandToHistory(batchCmd);\n    call('changed', selectedElements);\n  }\n};\n\n/**\n * Debug tool to easily see the current matrix in the browser's console.\n * @function module:svgcanvas~logMatrix\n * @param {SVGMatrix} m The matrix\n * @returns {undefined}\n */\nconst logMatrix = function (m) {\n  console.log([m.a, m.b, m.c, m.d, m.e, m.f]); // eslint-disable-line no-console\n};\n\n// Root Current Transformation Matrix in user units\nlet rootSctm = null;\n\n/**\n* Group: Selection\n*/\n\n// TODO: do we need to worry about selectedBBoxes here?\n\n/**\n* Selects only the given elements, shortcut for `clearSelection(); addToSelection()`.\n* @function module:svgcanvas.SvgCanvas#selectOnly\n* @param {Element[]} elems - an array of DOM elements to be selected\n* @param {boolean} showGrips - Indicates whether the resize grips should be shown\n* @returns {undefined}\n*/\nconst selectOnly = this.selectOnly = function (elems, showGrips) {\n  clearSelection(true);\n  addToSelection(elems, showGrips);\n};\n\n// TODO: could use slice here to make this faster?\n// TODO: should the 'selected' handler\n\n/**\n* Removes elements from the selection.\n* @function module:svgcanvas.SvgCanvas#removeFromSelection\n* @param {Element[]} elemsToRemove - An array of elements to remove from selection\n* @returns {undefined}\n*/\n/* const removeFromSelection = */ this.removeFromSelection = function (elemsToRemove) {\n  if (isNullish(selectedElements[0])) { return; }\n  if (!elemsToRemove.length) { return; }\n\n  // find every element and remove it from our array copy\n  const newSelectedItems = [],\n    len = selectedElements.length;\n  for (let i = 0; i < len; ++i) {\n    const elem = selectedElements[i];\n    if (elem) {\n      // keep the item\n      if (!elemsToRemove.includes(elem)) {\n        newSelectedItems.push(elem);\n      } else { // remove the item and its selector\n        selectorManager.releaseSelector(elem);\n      }\n    }\n  }\n  // the copy becomes the master now\n  selectedElements = newSelectedItems;\n};\n\n/**\n* Clears the selection, then adds all elements in the current layer to the selection.\n* @function module:svgcanvas.SvgCanvas#selectAllInCurrentLayer\n* @returns {undefined}\n*/\nthis.selectAllInCurrentLayer = function () {\n  const currentLayer = getCurrentDrawing().getCurrentLayer();\n  if (currentLayer) {\n    currentMode = 'select';\n    selectOnly($(currentGroup || currentLayer).children());\n  }\n};\n\nlet drawnPath = null;\n\n// Mouse events\n(function () {\nconst freehand = {\n  minx: null,\n  miny: null,\n  maxx: null,\n  maxy: null\n};\nconst THRESHOLD_DIST = 0.8,\n  STEP_COUNT = 10;\nlet dAttr = null,\n  startX = null,\n  startY = null,\n  rStartX = null,\n  rStartY = null,\n  initBbox = {},\n  sumDistance = 0,\n  controllPoint2 = {x: 0, y: 0},\n  controllPoint1 = {x: 0, y: 0},\n  start = {x: 0, y: 0},\n  end = {x: 0, y: 0},\n  bSpline = {x: 0, y: 0},\n  nextPos = {x: 0, y: 0},\n  parameter,\n  nextParameter;\n\nconst getBsplinePoint = function (t) {\n  const spline = {x: 0, y: 0},\n    p0 = controllPoint2,\n    p1 = controllPoint1,\n    p2 = start,\n    p3 = end,\n    S = 1.0 / 6.0,\n    t2 = t * t,\n    t3 = t2 * t;\n\n  const m = [\n    [-1, 3, -3, 1],\n    [3, -6, 3, 0],\n    [-3, 0, 3, 0],\n    [1, 4, 1, 0]\n  ];\n\n  spline.x = S * (\n    (p0.x * m[0][0] + p1.x * m[0][1] + p2.x * m[0][2] + p3.x * m[0][3]) * t3 +\n      (p0.x * m[1][0] + p1.x * m[1][1] + p2.x * m[1][2] + p3.x * m[1][3]) * t2 +\n      (p0.x * m[2][0] + p1.x * m[2][1] + p2.x * m[2][2] + p3.x * m[2][3]) * t +\n      (p0.x * m[3][0] + p1.x * m[3][1] + p2.x * m[3][2] + p3.x * m[3][3])\n  );\n  spline.y = S * (\n    (p0.y * m[0][0] + p1.y * m[0][1] + p2.y * m[0][2] + p3.y * m[0][3]) * t3 +\n      (p0.y * m[1][0] + p1.y * m[1][1] + p2.y * m[1][2] + p3.y * m[1][3]) * t2 +\n      (p0.y * m[2][0] + p1.y * m[2][1] + p2.y * m[2][2] + p3.y * m[2][3]) * t +\n      (p0.y * m[3][0] + p1.y * m[3][1] + p2.y * m[3][2] + p3.y * m[3][3])\n  );\n\n  return {\n    x: spline.x,\n    y: spline.y\n  };\n};\n/**\n * Follows these conditions:\n * - When we are in a create mode, the element is added to the canvas but the\n *   action is not recorded until mousing up.\n * - When we are in select mode, select the element, remember the position\n *   and do nothing else.\n * @param {MouseEvent} evt\n * @fires module:svgcanvas.SvgCanvas#event:ext-mouseDown\n * @returns {undefined}\n */\nconst mouseDown = function (evt) {\n  if (canvas.spaceKey || evt.button === 1) { return; }\n\n  const rightClick = evt.button === 2;\n\n  if (evt.altKey) { // duplicate when dragging\n    canvas.cloneSelectedElements(0, 0);\n  }\n\n  rootSctm = $('#svgcontent g')[0].getScreenCTM().inverse();\n\n  const pt = transformPoint(evt.pageX, evt.pageY, rootSctm),\n    mouseX = pt.x * currentZoom,\n    mouseY = pt.y * currentZoom;\n\n  evt.preventDefault();\n\n  if (rightClick) {\n    currentMode = 'select';\n    lastClickPoint = pt;\n  }\n\n  // This would seem to be unnecessary...\n  // if (!['select', 'resize'].includes(currentMode)) {\n  //   setGradient();\n  // }\n\n  let x = mouseX / currentZoom,\n    y = mouseY / currentZoom;\n  let mouseTarget = getMouseTarget(evt);\n\n  if (mouseTarget.tagName === 'a' && mouseTarget.childNodes.length === 1) {\n    mouseTarget = mouseTarget.firstChild;\n  }\n\n  // realX/y ignores grid-snap value\n  const realX = x;\n  rStartX = startX = x;\n  const realY = y;\n  rStartY = startY = y;\n\n  if (curConfig.gridSnapping) {\n    x = snapToGrid(x);\n    y = snapToGrid(y);\n    startX = snapToGrid(startX);\n    startY = snapToGrid(startY);\n  }\n\n  // if it is a selector grip, then it must be a single element selected,\n  // set the mouseTarget to that and update the mode to rotate/resize\n\n  if (mouseTarget === selectorManager.selectorParentGroup && !isNullish(selectedElements[0])) {\n    const grip = evt.target;\n    const griptype = elData(grip, 'type');\n    // rotating\n    if (griptype === 'rotate') {\n      currentMode = 'rotate';\n    // resizing\n    } else if (griptype === 'resize') {\n      currentMode = 'resize';\n      currentResizeMode = elData(grip, 'dir');\n    }\n    mouseTarget = selectedElements[0];\n  }\n\n  startTransform = mouseTarget.getAttribute('transform');\n\n  const tlist = getTransformList(mouseTarget);\n  switch (currentMode) {\n  case 'select':\n    started = true;\n    currentResizeMode = 'none';\n    if (rightClick) { started = false; }\n\n    if (mouseTarget !== svgroot) {\n      // if this element is not yet selected, clear selection and select it\n      if (!selectedElements.includes(mouseTarget)) {\n        // only clear selection if shift is not pressed (otherwise, add\n        // element to selection)\n        if (!evt.shiftKey) {\n          // No need to do the call here as it will be done on addToSelection\n          clearSelection(true);\n        }\n        addToSelection([mouseTarget]);\n        justSelected = mouseTarget;\n        pathActions.clear();\n      }\n      // else if it's a path, go into pathedit mode in mouseup\n\n      if (!rightClick) {\n        // insert a dummy transform so if the element(s) are moved it will have\n        // a transform to use for its translate\n        for (let i = 0; i < selectedElements.length; ++i) {\n          if (isNullish(selectedElements[i])) { continue; }\n          const slist = getTransformList(selectedElements[i]);\n          if (slist.numberOfItems) {\n            slist.insertItemBefore(svgroot.createSVGTransform(), 0);\n          } else {\n            slist.appendItem(svgroot.createSVGTransform());\n          }\n        }\n      }\n    } else if (!rightClick) {\n      clearSelection();\n      currentMode = 'multiselect';\n      if (isNullish(rubberBox)) {\n        rubberBox = selectorManager.getRubberBandBox();\n      }\n      rStartX *= currentZoom;\n      rStartY *= currentZoom;\n      // console.log('p',[evt.pageX, evt.pageY]);\n      // console.log('c',[evt.clientX, evt.clientY]);\n      // console.log('o',[evt.offsetX, evt.offsetY]);\n      // console.log('s',[startX, startY]);\n\n      assignAttributes(rubberBox, {\n        x: rStartX,\n        y: rStartY,\n        width: 0,\n        height: 0,\n        display: 'inline'\n      }, 100);\n    }\n    break;\n  case 'zoom':\n    started = true;\n    if (isNullish(rubberBox)) {\n      rubberBox = selectorManager.getRubberBandBox();\n    }\n    assignAttributes(rubberBox, {\n      x: realX * currentZoom,\n      y: realX * currentZoom,\n      width: 0,\n      height: 0,\n      display: 'inline'\n    }, 100);\n    break;\n  case 'resize': {\n    started = true;\n    startX = x;\n    startY = y;\n\n    // Getting the BBox from the selection box, since we know we\n    // want to orient around it\n    initBbox = utilsGetBBox($('#selectedBox0')[0]);\n    const bb = {};\n    $.each(initBbox, function (key, val) {\n      bb[key] = val / currentZoom;\n    });\n    initBbox = bb;\n\n    // append three dummy transforms to the tlist so that\n    // we can translate,scale,translate in mousemove\n    const pos = getRotationAngle(mouseTarget) ? 1 : 0;\n\n    if (hasMatrixTransform(tlist)) {\n      tlist.insertItemBefore(svgroot.createSVGTransform(), pos);\n      tlist.insertItemBefore(svgroot.createSVGTransform(), pos);\n      tlist.insertItemBefore(svgroot.createSVGTransform(), pos);\n    } else {\n      tlist.appendItem(svgroot.createSVGTransform());\n      tlist.appendItem(svgroot.createSVGTransform());\n      tlist.appendItem(svgroot.createSVGTransform());\n\n      if (supportsNonScalingStroke()) {\n        // Handle crash for newer Chrome and Safari 6 (Mobile and Desktop):\n        // https://code.google.com/p/svg-edit/issues/detail?id=904\n        // Chromium issue: https://code.google.com/p/chromium/issues/detail?id=114625\n        // TODO: Remove this workaround once vendor fixes the issue\n        const iswebkit = isWebkit();\n\n        let delayedStroke;\n        if (iswebkit) {\n          delayedStroke = function (ele) {\n            const _stroke = ele.getAttribute('stroke');\n            ele.removeAttribute('stroke');\n            // Re-apply stroke after delay. Anything higher than 1 seems to cause flicker\n            if (_stroke !== null) setTimeout(function () { ele.setAttribute('stroke', _stroke); }, 0);\n          };\n        }\n        mouseTarget.style.vectorEffect = 'non-scaling-stroke';\n        if (iswebkit) { delayedStroke(mouseTarget); }\n\n        const all = mouseTarget.getElementsByTagName('*'),\n          len = all.length;\n        for (let i = 0; i < len; i++) {\n          if (!all[i].style) { // mathML\n            continue;\n          }\n          all[i].style.vectorEffect = 'non-scaling-stroke';\n          if (iswebkit) { delayedStroke(all[i]); }\n        }\n      }\n    }\n    break;\n  } case 'fhellipse':\n  case 'fhrect':\n  case 'fhpath':\n    start.x = realX;\n    start.y = realY;\n    started = true;\n    dAttr = realX + ',' + realY + ' ';\n    // Commented out as doing nothing now:\n    // strokeW = parseFloat(curShape.stroke_width) === 0 ? 1 : curShape.stroke_width;\n    addSVGElementFromJson({\n      element: 'polyline',\n      curStyles: true,\n      attr: {\n        points: dAttr,\n        id: getNextId(),\n        fill: 'none',\n        opacity: curShape.opacity / 2,\n        'stroke-linecap': 'round',\n        style: 'pointer-events:none'\n      }\n    });\n    freehand.minx = realX;\n    freehand.maxx = realX;\n    freehand.miny = realY;\n    freehand.maxy = realY;\n    break;\n  case 'image': {\n    started = true;\n    const newImage = addSVGElementFromJson({\n      element: 'image',\n      attr: {\n        x,\n        y,\n        width: 0,\n        height: 0,\n        id: getNextId(),\n        opacity: curShape.opacity / 2,\n        style: 'pointer-events:inherit'\n      }\n    });\n    setHref(newImage, lastGoodImgUrl);\n    preventClickDefault(newImage);\n    break;\n  } case 'square':\n    // FIXME: once we create the rect, we lose information that this was a square\n    // (for resizing purposes this could be important)\n    // Fallthrough\n  case 'rect':\n    started = true;\n    startX = x;\n    startY = y;\n    addSVGElementFromJson({\n      element: 'rect',\n      curStyles: true,\n      attr: {\n        x,\n        y,\n        width: 0,\n        height: 0,\n        id: getNextId(),\n        opacity: curShape.opacity / 2\n      }\n    });\n    break;\n  case 'line': {\n    started = true;\n    const strokeW = Number(curShape.stroke_width) === 0 ? 1 : curShape.stroke_width;\n    addSVGElementFromJson({\n      element: 'line',\n      curStyles: true,\n      attr: {\n        x1: x,\n        y1: y,\n        x2: x,\n        y2: y,\n        id: getNextId(),\n        stroke: curShape.stroke,\n        'stroke-width': strokeW,\n        'stroke-dasharray': curShape.stroke_dasharray,\n        'stroke-linejoin': curShape.stroke_linejoin,\n        'stroke-linecap': curShape.stroke_linecap,\n        'stroke-opacity': curShape.stroke_opacity,\n        fill: 'none',\n        opacity: curShape.opacity / 2,\n        style: 'pointer-events:none'\n      }\n    });\n    break;\n  } case 'circle':\n    started = true;\n    addSVGElementFromJson({\n      element: 'circle',\n      curStyles: true,\n      attr: {\n        cx: x,\n        cy: y,\n        r: 0,\n        id: getNextId(),\n        opacity: curShape.opacity / 2\n      }\n    });\n    break;\n  case 'ellipse':\n    started = true;\n    addSVGElementFromJson({\n      element: 'ellipse',\n      curStyles: true,\n      attr: {\n        cx: x,\n        cy: y,\n        rx: 0,\n        ry: 0,\n        id: getNextId(),\n        opacity: curShape.opacity / 2\n      }\n    });\n    break;\n  case 'text':\n    started = true;\n    /* const newText = */ addSVGElementFromJson({\n      element: 'text',\n      curStyles: true,\n      attr: {\n        x,\n        y,\n        id: getNextId(),\n        fill: curText.fill,\n        'stroke-width': curText.stroke_width,\n        'font-size': curText.font_size,\n        'font-family': curText.font_family,\n        'text-anchor': 'middle',\n        'xml:space': 'preserve',\n        opacity: curShape.opacity\n      }\n    });\n    // newText.textContent = 'text';\n    break;\n  case 'path':\n    // Fall through\n  case 'pathedit':\n    startX *= currentZoom;\n    startY *= currentZoom;\n    pathActions.mouseDown(evt, mouseTarget, startX, startY);\n    started = true;\n    break;\n  case 'textedit':\n    startX *= currentZoom;\n    startY *= currentZoom;\n    textActions.mouseDown(evt, mouseTarget, startX, startY);\n    started = true;\n    break;\n  case 'rotate':\n    started = true;\n    // we are starting an undoable change (a drag-rotation)\n    canvas.undoMgr.beginUndoableChange('transform', selectedElements);\n    break;\n  default:\n    // This could occur in an extension\n    break;\n  }\n\n  /**\n   * The main (left) mouse button is held down on the canvas area\n   * @event module:svgcanvas.SvgCanvas#event:ext-mouseDown\n   * @type {PlainObject}\n   * @property {MouseEvent} event The event object\n   * @property {Float} start_x x coordinate on canvas\n   * @property {Float} start_y y coordinate on canvas\n   * @property {Element[]} selectedElements An array of the selected Elements\n  */\n  const extResult = runExtensions('mouseDown', /** @type {module:svgcanvas.SvgCanvas#event:ext-mouseDown} */ {\n    event: evt,\n    start_x: startX,\n    start_y: startY,\n    selectedElements\n  }, true);\n\n  $.each(extResult, function (i, r) {\n    if (r && r.started) {\n      started = true;\n    }\n  });\n};\n\n// in this function we do not record any state changes yet (but we do update\n// any elements that are still being created, moved or resized on the canvas)\n/**\n *\n * @param {MouseEvent} evt\n * @fires module:svgcanvas.SvgCanvas#event:transition\n * @fires module:svgcanvas.SvgCanvas#event:ext-mouseMove\n * @returns {undefined}\n */\nconst mouseMove = function (evt) {\n  if (!started) { return; }\n  if (evt.button === 1 || canvas.spaceKey) { return; }\n\n  let i, xya, c, cx, cy, dx, dy, len, angle, box,\n    selected = selectedElements[0];\n  const\n    pt = transformPoint(evt.pageX, evt.pageY, rootSctm),\n    mouseX = pt.x * currentZoom,\n    mouseY = pt.y * currentZoom,\n    shape = getElem(getId());\n\n  let realX = mouseX / currentZoom;\n  let x = realX;\n  let realY = mouseY / currentZoom;\n  let y = realY;\n\n  if (curConfig.gridSnapping) {\n    x = snapToGrid(x);\n    y = snapToGrid(y);\n  }\n\n  evt.preventDefault();\n  let tlist;\n  switch (currentMode) {\n  case 'select': {\n    // we temporarily use a translate on the element(s) being dragged\n    // this transform is removed upon mousing up and the element is\n    // relocated to the new location\n    if (selectedElements[0] !== null) {\n      dx = x - startX;\n      dy = y - startY;\n\n      if (curConfig.gridSnapping) {\n        dx = snapToGrid(dx);\n        dy = snapToGrid(dy);\n      }\n\n      /*\n      // Commenting out as currently has no effect\n      if (evt.shiftKey) {\n        xya = snapToAngle(startX, startY, x, y);\n        ({x, y} = xya);\n      }\n      */\n\n      if (dx !== 0 || dy !== 0) {\n        len = selectedElements.length;\n        for (i = 0; i < len; ++i) {\n          selected = selectedElements[i];\n          if (isNullish(selected)) { break; }\n          // if (i === 0) {\n          //   const box = utilsGetBBox(selected);\n          //     selectedBBoxes[i].x = box.x + dx;\n          //     selectedBBoxes[i].y = box.y + dy;\n          // }\n\n          // update the dummy transform in our transform list\n          // to be a translate\n          const xform = svgroot.createSVGTransform();\n          tlist = getTransformList(selected);\n          // Note that if Webkit and there's no ID for this\n          // element, the dummy transform may have gotten lost.\n          // This results in unexpected behaviour\n\n          xform.setTranslate(dx, dy);\n          if (tlist.numberOfItems) {\n            tlist.replaceItem(xform, 0);\n          } else {\n            tlist.appendItem(xform);\n          }\n\n          // update our internal bbox that we're tracking while dragging\n          selectorManager.requestSelector(selected).resize();\n        }\n\n        call('transition', selectedElements);\n      }\n    }\n    break;\n  } case 'multiselect': {\n    realX *= currentZoom;\n    realY *= currentZoom;\n    assignAttributes(rubberBox, {\n      x: Math.min(rStartX, realX),\n      y: Math.min(rStartY, realY),\n      width: Math.abs(realX - rStartX),\n      height: Math.abs(realY - rStartY)\n    }, 100);\n\n    // for each selected:\n    // - if newList contains selected, do nothing\n    // - if newList doesn't contain selected, remove it from selected\n    // - for any newList that was not in selectedElements, add it to selected\n    const elemsToRemove = selectedElements.slice(), elemsToAdd = [],\n      newList = getIntersectionList();\n\n    // For every element in the intersection, add if not present in selectedElements.\n    len = newList.length;\n    for (i = 0; i < len; ++i) {\n      const intElem = newList[i];\n      // Found an element that was not selected before, so we should add it.\n      if (!selectedElements.includes(intElem)) {\n        elemsToAdd.push(intElem);\n      }\n      // Found an element that was already selected, so we shouldn't remove it.\n      const foundInd = elemsToRemove.indexOf(intElem);\n      if (foundInd !== -1) {\n        elemsToRemove.splice(foundInd, 1);\n      }\n    }\n\n    if (elemsToRemove.length > 0) {\n      canvas.removeFromSelection(elemsToRemove);\n    }\n\n    if (elemsToAdd.length > 0) {\n      canvas.addToSelection(elemsToAdd);\n    }\n\n    break;\n  } case 'resize': {\n    // we track the resize bounding box and translate/scale the selected element\n    // while the mouse is down, when mouse goes up, we use this to recalculate\n    // the shape's coordinates\n    tlist = getTransformList(selected);\n    const hasMatrix = hasMatrixTransform(tlist);\n    box = hasMatrix ? initBbox : utilsGetBBox(selected);\n    let left = box.x,\n      top = box.y,\n      {width, height} = box;\n    dx = (x - startX);\n    dy = (y - startY);\n\n    if (curConfig.gridSnapping) {\n      dx = snapToGrid(dx);\n      dy = snapToGrid(dy);\n      height = snapToGrid(height);\n      width = snapToGrid(width);\n    }\n\n    // if rotated, adjust the dx,dy values\n    angle = getRotationAngle(selected);\n    if (angle) {\n      const r = Math.sqrt(dx * dx + dy * dy),\n        theta = Math.atan2(dy, dx) - angle * Math.PI / 180.0;\n      dx = r * Math.cos(theta);\n      dy = r * Math.sin(theta);\n    }\n\n    // if not stretching in y direction, set dy to 0\n    // if not stretching in x direction, set dx to 0\n    if (!currentResizeMode.includes('n') && !currentResizeMode.includes('s')) {\n      dy = 0;\n    }\n    if (!currentResizeMode.includes('e') && !currentResizeMode.includes('w')) {\n      dx = 0;\n    }\n\n    let // ts = null,\n      tx = 0, ty = 0,\n      sy = height ? (height + dy) / height : 1,\n      sx = width ? (width + dx) / width : 1;\n    // if we are dragging on the north side, then adjust the scale factor and ty\n    if (currentResizeMode.includes('n')) {\n      sy = height ? (height - dy) / height : 1;\n      ty = height;\n    }\n\n    // if we dragging on the east side, then adjust the scale factor and tx\n    if (currentResizeMode.includes('w')) {\n      sx = width ? (width - dx) / width : 1;\n      tx = width;\n    }\n\n    // update the transform list with translate,scale,translate\n    const translateOrigin = svgroot.createSVGTransform(),\n      scale = svgroot.createSVGTransform(),\n      translateBack = svgroot.createSVGTransform();\n\n    if (curConfig.gridSnapping) {\n      left = snapToGrid(left);\n      tx = snapToGrid(tx);\n      top = snapToGrid(top);\n      ty = snapToGrid(ty);\n    }\n\n    translateOrigin.setTranslate(-(left + tx), -(top + ty));\n    if (evt.shiftKey) {\n      if (sx === 1) {\n        sx = sy;\n      } else { sy = sx; }\n    }\n    scale.setScale(sx, sy);\n\n    translateBack.setTranslate(left + tx, top + ty);\n    if (hasMatrix) {\n      const diff = angle ? 1 : 0;\n      tlist.replaceItem(translateOrigin, 2 + diff);\n      tlist.replaceItem(scale, 1 + diff);\n      tlist.replaceItem(translateBack, Number(diff));\n    } else {\n      const N = tlist.numberOfItems;\n      tlist.replaceItem(translateBack, N - 3);\n      tlist.replaceItem(scale, N - 2);\n      tlist.replaceItem(translateOrigin, N - 1);\n    }\n\n    selectorManager.requestSelector(selected).resize();\n\n    call('transition', selectedElements);\n\n    break;\n  } case 'zoom': {\n    realX *= currentZoom;\n    realY *= currentZoom;\n    assignAttributes(rubberBox, {\n      x: Math.min(rStartX * currentZoom, realX),\n      y: Math.min(rStartY * currentZoom, realY),\n      width: Math.abs(realX - rStartX * currentZoom),\n      height: Math.abs(realY - rStartY * currentZoom)\n    }, 100);\n    break;\n  } case 'text': {\n    assignAttributes(shape, {\n      x,\n      y\n    }, 1000);\n    break;\n  } case 'line': {\n    if (curConfig.gridSnapping) {\n      x = snapToGrid(x);\n      y = snapToGrid(y);\n    }\n\n    let x2 = x;\n    let y2 = y;\n\n    if (evt.shiftKey) {\n      xya = snapToAngle(startX, startY, x2, y2);\n      x2 = xya.x;\n      y2 = xya.y;\n    }\n\n    shape.setAttribute('x2', x2);\n    shape.setAttribute('y2', y2);\n    break;\n  } case 'foreignObject':\n    // fall through\n  case 'square':\n    // fall through\n  case 'rect':\n    // fall through\n  case 'image': {\n    const square = (currentMode === 'square') || evt.shiftKey;\n    let\n      w = Math.abs(x - startX),\n      h = Math.abs(y - startY);\n    let newX, newY;\n    if (square) {\n      w = h = Math.max(w, h);\n      newX = startX < x ? startX : startX - w;\n      newY = startY < y ? startY : startY - h;\n    } else {\n      newX = Math.min(startX, x);\n      newY = Math.min(startY, y);\n    }\n\n    if (curConfig.gridSnapping) {\n      w = snapToGrid(w);\n      h = snapToGrid(h);\n      newX = snapToGrid(newX);\n      newY = snapToGrid(newY);\n    }\n\n    assignAttributes(shape, {\n      width: w,\n      height: h,\n      x: newX,\n      y: newY\n    }, 1000);\n\n    break;\n  } case 'circle': {\n    c = $(shape).attr(['cx', 'cy']);\n    ({cx, cy} = c);\n    let rad = Math.sqrt((x - cx) * (x - cx) + (y - cy) * (y - cy));\n    if (curConfig.gridSnapping) {\n      rad = snapToGrid(rad);\n    }\n    shape.setAttribute('r', rad);\n    break;\n  } case 'ellipse': {\n    c = $(shape).attr(['cx', 'cy']);\n    ({cx, cy} = c);\n    if (curConfig.gridSnapping) {\n      x = snapToGrid(x);\n      cx = snapToGrid(cx);\n      y = snapToGrid(y);\n      cy = snapToGrid(cy);\n    }\n    shape.setAttribute('rx', Math.abs(x - cx));\n    const ry = Math.abs(evt.shiftKey ? (x - cx) : (y - cy));\n    shape.setAttribute('ry', ry);\n    break;\n  }\n  case 'fhellipse':\n  case 'fhrect': {\n    freehand.minx = Math.min(realX, freehand.minx);\n    freehand.maxx = Math.max(realX, freehand.maxx);\n    freehand.miny = Math.min(realY, freehand.miny);\n    freehand.maxy = Math.max(realY, freehand.maxy);\n  }\n  // Fallthrough\n  case 'fhpath': {\n    // dAttr += + realX + ',' + realY + ' ';\n    // shape.setAttribute('points', dAttr);\n    end.x = realX; end.y = realY;\n    if (controllPoint2.x && controllPoint2.y) {\n      for (i = 0; i < STEP_COUNT - 1; i++) {\n        parameter = i / STEP_COUNT;\n        nextParameter = (i + 1) / STEP_COUNT;\n        bSpline = getBsplinePoint(nextParameter);\n        nextPos = bSpline;\n        bSpline = getBsplinePoint(parameter);\n        sumDistance += Math.sqrt((nextPos.x - bSpline.x) * (nextPos.x - bSpline.x) + (nextPos.y - bSpline.y) * (nextPos.y - bSpline.y));\n        if (sumDistance > THRESHOLD_DIST) {\n          sumDistance -= THRESHOLD_DIST;\n\n          // Faster than completely re-writing the points attribute.\n          const point = svgcontent.createSVGPoint();\n          point.x = bSpline.x;\n          point.y = bSpline.y;\n          shape.points.appendItem(point);\n        }\n      }\n    }\n    controllPoint2 = {x: controllPoint1.x, y: controllPoint1.y};\n    controllPoint1 = {x: start.x, y: start.y};\n    start = {x: end.x, y: end.y};\n    break;\n  // update path stretch line coordinates\n} case 'path':\n  // fall through\n  case 'pathedit': {\n    x *= currentZoom;\n    y *= currentZoom;\n\n    if (curConfig.gridSnapping) {\n      x = snapToGrid(x);\n      y = snapToGrid(y);\n      startX = snapToGrid(startX);\n      startY = snapToGrid(startY);\n    }\n    if (evt.shiftKey) {\n      const {path} = pathModule;\n      let x1, y1;\n      if (path) {\n        x1 = path.dragging ? path.dragging[0] : startX;\n        y1 = path.dragging ? path.dragging[1] : startY;\n      } else {\n        x1 = startX;\n        y1 = startY;\n      }\n      xya = snapToAngle(x1, y1, x, y);\n      ({x, y} = xya);\n    }\n\n    if (rubberBox && rubberBox.getAttribute('display') !== 'none') {\n      realX *= currentZoom;\n      realY *= currentZoom;\n      assignAttributes(rubberBox, {\n        x: Math.min(rStartX * currentZoom, realX),\n        y: Math.min(rStartY * currentZoom, realY),\n        width: Math.abs(realX - rStartX * currentZoom),\n        height: Math.abs(realY - rStartY * currentZoom)\n      }, 100);\n    }\n    pathActions.mouseMove(x, y);\n\n    break;\n  } case 'textedit': {\n    x *= currentZoom;\n    y *= currentZoom;\n    // if (rubberBox && rubberBox.getAttribute('display') !== 'none') {\n    //   assignAttributes(rubberBox, {\n    //     x: Math.min(startX, x),\n    //     y: Math.min(startY, y),\n    //     width: Math.abs(x - startX),\n    //     height: Math.abs(y - startY)\n    //   }, 100);\n    // }\n\n    textActions.mouseMove(mouseX, mouseY);\n\n    break;\n  } case 'rotate': {\n    box = utilsGetBBox(selected);\n    cx = box.x + box.width / 2;\n    cy = box.y + box.height / 2;\n    const m = getMatrix(selected),\n      center = transformPoint(cx, cy, m);\n    cx = center.x;\n    cy = center.y;\n    angle = ((Math.atan2(cy - y, cx - x) * (180 / Math.PI)) - 90) % 360;\n    if (curConfig.gridSnapping) {\n      angle = snapToGrid(angle);\n    }\n    if (evt.shiftKey) { // restrict rotations to nice angles (WRS)\n      const snap = 45;\n      angle = Math.round(angle / snap) * snap;\n    }\n\n    canvas.setRotationAngle(angle < -180 ? (360 + angle) : angle, true);\n    call('transition', selectedElements);\n    break;\n  } default:\n    break;\n  }\n\n  /**\n  * The mouse has moved on the canvas area\n  * @event module:svgcanvas.SvgCanvas#event:ext-mouseMove\n  * @type {PlainObject}\n  * @property {MouseEvent} event The event object\n  * @property {Float} mouse_x x coordinate on canvas\n  * @property {Float} mouse_y y coordinate on canvas\n  * @property {Element} selected Refers to the first selected element\n  */\n  runExtensions('mouseMove', /** @type {module:svgcanvas.SvgCanvas#event:ext-mouseMove} */ {\n    event: evt,\n    mouse_x: mouseX,\n    mouse_y: mouseY,\n    selected\n  });\n}; // mouseMove()\n\n// - in create mode, the element's opacity is set properly, we create an InsertElementCommand\n// and store it on the Undo stack\n// - in move/resize mode, the element's attributes which were affected by the move/resize are\n// identified, a ChangeElementCommand is created and stored on the stack for those attrs\n// this is done in when we recalculate the selected dimensions()\n/**\n *\n * @param {MouseEvent} evt\n * @fires module:svgcanvas.SvgCanvas#event:zoomed\n * @fires module:svgcanvas.SvgCanvas#event:changed\n * @fires module:svgcanvas.SvgCanvas#event:ext-mouseUp\n * @returns {undefined}\n */\nconst mouseUp = function (evt) {\n  if (evt.button === 2) { return; }\n  const tempJustSelected = justSelected;\n  justSelected = null;\n  if (!started) { return; }\n  const pt = transformPoint(evt.pageX, evt.pageY, rootSctm),\n    mouseX = pt.x * currentZoom,\n    mouseY = pt.y * currentZoom,\n    x = mouseX / currentZoom,\n    y = mouseY / currentZoom;\n\n  let element = getElem(getId());\n  let keep = false;\n\n  const realX = x;\n  const realY = y;\n\n  // TODO: Make true when in multi-unit mode\n  const useUnit = false; // (curConfig.baseUnit !== 'px');\n  started = false;\n  let attrs, t;\n  switch (currentMode) {\n  // intentionally fall-through to select here\n  case 'resize':\n  case 'multiselect':\n    if (!isNullish(rubberBox)) {\n      rubberBox.setAttribute('display', 'none');\n      curBBoxes = [];\n    }\n    currentMode = 'select';\n    // Fallthrough\n  case 'select':\n    if (!isNullish(selectedElements[0])) {\n      // if we only have one selected element\n      if (isNullish(selectedElements[1])) {\n        // set our current stroke/fill properties to the element's\n        const selected = selectedElements[0];\n        switch (selected.tagName) {\n        case 'g':\n        case 'use':\n        case 'image':\n        case 'foreignObject':\n          break;\n        default:\n          curProperties.fill = selected.getAttribute('fill');\n          curProperties.fill_opacity = selected.getAttribute('fill-opacity');\n          curProperties.stroke = selected.getAttribute('stroke');\n          curProperties.stroke_opacity = selected.getAttribute('stroke-opacity');\n          curProperties.stroke_width = selected.getAttribute('stroke-width');\n          curProperties.stroke_dasharray = selected.getAttribute('stroke-dasharray');\n          curProperties.stroke_linejoin = selected.getAttribute('stroke-linejoin');\n          curProperties.stroke_linecap = selected.getAttribute('stroke-linecap');\n        }\n\n        if (selected.tagName === 'text') {\n          curText.font_size = selected.getAttribute('font-size');\n          curText.font_family = selected.getAttribute('font-family');\n        }\n        selectorManager.requestSelector(selected).showGrips(true);\n\n        // This shouldn't be necessary as it was done on mouseDown...\n        // call('selected', [selected]);\n      }\n      // always recalculate dimensions to strip off stray identity transforms\n      recalculateAllSelectedDimensions();\n      // if it was being dragged/resized\n      if (realX !== rStartX || realY !== rStartY) {\n        const len = selectedElements.length;\n        for (let i = 0; i < len; ++i) {\n          if (isNullish(selectedElements[i])) { break; }\n          if (!selectedElements[i].firstChild) {\n            // Not needed for groups (incorrectly resizes elems), possibly not needed at all?\n            selectorManager.requestSelector(selectedElements[i]).resize();\n          }\n        }\n      // no change in position/size, so maybe we should move to pathedit\n      } else {\n        t = evt.target;\n        if (selectedElements[0].nodeName === 'path' && isNullish(selectedElements[1])) {\n          pathActions.select(selectedElements[0]);\n        // if it was a path\n        // else, if it was selected and this is a shift-click, remove it from selection\n        } else if (evt.shiftKey) {\n          if (tempJustSelected !== t) {\n            canvas.removeFromSelection([t]);\n          }\n        }\n      } // no change in mouse position\n\n      // Remove non-scaling stroke\n      if (supportsNonScalingStroke()) {\n        const elem = selectedElements[0];\n        if (elem) {\n          elem.removeAttribute('style');\n          walkTree(elem, function (el) {\n            el.removeAttribute('style');\n          });\n        }\n      }\n    }\n    return;\n  case 'zoom': {\n    if (!isNullish(rubberBox)) {\n      rubberBox.setAttribute('display', 'none');\n    }\n    const factor = evt.shiftKey ? 0.5 : 2;\n    call('zoomed', {\n      x: Math.min(rStartX, realX),\n      y: Math.min(rStartY, realY),\n      width: Math.abs(realX - rStartX),\n      height: Math.abs(realY - rStartY),\n      factor\n    });\n    return;\n  } case 'fhpath': {\n    // Check that the path contains at least 2 points; a degenerate one-point path\n    // causes problems.\n    // Webkit ignores how we set the points attribute with commas and uses space\n    // to separate all coordinates, see https://bugs.webkit.org/show_bug.cgi?id=29870\n    sumDistance = 0;\n    controllPoint2 = {x: 0, y: 0};\n    controllPoint1 = {x: 0, y: 0};\n    start = {x: 0, y: 0};\n    end = {x: 0, y: 0};\n    const coords = element.getAttribute('points');\n    const commaIndex = coords.indexOf(',');\n    if (commaIndex >= 0) {\n      keep = coords.indexOf(',', commaIndex + 1) >= 0;\n    } else {\n      keep = coords.indexOf(' ', coords.indexOf(' ') + 1) >= 0;\n    }\n    if (keep) {\n      element = pathActions.smoothPolylineIntoPath(element);\n    }\n    break;\n  } case 'line':\n    attrs = $(element).attr(['x1', 'x2', 'y1', 'y2']);\n    keep = (attrs.x1 !== attrs.x2 || attrs.y1 !== attrs.y2);\n    break;\n  case 'foreignObject':\n  case 'square':\n  case 'rect':\n  case 'image':\n    attrs = $(element).attr(['width', 'height']);\n    // Image should be kept regardless of size (use inherit dimensions later)\n    keep = (attrs.width || attrs.height) || currentMode === 'image';\n    break;\n  case 'circle':\n    keep = (element.getAttribute('r') !== '0');\n    break;\n  case 'ellipse':\n    attrs = $(element).attr(['rx', 'ry']);\n    keep = (attrs.rx || attrs.ry);\n    break;\n  case 'fhellipse':\n    if ((freehand.maxx - freehand.minx) > 0 &&\n      (freehand.maxy - freehand.miny) > 0) {\n      element = addSVGElementFromJson({\n        element: 'ellipse',\n        curStyles: true,\n        attr: {\n          cx: (freehand.minx + freehand.maxx) / 2,\n          cy: (freehand.miny + freehand.maxy) / 2,\n          rx: (freehand.maxx - freehand.minx) / 2,\n          ry: (freehand.maxy - freehand.miny) / 2,\n          id: getId()\n        }\n      });\n      call('changed', [element]);\n      keep = true;\n    }\n    break;\n  case 'fhrect':\n    if ((freehand.maxx - freehand.minx) > 0 &&\n      (freehand.maxy - freehand.miny) > 0) {\n      element = addSVGElementFromJson({\n        element: 'rect',\n        curStyles: true,\n        attr: {\n          x: freehand.minx,\n          y: freehand.miny,\n          width: (freehand.maxx - freehand.minx),\n          height: (freehand.maxy - freehand.miny),\n          id: getId()\n        }\n      });\n      call('changed', [element]);\n      keep = true;\n    }\n    break;\n  case 'text':\n    keep = true;\n    selectOnly([element]);\n    textActions.start(element);\n    break;\n  case 'path': {\n    // set element to null here so that it is not removed nor finalized\n    element = null;\n    // continue to be set to true so that mouseMove happens\n    started = true;\n\n    const res = pathActions.mouseUp(evt, element, mouseX, mouseY);\n    ({element} = res);\n    ({keep} = res);\n    break;\n  } case 'pathedit':\n    keep = true;\n    element = null;\n    pathActions.mouseUp(evt);\n    break;\n  case 'textedit':\n    keep = false;\n    element = null;\n    textActions.mouseUp(evt, mouseX, mouseY);\n    break;\n  case 'rotate': {\n    keep = true;\n    element = null;\n    currentMode = 'select';\n    const batchCmd = canvas.undoMgr.finishUndoableChange();\n    if (!batchCmd.isEmpty()) {\n      addCommandToHistory(batchCmd);\n    }\n    // perform recalculation to weed out any stray identity transforms that might get stuck\n    recalculateAllSelectedDimensions();\n    call('changed', selectedElements);\n    break;\n  } default:\n    // This could occur in an extension\n    break;\n  }\n\n  /**\n  * The main (left) mouse button is released (anywhere)\n  * @event module:svgcanvas.SvgCanvas#event:ext-mouseUp\n  * @type {PlainObject}\n  * @property {MouseEvent} event The event object\n  * @property {Float} mouse_x x coordinate on canvas\n  * @property {Float} mouse_y y coordinate on canvas\n  */\n  const extResult = runExtensions('mouseUp', /** @type {module:svgcanvas.SvgCanvas#event:ext-mouseUp} */ {\n    event: evt,\n    mouse_x: mouseX,\n    mouse_y: mouseY\n  }, true);\n\n  $.each(extResult, function (i, r) {\n    if (r) {\n      keep = r.keep || keep;\n      ({element} = r);\n      started = r.started || started;\n    }\n  });\n\n  if (!keep && !isNullish(element)) {\n    getCurrentDrawing().releaseId(getId());\n    element.remove();\n    element = null;\n\n    t = evt.target;\n\n    // if this element is in a group, go up until we reach the top-level group\n    // just below the layer groups\n    // TODO: once we implement links, we also would have to check for <a> elements\n    while (t && t.parentNode && t.parentNode.parentNode && t.parentNode.parentNode.tagName === 'g') {\n      t = t.parentNode;\n    }\n    // if we are not in the middle of creating a path, and we've clicked on some shape,\n    // then go to Select mode.\n    // WebKit returns <div> when the canvas is clicked, Firefox/Opera return <svg>\n    if ((currentMode !== 'path' || !drawnPath) &&\n      t && t.parentNode &&\n      t.parentNode.id !== 'selectorParentGroup' &&\n      t.id !== 'svgcanvas' && t.id !== 'svgroot'\n    ) {\n      // switch into \"select\" mode if we've clicked on an element\n      canvas.setMode('select');\n      selectOnly([t], true);\n    }\n  } else if (!isNullish(element)) {\n    /**\n    * @name module:svgcanvas.SvgCanvas#addedNew\n    * @type {boolean}\n    */\n    canvas.addedNew = true;\n\n    if (useUnit) { convertAttrs(element); }\n\n    let aniDur = 0.2;\n    let cAni;\n    if (opacAni.beginElement && parseFloat(element.getAttribute('opacity')) !== curShape.opacity) {\n      cAni = $(opacAni).clone().attr({\n        to: curShape.opacity,\n        dur: aniDur\n      }).appendTo(element);\n      try {\n        // Fails in FF4 on foreignObject\n        cAni[0].beginElement();\n      } catch (e) {}\n    } else {\n      aniDur = 0;\n    }\n\n    // Ideally this would be done on the endEvent of the animation,\n    // but that doesn't seem to be supported in Webkit\n    setTimeout(function () {\n      if (cAni) { cAni.remove(); }\n      element.setAttribute('opacity', curShape.opacity);\n      element.setAttribute('style', 'pointer-events:inherit');\n      cleanupElement(element);\n      if (currentMode === 'path') {\n        pathActions.toEditMode(element);\n      } else if (curConfig.selectNew) {\n        selectOnly([element], true);\n      }\n      // we create the insert command that is stored on the stack\n      // undo means to call cmd.unapply(), redo means to call cmd.apply()\n      addCommandToHistory(new InsertElementCommand(element));\n\n      call('changed', [element]);\n    }, aniDur * 1000);\n  }\n\n  startTransform = null;\n};\n\nconst dblClick = function (evt) {\n  const evtTarget = evt.target;\n  const parent = evtTarget.parentNode;\n\n  // Do nothing if already in current group\n  if (parent === currentGroup) { return; }\n\n  let mouseTarget = getMouseTarget(evt);\n  const {tagName} = mouseTarget;\n\n  if (tagName === 'text' && currentMode !== 'textedit') {\n    const pt = transformPoint(evt.pageX, evt.pageY, rootSctm);\n    textActions.select(mouseTarget, pt.x, pt.y);\n  }\n\n  if ((tagName === 'g' || tagName === 'a') &&\n    getRotationAngle(mouseTarget)\n  ) {\n    // TODO: Allow method of in-group editing without having to do\n    // this (similar to editing rotated paths)\n\n    // Ungroup and regroup\n    pushGroupProperties(mouseTarget);\n    mouseTarget = selectedElements[0];\n    clearSelection(true);\n  }\n  // Reset context\n  if (currentGroup) {\n    draw.leaveContext();\n  }\n\n  if ((parent.tagName !== 'g' && parent.tagName !== 'a') ||\n    parent === getCurrentDrawing().getCurrentLayer() ||\n    mouseTarget === selectorManager.selectorParentGroup\n  ) {\n    // Escape from in-group edit\n    return;\n  }\n  draw.setContext(mouseTarget);\n};\n\n// prevent links from being followed in the canvas\nconst handleLinkInCanvas = function (e) {\n  e.preventDefault();\n  return false;\n};\n\n// Added mouseup to the container here.\n// TODO(codedread): Figure out why after the Closure compiler, the window mouseup is ignored.\n$(container).mousedown(mouseDown).mousemove(mouseMove).click(handleLinkInCanvas).dblclick(dblClick).mouseup(mouseUp);\n// $(window).mouseup(mouseUp);\n\n// TODO(rafaelcastrocouto): User preference for shift key and zoom factor\n$(container).bind(\n  'mousewheel DOMMouseScroll',\n  /**\n   * @param {Event} e\n   * @fires module:svgcanvas.SvgCanvas#event:updateCanvas\n   * @fires module:svgcanvas.SvgCanvas#event:zoomDone\n   * @returns {undefined}\n   */\n  function (e) {\n    if (!e.shiftKey) { return; }\n\n    e.preventDefault();\n    const evt = e.originalEvent;\n\n    rootSctm = $('#svgcontent g')[0].getScreenCTM().inverse();\n\n    const workarea = $('#workarea');\n    const scrbar = 15;\n    const rulerwidth = curConfig.showRulers ? 16 : 0;\n\n    // mouse relative to content area in content pixels\n    const pt = transformPoint(evt.pageX, evt.pageY, rootSctm);\n\n    // full work area width in screen pixels\n    const editorFullW = workarea.width();\n    const editorFullH = workarea.height();\n\n    // work area width minus scroll and ruler in screen pixels\n    const editorW = editorFullW - scrbar - rulerwidth;\n    const editorH = editorFullH - scrbar - rulerwidth;\n\n    // work area width in content pixels\n    const workareaViewW = editorW * rootSctm.a;\n    const workareaViewH = editorH * rootSctm.d;\n\n    // content offset from canvas in screen pixels\n    const wOffset = workarea.offset();\n    const wOffsetLeft = wOffset.left + rulerwidth;\n    const wOffsetTop = wOffset.top + rulerwidth;\n\n    const delta = (evt.wheelDelta) ? evt.wheelDelta : (evt.detail) ? -evt.detail : 0;\n    if (!delta) { return; }\n\n    let factor = Math.max(3 / 4, Math.min(4 / 3, (delta)));\n\n    let wZoom, hZoom;\n    if (factor > 1) {\n      wZoom = Math.ceil(editorW / workareaViewW * factor * 100) / 100;\n      hZoom = Math.ceil(editorH / workareaViewH * factor * 100) / 100;\n    } else {\n      wZoom = Math.floor(editorW / workareaViewW * factor * 100) / 100;\n      hZoom = Math.floor(editorH / workareaViewH * factor * 100) / 100;\n    }\n    let zoomlevel = Math.min(wZoom, hZoom);\n    zoomlevel = Math.min(10, Math.max(0.01, zoomlevel));\n    if (zoomlevel === currentZoom) {\n      return;\n    }\n    factor = zoomlevel / currentZoom;\n\n    // top left of workarea in content pixels before zoom\n    const topLeftOld = transformPoint(wOffsetLeft, wOffsetTop, rootSctm);\n\n    // top left of workarea in content pixels after zoom\n    const topLeftNew = {\n      x: pt.x - (pt.x - topLeftOld.x) / factor,\n      y: pt.y - (pt.y - topLeftOld.y) / factor\n    };\n\n    // top left of workarea in canvas pixels relative to content after zoom\n    const topLeftNewCanvas = {\n      x: topLeftNew.x * zoomlevel,\n      y: topLeftNew.y * zoomlevel\n    };\n\n    // new center in canvas pixels\n    const newCtr = {\n      x: topLeftNewCanvas.x - rulerwidth + editorFullW / 2,\n      y: topLeftNewCanvas.y - rulerwidth + editorFullH / 2\n    };\n\n    canvas.setZoom(zoomlevel);\n    $('#zoom').val((zoomlevel * 100).toFixed(1));\n\n    call('updateCanvas', {center: false, newCtr});\n    call('zoomDone');\n  }\n);\n}());\n\n/**\n* Group: Text edit functions\n* Functions relating to editing text elements\n* @namespace {PlainObject} textActions\n* @memberof module:svgcanvas.SvgCanvas#\n*/\nconst textActions = canvas.textActions = (function () {\nlet curtext;\nlet textinput;\nlet cursor;\nlet selblock;\nlet blinker;\nlet chardata = [];\nlet textbb; // , transbb;\nlet matrix;\nlet lastX, lastY;\nlet allowDbl;\n\n/**\n *\n * @param {Integer} index\n * @returns {undefined}\n */\nfunction setCursor (index) {\n  const empty = (textinput.value === '');\n  $(textinput).focus();\n\n  if (!arguments.length) {\n    if (empty) {\n      index = 0;\n    } else {\n      if (textinput.selectionEnd !== textinput.selectionStart) { return; }\n      index = textinput.selectionEnd;\n    }\n  }\n\n  const charbb = chardata[index];\n  if (!empty) {\n    textinput.setSelectionRange(index, index);\n  }\n  cursor = getElem('text_cursor');\n  if (!cursor) {\n    cursor = document.createElementNS(NS.SVG, 'line');\n    assignAttributes(cursor, {\n      id: 'text_cursor',\n      stroke: '#333',\n      'stroke-width': 1\n    });\n    cursor = getElem('selectorParentGroup').appendChild(cursor);\n  }\n\n  if (!blinker) {\n    blinker = setInterval(function () {\n      const show = (cursor.getAttribute('display') === 'none');\n      cursor.setAttribute('display', show ? 'inline' : 'none');\n    }, 600);\n  }\n\n  const startPt = ptToScreen(charbb.x, textbb.y);\n  const endPt = ptToScreen(charbb.x, (textbb.y + textbb.height));\n\n  assignAttributes(cursor, {\n    x1: startPt.x,\n    y1: startPt.y,\n    x2: endPt.x,\n    y2: endPt.y,\n    visibility: 'visible',\n    display: 'inline'\n  });\n\n  if (selblock) { selblock.setAttribute('d', ''); }\n}\n\n/**\n *\n * @param {Integer} start\n * @param {Integer} end\n * @param {boolean} skipInput\n * @returns {undefined}\n */\nfunction setSelection (start, end, skipInput) {\n  if (start === end) {\n    setCursor(end);\n    return;\n  }\n\n  if (!skipInput) {\n    textinput.setSelectionRange(start, end);\n  }\n\n  selblock = getElem('text_selectblock');\n  if (!selblock) {\n    selblock = document.createElementNS(NS.SVG, 'path');\n    assignAttributes(selblock, {\n      id: 'text_selectblock',\n      fill: 'green',\n      opacity: 0.5,\n      style: 'pointer-events:none'\n    });\n    getElem('selectorParentGroup').append(selblock);\n  }\n\n  const startbb = chardata[start];\n  const endbb = chardata[end];\n\n  cursor.setAttribute('visibility', 'hidden');\n\n  const tl = ptToScreen(startbb.x, textbb.y),\n    tr = ptToScreen(startbb.x + (endbb.x - startbb.x), textbb.y),\n    bl = ptToScreen(startbb.x, textbb.y + textbb.height),\n    br = ptToScreen(startbb.x + (endbb.x - startbb.x), textbb.y + textbb.height);\n\n  const dstr = 'M' + tl.x + ',' + tl.y +\n    ' L' + tr.x + ',' + tr.y +\n    ' ' + br.x + ',' + br.y +\n    ' ' + bl.x + ',' + bl.y + 'z';\n\n  assignAttributes(selblock, {\n    d: dstr,\n    display: 'inline'\n  });\n}\n\n/**\n *\n * @param {Float} mouseX\n * @param {Float} mouseY\n * @returns {Integer}\n */\nfunction getIndexFromPoint (mouseX, mouseY) {\n  // Position cursor here\n  const pt = svgroot.createSVGPoint();\n  pt.x = mouseX;\n  pt.y = mouseY;\n\n  // No content, so return 0\n  if (chardata.length === 1) { return 0; }\n  // Determine if cursor should be on left or right of character\n  let charpos = curtext.getCharNumAtPosition(pt);\n  if (charpos < 0) {\n    // Out of text range, look at mouse coords\n    charpos = chardata.length - 2;\n    if (mouseX <= chardata[0].x) {\n      charpos = 0;\n    }\n  } else if (charpos >= chardata.length - 2) {\n    charpos = chardata.length - 2;\n  }\n  const charbb = chardata[charpos];\n  const mid = charbb.x + (charbb.width / 2);\n  if (mouseX > mid) {\n    charpos++;\n  }\n  return charpos;\n}\n\n/**\n *\n * @param {Float} mouseX\n * @param {Float} mouseY\n * @returns {undefined}\n */\nfunction setCursorFromPoint (mouseX, mouseY) {\n  setCursor(getIndexFromPoint(mouseX, mouseY));\n}\n\n/**\n *\n * @param {Float} x\n * @param {Float} y\n * @param {boolean} apply\n * @returns {undefined}\n */\nfunction setEndSelectionFromPoint (x, y, apply) {\n  const i1 = textinput.selectionStart;\n  const i2 = getIndexFromPoint(x, y);\n\n  const start = Math.min(i1, i2);\n  const end = Math.max(i1, i2);\n  setSelection(start, end, !apply);\n}\n\n/**\n *\n * @param {Float} xIn\n * @param {Float} yIn\n * @returns {module:math.XYObject}\n */\nfunction screenToPt (xIn, yIn) {\n  const out = {\n    x: xIn,\n    y: yIn\n  };\n\n  out.x /= currentZoom;\n  out.y /= currentZoom;\n\n  if (matrix) {\n    const pt = transformPoint(out.x, out.y, matrix.inverse());\n    out.x = pt.x;\n    out.y = pt.y;\n  }\n\n  return out;\n}\n\n/**\n *\n * @param {Float} xIn\n * @param {Float} yIn\n * @returns {module:math.XYObject}\n */\nfunction ptToScreen (xIn, yIn) {\n  const out = {\n    x: xIn,\n    y: yIn\n  };\n\n  if (matrix) {\n    const pt = transformPoint(out.x, out.y, matrix);\n    out.x = pt.x;\n    out.y = pt.y;\n  }\n\n  out.x *= currentZoom;\n  out.y *= currentZoom;\n\n  return out;\n}\n\n/*\n// Not currently in use\nfunction hideCursor () {\n  if (cursor) {\n    cursor.setAttribute('visibility', 'hidden');\n  }\n}\n*/\n\n/**\n *\n * @param {Event} evt\n * @returns {undefined}\n */\nfunction selectAll (evt) {\n  setSelection(0, curtext.textContent.length);\n  $(this).unbind(evt);\n}\n\n/**\n *\n * @param {Event} evt\n * @returns {undefined}\n */\nfunction selectWord (evt) {\n  if (!allowDbl || !curtext) { return; }\n\n  const ept = transformPoint(evt.pageX, evt.pageY, rootSctm),\n    mouseX = ept.x * currentZoom,\n    mouseY = ept.y * currentZoom;\n  const pt = screenToPt(mouseX, mouseY);\n\n  const index = getIndexFromPoint(pt.x, pt.y);\n  const str = curtext.textContent;\n  const first = str.substr(0, index).replace(/[a-z0-9]+$/i, '').length;\n  const m = str.substr(index).match(/^[a-z0-9]+/i);\n  const last = (m ? m[0].length : 0) + index;\n  setSelection(first, last);\n\n  // Set tripleclick\n  $(evt.target).click(selectAll);\n  setTimeout(function () {\n    $(evt.target).unbind('click', selectAll);\n  }, 300);\n}\n\nreturn /** @lends module:svgcanvas.SvgCanvas#textActions */ {\n  /**\n  * @param {Element} target\n  * @param {Float} x\n  * @param {Float} y\n  * @returns {undefined}\n  */\n  select (target, x, y) {\n    curtext = target;\n    textActions.toEditMode(x, y);\n  },\n  /**\n  * @param {Element} elem\n  * @returns {undefined}\n  */\n  start (elem) {\n    curtext = elem;\n    textActions.toEditMode();\n  },\n  /**\n  * @param {external:MouseEvent} evt\n  * @param {Element} mouseTarget\n  * @param {Float} startX\n  * @param {Float} startY\n  * @returns {undefined}\n  */\n  mouseDown (evt, mouseTarget, startX, startY) {\n    const pt = screenToPt(startX, startY);\n\n    textinput.focus();\n    setCursorFromPoint(pt.x, pt.y);\n    lastX = startX;\n    lastY = startY;\n\n    // TODO: Find way to block native selection\n  },\n  /**\n  * @param {Float} mouseX\n  * @param {Float} mouseY\n  * @returns {undefined}\n  */\n  mouseMove (mouseX, mouseY) {\n    const pt = screenToPt(mouseX, mouseY);\n    setEndSelectionFromPoint(pt.x, pt.y);\n  },\n  /**\n  * @param {external:MouseEvent} evt\n  * @param {Float} mouseX\n  * @param {Float} mouseY\n  * @returns {undefined}\n  */\n  mouseUp (evt, mouseX, mouseY) {\n    const pt = screenToPt(mouseX, mouseY);\n\n    setEndSelectionFromPoint(pt.x, pt.y, true);\n\n    // TODO: Find a way to make this work: Use transformed BBox instead of evt.target\n    // if (lastX === mouseX && lastY === mouseY\n    //   && !rectsIntersect(transbb, {x: pt.x, y: pt.y, width: 0, height: 0})) {\n    //   textActions.toSelectMode(true);\n    // }\n\n    if (\n      evt.target !== curtext &&\n      mouseX < lastX + 2 &&\n      mouseX > lastX - 2 &&\n      mouseY < lastY + 2 &&\n      mouseY > lastY - 2\n    ) {\n      textActions.toSelectMode(true);\n    }\n  },\n  /**\n  * @function\n  * @param {Integer} index\n  * @returns {undefined}\n  */\n  setCursor,\n  /**\n  * @param {Float} x\n  * @param {Float} y\n  * @returns {undefined}\n  */\n  toEditMode (x, y) {\n    allowDbl = false;\n    currentMode = 'textedit';\n    selectorManager.requestSelector(curtext).showGrips(false);\n    // Make selector group accept clicks\n    /* const selector = */ selectorManager.requestSelector(curtext); // Do we need this? Has side effect of setting lock, so keeping for now, but next line wasn't being used\n    // const sel = selector.selectorRect;\n\n    textActions.init();\n\n    $(curtext).css('cursor', 'text');\n\n    // if (supportsEditableText()) {\n    //   curtext.setAttribute('editable', 'simple');\n    //   return;\n    // }\n\n    if (!arguments.length) {\n      setCursor();\n    } else {\n      const pt = screenToPt(x, y);\n      setCursorFromPoint(pt.x, pt.y);\n    }\n\n    setTimeout(function () {\n      allowDbl = true;\n    }, 300);\n  },\n  /**\n  * @param {boolean|Element} selectElem\n  * @fires module:svgcanvas.SvgCanvas#event:selected\n  * @returns {undefined}\n  */\n  toSelectMode (selectElem) {\n    currentMode = 'select';\n    clearInterval(blinker);\n    blinker = null;\n    if (selblock) { $(selblock).attr('display', 'none'); }\n    if (cursor) { $(cursor).attr('visibility', 'hidden'); }\n    $(curtext).css('cursor', 'move');\n\n    if (selectElem) {\n      clearSelection();\n      $(curtext).css('cursor', 'move');\n\n      call('selected', [curtext]);\n      addToSelection([curtext], true);\n    }\n    if (curtext && !curtext.textContent.length) {\n      // No content, so delete\n      canvas.deleteSelectedElements();\n    }\n\n    $(textinput).blur();\n\n    curtext = false;\n\n    // if (supportsEditableText()) {\n    //   curtext.removeAttribute('editable');\n    // }\n  },\n  /**\n  * @param {Element} elem\n  * @returns {undefined}\n  */\n  setInputElem (elem) {\n    textinput = elem;\n    // $(textinput).blur(hideCursor);\n  },\n  /**\n  * @returns {undefined}\n  */\n  clear () {\n    if (currentMode === 'textedit') {\n      textActions.toSelectMode();\n    }\n  },\n  /**\n  * @param {Element} inputElem Not in use\n  * @returns {undefined}\n  */\n  init (inputElem) {\n    if (!curtext) { return; }\n    let i, end;\n    // if (supportsEditableText()) {\n    //   curtext.select();\n    //   return;\n    // }\n\n    if (!curtext.parentNode) {\n      // Result of the ffClone, need to get correct element\n      curtext = selectedElements[0];\n      selectorManager.requestSelector(curtext).showGrips(false);\n    }\n\n    const str = curtext.textContent;\n    const len = str.length;\n\n    const xform = curtext.getAttribute('transform');\n\n    textbb = utilsGetBBox(curtext);\n\n    matrix = xform ? getMatrix(curtext) : null;\n\n    chardata = [];\n    chardata.length = len;\n    textinput.focus();\n\n    $(curtext).unbind('dblclick', selectWord).dblclick(selectWord);\n\n    if (!len) {\n      end = {x: textbb.x + (textbb.width / 2), width: 0};\n    }\n\n    for (i = 0; i < len; i++) {\n      const start = curtext.getStartPositionOfChar(i);\n      end = curtext.getEndPositionOfChar(i);\n\n      if (!supportsGoodTextCharPos()) {\n        const offset = canvas.contentW * currentZoom;\n        start.x -= offset;\n        end.x -= offset;\n\n        start.x /= currentZoom;\n        end.x /= currentZoom;\n      }\n\n      // Get a \"bbox\" equivalent for each character. Uses the\n      // bbox data of the actual text for y, height purposes\n\n      // TODO: Decide if y, width and height are actually necessary\n      chardata[i] = {\n        x: start.x,\n        y: textbb.y, // start.y?\n        width: end.x - start.x,\n        height: textbb.height\n      };\n    }\n\n    // Add a last bbox for cursor at end of text\n    chardata.push({\n      x: end.x,\n      width: 0\n    });\n    setSelection(textinput.selectionStart, textinput.selectionEnd, true);\n  }\n};\n}());\n\n/**\n* Group: Serialization\n*/\n\n/**\n* Looks at DOM elements inside the `<defs>` to see if they are referred to,\n* removes them from the DOM if they are not.\n* @function module:svgcanvas.SvgCanvas#removeUnusedDefElems\n* @returns {Integer} The number of elements that were removed\n*/\nconst removeUnusedDefElems = this.removeUnusedDefElems = function () {\n  const defs = svgcontent.getElementsByTagNameNS(NS.SVG, 'defs');\n  if (!defs || !defs.length) { return 0; }\n\n  // if (!defs.firstChild) { return; }\n\n  const defelemUses = [];\n  let numRemoved = 0;\n  const attrs = ['fill', 'stroke', 'filter', 'marker-start', 'marker-mid', 'marker-end'];\n  const alen = attrs.length;\n\n  const allEls = svgcontent.getElementsByTagNameNS(NS.SVG, '*');\n  const allLen = allEls.length;\n\n  let i, j;\n  for (i = 0; i < allLen; i++) {\n    const el = allEls[i];\n    for (j = 0; j < alen; j++) {\n      const ref = getUrlFromAttr(el.getAttribute(attrs[j]));\n      if (ref) {\n        defelemUses.push(ref.substr(1));\n      }\n    }\n\n    // gradients can refer to other gradients\n    const href = getHref(el);\n    if (href && href.startsWith('#')) {\n      defelemUses.push(href.substr(1));\n    }\n  }\n\n  const defelems = $(defs).find('linearGradient, radialGradient, filter, marker, svg, symbol');\n  i = defelems.length;\n  while (i--) {\n    const defelem = defelems[i];\n    const {id} = defelem;\n    if (!defelemUses.includes(id)) {\n      // Not found, so remove (but remember)\n      removedElements[id] = defelem;\n      defelem.remove();\n      numRemoved++;\n    }\n  }\n\n  return numRemoved;\n};\n\n/**\n* Main function to set up the SVG content for output.\n* @function module:svgcanvas.SvgCanvas#svgCanvasToString\n* @returns {string} The SVG image for output\n*/\nthis.svgCanvasToString = function () {\n  // keep calling it until there are none to remove\n  while (removeUnusedDefElems() > 0) {} // eslint-disable-line no-empty\n\n  pathActions.clear(true);\n\n  // Keep SVG-Edit comment on top\n  $.each(svgcontent.childNodes, function (i, node) {\n    if (i && node.nodeType === 8 && node.data.includes('Created with')) {\n      svgcontent.firstChild.before(node);\n    }\n  });\n\n  // Move out of in-group editing mode\n  if (currentGroup) {\n    draw.leaveContext();\n    selectOnly([currentGroup]);\n  }\n\n  const nakedSvgs = [];\n\n  // Unwrap gsvg if it has no special attributes (only id and style)\n  $(svgcontent).find('g:data(gsvg)').each(function () {\n    const attrs = this.attributes;\n    let len = attrs.length;\n    for (let i = 0; i < len; i++) {\n      if (attrs[i].nodeName === 'id' || attrs[i].nodeName === 'style') {\n        len--;\n      }\n    }\n    // No significant attributes, so ungroup\n    if (len <= 0) {\n      const svg = this.firstChild;\n      nakedSvgs.push(svg);\n      $(this).replaceWith(svg);\n    }\n  });\n  const output = this.svgToString(svgcontent, 0);\n\n  // Rewrap gsvg\n  if (nakedSvgs.length) {\n    $(nakedSvgs).each(function () {\n      groupSvgElem(this);\n    });\n  }\n\n  return output;\n};\n\n/**\n* Sub function ran on each SVG element to convert it to a string as desired.\n* @function module:svgcanvas.SvgCanvas#svgToString\n* @param {Element} elem - The SVG element to convert\n* @param {Integer} indent - Number of spaces to indent this tag\n* @returns {string} The given element as an SVG tag\n*/\nthis.svgToString = function (elem, indent) {\n  const out = [];\n  const unit = curConfig.baseUnit;\n  const unitRe = new RegExp('^-?[\\\\d\\\\.]+' + unit + '$');\n\n  if (elem) {\n    cleanupElement(elem);\n    const attrs = [...elem.attributes];\n    const childs = elem.childNodes;\n    attrs.sort((a, b) => {\n      return a.name > b.name ? -1 : 1;\n    });\n\n    for (let i = 0; i < indent; i++) { out.push(' '); }\n    out.push('<'); out.push(elem.nodeName);\n    if (elem.id === 'svgcontent') {\n      // Process root element separately\n      const res = getResolution();\n\n      const vb = '';\n      // TODO: Allow this by dividing all values by current baseVal\n      // Note that this also means we should properly deal with this on import\n      // if (curConfig.baseUnit !== 'px') {\n      //   const unit = curConfig.baseUnit;\n      //   const unitM = getTypeMap()[unit];\n      //   res.w = shortFloat(res.w / unitM);\n      //   res.h = shortFloat(res.h / unitM);\n      //   vb = ' viewBox=\"' + [0, 0, res.w, res.h].join(' ') + '\"';\n      //   res.w += unit;\n      //   res.h += unit;\n      // }\n\n      if (unit !== 'px') {\n        res.w = convertUnit(res.w, unit) + unit;\n        res.h = convertUnit(res.h, unit) + unit;\n      }\n\n      out.push(' width=\"' + res.w + '\" height=\"' + res.h + '\"' + vb + ' xmlns=\"' + NS.SVG + '\"');\n\n      const nsuris = {};\n\n      // Check elements for namespaces, add if found\n      $(elem).find('*').andSelf().each(function () {\n        // const el = this;\n        // for some elements have no attribute\n        const uri = this.namespaceURI;\n        if (uri && !nsuris[uri] && nsMap[uri] && nsMap[uri] !== 'xmlns' && nsMap[uri] !== 'xml') {\n          nsuris[uri] = true;\n          out.push(' xmlns:' + nsMap[uri] + '=\"' + uri + '\"');\n        }\n\n        $.each(this.attributes, function (i, attr) {\n          const u = attr.namespaceURI;\n          if (u && !nsuris[u] && nsMap[u] !== 'xmlns' && nsMap[u] !== 'xml') {\n            nsuris[u] = true;\n            out.push(' xmlns:' + nsMap[u] + '=\"' + u + '\"');\n          }\n        });\n      });\n\n      let i = attrs.length;\n      const attrNames = ['width', 'height', 'xmlns', 'x', 'y', 'viewBox', 'id', 'overflow'];\n      while (i--) {\n        const attr = attrs[i];\n        const attrVal = toXml(attr.value);\n\n        // Namespaces have already been dealt with, so skip\n        if (attr.nodeName.startsWith('xmlns:')) { continue; }\n\n        // only serialize attributes we don't use internally\n        if (attrVal !== '' && !attrNames.includes(attr.localName)) {\n          if (!attr.namespaceURI || nsMap[attr.namespaceURI]) {\n            out.push(' ');\n            out.push(attr.nodeName); out.push('=\"');\n            out.push(attrVal); out.push('\"');\n          }\n        }\n      }\n    } else {\n      // Skip empty defs\n      if (elem.nodeName === 'defs' && !elem.firstChild) { return ''; }\n\n      const mozAttrs = ['-moz-math-font-style', '_moz-math-font-style'];\n      for (let i = attrs.length - 1; i >= 0; i--) {\n        const attr = attrs[i];\n        let attrVal = toXml(attr.value);\n        // remove bogus attributes added by Gecko\n        if (mozAttrs.includes(attr.localName)) { continue; }\n        if (attrVal !== '') {\n          if (attrVal.startsWith('pointer-events')) { continue; }\n          if (attr.localName === 'class' && attrVal.startsWith('se_')) { continue; }\n          out.push(' ');\n          if (attr.localName === 'd') { attrVal = pathActions.convertPath(elem, true); }\n          if (!isNaN(attrVal)) {\n            attrVal = shortFloat(attrVal);\n          } else if (unitRe.test(attrVal)) {\n            attrVal = shortFloat(attrVal) + unit;\n          }\n\n          // Embed images when saving\n          if (saveOptions.apply &&\n            elem.nodeName === 'image' &&\n            attr.localName === 'href' &&\n            saveOptions.images &&\n            saveOptions.images === 'embed'\n          ) {\n            const img = encodableImages[attrVal];\n            if (img) { attrVal = img; }\n          }\n\n          // map various namespaces to our fixed namespace prefixes\n          // (the default xmlns attribute itself does not get a prefix)\n          if (!attr.namespaceURI || attr.namespaceURI === NS.SVG || nsMap[attr.namespaceURI]) {\n            out.push(attr.nodeName); out.push('=\"');\n            out.push(attrVal); out.push('\"');\n          }\n        }\n      }\n    }\n\n    if (elem.hasChildNodes()) {\n      out.push('>');\n      indent++;\n      let bOneLine = false;\n\n      for (let i = 0; i < childs.length; i++) {\n        const child = childs.item(i);\n        switch (child.nodeType) {\n        case 1: // element node\n          out.push('\\n');\n          out.push(this.svgToString(childs.item(i), indent));\n          break;\n        case 3: { // text node\n          const str = child.nodeValue.replace(/^\\s+|\\s+$/g, '');\n          if (str !== '') {\n            bOneLine = true;\n            out.push(String(toXml(str)));\n          }\n          break;\n        } case 4: // cdata node\n          out.push('\\n');\n          out.push(new Array(indent + 1).join(' '));\n          out.push('<![CDATA[');\n          out.push(child.nodeValue);\n          out.push(']]>');\n          break;\n        case 8: // comment\n          out.push('\\n');\n          out.push(new Array(indent + 1).join(' '));\n          out.push('<!--');\n          out.push(child.data);\n          out.push('-->');\n          break;\n        } // switch on node type\n      }\n      indent--;\n      if (!bOneLine) {\n        out.push('\\n');\n        for (let i = 0; i < indent; i++) { out.push(' '); }\n      }\n      out.push('</'); out.push(elem.nodeName); out.push('>');\n    } else {\n      out.push('/>');\n    }\n  }\n  return out.join('');\n}; // end svgToString()\n\n/**\n * Function to run when image data is found\n * @callback module:svgcanvas.ImageEmbeddedCallback\n * @param {string|false} result Data URL\n * @returns {undefined}\n */\n/**\n* Converts a given image file to a data URL when possible, then runs a given callback.\n* @function module:svgcanvas.SvgCanvas#embedImage\n* @param {string} src - The path/URL of the image\n* @returns {Promise} Resolves to Data URL (string|false)\n*/\nthis.embedImage = function (src) {\n  // Todo: Remove this Promise in favor of making an async/await `Image.load` utility\n  return new Promise(function (resolve, reject) { // eslint-disable-line promise/avoid-new\n    // load in the image and once it's loaded, get the dimensions\n    $(new Image()).load(function (response, status, xhr) {\n      if (status === 'error') {\n        reject(new Error('Error loading image: ' + xhr.status + ' ' + xhr.statusText));\n        return;\n      }\n      // create a canvas the same size as the raster image\n      const cvs = document.createElement('canvas');\n      cvs.width = this.width;\n      cvs.height = this.height;\n      // load the raster image into the canvas\n      cvs.getContext('2d').drawImage(this, 0, 0);\n      // retrieve the data: URL\n      try {\n        let urldata = ';svgedit_url=' + encodeURIComponent(src);\n        urldata = cvs.toDataURL().replace(';base64', urldata + ';base64');\n        encodableImages[src] = urldata;\n      } catch (e) {\n        encodableImages[src] = false;\n      }\n      lastGoodImgUrl = src;\n      resolve(encodableImages[src]);\n    }).attr('src', src);\n  });\n};\n\n/**\n* Sets a given URL to be a \"last good image\" URL.\n* @function module:svgcanvas.SvgCanvas#setGoodImage\n* @param {string} val\n* @returns {undefined}\n*/\nthis.setGoodImage = function (val) {\n  lastGoodImgUrl = val;\n};\n\n/**\n* Does nothing by default, handled by optional widget/extension.\n* @function module:svgcanvas.SvgCanvas#open\n* @returns {undefined}\n*/\nthis.open = function () {\n  /* */\n};\n\n/**\n* Serializes the current drawing into SVG XML text and passes it to the 'saved' handler.\n* This function also includes the XML prolog. Clients of the `SvgCanvas` bind their save\n* function to the 'saved' event.\n* @function module:svgcanvas.SvgCanvas#save\n* @param {module:svgcanvas.SaveOptions} opts\n* @fires module:svgcanvas.SvgCanvas#event:saved\n* @returns {undefined}\n*/\nthis.save = function (opts) {\n  // remove the selected outline before serializing\n  clearSelection();\n  // Update save options if provided\n  if (opts) { $.extend(saveOptions, opts); }\n  saveOptions.apply = true;\n\n  // no need for doctype, see https://jwatt.org/svg/authoring/#doctype-declaration\n  const str = this.svgCanvasToString();\n  call('saved', str);\n};\n\n/**\n* @typedef {PlainObject} module:svgcanvas.IssuesAndCodes\n* @property {string[]} issueCodes The locale-independent code names\n* @property {string[]} issues The localized descriptions\n*/\n\n/**\n* Codes only is useful for locale-independent detection.\n* @returns {module:svgcanvas.IssuesAndCodes}\n*/\nfunction getIssues () {\n  // remove the selected outline before serializing\n  clearSelection();\n\n  // Check for known CanVG issues\n  const issues = [];\n  const issueCodes = [];\n\n  // Selector and notice\n  const issueList = {\n    feGaussianBlur: uiStrings.exportNoBlur,\n    foreignObject: uiStrings.exportNoforeignObject,\n    '[stroke-dasharray]': uiStrings.exportNoDashArray\n  };\n  const content = $(svgcontent);\n\n  // Add font/text check if Canvas Text API is not implemented\n  if (!('font' in $('<canvas>')[0].getContext('2d'))) {\n    issueList.text = uiStrings.exportNoText;\n  }\n\n  $.each(issueList, function (sel, descr) {\n    if (content.find(sel).length) {\n      issueCodes.push(sel);\n      issues.push(descr);\n    }\n  });\n  return {issues, issueCodes};\n}\n\nlet canvg;\n/**\n* @typedef {\"feGaussianBlur\"|\"foreignObject\"|\"[stroke-dasharray]\"|\"text\"} module:svgcanvas.IssueCode\n*/\n/**\n* @typedef {PlainObject} module:svgcanvas.ImageExportedResults\n* @property {string} datauri Contents as a Data URL\n* @property {string} bloburl May be the empty string\n* @property {string} svg The SVG contents as a string\n* @property {string[]} issues The localization messages of `issueCodes`\n* @property {module:svgcanvas.IssueCode[]} issueCodes CanVG issues found with the SVG\n* @property {\"PNG\"|\"JPEG\"|\"BMP\"|\"WEBP\"|\"ICO\"} type The chosen image type\n* @property {\"image/png\"|\"image/jpeg\"|\"image/bmp\"|\"image/webp\"} mimeType The image MIME type\n* @property {Float} quality A decimal between 0 and 1 (for use with JPEG or WEBP)\n* @property {string} exportWindowName A convenience for passing along a `window.name` to target a window on which the export could be added\n*/\n\n/**\n* Generates a PNG (or JPG, BMP, WEBP) Data URL based on the current image,\n* then calls \"exported\" with an object including the string, image\n* information, and any issues found.\n* @function module:svgcanvas.SvgCanvas#rasterExport\n* @param {\"PNG\"|\"JPEG\"|\"BMP\"|\"WEBP\"|\"ICO\"} [imgType=\"PNG\"]\n* @param {Float} [quality] Between 0 and 1\n* @param {string} [exportWindowName]\n* @param {PlainObject} [opts]\n* @param {boolean} [opts.avoidEvent]\n* @fires module:svgcanvas.SvgCanvas#event:exported\n* @todo Confirm/fix ICO type\n* @returns {Promise} Resolves to {@link module:svgcanvas.ImageExportedResults}\n*/\nthis.rasterExport = async function (imgType, quality, exportWindowName, opts = {}) {\n  const type = imgType === 'ICO' ? 'BMP' : (imgType || 'PNG');\n  const mimeType = 'image/' + type.toLowerCase();\n  const {issues, issueCodes} = getIssues();\n  const svg = this.svgCanvasToString();\n\n  if (!canvg) {\n    ({canvg} = await importSetGlobal(curConfig.canvgPath + 'canvg.js', {\n      global: 'canvg'\n    }));\n  }\n  if (!$('#export_canvas').length) {\n    $('<canvas>', {id: 'export_canvas'}).hide().appendTo('body');\n  }\n  const c = $('#export_canvas')[0];\n  c.width = canvas.contentW;\n  c.height = canvas.contentH;\n\n  await canvg(c, svg);\n  // Todo: Make async/await utility in place of `toBlob`, so we can remove this constructor\n  return new Promise((resolve, reject) => { // eslint-disable-line promise/avoid-new\n    const dataURLType = type.toLowerCase();\n    const datauri = quality\n      ? c.toDataURL('image/' + dataURLType, quality)\n      : c.toDataURL('image/' + dataURLType);\n    let bloburl;\n    /**\n     * Called when `bloburl` is available for export.\n     * @returns {undefined}\n     */\n    function done () {\n      const obj = {\n        datauri, bloburl, svg, issues, issueCodes, type: imgType,\n        mimeType, quality, exportWindowName\n      };\n      if (!opts.avoidEvent) {\n        call('exported', obj);\n      }\n      resolve(obj);\n    }\n    if (c.toBlob) {\n      c.toBlob((blob) => {\n        bloburl = createObjectURL(blob);\n        done();\n      }, mimeType, quality);\n      return;\n    }\n    bloburl = dataURLToObjectURL(datauri);\n    done();\n  });\n};\n/**\n * @external jsPDF\n */\n/**\n * @typedef {undefined|\"save\"|\"arraybuffer\"|\"blob\"|\"datauristring\"|\"dataurlstring\"|\"dataurlnewwindow\"|\"datauri\"|\"dataurl\"} external:jsPDF.OutputType\n * @todo Newer version to add also allows these `outputType` values \"bloburi\"|\"bloburl\" which return strings, so document here and for `outputType` of `module:svgcanvas.PDFExportedResults` below if added\n*/\n/**\n* @typedef {PlainObject} module:svgcanvas.PDFExportedResults\n* @property {string} svg The SVG PDF output\n* @property {string|ArrayBuffer|Blob|window} output The output based on the `outputType`;\n* if `undefined`, \"datauristring\", \"dataurlstring\", \"datauri\",\n* or \"dataurl\", will be a string (`undefined` gives a document, while the others\n* build as Data URLs; \"datauri\" and \"dataurl\" change the location of the current page); if\n* \"arraybuffer\", will return `ArrayBuffer`; if \"blob\", returns a `Blob`;\n* if \"dataurlnewwindow\", will change the current page's location and return a string\n* if in Safari and no window object is found; otherwise opens in, and returns, a new `window`\n* object; if \"save\", will have the same return as \"dataurlnewwindow\" if\n* `navigator.getUserMedia` support is found without `URL.createObjectURL` support; otherwise\n* returns `undefined` but attempts to save\n* @property {external:jsPDF.OutputType} outputType\n* @property {string[]} issues The human-readable localization messages of corresponding `issueCodes`\n* @property {module:svgcanvas.IssueCode[]} issueCodes\n* @property {string} exportWindowName\n*/\n\n/**\n* Generates a PDF based on the current image, then calls \"exportedPDF\" with\n* an object including the string, the data URL, and any issues found.\n* @function module:svgcanvas.SvgCanvas#exportPDF\n* @param {string} [exportWindowName] Will also be used for the download file name here\n* @param {external:jsPDF.OutputType} [outputType=\"dataurlstring\"]\n* @fires module:svgcanvas.SvgCanvas#event:exportedPDF\n* @returns {Promise} Resolves to {@link module:svgcanvas.PDFExportedResults}\n*/\nthis.exportPDF = async function (\n  exportWindowName,\n  outputType = isChrome() ? 'save' : undefined\n) {\n  if (!window.jsPDF) {\n    // Todo: Switch to `import()` when widely supported and available (also allow customization of path)\n    await importScript([\n      // We do not currently have these paths configurable as they are\n      //   currently global-only, so not Rolled-up\n      'jspdf/underscore-min.js',\n      'jspdf/jspdf.min.js'\n    ]);\n\n    const modularVersion = !('svgEditor' in window) ||\n      !window.svgEditor ||\n      window.svgEditor.modules !== false;\n    // Todo: Switch to `import()` when widely supported and available (also allow customization of path)\n    await importScript(curConfig.jspdfPath + 'jspdf.plugin.svgToPdf.js', {\n      type: modularVersion\n        ? 'module'\n        : 'text/javascript'\n    });\n    // await importModule('jspdf/jspdf.plugin.svgToPdf.js');\n  }\n\n  const res = getResolution();\n  const orientation = res.w > res.h ? 'landscape' : 'portrait';\n  const unit = 'pt'; // curConfig.baseUnit; // We could use baseUnit, but that is presumably not intended for export purposes\n\n  // Todo: Give options to use predefined jsPDF formats like \"a4\", etc. from pull-down (with option to keep customizable)\n  const doc = jsPDF({\n    orientation,\n    unit,\n    format: [res.w, res.h]\n    // , compressPdf: true\n  });\n  const docTitle = getDocumentTitle();\n  doc.setProperties({\n    title: docTitle /* ,\n    subject: '',\n    author: '',\n    keywords: '',\n    creator: '' */\n  });\n  const {issues, issueCodes} = getIssues();\n  const svg = this.svgCanvasToString();\n  doc.addSVG(svg, 0, 0);\n\n  // doc.output('save'); // Works to open in a new\n  //  window; todo: configure this and other export\n  //  options to optionally work in this manner as\n  //  opposed to opening a new tab\n  outputType = outputType || 'dataurlstring';\n  const obj = {svg, issues, issueCodes, exportWindowName, outputType};\n  obj.output = doc.output(outputType, outputType === 'save' ? (exportWindowName || 'svg.pdf') : undefined);\n  call('exportedPDF', obj);\n  return obj;\n};\n\n/**\n* Returns the current drawing as raw SVG XML text.\n* @function module:svgcanvas.SvgCanvas#getSvgString\n* @returns {string} The current drawing as raw SVG XML text.\n*/\nthis.getSvgString = function () {\n  saveOptions.apply = false;\n  return this.svgCanvasToString();\n};\n\n/**\n* This function determines whether to use a nonce in the prefix, when\n* generating IDs for future documents in SVG-Edit.\n* If you're controlling SVG-Edit externally, and want randomized IDs, call\n* this BEFORE calling `svgCanvas.setSvgString`.\n* @function module:svgcanvas.SvgCanvas#randomizeIds\n* @param {boolean} [enableRandomization] If true, adds a nonce to the prefix. Thus\n* `svgCanvas.randomizeIds() <==> svgCanvas.randomizeIds(true)`\n* @returns {undefined}\n*/\nthis.randomizeIds = function (enableRandomization) {\n  if (arguments.length > 0 && enableRandomization === false) {\n    draw.randomizeIds(false, getCurrentDrawing());\n  } else {\n    draw.randomizeIds(true, getCurrentDrawing());\n  }\n};\n\n/**\n* Ensure each element has a unique ID.\n* @function module:svgcanvas.SvgCanvas#uniquifyElems\n* @param {Element} g - The parent element of the tree to give unique IDs\n* @returns {undefined}\n*/\nconst uniquifyElems = this.uniquifyElems = function (g) {\n  const ids = {};\n  // TODO: Handle markers and connectors. These are not yet re-identified properly\n  // as their referring elements do not get remapped.\n  //\n  // <marker id='se_marker_end_svg_7'/>\n  // <polyline id='svg_7' se:connector='svg_1 svg_6' marker-end='url(#se_marker_end_svg_7)'/>\n  //\n  // Problem #1: if svg_1 gets renamed, we do not update the polyline's se:connector attribute\n  // Problem #2: if the polyline svg_7 gets renamed, we do not update the marker id nor the polyline's marker-end attribute\n  const refElems = ['filter', 'linearGradient', 'pattern', 'radialGradient', 'symbol', 'textPath', 'use'];\n\n  walkTree(g, function (n) {\n    // if it's an element node\n    if (n.nodeType === 1) {\n      // and the element has an ID\n      if (n.id) {\n        // and we haven't tracked this ID yet\n        if (!(n.id in ids)) {\n          // add this id to our map\n          ids[n.id] = {elem: null, attrs: [], hrefs: []};\n        }\n        ids[n.id].elem = n;\n      }\n\n      // now search for all attributes on this element that might refer\n      // to other elements\n      $.each(refAttrs, function (i, attr) {\n        const attrnode = n.getAttributeNode(attr);\n        if (attrnode) {\n          // the incoming file has been sanitized, so we should be able to safely just strip off the leading #\n          const url = getUrlFromAttr(attrnode.value),\n            refid = url ? url.substr(1) : null;\n          if (refid) {\n            if (!(refid in ids)) {\n              // add this id to our map\n              ids[refid] = {elem: null, attrs: [], hrefs: []};\n            }\n            ids[refid].attrs.push(attrnode);\n          }\n        }\n      });\n\n      // check xlink:href now\n      const href = getHref(n);\n      // TODO: what if an <image> or <a> element refers to an element internally?\n      if (href && refElems.includes(n.nodeName)) {\n        const refid = href.substr(1);\n        if (refid) {\n          if (!(refid in ids)) {\n            // add this id to our map\n            ids[refid] = {elem: null, attrs: [], hrefs: []};\n          }\n          ids[refid].hrefs.push(n);\n        }\n      }\n    }\n  });\n\n  // in ids, we now have a map of ids, elements and attributes, let's re-identify\n  for (const oldid in ids) {\n    if (!oldid) { continue; }\n    const {elem} = ids[oldid];\n    if (elem) {\n      const newid = getNextId();\n\n      // assign element its new id\n      elem.id = newid;\n\n      // remap all url() attributes\n      const {attrs} = ids[oldid];\n      let j = attrs.length;\n      while (j--) {\n        const attr = attrs[j];\n        attr.ownerElement.setAttribute(attr.name, 'url(#' + newid + ')');\n      }\n\n      // remap all href attributes\n      const hreffers = ids[oldid].hrefs;\n      let k = hreffers.length;\n      while (k--) {\n        const hreffer = hreffers[k];\n        setHref(hreffer, '#' + newid);\n      }\n    }\n  }\n};\n\n/**\n* Assigns reference data for each use element.\n* @function module:svgcanvas.SvgCanvas#setUseData\n* @param {Element} parent\n* @returns {undefined}\n*/\nconst setUseData = this.setUseData = function (parent) {\n  let elems = $(parent);\n\n  if (parent.tagName !== 'use') {\n    elems = elems.find('use');\n  }\n\n  elems.each(function () {\n    const id = getHref(this).substr(1);\n    const refElem = getElem(id);\n    if (!refElem) { return; }\n    $(this).data('ref', refElem);\n    if (refElem.tagName === 'symbol' || refElem.tagName === 'svg') {\n      $(this).data('symbol', refElem).data('ref', refElem);\n    }\n  });\n};\n\n/**\n* Converts gradients from userSpaceOnUse to objectBoundingBox.\n* @function module:svgcanvas.SvgCanvas#convertGradients\n* @param {Element} elem\n* @returns {undefined}\n*/\nconst convertGradients = this.convertGradients = function (elem) {\n  let elems = $(elem).find('linearGradient, radialGradient');\n  if (!elems.length && isWebkit()) {\n    // Bug in webkit prevents regular *Gradient selector search\n    elems = $(elem).find('*').filter(function () {\n      return (this.tagName.includes('Gradient'));\n    });\n  }\n\n  elems.each(function () {\n    const grad = this; // eslint-disable-line consistent-this\n    if ($(grad).attr('gradientUnits') === 'userSpaceOnUse') {\n      // TODO: Support more than one element with this ref by duplicating parent grad\n      const fillStrokeElems = $(svgcontent).find('[fill=\"url(#' + grad.id + ')\"],[stroke=\"url(#' + grad.id + ')\"]');\n      if (!fillStrokeElems.length) { return; }\n\n      // get object's bounding box\n      const bb = utilsGetBBox(fillStrokeElems[0]);\n\n      // This will occur if the element is inside a <defs> or a <symbol>,\n      // in which we shouldn't need to convert anyway.\n      if (!bb) { return; }\n\n      if (grad.tagName === 'linearGradient') {\n        const gCoords = $(grad).attr(['x1', 'y1', 'x2', 'y2']);\n\n        // If has transform, convert\n        const tlist = grad.gradientTransform.baseVal;\n        if (tlist && tlist.numberOfItems > 0) {\n          const m = transformListToTransform(tlist).matrix;\n          const pt1 = transformPoint(gCoords.x1, gCoords.y1, m);\n          const pt2 = transformPoint(gCoords.x2, gCoords.y2, m);\n\n          gCoords.x1 = pt1.x;\n          gCoords.y1 = pt1.y;\n          gCoords.x2 = pt2.x;\n          gCoords.y2 = pt2.y;\n          grad.removeAttribute('gradientTransform');\n        }\n\n        $(grad).attr({\n          x1: (gCoords.x1 - bb.x) / bb.width,\n          y1: (gCoords.y1 - bb.y) / bb.height,\n          x2: (gCoords.x2 - bb.x) / bb.width,\n          y2: (gCoords.y2 - bb.y) / bb.height\n        });\n        grad.removeAttribute('gradientUnits');\n      }\n      // else {\n      //   Note: radialGradient elements cannot be easily converted\n      //   because userSpaceOnUse will keep circular gradients, while\n      //   objectBoundingBox will x/y scale the gradient according to\n      //   its bbox.\n      //\n      //   For now we'll do nothing, though we should probably have\n      //   the gradient be updated as the element is moved, as\n      //   inkscape/illustrator do.\n      //\n      //   const gCoords = $(grad).attr(['cx', 'cy', 'r']);\n      //\n      //   $(grad).attr({\n      //     cx: (gCoords.cx - bb.x) / bb.width,\n      //     cy: (gCoords.cy - bb.y) / bb.height,\n      //     r: gCoords.r\n      //   });\n      //\n      //   grad.removeAttribute('gradientUnits');\n      // }\n    }\n  });\n};\n\n/**\n* Converts selected/given `<use>` or child SVG element to a group.\n* @function module:svgcanvas.SvgCanvas#convertToGroup\n* @param {Element} elem\n* @fires module:svgcanvas.SvgCanvas#event:selected\n* @returns {undefined}\n*/\nconst convertToGroup = this.convertToGroup = function (elem) {\n  if (!elem) {\n    elem = selectedElements[0];\n  }\n  const $elem = $(elem);\n  const batchCmd = new BatchCommand();\n  let ts;\n\n  if ($elem.data('gsvg')) {\n    // Use the gsvg as the new group\n    const svg = elem.firstChild;\n    const pt = $(svg).attr(['x', 'y']);\n\n    $(elem.firstChild.firstChild).unwrap();\n    $(elem).removeData('gsvg');\n\n    const tlist = getTransformList(elem);\n    const xform = svgroot.createSVGTransform();\n    xform.setTranslate(pt.x, pt.y);\n    tlist.appendItem(xform);\n    recalculateDimensions(elem);\n    call('selected', [elem]);\n  } else if ($elem.data('symbol')) {\n    elem = $elem.data('symbol');\n\n    ts = $elem.attr('transform');\n    const pos = $elem.attr(['x', 'y']);\n\n    const vb = elem.getAttribute('viewBox');\n\n    if (vb) {\n      const nums = vb.split(' ');\n      pos.x -= Number(nums[0]);\n      pos.y -= Number(nums[1]);\n    }\n\n    // Not ideal, but works\n    ts += ' translate(' + (pos.x || 0) + ',' + (pos.y || 0) + ')';\n\n    const prev = $elem.prev();\n\n    // Remove <use> element\n    batchCmd.addSubCommand(new RemoveElementCommand($elem[0], $elem[0].nextSibling, $elem[0].parentNode));\n    $elem.remove();\n\n    // See if other elements reference this symbol\n    const hasMore = $(svgcontent).find('use:data(symbol)').length;\n\n    const g = svgdoc.createElementNS(NS.SVG, 'g');\n    const childs = elem.childNodes;\n\n    let i;\n    for (i = 0; i < childs.length; i++) {\n      g.append(childs[i].cloneNode(true));\n    }\n\n    // Duplicate the gradients for Gecko, since they weren't included in the <symbol>\n    if (isGecko()) {\n      const dupeGrads = $(findDefs()).children('linearGradient,radialGradient,pattern').clone();\n      $(g).append(dupeGrads);\n    }\n\n    if (ts) {\n      g.setAttribute('transform', ts);\n    }\n\n    const parent = elem.parentNode;\n\n    uniquifyElems(g);\n\n    // Put the dupe gradients back into <defs> (after uniquifying them)\n    if (isGecko()) {\n      $(findDefs()).append($(g).find('linearGradient,radialGradient,pattern'));\n    }\n\n    // now give the g itself a new id\n    g.id = getNextId();\n\n    prev.after(g);\n\n    if (parent) {\n      if (!hasMore) {\n        // remove symbol/svg element\n        const {nextSibling} = elem;\n        elem.remove();\n        batchCmd.addSubCommand(new RemoveElementCommand(elem, nextSibling, parent));\n      }\n      batchCmd.addSubCommand(new InsertElementCommand(g));\n    }\n\n    setUseData(g);\n\n    if (isGecko()) {\n      convertGradients(findDefs());\n    } else {\n      convertGradients(g);\n    }\n\n    // recalculate dimensions on the top-level children so that unnecessary transforms\n    // are removed\n    walkTreePost(g, function (n) {\n      try {\n        recalculateDimensions(n);\n      } catch (e) {\n        console.log(e); // eslint-disable-line no-console\n      }\n    });\n\n    // Give ID for any visible element missing one\n    $(g).find(visElems).each(function () {\n      if (!this.id) { this.id = getNextId(); }\n    });\n\n    selectOnly([g]);\n\n    const cm = pushGroupProperties(g, true);\n    if (cm) {\n      batchCmd.addSubCommand(cm);\n    }\n\n    addCommandToHistory(batchCmd);\n  } else {\n    console.log('Unexpected element to ungroup:', elem); // eslint-disable-line no-console\n  }\n};\n\n/**\n* This function sets the current drawing as the input SVG XML.\n* @function module:svgcanvas.SvgCanvas#setSvgString\n* @param {string} xmlString - The SVG as XML text.\n* @param {boolean} [preventUndo=false] - Indicates if we want to do the\n* changes without adding them to the undo stack - e.g. for initializing a\n* drawing on page load.\n* @fires module:svgcanvas.SvgCanvas#event:setnonce\n* @fires module:svgcanvas.SvgCanvas#event:unsetnonce\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {boolean} This function returns `false` if the set was\n*     unsuccessful, `true` otherwise.\n*/\nthis.setSvgString = function (xmlString, preventUndo) {\n  try {\n    // convert string into XML document\n    const newDoc = text2xml(xmlString);\n    if (newDoc.firstElementChild &&\n      newDoc.firstElementChild.namespaceURI !== NS.SVG) {\n      return false;\n    }\n\n    this.prepareSvg(newDoc);\n\n    const batchCmd = new BatchCommand('Change Source');\n\n    // remove old svg document\n    const {nextSibling} = svgcontent;\n    const oldzoom = svgroot.removeChild(svgcontent);\n    batchCmd.addSubCommand(new RemoveElementCommand(oldzoom, nextSibling, svgroot));\n\n    // set new svg document\n    // If DOM3 adoptNode() available, use it. Otherwise fall back to DOM2 importNode()\n    if (svgdoc.adoptNode) {\n      svgcontent = svgdoc.adoptNode(newDoc.documentElement);\n    } else {\n      svgcontent = svgdoc.importNode(newDoc.documentElement, true);\n    }\n\n    svgroot.append(svgcontent);\n    const content = $(svgcontent);\n\n    canvas.current_drawing_ = new draw.Drawing(svgcontent, idprefix);\n\n    // retrieve or set the nonce\n    const nonce = getCurrentDrawing().getNonce();\n    if (nonce) {\n      call('setnonce', nonce);\n    } else {\n      call('unsetnonce');\n    }\n\n    // change image href vals if possible\n    content.find('image').each(function () {\n      const image = this; // eslint-disable-line consistent-this\n      preventClickDefault(image);\n      const val = getHref(this);\n      if (val) {\n        if (val.startsWith('data:')) {\n          // Check if an SVG-edit data URI\n          const m = val.match(/svgedit_url=(.*?);/);\n          if (m) {\n            const url = decodeURIComponent(m[1]);\n            $(new Image()).load(function () {\n              image.setAttributeNS(NS.XLINK, 'xlink:href', url);\n            }).attr('src', url);\n          }\n        }\n        // Add to encodableImages if it loads\n        canvas.embedImage(val);\n      }\n    });\n\n    // Wrap child SVGs in group elements\n    content.find('svg').each(function () {\n      // Skip if it's in a <defs>\n      if ($(this).closest('defs').length) { return; }\n\n      uniquifyElems(this);\n\n      // Check if it already has a gsvg group\n      const pa = this.parentNode;\n      if (pa.childNodes.length === 1 && pa.nodeName === 'g') {\n        $(pa).data('gsvg', this);\n        pa.id = pa.id || getNextId();\n      } else {\n        groupSvgElem(this);\n      }\n    });\n\n    // For Firefox: Put all paint elems in defs\n    if (isGecko()) {\n      content.find('linearGradient, radialGradient, pattern').appendTo(findDefs());\n    }\n\n    // Set ref element for <use> elements\n\n    // TODO: This should also be done if the object is re-added through \"redo\"\n    setUseData(content);\n\n    convertGradients(content[0]);\n\n    const attrs = {\n      id: 'svgcontent',\n      overflow: curConfig.show_outside_canvas ? 'visible' : 'hidden'\n    };\n\n    let percs = false;\n\n    // determine proper size\n    if (content.attr('viewBox')) {\n      const vb = content.attr('viewBox').split(' ');\n      attrs.width = vb[2];\n      attrs.height = vb[3];\n    // handle content that doesn't have a viewBox\n    } else {\n      $.each(['width', 'height'], function (i, dim) {\n        // Set to 100 if not given\n        const val = content.attr(dim) || '100%';\n\n        if (String(val).substr(-1) === '%') {\n          // Use user units if percentage given\n          percs = true;\n        } else {\n          attrs[dim] = convertToNum(dim, val);\n        }\n      });\n    }\n\n    // identify layers\n    draw.identifyLayers();\n\n    // Give ID for any visible layer children missing one\n    content.children().find(visElems).each(function () {\n      if (!this.id) { this.id = getNextId(); }\n    });\n\n    // Percentage width/height, so let's base it on visible elements\n    if (percs) {\n      const bb = getStrokedBBoxDefaultVisible();\n      attrs.width = bb.width + bb.x;\n      attrs.height = bb.height + bb.y;\n    }\n\n    // Just in case negative numbers are given or\n    // result from the percs calculation\n    if (attrs.width <= 0) { attrs.width = 100; }\n    if (attrs.height <= 0) { attrs.height = 100; }\n\n    content.attr(attrs);\n    this.contentW = attrs.width;\n    this.contentH = attrs.height;\n\n    batchCmd.addSubCommand(new InsertElementCommand(svgcontent));\n    // update root to the correct size\n    const changes = content.attr(['width', 'height']);\n    batchCmd.addSubCommand(new ChangeElementCommand(svgroot, changes));\n\n    // reset zoom\n    currentZoom = 1;\n\n    // reset transform lists\n    resetListMap();\n    clearSelection();\n    pathModule.clearData();\n    svgroot.append(selectorManager.selectorParentGroup);\n\n    if (!preventUndo) addCommandToHistory(batchCmd);\n    call('changed', [svgcontent]);\n  } catch (e) {\n    console.log(e); // eslint-disable-line no-console\n    return false;\n  }\n\n  return true;\n};\n\n/**\n* This function imports the input SVG XML as a `<symbol>` in the `<defs>`, then adds a\n* `<use>` to the current layer.\n* @function module:svgcanvas.SvgCanvas#importSvgString\n* @param {string} xmlString - The SVG as XML text.\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {null|Element} This function returns null if the import was unsuccessful, or the element otherwise.\n* @todo\n* - properly handle if namespace is introduced by imported content (must add to svgcontent\n* and update all prefixes in the imported node)\n* - properly handle recalculating dimensions, `recalculateDimensions()` doesn't handle\n* arbitrary transform lists, but makes some assumptions about how the transform list\n* was obtained\n*/\nthis.importSvgString = function (xmlString) {\n  let j, ts, useEl;\n  try {\n    // Get unique ID\n    const uid = encode64(xmlString.length + xmlString).substr(0, 32);\n\n    let useExisting = false;\n    // Look for symbol and make sure symbol exists in image\n    if (importIds[uid]) {\n      if ($(importIds[uid].symbol).parents('#svgroot').length) {\n        useExisting = true;\n      }\n    }\n\n    const batchCmd = new BatchCommand('Import Image');\n    let symbol;\n    if (useExisting) {\n      ({symbol} = importIds[uid]);\n      ts = importIds[uid].xform;\n    } else {\n      // convert string into XML document\n      const newDoc = text2xml(xmlString);\n\n      this.prepareSvg(newDoc);\n\n      // import new svg document into our document\n      let svg;\n      // If DOM3 adoptNode() available, use it. Otherwise fall back to DOM2 importNode()\n      if (svgdoc.adoptNode) {\n        svg = svgdoc.adoptNode(newDoc.documentElement);\n      } else {\n        svg = svgdoc.importNode(newDoc.documentElement, true);\n      }\n\n      uniquifyElems(svg);\n\n      const innerw = convertToNum('width', svg.getAttribute('width')),\n        innerh = convertToNum('height', svg.getAttribute('height')),\n        innervb = svg.getAttribute('viewBox'),\n        // if no explicit viewbox, create one out of the width and height\n        vb = innervb ? innervb.split(' ') : [0, 0, innerw, innerh];\n      for (j = 0; j < 4; ++j) {\n        vb[j] = Number(vb[j]);\n      }\n\n      // TODO: properly handle preserveAspectRatio\n      const // canvasw = +svgcontent.getAttribute('width'),\n        canvash = Number(svgcontent.getAttribute('height'));\n      // imported content should be 1/3 of the canvas on its largest dimension\n\n      if (innerh > innerw) {\n        ts = 'scale(' + (canvash / 3) / vb[3] + ')';\n      } else {\n        ts = 'scale(' + (canvash / 3) / vb[2] + ')';\n      }\n\n      // Hack to make recalculateDimensions understand how to scale\n      ts = 'translate(0) ' + ts + ' translate(0)';\n\n      symbol = svgdoc.createElementNS(NS.SVG, 'symbol');\n      const defs = findDefs();\n\n      if (isGecko()) {\n        // Move all gradients into root for Firefox, workaround for this bug:\n        // https://bugzilla.mozilla.org/show_bug.cgi?id=353575\n        // TODO: Make this properly undo-able.\n        $(svg).find('linearGradient, radialGradient, pattern').appendTo(defs);\n      }\n\n      while (svg.firstChild) {\n        const first = svg.firstChild;\n        symbol.append(first);\n      }\n      const attrs = svg.attributes;\n      for (let i = 0; i < attrs.length; i++) {\n        const attr = attrs[i];\n        symbol.setAttribute(attr.nodeName, attr.value);\n      }\n      symbol.id = getNextId();\n\n      // Store data\n      importIds[uid] = {\n        symbol,\n        xform: ts\n      };\n\n      findDefs().append(symbol);\n      batchCmd.addSubCommand(new InsertElementCommand(symbol));\n    }\n\n    useEl = svgdoc.createElementNS(NS.SVG, 'use');\n    useEl.id = getNextId();\n    setHref(useEl, '#' + symbol.id);\n\n    (currentGroup || getCurrentDrawing().getCurrentLayer()).append(useEl);\n    batchCmd.addSubCommand(new InsertElementCommand(useEl));\n    clearSelection();\n\n    useEl.setAttribute('transform', ts);\n    recalculateDimensions(useEl);\n    $(useEl).data('symbol', symbol).data('ref', symbol);\n    addToSelection([useEl]);\n\n    // TODO: Find way to add this in a recalculateDimensions-parsable way\n    // if (vb[0] !== 0 || vb[1] !== 0) {\n    //   ts = 'translate(' + (-vb[0]) + ',' + (-vb[1]) + ') ' + ts;\n    // }\n    addCommandToHistory(batchCmd);\n    call('changed', [svgcontent]);\n  } catch (e) {\n    console.log(e); // eslint-disable-line no-console\n    return null;\n  }\n\n  // we want to return the element so we can automatically select it\n  return useEl;\n};\n\n// Could deprecate, but besides external uses, their usage makes clear that\n//  canvas is a dependency for all of these\nconst dr = {\n  identifyLayers, createLayer, cloneLayer, deleteCurrentLayer,\n  setCurrentLayer, renameCurrentLayer, setCurrentLayerPosition,\n  setLayerVisibility, moveSelectedToLayer, mergeLayer, mergeAllLayers,\n  leaveContext, setContext\n};\nObject.entries(dr).forEach(([prop, propVal]) => {\n  canvas[prop] = propVal;\n});\ndraw.init(\n  /**\n  * @implements {module:draw.DrawCanvasInit}\n  */\n  {\n    pathActions,\n    getCurrentGroup () {\n      return currentGroup;\n    },\n    setCurrentGroup (cg) {\n      currentGroup = cg;\n    },\n    getSelectedElements,\n    getSVGContent,\n    undoMgr,\n    elData,\n    getCurrentDrawing,\n    clearSelection,\n    call,\n    addCommandToHistory,\n    /**\n     * @fires module:svgcanvas.SvgCanvas#event:changed\n     * @returns {undefined}\n     */\n    changeSVGContent () {\n      call('changed', [svgcontent]);\n    }\n  }\n);\n\n/**\n* Group: Document functions\n*/\n\n/**\n* Clears the current document. This is not an undoable action.\n* @function module:svgcanvas.SvgCanvas#clear\n* @fires module:svgcanvas.SvgCanvas#event:cleared\n* @returns {undefined}\n*/\nthis.clear = function () {\n  pathActions.clear();\n\n  clearSelection();\n\n  // clear the svgcontent node\n  canvas.clearSvgContentElement();\n\n  // create new document\n  canvas.current_drawing_ = new draw.Drawing(svgcontent);\n\n  // create empty first layer\n  canvas.createLayer('Layer 1');\n\n  // clear the undo stack\n  canvas.undoMgr.resetUndoStack();\n\n  // reset the selector manager\n  selectorManager.initGroup();\n\n  // reset the rubber band box\n  rubberBox = selectorManager.getRubberBandBox();\n\n  call('cleared');\n};\n\n// Alias function\nthis.linkControlPoints = pathActions.linkControlPoints;\n\n/**\n* @function module:svgcanvas.SvgCanvas#getContentElem\n* @returns {Element} The content DOM element\n*/\nthis.getContentElem = function () { return svgcontent; };\n\n/**\n* @function module:svgcanvas.SvgCanvas#getRootElem\n* @returns {SVGSVGElement} The root DOM element\n*/\nthis.getRootElem = function () { return svgroot; };\n\n/**\n* @typedef {PlainObject} DimensionsAndZoom\n* @property {Float} w Width\n* @property {Float} h Height\n* @property {Float} zoom Zoom\n*/\n\n/**\n* @function module:svgcanvas.SvgCanvas#getResolution\n* @returns {DimensionsAndZoom} The current dimensions and zoom level in an object\n*/\nconst getResolution = this.getResolution = function () {\n//    const vb = svgcontent.getAttribute('viewBox').split(' ');\n//    return {w:vb[2], h:vb[3], zoom: currentZoom};\n\n  const w = svgcontent.getAttribute('width') / currentZoom;\n  const h = svgcontent.getAttribute('height') / currentZoom;\n\n  return {\n    w,\n    h,\n    zoom: currentZoom\n  };\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getSnapToGrid\n* @returns {boolean} The current snap to grid setting\n*/\nthis.getSnapToGrid = function () { return curConfig.gridSnapping; };\n\n/**\n* @function module:svgcanvas.SvgCanvas#getVersion\n* @returns {string} A string which describes the revision number of SvgCanvas.\n*/\nthis.getVersion = function () {\n  return 'svgcanvas.js ($Rev$)';\n};\n\n/**\n* Update interface strings with given values.\n* @function module:svgcanvas.SvgCanvas#setUiStrings\n* @param {module:path.uiStrings} strs - Object with strings (see the [locales API]{@link module:locale.LocaleStrings} and the [tutorial]{@tutorial LocaleDocs})\n* @returns {undefined}\n*/\nthis.setUiStrings = function (strs) {\n  Object.assign(uiStrings, strs.notification);\n  $ = jQueryPluginDBox($, strs.common);\n  pathModule.setUiStrings(strs);\n};\n\n/**\n* Update configuration options with given values.\n* @function module:svgcanvas.SvgCanvas#setConfig\n* @param {module:SVGEditor.Config} opts - Object with options\n* @returns {undefined}\n*/\nthis.setConfig = function (opts) {\n  Object.assign(curConfig, opts);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getTitle\n* @param {Element} [elem]\n* @returns {string|undefined} the current group/SVG's title contents or\n* `undefined` if no element is passed nd there are no selected elements.\n*/\nthis.getTitle = function (elem) {\n  elem = elem || selectedElements[0];\n  if (!elem) { return undefined; }\n  elem = $(elem).data('gsvg') || $(elem).data('symbol') || elem;\n  const childs = elem.childNodes;\n  for (let i = 0; i < childs.length; i++) {\n    if (childs[i].nodeName === 'title') {\n      return childs[i].textContent;\n    }\n  }\n  return '';\n};\n\n/**\n* Sets the group/SVG's title content.\n* @function module:svgcanvas.SvgCanvas#setGroupTitle\n* @param {string} val\n* @todo Combine this with `setDocumentTitle`\n* @returns {undefined}\n*/\nthis.setGroupTitle = function (val) {\n  let elem = selectedElements[0];\n  elem = $(elem).data('gsvg') || elem;\n\n  const ts = $(elem).children('title');\n\n  const batchCmd = new BatchCommand('Set Label');\n\n  let title;\n  if (!val.length) {\n    // Remove title element\n    const tsNextSibling = ts.nextSibling;\n    batchCmd.addSubCommand(new RemoveElementCommand(ts[0], tsNextSibling, elem));\n    ts.remove();\n  } else if (ts.length) {\n    // Change title contents\n    title = ts[0];\n    batchCmd.addSubCommand(new ChangeElementCommand(title, {'#text': title.textContent}));\n    title.textContent = val;\n  } else {\n    // Add title element\n    title = svgdoc.createElementNS(NS.SVG, 'title');\n    title.textContent = val;\n    $(elem).prepend(title);\n    batchCmd.addSubCommand(new InsertElementCommand(title));\n  }\n\n  addCommandToHistory(batchCmd);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getDocumentTitle\n* @returns {string|undefined} The current document title or an empty string if not found\n*/\nconst getDocumentTitle = this.getDocumentTitle = function () {\n  return canvas.getTitle(svgcontent);\n};\n\n/**\n* Adds/updates a title element for the document with the given name.\n* This is an undoable action.\n* @function module:svgcanvas.SvgCanvas#setDocumentTitle\n* @param {string} newTitle - String with the new title\n* @returns {undefined}\n*/\nthis.setDocumentTitle = function (newTitle) {\n  const childs = svgcontent.childNodes;\n  let docTitle = false, oldTitle = '';\n\n  const batchCmd = new BatchCommand('Change Image Title');\n\n  for (let i = 0; i < childs.length; i++) {\n    if (childs[i].nodeName === 'title') {\n      docTitle = childs[i];\n      oldTitle = docTitle.textContent;\n      break;\n    }\n  }\n  if (!docTitle) {\n    docTitle = svgdoc.createElementNS(NS.SVG, 'title');\n    svgcontent.insertBefore(docTitle, svgcontent.firstChild);\n    // svgcontent.firstChild.before(docTitle); // Ok to replace above with this?\n  }\n\n  if (newTitle.length) {\n    docTitle.textContent = newTitle;\n  } else {\n    // No title given, so element is not necessary\n    docTitle.remove();\n  }\n  batchCmd.addSubCommand(new ChangeElementCommand(docTitle, {'#text': oldTitle}));\n  addCommandToHistory(batchCmd);\n};\n\n/**\n* Returns the editor's namespace URL, optionally adding it to the root element.\n* @function module:svgcanvas.SvgCanvas#getEditorNS\n* @param {boolean} [add] - Indicates whether or not to add the namespace value\n* @returns {string} The editor's namespace URL\n*/\nthis.getEditorNS = function (add) {\n  if (add) {\n    svgcontent.setAttribute('xmlns:se', NS.SE);\n  }\n  return NS.SE;\n};\n\n/**\n* Changes the document's dimensions to the given size.\n* @function module:svgcanvas.SvgCanvas#setResolution\n* @param {Float|\"fit\"} x - Number with the width of the new dimensions in user units.\n* Can also be the string \"fit\" to indicate \"fit to content\".\n* @param {Float} y - Number with the height of the new dimensions in user units.\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {boolean} Indicates if resolution change was successful.\n* It will fail on \"fit to content\" option with no content to fit to.\n*/\nthis.setResolution = function (x, y) {\n  const res = getResolution();\n  const {w, h} = res;\n  let batchCmd;\n\n  if (x === 'fit') {\n    // Get bounding box\n    const bbox = getStrokedBBoxDefaultVisible();\n\n    if (bbox) {\n      batchCmd = new BatchCommand('Fit Canvas to Content');\n      const visEls = getVisibleElements();\n      addToSelection(visEls);\n      const dx = [], dy = [];\n      $.each(visEls, function (i, item) {\n        dx.push(bbox.x * -1);\n        dy.push(bbox.y * -1);\n      });\n\n      const cmd = canvas.moveSelectedElements(dx, dy, true);\n      batchCmd.addSubCommand(cmd);\n      clearSelection();\n\n      x = Math.round(bbox.width);\n      y = Math.round(bbox.height);\n    } else {\n      return false;\n    }\n  }\n  if (x !== w || y !== h) {\n    if (!batchCmd) {\n      batchCmd = new BatchCommand('Change Image Dimensions');\n    }\n\n    x = convertToNum('width', x);\n    y = convertToNum('height', y);\n\n    svgcontent.setAttribute('width', x);\n    svgcontent.setAttribute('height', y);\n\n    this.contentW = x;\n    this.contentH = y;\n    batchCmd.addSubCommand(new ChangeElementCommand(svgcontent, {width: w, height: h}));\n\n    svgcontent.setAttribute('viewBox', [0, 0, x / currentZoom, y / currentZoom].join(' '));\n    batchCmd.addSubCommand(new ChangeElementCommand(svgcontent, {viewBox: ['0 0', w, h].join(' ')}));\n\n    addCommandToHistory(batchCmd);\n    call('changed', [svgcontent]);\n  }\n  return true;\n};\n\n/**\n* @typedef {module:jQueryAttr.Attributes} module:svgcanvas.ElementPositionInCanvas\n* @property {Float} x\n* @property {Float} y\n*/\n\n/**\n* @function module:svgcanvas.SvgCanvas#getOffset\n* @returns {module:svgcanvas.ElementPositionInCanvas} An object with `x`, `y` values indicating the svgcontent element's\n* position in the editor's canvas.\n*/\nthis.getOffset = function () {\n  return $(svgcontent).attr(['x', 'y']);\n};\n\n/**\n * @typedef {PlainObject} module:svgcanvas.ZoomAndBBox\n * @property {Float} zoom\n * @property {module:utilities.BBoxObject} bbox\n */\n/**\n* Sets the zoom level on the canvas-side based on the given value.\n* @function module:svgcanvas.SvgCanvas#setBBoxZoom\n* @param {\"selection\"|\"canvas\"|\"content\"|\"layer\"|module:SVGEditor.BBoxObjectWithFactor} val - Bounding box object to zoom to or string indicating zoom option. Note: the object value type is defined in `svg-editor.js`\n* @param {Integer} editorW - The editor's workarea box's width\n* @param {Integer} editorH - The editor's workarea box's height\n* @returns {module:svgcanvas.ZoomAndBBox|undefined}\n*/\nthis.setBBoxZoom = function (val, editorW, editorH) {\n  let spacer = 0.85;\n  let bb;\n  const calcZoom = function (bb) { // eslint-disable-line no-shadow\n    if (!bb) { return false; }\n    const wZoom = Math.round((editorW / bb.width) * 100 * spacer) / 100;\n    const hZoom = Math.round((editorH / bb.height) * 100 * spacer) / 100;\n    const zoom = Math.min(wZoom, hZoom);\n    canvas.setZoom(zoom);\n    return {zoom, bbox: bb};\n  };\n\n  if (typeof val === 'object') {\n    bb = val;\n    if (bb.width === 0 || bb.height === 0) {\n      const newzoom = bb.zoom ? bb.zoom : currentZoom * bb.factor;\n      canvas.setZoom(newzoom);\n      return {zoom: currentZoom, bbox: bb};\n    }\n    return calcZoom(bb);\n  }\n\n  switch (val) {\n  case 'selection': {\n    if (!selectedElements[0]) { return undefined; }\n    const selectedElems = $.map(selectedElements, function (n) {\n      if (n) {\n        return n;\n      }\n      return undefined;\n    });\n    bb = getStrokedBBoxDefaultVisible(selectedElems);\n    break;\n  } case 'canvas': {\n    const res = getResolution();\n    spacer = 0.95;\n    bb = {width: res.w, height: res.h, x: 0, y: 0};\n    break;\n  } case 'content':\n    bb = getStrokedBBoxDefaultVisible();\n    break;\n  case 'layer':\n    bb = getStrokedBBoxDefaultVisible(getVisibleElements(getCurrentDrawing().getCurrentLayer()));\n    break;\n  default:\n    return undefined;\n  }\n  return calcZoom(bb);\n};\n\n/**\n* The zoom level has changed. Supplies the new zoom level as a number (not percentage).\n* @event module:svgcanvas.SvgCanvas#event:ext-zoomChanged\n* @type {Float}\n*/\n/**\n* The bottom panel was updated\n* @event module:svgcanvas.SvgCanvas#event:ext-toolButtonStateUpdate\n* @type {PlainObject}\n* @property {boolean} nofill Indicates fill is disabled\n* @property {boolean} nostroke Indicates stroke is disabled\n*/\n/**\n* The element selection has changed (elements were added/removed from selection)\n* @event module:svgcanvas.SvgCanvas#event:ext-selectedChanged\n* @type {PlainObject}\n* @property {Element[]} elems Array of the newly selected elements\n* @property {Element|null} selectedElement The single selected element\n* @property {boolean} multiselected Indicates whether one or more elements were selected\n*/\n/**\n* Called when part of element is in process of changing, generally on\n* mousemove actions like rotate, move, etc.\n* @event module:svgcanvas.SvgCanvas#event:ext-elementTransition\n* @type {PlainObject}\n* @property {Element[]} elems Array of transitioning elements\n*/\n/**\n* One or more elements were changed\n* @event module:svgcanvas.SvgCanvas#event:ext-elementChanged\n* @type {PlainObject}\n* @property {Element[]} elems Array of the affected elements\n*/\n/**\n* Invoked as soon as the locale is ready\n* @event module:svgcanvas.SvgCanvas#event:ext-langReady\n* @type {PlainObject}\n* @property {string} lang The two-letter language code\n* @property {module:SVGEditor.uiStrings} uiStrings\n* @property {module:SVGEditor~ImportLocale} importLocale\n*/\n/**\n* The language was changed. Two-letter code of the new language.\n* @event module:svgcanvas.SvgCanvas#event:ext-langChanged\n* @type {string}\n*/\n/**\n* Means for an extension to add locale data. The two-letter language code.\n* @event module:svgcanvas.SvgCanvas#event:ext-addLangData\n* @type {PlainObject}\n* @property {string} lang\n* @property {module:SVGEditor~ImportLocale} importLocale\n*/\n/**\n * Called when new image is created\n * @event module:svgcanvas.SvgCanvas#event:ext-onNewDocument\n * @type {undefined}\n */\n/**\n * Called when sidepanel is resized or toggled\n * @event module:svgcanvas.SvgCanvas#event:ext-workareaResized\n * @type {undefined}\n*/\n/**\n * Called upon addition of the extension, or, if svgicons are set,\n * after the icons are ready when extension SVG icons have loaded.\n * @event module:svgcanvas.SvgCanvas#event:ext-callback\n * @type {undefined}\n*/\n\n/**\n* Sets the zoom to the given level.\n* @function module:svgcanvas.SvgCanvas#setZoom\n* @param {Float} zoomLevel - Float indicating the zoom level to change to\n* @fires module:svgcanvas.SvgCanvas#event:ext-zoomChanged\n* @returns {undefined}\n*/\nthis.setZoom = function (zoomLevel) {\n  const res = getResolution();\n  svgcontent.setAttribute('viewBox', '0 0 ' + res.w / zoomLevel + ' ' + res.h / zoomLevel);\n  currentZoom = zoomLevel;\n  $.each(selectedElements, function (i, elem) {\n    if (!elem) { return; }\n    selectorManager.requestSelector(elem).resize();\n  });\n  pathActions.zoomChange();\n  runExtensions('zoomChanged', /** @type {module:svgcanvas.SvgCanvas#event:ext-zoomChanged} */ zoomLevel);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getMode\n* @returns {string} The current editor mode string\n*/\nthis.getMode = function () {\n  return currentMode;\n};\n\n/**\n* Sets the editor's mode to the given string.\n* @function module:svgcanvas.SvgCanvas#setMode\n* @param {string} name - String with the new mode to change to\n* @returns {undefined}\n*/\nthis.setMode = function (name) {\n  pathActions.clear(true);\n  textActions.clear();\n  curProperties = (selectedElements[0] && selectedElements[0].nodeName === 'text') ? curText : curShape;\n  currentMode = name;\n};\n\n/**\n* Group: Element Styling\n*/\n\n/**\n* @typedef {PlainObject} module:svgcanvas.PaintOptions\n* @property {\"solidColor\"} type\n*/\n\n/**\n* @function module:svgcanvas.SvgCanvas#getColor\n* @param {string} type\n* @returns {string|module:svgcanvas.PaintOptions|Float|module:jGraduate~Paint} The current fill/stroke option\n*/\nthis.getColor = function (type) {\n  return curProperties[type];\n};\n\n/**\n* Change the current stroke/fill color/gradient value.\n* @function module:svgcanvas.SvgCanvas#setColor\n* @param {string} type - String indicating fill or stroke\n* @param {string} val - The value to set the stroke attribute to\n* @param {boolean} preventUndo - Boolean indicating whether or not this should be an undoable option\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.setColor = function (type, val, preventUndo) {\n  curShape[type] = val;\n  curProperties[type + '_paint'] = {type: 'solidColor'};\n  const elems = [];\n  /**\n   *\n   * @param {Element} e\n   * @returns {undefined}\n   */\n  function addNonG (e) {\n    if (e.nodeName !== 'g') {\n      elems.push(e);\n    }\n  }\n  let i = selectedElements.length;\n  while (i--) {\n    const elem = selectedElements[i];\n    if (elem) {\n      if (elem.tagName === 'g') {\n        walkTree(elem, addNonG);\n      } else if (type === 'fill') {\n        if (elem.tagName !== 'polyline' && elem.tagName !== 'line') {\n          elems.push(elem);\n        }\n      } else {\n        elems.push(elem);\n      }\n    }\n  }\n  if (elems.length > 0) {\n    if (!preventUndo) {\n      changeSelectedAttribute(type, val, elems);\n      call('changed', elems);\n    } else {\n      changeSelectedAttributeNoUndo(type, val, elems);\n    }\n  }\n};\n\n/**\n* Apply the current gradient to selected element's fill or stroke.\n* @function module:svgcanvas.SvgCanvas#setGradient\n* @param {\"fill\"|\"stroke\"} type - String indicating \"fill\" or \"stroke\" to apply to an element\n* @returns {undefined}\n*/\nconst setGradient = this.setGradient = function (type) {\n  if (!curProperties[type + '_paint'] || curProperties[type + '_paint'].type === 'solidColor') { return; }\n  let grad = canvas[type + 'Grad'];\n  // find out if there is a duplicate gradient already in the defs\n  const duplicateGrad = findDuplicateGradient(grad);\n  const defs = findDefs();\n  // no duplicate found, so import gradient into defs\n  if (!duplicateGrad) {\n    // const origGrad = grad;\n    grad = defs.appendChild(svgdoc.importNode(grad, true));\n    // get next id and set it on the grad\n    grad.id = getNextId();\n  } else { // use existing gradient\n    grad = duplicateGrad;\n  }\n  canvas.setColor(type, 'url(#' + grad.id + ')');\n};\n\n/**\n* Check if exact gradient already exists.\n* @function module:svgcanvas~findDuplicateGradient\n* @param {SVGGradientElement} grad - The gradient DOM element to compare to others\n* @returns {SVGGradientElement} The existing gradient if found, `null` if not\n*/\nconst findDuplicateGradient = function (grad) {\n  const defs = findDefs();\n  const existingGrads = $(defs).find('linearGradient, radialGradient');\n  let i = existingGrads.length;\n  const radAttrs = ['r', 'cx', 'cy', 'fx', 'fy'];\n  while (i--) {\n    const og = existingGrads[i];\n    if (grad.tagName === 'linearGradient') {\n      if (grad.getAttribute('x1') !== og.getAttribute('x1') ||\n        grad.getAttribute('y1') !== og.getAttribute('y1') ||\n        grad.getAttribute('x2') !== og.getAttribute('x2') ||\n        grad.getAttribute('y2') !== og.getAttribute('y2')\n      ) {\n        continue;\n      }\n    } else {\n      const gradAttrs = $(grad).attr(radAttrs);\n      const ogAttrs = $(og).attr(radAttrs);\n\n      let diff = false;\n      $.each(radAttrs, function (j, attr) {\n        if (gradAttrs[attr] !== ogAttrs[attr]) { diff = true; }\n      });\n\n      if (diff) { continue; }\n    }\n\n    // else could be a duplicate, iterate through stops\n    const stops = grad.getElementsByTagNameNS(NS.SVG, 'stop');\n    const ostops = og.getElementsByTagNameNS(NS.SVG, 'stop');\n\n    if (stops.length !== ostops.length) {\n      continue;\n    }\n\n    let j = stops.length;\n    while (j--) {\n      const stop = stops[j];\n      const ostop = ostops[j];\n\n      if (stop.getAttribute('offset') !== ostop.getAttribute('offset') ||\n        stop.getAttribute('stop-opacity') !== ostop.getAttribute('stop-opacity') ||\n        stop.getAttribute('stop-color') !== ostop.getAttribute('stop-color')) {\n        break;\n      }\n    }\n\n    if (j === -1) {\n      return og;\n    }\n  } // for each gradient in defs\n\n  return null;\n};\n\n/**\n* Set a color/gradient to a fill/stroke.\n* @function module:svgcanvas.SvgCanvas#setPaint\n* @param {\"fill\"|\"stroke\"} type - String with \"fill\" or \"stroke\"\n* @param {module:jGraduate.jGraduatePaintOptions} paint - The jGraduate paint object to apply\n* @returns {undefined}\n*/\nthis.setPaint = function (type, paint) {\n  // make a copy\n  const p = new $.jGraduate.Paint(paint);\n  this.setPaintOpacity(type, p.alpha / 100, true);\n\n  // now set the current paint object\n  curProperties[type + '_paint'] = p;\n  switch (p.type) {\n  case 'solidColor':\n    this.setColor(type, p.solidColor !== 'none' ? '#' + p.solidColor : 'none');\n    break;\n  case 'linearGradient':\n  case 'radialGradient':\n    canvas[type + 'Grad'] = p[p.type];\n    setGradient(type);\n    break;\n  }\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#setStrokePaint\n* @param {module:jGraduate~Paint} paint\n* @returns {undefined}\n*/\nthis.setStrokePaint = function (paint) {\n  this.setPaint('stroke', paint);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#setFillPaint\n* @param {module:jGraduate~Paint} paint\n* @returns {undefined}\n*/\nthis.setFillPaint = function (paint) {\n  this.setPaint('fill', paint);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getStrokeWidth\n* @returns {Float|string} The current stroke-width value\n*/\nthis.getStrokeWidth = function () {\n  return curProperties.stroke_width;\n};\n\n/**\n* Sets the stroke width for the current selected elements.\n* When attempting to set a line's width to 0, this changes it to 1 instead.\n* @function module:svgcanvas.SvgCanvas#setStrokeWidth\n* @param {Float} val - A Float indicating the new stroke width value\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.setStrokeWidth = function (val) {\n  if (val === 0 && ['line', 'path'].includes(currentMode)) {\n    canvas.setStrokeWidth(1);\n    return;\n  }\n  curProperties.stroke_width = val;\n\n  const elems = [];\n  /**\n   *\n   * @param {Element} e\n   * @returns {undefined}\n   */\n  function addNonG (e) {\n    if (e.nodeName !== 'g') {\n      elems.push(e);\n    }\n  }\n  let i = selectedElements.length;\n  while (i--) {\n    const elem = selectedElements[i];\n    if (elem) {\n      if (elem.tagName === 'g') {\n        walkTree(elem, addNonG);\n      } else {\n        elems.push(elem);\n      }\n    }\n  }\n  if (elems.length > 0) {\n    changeSelectedAttribute('stroke-width', val, elems);\n    call('changed', selectedElements);\n  }\n};\n\n/**\n* Set the given stroke-related attribute the given value for selected elements.\n* @function module:svgcanvas.SvgCanvas#setStrokeAttr\n* @param {string} attr - String with the attribute name\n* @param {string|Float} val - String or number with the attribute value\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.setStrokeAttr = function (attr, val) {\n  curShape[attr.replace('-', '_')] = val;\n  const elems = [];\n\n  let i = selectedElements.length;\n  while (i--) {\n    const elem = selectedElements[i];\n    if (elem) {\n      if (elem.tagName === 'g') {\n        walkTree(elem, function (e) { if (e.nodeName !== 'g') { elems.push(e); } });\n      } else {\n        elems.push(elem);\n      }\n    }\n  }\n  if (elems.length > 0) {\n    changeSelectedAttribute(attr, val, elems);\n    call('changed', selectedElements);\n  }\n};\n\n/**\n* @typedef {PlainObject} module:svgcanvas.StyleOptions\n* @property {string} fill\n* @property {Float} fill_opacity\n* @property {string} stroke\n* @property {Float} stroke_width\n* @property {string} stroke_dasharray\n* @property {string} stroke_linejoin\n* @property {string} stroke_linecap\n* @property {Float} stroke_opacity\n* @property {Float} opacity\n*/\n\n/**\n* @function module:svgcanvas.SvgCanvas#getStyle\n* @returns {module:svgcanvas.StyleOptions} current style options\n*/\nthis.getStyle = function () {\n  return curShape;\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getOpacity\n* @returns {Float} the current opacity\n*/\nthis.getOpacity = getOpacity;\n\n/**\n* Sets the given opacity on the current selected elements.\n* @function module:svgcanvas.SvgCanvas#setOpacity\n* @param {string} val\n* @returns {undefined}\n*/\nthis.setOpacity = function (val) {\n  curShape.opacity = val;\n  changeSelectedAttribute('opacity', val);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getFillOpacity\n* @returns {Float} the current fill opacity\n*/\nthis.getFillOpacity = function () {\n  return curShape.fill_opacity;\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getStrokeOpacity\n* @returns {string} the current stroke opacity\n*/\nthis.getStrokeOpacity = function () {\n  return curShape.stroke_opacity;\n};\n\n/**\n* Sets the current fill/stroke opacity.\n* @function module:svgcanvas.SvgCanvas#setPaintOpacity\n* @param {string} type - String with \"fill\" or \"stroke\"\n* @param {Float} val - Float with the new opacity value\n* @param {boolean} preventUndo - Indicates whether or not this should be an undoable action\n* @returns {undefined}\n*/\nthis.setPaintOpacity = function (type, val, preventUndo) {\n  curShape[type + '_opacity'] = val;\n  if (!preventUndo) {\n    changeSelectedAttribute(type + '-opacity', val);\n  } else {\n    changeSelectedAttributeNoUndo(type + '-opacity', val);\n  }\n};\n\n/**\n* Gets the current fill/stroke opacity.\n* @function module:svgcanvas.SvgCanvas#getPaintOpacity\n* @param {\"fill\"|\"stroke\"} type - String with \"fill\" or \"stroke\"\n* @returns {Float} Fill/stroke opacity\n*/\nthis.getPaintOpacity = function (type) {\n  return type === 'fill' ? this.getFillOpacity() : this.getStrokeOpacity();\n};\n\n/**\n* Gets the `stdDeviation` blur value of the given element.\n* @function module:svgcanvas.SvgCanvas#getBlur\n* @param {Element} elem - The element to check the blur value for\n* @returns {string} stdDeviation blur attribute value\n*/\nthis.getBlur = function (elem) {\n  let val = 0;\n  // const elem = selectedElements[0];\n\n  if (elem) {\n    const filterUrl = elem.getAttribute('filter');\n    if (filterUrl) {\n      const blur = getElem(elem.id + '_blur');\n      if (blur) {\n        val = blur.firstChild.getAttribute('stdDeviation');\n      }\n    }\n  }\n  return val;\n};\n\n(function () {\nlet curCommand = null;\nlet filter = null;\nlet filterHidden = false;\n\n/**\n* Sets the `stdDeviation` blur value on the selected element without being undoable.\n* @function module:svgcanvas.SvgCanvas#setBlurNoUndo\n* @param {Float} val - The new `stdDeviation` value\n* @returns {undefined}\n*/\ncanvas.setBlurNoUndo = function (val) {\n  if (!filter) {\n    canvas.setBlur(val);\n    return;\n  }\n  if (val === 0) {\n    // Don't change the StdDev, as that will hide the element.\n    // Instead, just remove the value for \"filter\"\n    changeSelectedAttributeNoUndo('filter', '');\n    filterHidden = true;\n  } else {\n    const elem = selectedElements[0];\n    if (filterHidden) {\n      changeSelectedAttributeNoUndo('filter', 'url(#' + elem.id + '_blur)');\n    }\n    if (isWebkit()) {\n      // console.log('e', elem); // eslint-disable-line no-console\n      elem.removeAttribute('filter');\n      elem.setAttribute('filter', 'url(#' + elem.id + '_blur)');\n    }\n    changeSelectedAttributeNoUndo('stdDeviation', val, [filter.firstChild]);\n    canvas.setBlurOffsets(filter, val);\n  }\n};\n\n/**\n *\n * @returns {undefined}\n */\nfunction finishChange () {\n  const bCmd = canvas.undoMgr.finishUndoableChange();\n  curCommand.addSubCommand(bCmd);\n  addCommandToHistory(curCommand);\n  curCommand = null;\n  filter = null;\n}\n\n/**\n* Sets the `x`, `y`, `width`, `height` values of the filter element in order to\n* make the blur not be clipped. Removes them if not neeeded.\n* @function module:svgcanvas.SvgCanvas#setBlurOffsets\n* @param {Element} filterElem - The filter DOM element to update\n* @param {Float} stdDev - The standard deviation value on which to base the offset size\n* @returns {undefined}\n*/\ncanvas.setBlurOffsets = function (filterElem, stdDev) {\n  if (stdDev > 3) {\n    // TODO: Create algorithm here where size is based on expected blur\n    assignAttributes(filterElem, {\n      x: '-50%',\n      y: '-50%',\n      width: '200%',\n      height: '200%'\n    }, 100);\n  // Removing these attributes hides text in Chrome (see Issue 579)\n  } else if (!isWebkit()) {\n      filterElem.removeAttribute('x');\n      filterElem.removeAttribute('y');\n      filterElem.removeAttribute('width');\n      filterElem.removeAttribute('height');\n  }\n};\n\n/**\n* Adds/updates the blur filter to the selected element.\n* @function module:svgcanvas.SvgCanvas#setBlur\n* @param {Float} val - Float with the new `stdDeviation` blur value\n* @param {boolean} complete - Whether or not the action should be completed (to add to the undo manager)\n* @returns {undefined}\n*/\ncanvas.setBlur = function (val, complete) {\n  if (curCommand) {\n    finishChange();\n    return;\n  }\n\n  // Looks for associated blur, creates one if not found\n  const elem = selectedElements[0];\n  const elemId = elem.id;\n  filter = getElem(elemId + '_blur');\n\n  val -= 0;\n\n  const batchCmd = new BatchCommand();\n\n  // Blur found!\n  if (filter) {\n    if (val === 0) {\n      filter = null;\n    }\n  } else {\n    // Not found, so create\n    const newblur = addSVGElementFromJson({element: 'feGaussianBlur',\n      attr: {\n        in: 'SourceGraphic',\n        stdDeviation: val\n      }\n    });\n\n    filter = addSVGElementFromJson({element: 'filter',\n      attr: {\n        id: elemId + '_blur'\n      }\n    });\n\n    filter.append(newblur);\n    findDefs().append(filter);\n\n    batchCmd.addSubCommand(new InsertElementCommand(filter));\n  }\n\n  const changes = {filter: elem.getAttribute('filter')};\n\n  if (val === 0) {\n    elem.removeAttribute('filter');\n    batchCmd.addSubCommand(new ChangeElementCommand(elem, changes));\n    return;\n  }\n\n  changeSelectedAttribute('filter', 'url(#' + elemId + '_blur)');\n  batchCmd.addSubCommand(new ChangeElementCommand(elem, changes));\n  canvas.setBlurOffsets(filter, val);\n\n  curCommand = batchCmd;\n  canvas.undoMgr.beginUndoableChange('stdDeviation', [filter ? filter.firstChild : null]);\n  if (complete) {\n    canvas.setBlurNoUndo(val);\n    finishChange();\n  }\n};\n}());\n\n/**\n* Check whether selected element is bold or not.\n* @function module:svgcanvas.SvgCanvas#getBold\n* @returns {boolean} Indicates whether or not element is bold\n*/\nthis.getBold = function () {\n  // should only have one element selected\n  const selected = selectedElements[0];\n  if (!isNullish(selected) && selected.tagName === 'text' &&\n    isNullish(selectedElements[1])) {\n    return (selected.getAttribute('font-weight') === 'bold');\n  }\n  return false;\n};\n\n/**\n* Make the selected element bold or normal.\n* @function module:svgcanvas.SvgCanvas#setBold\n* @param {boolean} b - Indicates bold (`true`) or normal (`false`)\n* @returns {undefined}\n*/\nthis.setBold = function (b) {\n  const selected = selectedElements[0];\n  if (!isNullish(selected) && selected.tagName === 'text' &&\n    isNullish(selectedElements[1])) {\n    changeSelectedAttribute('font-weight', b ? 'bold' : 'normal');\n  }\n  if (!selectedElements[0].textContent) {\n    textActions.setCursor();\n  }\n};\n\n/**\n* Check whether selected element is in italics or not.\n* @function module:svgcanvas.SvgCanvas#getItalic\n* @returns {boolean} Indicates whether or not element is italic\n*/\nthis.getItalic = function () {\n  const selected = selectedElements[0];\n  if (!isNullish(selected) && selected.tagName === 'text' &&\n    isNullish(selectedElements[1])) {\n    return (selected.getAttribute('font-style') === 'italic');\n  }\n  return false;\n};\n\n/**\n* Make the selected element italic or normal.\n* @function module:svgcanvas.SvgCanvas#setItalic\n* @param {boolean} i - Indicates italic (`true`) or normal (`false`)\n* @returns {undefined}\n*/\nthis.setItalic = function (i) {\n  const selected = selectedElements[0];\n  if (!isNullish(selected) && selected.tagName === 'text' &&\n    isNullish(selectedElements[1])) {\n    changeSelectedAttribute('font-style', i ? 'italic' : 'normal');\n  }\n  if (!selectedElements[0].textContent) {\n    textActions.setCursor();\n  }\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getFontFamily\n* @returns {string} The current font family\n*/\nthis.getFontFamily = function () {\n  return curText.font_family;\n};\n\n/**\n* Set the new font family.\n* @function module:svgcanvas.SvgCanvas#setFontFamily\n* @param {string} val - String with the new font family\n* @returns {undefined}\n*/\nthis.setFontFamily = function (val) {\n  curText.font_family = val;\n  changeSelectedAttribute('font-family', val);\n  if (selectedElements[0] && !selectedElements[0].textContent) {\n    textActions.setCursor();\n  }\n};\n\n/**\n* Set the new font color.\n* @function module:svgcanvas.SvgCanvas#setFontColor\n* @param {string} val - String with the new font color\n* @returns {undefined}\n*/\nthis.setFontColor = function (val) {\n  curText.fill = val;\n  changeSelectedAttribute('fill', val);\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getFontColor\n* @returns {string} The current font color\n*/\nthis.getFontColor = function () {\n  return curText.fill;\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getFontSize\n* @returns {Float} The current font size\n*/\nthis.getFontSize = function () {\n  return curText.font_size;\n};\n\n/**\n* Applies the given font size to the selected element.\n* @function module:svgcanvas.SvgCanvas#setFontSize\n* @param {Float} val - Float with the new font size\n* @returns {undefined}\n*/\nthis.setFontSize = function (val) {\n  curText.font_size = val;\n  changeSelectedAttribute('font-size', val);\n  if (!selectedElements[0].textContent) {\n    textActions.setCursor();\n  }\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#getText\n* @returns {string} The current text (`textContent`) of the selected element\n*/\nthis.getText = function () {\n  const selected = selectedElements[0];\n  if (isNullish(selected)) { return ''; }\n  return selected.textContent;\n};\n\n/**\n* Updates the text element with the given string.\n* @function module:svgcanvas.SvgCanvas#setTextContent\n* @param {string} val - String with the new text\n* @returns {undefined}\n*/\nthis.setTextContent = function (val) {\n  changeSelectedAttribute('#text', val);\n  textActions.init(val);\n  textActions.setCursor();\n};\n\n/**\n* Sets the new image URL for the selected image element. Updates its size if\n* a new URL is given.\n* @function module:svgcanvas.SvgCanvas#setImageURL\n* @param {string} val - String with the image URL/path\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.setImageURL = function (val) {\n  const elem = selectedElements[0];\n  if (!elem) { return; }\n\n  const attrs = $(elem).attr(['width', 'height']);\n  const setsize = (!attrs.width || !attrs.height);\n\n  const curHref = getHref(elem);\n\n  // Do nothing if no URL change or size change\n  if (curHref === val && !setsize) {\n    return;\n  }\n\n  const batchCmd = new BatchCommand('Change Image URL');\n\n  setHref(elem, val);\n  batchCmd.addSubCommand(new ChangeElementCommand(elem, {\n    '#href': curHref\n  }));\n\n  $(new Image()).load(function () {\n    const changes = $(elem).attr(['width', 'height']);\n\n    $(elem).attr({\n      width: this.width,\n      height: this.height\n    });\n\n    selectorManager.requestSelector(elem).resize();\n\n    batchCmd.addSubCommand(new ChangeElementCommand(elem, changes));\n    addCommandToHistory(batchCmd);\n    call('changed', [elem]);\n  }).attr('src', val);\n};\n\n/**\n* Sets the new link URL for the selected anchor element.\n* @function module:svgcanvas.SvgCanvas#setLinkURL\n* @param {string} val - String with the link URL/path\n* @returns {undefined}\n*/\nthis.setLinkURL = function (val) {\n  let elem = selectedElements[0];\n  if (!elem) { return; }\n  if (elem.tagName !== 'a') {\n    // See if parent is an anchor\n    const parentsA = $(elem).parents('a');\n    if (parentsA.length) {\n      elem = parentsA[0];\n    } else {\n      return;\n    }\n  }\n\n  const curHref = getHref(elem);\n\n  if (curHref === val) { return; }\n\n  const batchCmd = new BatchCommand('Change Link URL');\n\n  setHref(elem, val);\n  batchCmd.addSubCommand(new ChangeElementCommand(elem, {\n    '#href': curHref\n  }));\n\n  addCommandToHistory(batchCmd);\n};\n\n/**\n* Sets the `rx` and `ry` values to the selected `rect` element\n* to change its corner radius.\n* @function module:svgcanvas.SvgCanvas#setRectRadius\n* @param {string|Float} val - The new radius\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.setRectRadius = function (val) {\n  const selected = selectedElements[0];\n  if (!isNullish(selected) && selected.tagName === 'rect') {\n    const r = selected.getAttribute('rx');\n    if (r !== String(val)) {\n      selected.setAttribute('rx', val);\n      selected.setAttribute('ry', val);\n      addCommandToHistory(new ChangeElementCommand(selected, {rx: r, ry: r}, 'Radius'));\n      call('changed', [selected]);\n    }\n  }\n};\n\n/**\n* Wraps the selected element(s) in an anchor element or converts group to one.\n* @function module:svgcanvas.SvgCanvas#makeHyperlink\n* @param {string} url\n* @returns {undefined}\n*/\nthis.makeHyperlink = function (url) {\n  canvas.groupSelectedElements('a', url);\n\n  // TODO: If element is a single \"g\", convert to \"a\"\n  //  if (selectedElements.length > 1 && selectedElements[1]) {\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#removeHyperlink\n* @returns {undefined}\n*/\nthis.removeHyperlink = function () {\n  canvas.ungroupSelectedElement();\n};\n\n/**\n* Group: Element manipulation\n*/\n\n/**\n* Sets the new segment type to the selected segment(s).\n* @function module:svgcanvas.SvgCanvas#setSegType\n* @param {Integer} newType - New segment type. See {@link https://www.w3.org/TR/SVG/paths.html#InterfaceSVGPathSeg} for list\n* @returns {undefined}\n*/\nthis.setSegType = function (newType) {\n  pathActions.setSegType(newType);\n};\n\n/**\n* Convert selected element to a path, or get the BBox of an element-as-path.\n* @function module:svgcanvas.SvgCanvas#convertToPath\n* @todo (codedread): Remove the getBBox argument and split this function into two.\n* @param {Element} elem - The DOM element to be converted\n* @param {boolean} getBBox - Boolean on whether or not to only return the path's BBox\n* @returns {undefined|DOMRect|false|SVGPathElement|null} If the getBBox flag is true, the resulting path's bounding box object.\n* Otherwise the resulting path element is returned.\n*/\nthis.convertToPath = function (elem, getBBox) {\n  if (isNullish(elem)) {\n    const elems = selectedElements;\n    $.each(elems, function (i, el) {\n      if (el) { canvas.convertToPath(el); }\n    });\n    return undefined;\n  }\n  if (getBBox) {\n    return getBBoxOfElementAsPath(elem, addSVGElementFromJson, pathActions);\n  }\n  // TODO: Why is this applying attributes from curShape, then inside utilities.convertToPath it's pulling addition attributes from elem?\n  // TODO: If convertToPath is called with one elem, curShape and elem are probably the same; but calling with multiple is a bug or cool feature.\n  const attrs = {\n    fill: curShape.fill,\n    'fill-opacity': curShape.fill_opacity,\n    stroke: curShape.stroke,\n    'stroke-width': curShape.stroke_width,\n    'stroke-dasharray': curShape.stroke_dasharray,\n    'stroke-linejoin': curShape.stroke_linejoin,\n    'stroke-linecap': curShape.stroke_linecap,\n    'stroke-opacity': curShape.stroke_opacity,\n    opacity: curShape.opacity,\n    visibility: 'hidden'\n  };\n  return convertToPath(elem, attrs, addSVGElementFromJson, pathActions, clearSelection, addToSelection, hstry, addCommandToHistory);\n};\n\n/**\n* This function makes the changes to the elements. It does not add the change\n* to the history stack.\n* @param {string} attr - Attribute name\n* @param {string|Float} newValue - String or number with the new attribute value\n* @param {Element[]} elems - The DOM elements to apply the change to\n* @returns {undefined}\n*/\nconst changeSelectedAttributeNoUndo = function (attr, newValue, elems) {\n  if (currentMode === 'pathedit') {\n    // Editing node\n    pathActions.moveNode(attr, newValue);\n  }\n  elems = elems || selectedElements;\n  let i = elems.length;\n  const noXYElems = ['g', 'polyline', 'path'];\n  // const goodGAttrs = ['transform', 'opacity', 'filter'];\n\n  while (i--) {\n    let elem = elems[i];\n    if (isNullish(elem)) { continue; }\n\n    // Set x,y vals on elements that don't have them\n    if ((attr === 'x' || attr === 'y') && noXYElems.includes(elem.tagName)) {\n      const bbox = getStrokedBBoxDefaultVisible([elem]);\n      const diffX = attr === 'x' ? newValue - bbox.x : 0;\n      const diffY = attr === 'y' ? newValue - bbox.y : 0;\n      canvas.moveSelectedElements(diffX * currentZoom, diffY * currentZoom, true);\n      continue;\n    }\n\n    // only allow the transform/opacity/filter attribute to change on <g> elements, slightly hacky\n    // TODO: FIXME: Missing statement body\n    // if (elem.tagName === 'g' && goodGAttrs.includes(attr)) {}\n    let oldval = attr === '#text' ? elem.textContent : elem.getAttribute(attr);\n    if (isNullish(oldval)) { oldval = ''; }\n    if (oldval !== String(newValue)) {\n      if (attr === '#text') {\n        // const oldW = utilsGetBBox(elem).width;\n        elem.textContent = newValue;\n\n        // FF bug occurs on on rotated elements\n        if ((/rotate/).test(elem.getAttribute('transform'))) {\n          elem = ffClone(elem);\n        }\n        // Hoped to solve the issue of moving text with text-anchor=\"start\",\n        // but this doesn't actually fix it. Hopefully on the right track, though. -Fyrd\n        // const box = getBBox(elem), left = box.x, top = box.y, {width, height} = box,\n        //   dx = width - oldW, dy = 0;\n        // const angle = getRotationAngle(elem, true);\n        // if (angle) {\n        //   const r = Math.sqrt(dx * dx + dy * dy);\n        //   const theta = Math.atan2(dy, dx) - angle;\n        //   dx = r * Math.cos(theta);\n        //   dy = r * Math.sin(theta);\n        //\n        //   elem.setAttribute('x', elem.getAttribute('x') - dx);\n        //   elem.setAttribute('y', elem.getAttribute('y') - dy);\n        // }\n      } else if (attr === '#href') {\n        setHref(elem, newValue);\n      } else { elem.setAttribute(attr, newValue); }\n\n      // Go into \"select\" mode for text changes\n      // NOTE: Important that this happens AFTER elem.setAttribute() or else attributes like\n      // font-size can get reset to their old value, ultimately by svgEditor.updateContextPanel(),\n      // after calling textActions.toSelectMode() below\n      if (currentMode === 'textedit' && attr !== '#text' && elem.textContent.length) {\n        textActions.toSelectMode(elem);\n      }\n\n      // if (i === 0) {\n      //   selectedBBoxes[0] = utilsGetBBox(elem);\n      // }\n\n      // Use the Firefox ffClone hack for text elements with gradients or\n      // where other text attributes are changed.\n      if (isGecko() && elem.nodeName === 'text' && (/rotate/).test(elem.getAttribute('transform'))) {\n        if (String(newValue).startsWith('url') || (['font-size', 'font-family', 'x', 'y'].includes(attr) && elem.textContent)) {\n          elem = ffClone(elem);\n        }\n      }\n      // Timeout needed for Opera & Firefox\n      // codedread: it is now possible for this function to be called with elements\n      // that are not in the selectedElements array, we need to only request a\n      // selector if the element is in that array\n      if (selectedElements.includes(elem)) {\n        setTimeout(function () {\n          // Due to element replacement, this element may no longer\n          // be part of the DOM\n          if (!elem.parentNode) { return; }\n          selectorManager.requestSelector(elem).resize();\n        }, 0);\n      }\n      // if this element was rotated, and we changed the position of this element\n      // we need to update the rotational transform attribute\n      const angle = getRotationAngle(elem);\n      if (angle !== 0 && attr !== 'transform') {\n        const tlist = getTransformList(elem);\n        let n = tlist.numberOfItems;\n        while (n--) {\n          const xform = tlist.getItem(n);\n          if (xform.type === 4) {\n            // remove old rotate\n            tlist.removeItem(n);\n\n            const box = utilsGetBBox(elem);\n            const center = transformPoint(box.x + box.width / 2, box.y + box.height / 2, transformListToTransform(tlist).matrix);\n            const cx = center.x,\n              cy = center.y;\n            const newrot = svgroot.createSVGTransform();\n            newrot.setRotate(angle, cx, cy);\n            tlist.insertItemBefore(newrot, n);\n            break;\n          }\n        }\n      }\n    } // if oldValue != newValue\n  } // for each elem\n};\n\n/**\n* Change the given/selected element and add the original value to the history stack.\n* If you want to change all `selectedElements`, ignore the `elems` argument.\n* If you want to change only a subset of `selectedElements`, then send the\n* subset to this function in the `elems` argument.\n* @function module:svgcanvas.SvgCanvas#changeSelectedAttribute\n* @param {string} attr - String with the attribute name\n* @param {string|Float} val - String or number with the new attribute value\n* @param {Element[]} elems - The DOM elements to apply the change to\n* @returns {undefined}\n*/\nconst changeSelectedAttribute = this.changeSelectedAttribute = function (attr, val, elems) {\n  elems = elems || selectedElements;\n  canvas.undoMgr.beginUndoableChange(attr, elems);\n  // const i = elems.length;\n\n  changeSelectedAttributeNoUndo(attr, val, elems);\n\n  const batchCmd = canvas.undoMgr.finishUndoableChange();\n  if (!batchCmd.isEmpty()) {\n    addCommandToHistory(batchCmd);\n  }\n};\n\n/**\n* Removes all selected elements from the DOM and adds the change to the\n* history stack.\n* @function module:svgcanvas.SvgCanvas#deleteSelectedElements\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.deleteSelectedElements = function () {\n  const batchCmd = new BatchCommand('Delete Elements');\n  const len = selectedElements.length;\n  const selectedCopy = []; // selectedElements is being deleted\n\n  for (let i = 0; i < len; ++i) {\n    const selected = selectedElements[i];\n    if (isNullish(selected)) { break; }\n\n    let parent = selected.parentNode;\n    let t = selected;\n\n    // this will unselect the element and remove the selectedOutline\n    selectorManager.releaseSelector(t);\n\n    // Remove the path if present.\n    pathModule.removePath_(t.id);\n\n    // Get the parent if it's a single-child anchor\n    if (parent.tagName === 'a' && parent.childNodes.length === 1) {\n      t = parent;\n      parent = parent.parentNode;\n    }\n\n    const {nextSibling} = t;\n    const elem = parent.removeChild(t);\n    selectedCopy.push(selected); // for the copy\n    batchCmd.addSubCommand(new RemoveElementCommand(elem, nextSibling, parent));\n  }\n  selectedElements = [];\n\n  if (!batchCmd.isEmpty()) { addCommandToHistory(batchCmd); }\n  call('changed', selectedCopy);\n  clearSelection();\n};\n\n/**\n* Removes all selected elements from the DOM and adds the change to the\n* history stack. Remembers removed elements on the clipboard.\n* @function module:svgcanvas.SvgCanvas#cutSelectedElements\n* @returns {undefined}\n*/\nthis.cutSelectedElements = function () {\n  canvas.copySelectedElements();\n  canvas.deleteSelectedElements();\n};\n\n/**\n* Remembers the current selected elements on the clipboard.\n* @function module:svgcanvas.SvgCanvas#copySelectedElements\n* @returns {undefined}\n*/\nthis.copySelectedElements = function () {\n  localStorage.setItem('svgedit_clipboard', JSON.stringify(\n    selectedElements.map(function (x) { return getJsonFromSvgElement(x); })\n  ));\n\n  $('#cmenu_canvas').enableContextMenuItems('#paste,#paste_in_place');\n};\n\n/**\n* @function module:svgcanvas.SvgCanvas#pasteElements\n* @param {\"in_place\"|\"point\"|undefined} type\n* @param {Integer|undefined} x Expected if type is \"point\"\n* @param {Integer|undefined} y Expected if type is \"point\"\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @fires module:svgcanvas.SvgCanvas#event:ext-IDsUpdated\n* @returns {undefined}\n*/\nthis.pasteElements = function (type, x, y) {\n  let clipb = JSON.parse(localStorage.getItem('svgedit_clipboard'));\n  let len = clipb.length;\n  if (!len) { return; }\n\n  const pasted = [];\n  const batchCmd = new BatchCommand('Paste elements');\n  // const drawing = getCurrentDrawing();\n  /**\n  * @typedef {PlainObject.<string, string>} module:svgcanvas.ChangedIDs\n  */\n  /**\n   * @type {module:svgcanvas.ChangedIDs}\n   */\n  const changedIDs = {};\n\n  // Recursively replace IDs and record the changes\n  /**\n   *\n   * @param {module:svgcanvas.SVGAsJSON} elem\n   * @returns {undefined}\n   */\n  function checkIDs (elem) {\n    if (elem.attr && elem.attr.id) {\n      changedIDs[elem.attr.id] = getNextId();\n      elem.attr.id = changedIDs[elem.attr.id];\n    }\n    if (elem.children) elem.children.forEach(checkIDs);\n  }\n  clipb.forEach(checkIDs);\n\n  // Give extensions like the connector extension a chance to reflect new IDs and remove invalid elements\n  /**\n  * Triggered when `pasteElements` is called from a paste action (context menu or key)\n  * @event module:svgcanvas.SvgCanvas#event:ext-IDsUpdated\n  * @type {PlainObject}\n  * @property {module:svgcanvas.SVGAsJSON[]} elems\n  * @property {module:svgcanvas.ChangedIDs} changes Maps past ID (on attribute) to current ID\n  */\n  runExtensions(\n    'IDsUpdated',\n    /** @type {module:svgcanvas.SvgCanvas#event:ext-IDsUpdated} */\n    {elems: clipb, changes: changedIDs},\n    true\n  ).forEach(function (extChanges) {\n    if (!extChanges || !('remove' in extChanges)) return;\n\n    extChanges.remove.forEach(function (removeID) {\n      clipb = clipb.filter(function (clipBoardItem) {\n        return clipBoardItem.attr.id !== removeID;\n      });\n    });\n  });\n\n  // Move elements to lastClickPoint\n  while (len--) {\n    const elem = clipb[len];\n    if (!elem) { continue; }\n\n    const copy = addSVGElementFromJson(elem);\n    pasted.push(copy);\n    batchCmd.addSubCommand(new InsertElementCommand(copy));\n\n    restoreRefElems(copy);\n  }\n\n  selectOnly(pasted);\n\n  if (type !== 'in_place') {\n    let ctrX, ctrY;\n\n    if (!type) {\n      ctrX = lastClickPoint.x;\n      ctrY = lastClickPoint.y;\n    } else if (type === 'point') {\n      ctrX = x;\n      ctrY = y;\n    }\n\n    const bbox = getStrokedBBoxDefaultVisible(pasted);\n    const cx = ctrX - (bbox.x + bbox.width / 2),\n      cy = ctrY - (bbox.y + bbox.height / 2),\n      dx = [],\n      dy = [];\n\n    $.each(pasted, function (i, item) {\n      dx.push(cx);\n      dy.push(cy);\n    });\n\n    const cmd = canvas.moveSelectedElements(dx, dy, false);\n    if (cmd) batchCmd.addSubCommand(cmd);\n  }\n\n  addCommandToHistory(batchCmd);\n  call('changed', pasted);\n};\n\n/**\n* Wraps all the selected elements in a group (`g`) element.\n* @function module:svgcanvas.SvgCanvas#groupSelectedElements\n* @param {\"a\"|\"g\"} [type=\"g\"] - type of element to group into, defaults to `<g>`\n* @param {string} [urlArg]\n* @returns {undefined}\n*/\nthis.groupSelectedElements = function (type, urlArg) {\n  if (!type) { type = 'g'; }\n  let cmdStr = '';\n  let url;\n\n  switch (type) {\n  case 'a': {\n    cmdStr = 'Make hyperlink';\n    url = urlArg || '';\n    break;\n  } default: {\n    type = 'g';\n    cmdStr = 'Group Elements';\n    break;\n  }\n  }\n\n  const batchCmd = new BatchCommand(cmdStr);\n\n  // create and insert the group element\n  const g = addSVGElementFromJson({\n    element: type,\n    attr: {\n      id: getNextId()\n    }\n  });\n  if (type === 'a') {\n    setHref(g, url);\n  }\n  batchCmd.addSubCommand(new InsertElementCommand(g));\n\n  // now move all children into the group\n  let i = selectedElements.length;\n  while (i--) {\n    let elem = selectedElements[i];\n    if (isNullish(elem)) { continue; }\n\n    if (elem.parentNode.tagName === 'a' && elem.parentNode.childNodes.length === 1) {\n      elem = elem.parentNode;\n    }\n\n    const oldNextSibling = elem.nextSibling;\n    const oldParent = elem.parentNode;\n    g.append(elem);\n    batchCmd.addSubCommand(new MoveElementCommand(elem, oldNextSibling, oldParent));\n  }\n  if (!batchCmd.isEmpty()) { addCommandToHistory(batchCmd); }\n\n  // update selection\n  selectOnly([g], true);\n};\n\n/**\n* Pushes all appropriate parent group properties down to its children, then\n* removes them from the group.\n* @function module:svgcanvas.SvgCanvas#pushGroupProperties\n* @param {SVGAElement|SVGGElement} g\n* @param {boolean} undoable\n* @returns {BatchCommand|undefined}\n*/\nconst pushGroupProperties = this.pushGroupProperties = function (g, undoable) {\n  const children = g.childNodes;\n  const len = children.length;\n  const xform = g.getAttribute('transform');\n\n  const glist = getTransformList(g);\n  const m = transformListToTransform(glist).matrix;\n\n  const batchCmd = new BatchCommand('Push group properties');\n\n  // TODO: get all fill/stroke properties from the group that we are about to destroy\n  // \"fill\", \"fill-opacity\", \"fill-rule\", \"stroke\", \"stroke-dasharray\", \"stroke-dashoffset\",\n  // \"stroke-linecap\", \"stroke-linejoin\", \"stroke-miterlimit\", \"stroke-opacity\",\n  // \"stroke-width\"\n  // and then for each child, if they do not have the attribute (or the value is 'inherit')\n  // then set the child's attribute\n\n  const gangle = getRotationAngle(g);\n\n  const gattrs = $(g).attr(['filter', 'opacity']);\n  let gfilter, gblur, changes;\n  const drawing = getCurrentDrawing();\n\n  for (let i = 0; i < len; i++) {\n    const elem = children[i];\n\n    if (elem.nodeType !== 1) { continue; }\n\n    if (gattrs.opacity !== null && gattrs.opacity !== 1) {\n      // const c_opac = elem.getAttribute('opacity') || 1;\n      const newOpac = Math.round((elem.getAttribute('opacity') || 1) * gattrs.opacity * 100) / 100;\n      changeSelectedAttribute('opacity', newOpac, [elem]);\n    }\n\n    if (gattrs.filter) {\n      let cblur = this.getBlur(elem);\n      const origCblur = cblur;\n      if (!gblur) { gblur = this.getBlur(g); }\n      if (cblur) {\n        // Is this formula correct?\n        cblur = Number(gblur) + Number(cblur);\n      } else if (cblur === 0) {\n        cblur = gblur;\n      }\n\n      // If child has no current filter, get group's filter or clone it.\n      if (!origCblur) {\n        // Set group's filter to use first child's ID\n        if (!gfilter) {\n          gfilter = getRefElem(gattrs.filter);\n        } else {\n          // Clone the group's filter\n          gfilter = drawing.copyElem(gfilter);\n          findDefs().append(gfilter);\n        }\n      } else {\n        gfilter = getRefElem(elem.getAttribute('filter'));\n      }\n\n      // Change this in future for different filters\n      const suffix = (gfilter.firstChild.tagName === 'feGaussianBlur') ? 'blur' : 'filter';\n      gfilter.id = elem.id + '_' + suffix;\n      changeSelectedAttribute('filter', 'url(#' + gfilter.id + ')', [elem]);\n\n      // Update blur value\n      if (cblur) {\n        changeSelectedAttribute('stdDeviation', cblur, [gfilter.firstChild]);\n        canvas.setBlurOffsets(gfilter, cblur);\n      }\n    }\n\n    let chtlist = getTransformList(elem);\n\n    // Don't process gradient transforms\n    if (elem.tagName.includes('Gradient')) { chtlist = null; }\n\n    // Hopefully not a problem to add this. Necessary for elements like <desc/>\n    if (!chtlist) { continue; }\n\n    // Apparently <defs> can get get a transformlist, but we don't want it to have one!\n    if (elem.tagName === 'defs') { continue; }\n\n    if (glist.numberOfItems) {\n      // TODO: if the group's transform is just a rotate, we can always transfer the\n      // rotate() down to the children (collapsing consecutive rotates and factoring\n      // out any translates)\n      if (gangle && glist.numberOfItems === 1) {\n        // [Rg] [Rc] [Mc]\n        // we want [Tr] [Rc2] [Mc] where:\n        //  - [Rc2] is at the child's current center but has the\n        // sum of the group and child's rotation angles\n        //  - [Tr] is the equivalent translation that this child\n        // undergoes if the group wasn't there\n\n        // [Tr] = [Rg] [Rc] [Rc2_inv]\n\n        // get group's rotation matrix (Rg)\n        const rgm = glist.getItem(0).matrix;\n\n        // get child's rotation matrix (Rc)\n        let rcm = svgroot.createSVGMatrix();\n        const cangle = getRotationAngle(elem);\n        if (cangle) {\n          rcm = chtlist.getItem(0).matrix;\n        }\n\n        // get child's old center of rotation\n        const cbox = utilsGetBBox(elem);\n        const ceqm = transformListToTransform(chtlist).matrix;\n        const coldc = transformPoint(cbox.x + cbox.width / 2, cbox.y + cbox.height / 2, ceqm);\n\n        // sum group and child's angles\n        const sangle = gangle + cangle;\n\n        // get child's rotation at the old center (Rc2_inv)\n        const r2 = svgroot.createSVGTransform();\n        r2.setRotate(sangle, coldc.x, coldc.y);\n\n        // calculate equivalent translate\n        const trm = matrixMultiply(rgm, rcm, r2.matrix.inverse());\n\n        // set up tlist\n        if (cangle) {\n          chtlist.removeItem(0);\n        }\n\n        if (sangle) {\n          if (chtlist.numberOfItems) {\n            chtlist.insertItemBefore(r2, 0);\n          } else {\n            chtlist.appendItem(r2);\n          }\n        }\n\n        if (trm.e || trm.f) {\n          const tr = svgroot.createSVGTransform();\n          tr.setTranslate(trm.e, trm.f);\n          if (chtlist.numberOfItems) {\n            chtlist.insertItemBefore(tr, 0);\n          } else {\n            chtlist.appendItem(tr);\n          }\n        }\n      } else { // more complicated than just a rotate\n        // transfer the group's transform down to each child and then\n        // call recalculateDimensions()\n        const oldxform = elem.getAttribute('transform');\n        changes = {};\n        changes.transform = oldxform || '';\n\n        const newxform = svgroot.createSVGTransform();\n\n        // [ gm ] [ chm ] = [ chm ] [ gm' ]\n        // [ gm' ] = [ chmInv ] [ gm ] [ chm ]\n        const chm = transformListToTransform(chtlist).matrix,\n          chmInv = chm.inverse();\n        const gm = matrixMultiply(chmInv, m, chm);\n        newxform.setMatrix(gm);\n        chtlist.appendItem(newxform);\n      }\n      const cmd = recalculateDimensions(elem);\n      if (cmd) { batchCmd.addSubCommand(cmd); }\n    }\n  }\n\n  // remove transform and make it undo-able\n  if (xform) {\n    changes = {};\n    changes.transform = xform;\n    g.setAttribute('transform', '');\n    g.removeAttribute('transform');\n    batchCmd.addSubCommand(new ChangeElementCommand(g, changes));\n  }\n\n  if (undoable && !batchCmd.isEmpty()) {\n    return batchCmd;\n  }\n  return undefined;\n};\n\n/**\n* Unwraps all the elements in a selected group (`g`) element. This requires\n* significant recalculations to apply group's transforms, etc. to its children.\n* @function module:svgcanvas.SvgCanvas#ungroupSelectedElement\n* @returns {undefined}\n*/\nthis.ungroupSelectedElement = function () {\n  let g = selectedElements[0];\n  if (!g) {\n    return;\n  }\n  if ($(g).data('gsvg') || $(g).data('symbol')) {\n    // Is svg, so actually convert to group\n    convertToGroup(g);\n    return;\n  }\n  if (g.tagName === 'use') {\n    // Somehow doesn't have data set, so retrieve\n    const symbol = getElem(getHref(g).substr(1));\n    $(g).data('symbol', symbol).data('ref', symbol);\n    convertToGroup(g);\n    return;\n  }\n  const parentsA = $(g).parents('a');\n  if (parentsA.length) {\n    g = parentsA[0];\n  }\n\n  // Look for parent \"a\"\n  if (g.tagName === 'g' || g.tagName === 'a') {\n    const batchCmd = new BatchCommand('Ungroup Elements');\n    const cmd = pushGroupProperties(g, true);\n    if (cmd) { batchCmd.addSubCommand(cmd); }\n\n    const parent = g.parentNode;\n    const anchor = g.nextSibling;\n    const children = new Array(g.childNodes.length);\n\n    let i = 0;\n    while (g.firstChild) {\n      let elem = g.firstChild;\n      const oldNextSibling = elem.nextSibling;\n      const oldParent = elem.parentNode;\n\n      // Remove child title elements\n      if (elem.tagName === 'title') {\n        const {nextSibling} = elem;\n        batchCmd.addSubCommand(new RemoveElementCommand(elem, nextSibling, oldParent));\n        elem.remove();\n        continue;\n      }\n\n      children[i++] = elem = parent.insertBefore(elem, anchor);\n      batchCmd.addSubCommand(new MoveElementCommand(elem, oldNextSibling, oldParent));\n    }\n\n    // remove the group from the selection\n    clearSelection();\n\n    // delete the group element (but make undo-able)\n    const gNextSibling = g.nextSibling;\n    g = parent.removeChild(g);\n    batchCmd.addSubCommand(new RemoveElementCommand(g, gNextSibling, parent));\n\n    if (!batchCmd.isEmpty()) { addCommandToHistory(batchCmd); }\n\n    // update selection\n    addToSelection(children);\n  }\n};\n\n/**\n* Repositions the selected element to the bottom in the DOM to appear on top of\n* other elements.\n* @function module:svgcanvas.SvgCanvas#moveToTopSelectedElement\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.moveToTopSelectedElement = function () {\n  const [selected] = selectedElements;\n  if (!isNullish(selected)) {\n    let t = selected;\n    const oldParent = t.parentNode;\n    const oldNextSibling = t.nextSibling;\n    t = t.parentNode.appendChild(t);\n    // If the element actually moved position, add the command and fire the changed\n    // event handler.\n    if (oldNextSibling !== t.nextSibling) {\n      addCommandToHistory(new MoveElementCommand(t, oldNextSibling, oldParent, 'top'));\n      call('changed', [t]);\n    }\n  }\n};\n\n/**\n* Repositions the selected element to the top in the DOM to appear under\n* other elements.\n* @function module:svgcanvas.SvgCanvas#moveToBottomSelectedElement\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.moveToBottomSelectedElement = function () {\n  const [selected] = selectedElements;\n  if (!isNullish(selected)) {\n    let t = selected;\n    const oldParent = t.parentNode;\n    const oldNextSibling = t.nextSibling;\n    let {firstChild} = t.parentNode;\n    if (firstChild.tagName === 'title') {\n      firstChild = firstChild.nextSibling;\n    }\n    // This can probably be removed, as the defs should not ever apppear\n    // inside a layer group\n    if (firstChild.tagName === 'defs') {\n      firstChild = firstChild.nextSibling;\n    }\n    t = t.parentNode.insertBefore(t, firstChild);\n    // If the element actually moved position, add the command and fire the changed\n    // event handler.\n    if (oldNextSibling !== t.nextSibling) {\n      addCommandToHistory(new MoveElementCommand(t, oldNextSibling, oldParent, 'bottom'));\n      call('changed', [t]);\n    }\n  }\n};\n\n/**\n* Moves the select element up or down the stack, based on the visibly\n* intersecting elements.\n* @function module:svgcanvas.SvgCanvas#moveUpDownSelected\n* @param {\"Up\"|\"Down\"} dir - String that's either 'Up' or 'Down'\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {undefined}\n*/\nthis.moveUpDownSelected = function (dir) {\n  const selected = selectedElements[0];\n  if (!selected) { return; }\n\n  curBBoxes = [];\n  let closest, foundCur;\n  // jQuery sorts this list\n  const list = $(getIntersectionList(getStrokedBBoxDefaultVisible([selected]))).toArray();\n  if (dir === 'Down') { list.reverse(); }\n\n  $.each(list, function () {\n    if (!foundCur) {\n      if (this === selected) {\n        foundCur = true;\n      }\n      return true;\n    }\n    closest = this; // eslint-disable-line consistent-this\n    return false;\n  });\n  if (!closest) { return; }\n\n  const t = selected;\n  const oldParent = t.parentNode;\n  const oldNextSibling = t.nextSibling;\n  $(closest)[dir === 'Down' ? 'before' : 'after'](t);\n  // If the element actually moved position, add the command and fire the changed\n  // event handler.\n  if (oldNextSibling !== t.nextSibling) {\n    addCommandToHistory(new MoveElementCommand(t, oldNextSibling, oldParent, 'Move ' + dir));\n    call('changed', [t]);\n  }\n};\n\n/**\n* Moves selected elements on the X/Y axis.\n* @function module:svgcanvas.SvgCanvas#moveSelectedElements\n* @param {Float} dx - Float with the distance to move on the x-axis\n* @param {Float} dy - Float with the distance to move on the y-axis\n* @param {boolean} undoable - Boolean indicating whether or not the action should be undoable\n* @fires module:svgcanvas.SvgCanvas#event:changed\n* @returns {BatchCommand|undefined} Batch command for the move\n*/\nthis.moveSelectedElements = function (dx, dy, undoable) {\n  // if undoable is not sent, default to true\n  // if single values, scale them to the zoom\n  if (dx.constructor !== Array) {\n    dx /= currentZoom;\n    dy /= currentZoom;\n  }\n  undoable = undoable || true;\n  const batchCmd = new BatchCommand('position');\n  let i = selectedElements.length;\n  while (i--) {\n    const selected = selectedElements[i];\n    if (!isNullish(selected)) {\n      // if (i === 0) {\n      //   selectedBBoxes[0] = utilsGetBBox(selected);\n      // }\n      // const b = {};\n      // for (const j in selectedBBoxes[i]) b[j] = selectedBBoxes[i][j];\n      // selectedBBoxes[i] = b;\n\n      const xform = svgroot.createSVGTransform();\n      const tlist = getTransformList(selected);\n\n      // dx and dy could be arrays\n      if (dx.constructor === Array) {\n        // if (i === 0) {\n        //   selectedBBoxes[0].x += dx[0];\n        //   selectedBBoxes[0].y += dy[0];\n        // }\n        xform.setTranslate(dx[i], dy[i]);\n      } else {\n        // if (i === 0) {\n        //   selectedBBoxes[0].x += dx;\n        //   selectedBBoxes[0].y += dy;\n        // }\n        xform.setTranslate(dx, dy);\n      }\n\n      if (tlist.numberOfItems) {\n        tlist.insertItemBefore(xform, 0);\n      } else {\n        tlist.appendItem(xform);\n      }\n\n      const cmd = recalculateDimensions(selected);\n      if (cmd) {\n        batchCmd.addSubCommand(cmd);\n      }\n\n      selectorManager.requestSelector(selected).resize();\n    }\n  }\n  if (!batchCmd.isEmpty()) {\n    if (undoable) {\n      addCommandToHistory(batchCmd);\n    }\n    call('changed', selectedElements);\n    return batchCmd;\n  }\n  return undefined;\n};\n\n/**\n* Create deep DOM copies (clones) of all selected elements and move them slightly\n* from their originals.\n* @function module:svgcanvas.SvgCanvas#cloneSelectedElements\n* @param {Float} x Float with the distance to move on the x-axis\n* @param {Float} y Float with the distance to move on the y-axis\n* @returns {undefined}\n*/\nthis.cloneSelectedElements = function (x, y) {\n  let i, elem;\n  const batchCmd = new BatchCommand('Clone Elements');\n  // find all the elements selected (stop at first null)\n  const len = selectedElements.length;\n  /**\n   * Sorts an array numerically and ascending.\n   * @param {Element} a\n   * @param {Element} b\n   * @returns {Integer}\n   */\n  function sortfunction (a, b) {\n    return ($(b).index() - $(a).index());\n  }\n  selectedElements.sort(sortfunction);\n  for (i = 0; i < len; ++i) {\n    elem = selectedElements[i];\n    if (isNullish(elem)) { break; }\n  }\n  // use slice to quickly get the subset of elements we need\n  const copiedElements = selectedElements.slice(0, i);\n  this.clearSelection(true);\n  // note that we loop in the reverse way because of the way elements are added\n  // to the selectedElements array (top-first)\n  const drawing = getCurrentDrawing();\n  i = copiedElements.length;\n  while (i--) {\n    // clone each element and replace it within copiedElements\n    elem = copiedElements[i] = drawing.copyElem(copiedElements[i]);\n    (currentGroup || drawing.getCurrentLayer()).append(elem);\n    batchCmd.addSubCommand(new InsertElementCommand(elem));\n  }\n\n  if (!batchCmd.isEmpty()) {\n    addToSelection(copiedElements.reverse()); // Need to reverse for correct selection-adding\n    this.moveSelectedElements(x, y, false);\n    addCommandToHistory(batchCmd);\n  }\n};\n\n/**\n* Aligns selected elements.\n* @function module:svgcanvas.SvgCanvas#alignSelectedElements\n* @param {string} type - String with single character indicating the alignment type\n* @param {\"selected\"|\"largest\"|\"smallest\"|\"page\"} relativeTo\n* @returns {undefined}\n*/\nthis.alignSelectedElements = function (type, relativeTo) {\n  const bboxes = []; // angles = [];\n  const len = selectedElements.length;\n  if (!len) { return; }\n  let minx = Number.MAX_VALUE, maxx = Number.MIN_VALUE,\n    miny = Number.MAX_VALUE, maxy = Number.MIN_VALUE;\n  let curwidth = Number.MIN_VALUE, curheight = Number.MIN_VALUE;\n  for (let i = 0; i < len; ++i) {\n    if (isNullish(selectedElements[i])) { break; }\n    const elem = selectedElements[i];\n    bboxes[i] = getStrokedBBoxDefaultVisible([elem]);\n\n    // now bbox is axis-aligned and handles rotation\n    switch (relativeTo) {\n    case 'smallest':\n      if (((type === 'l' || type === 'c' || type === 'r') &&\n        (curwidth === Number.MIN_VALUE || curwidth > bboxes[i].width)) ||\n        ((type === 't' || type === 'm' || type === 'b') &&\n        (curheight === Number.MIN_VALUE || curheight > bboxes[i].height))\n      ) {\n        minx = bboxes[i].x;\n        miny = bboxes[i].y;\n        maxx = bboxes[i].x + bboxes[i].width;\n        maxy = bboxes[i].y + bboxes[i].height;\n        curwidth = bboxes[i].width;\n        curheight = bboxes[i].height;\n      }\n      break;\n    case 'largest':\n      if (((type === 'l' || type === 'c' || type === 'r') &&\n        (curwidth === Number.MIN_VALUE || curwidth < bboxes[i].width)) ||\n        ((type === 't' || type === 'm' || type === 'b') &&\n        (curheight === Number.MIN_VALUE || curheight < bboxes[i].height))\n      ) {\n        minx = bboxes[i].x;\n        miny = bboxes[i].y;\n        maxx = bboxes[i].x + bboxes[i].width;\n        maxy = bboxes[i].y + bboxes[i].height;\n        curwidth = bboxes[i].width;\n        curheight = bboxes[i].height;\n      }\n      break;\n    default: // 'selected'\n      if (bboxes[i].x < minx) { minx = bboxes[i].x; }\n      if (bboxes[i].y < miny) { miny = bboxes[i].y; }\n      if (bboxes[i].x + bboxes[i].width > maxx) { maxx = bboxes[i].x + bboxes[i].width; }\n      if (bboxes[i].y + bboxes[i].height > maxy) { maxy = bboxes[i].y + bboxes[i].height; }\n      break;\n    }\n  } // loop for each element to find the bbox and adjust min/max\n\n  if (relativeTo === 'page') {\n    minx = 0;\n    miny = 0;\n    maxx = canvas.contentW;\n    maxy = canvas.contentH;\n  }\n\n  const dx = new Array(len);\n  const dy = new Array(len);\n  for (let i = 0; i < len; ++i) {\n    if (isNullish(selectedElements[i])) { break; }\n    // const elem = selectedElements[i];\n    const bbox = bboxes[i];\n    dx[i] = 0;\n    dy[i] = 0;\n    switch (type) {\n    case 'l': // left (horizontal)\n      dx[i] = minx - bbox.x;\n      break;\n    case 'c': // center (horizontal)\n      dx[i] = (minx + maxx) / 2 - (bbox.x + bbox.width / 2);\n      break;\n    case 'r': // right (horizontal)\n      dx[i] = maxx - (bbox.x + bbox.width);\n      break;\n    case 't': // top (vertical)\n      dy[i] = miny - bbox.y;\n      break;\n    case 'm': // middle (vertical)\n      dy[i] = (miny + maxy) / 2 - (bbox.y + bbox.height / 2);\n      break;\n    case 'b': // bottom (vertical)\n      dy[i] = maxy - (bbox.y + bbox.height);\n      break;\n    }\n  }\n  this.moveSelectedElements(dx, dy);\n};\n\n/**\n* Group: Additional editor tools\n*/\n\n/**\n* @name module:svgcanvas.SvgCanvas#contentW\n* @type {Float}\n*/\nthis.contentW = getResolution().w;\n/**\n* @name module:svgcanvas.SvgCanvas#contentH\n* @type {Float}\n*/\nthis.contentH = getResolution().h;\n\n/**\n* @typedef {PlainObject} module:svgcanvas.CanvasInfo\n* @property {Float} x - The canvas' new x coordinate\n* @property {Float} y - The canvas' new y coordinate\n* @property {string} oldX - The canvas' old x coordinate\n* @property {string} oldY - The canvas' old y coordinate\n* @property {Float} d_x - The x position difference\n* @property {Float} d_y - The y position difference\n*/\n\n/**\n* Updates the editor canvas width/height/position after a zoom has occurred.\n* @function module:svgcanvas.SvgCanvas#updateCanvas\n* @param {Float} w - Float with the new width\n* @param {Float} h - Float with the new height\n* @fires module:svgcanvas.SvgCanvas#event:ext-canvasUpdated\n* @returns {module:svgcanvas.CanvasInfo}\n*/\nthis.updateCanvas = function (w, h) {\n  svgroot.setAttribute('width', w);\n  svgroot.setAttribute('height', h);\n  const bg = $('#canvasBackground')[0];\n  const oldX = svgcontent.getAttribute('x');\n  const oldY = svgcontent.getAttribute('y');\n  const x = ((w - this.contentW * currentZoom) / 2);\n  const y = ((h - this.contentH * currentZoom) / 2);\n\n  assignAttributes(svgcontent, {\n    width: this.contentW * currentZoom,\n    height: this.contentH * currentZoom,\n    x,\n    y,\n    viewBox: '0 0 ' + this.contentW + ' ' + this.contentH\n  });\n\n  assignAttributes(bg, {\n    width: svgcontent.getAttribute('width'),\n    height: svgcontent.getAttribute('height'),\n    x,\n    y\n  });\n\n  const bgImg = getElem('background_image');\n  if (bgImg) {\n    assignAttributes(bgImg, {\n      width: '100%',\n      height: '100%'\n    });\n  }\n\n  selectorManager.selectorParentGroup.setAttribute('transform', 'translate(' + x + ',' + y + ')');\n\n  /**\n  * Invoked upon updates to the canvas.\n  * @event module:svgcanvas.SvgCanvas#event:ext-canvasUpdated\n  * @type {PlainObject}\n  * @property {Integer} new_x\n  * @property {Integer} new_y\n  * @property {string} old_x (Of Integer)\n  * @property {string} old_y (Of Integer)\n  * @property {Integer} d_x\n  * @property {Integer} d_y\n  */\n  runExtensions(\n    'canvasUpdated',\n    /**\n     * @type {module:svgcanvas.SvgCanvas#event:ext-canvasUpdated}\n     */\n    {new_x: x, new_y: y, old_x: oldX, old_y: oldY, d_x: x - oldX, d_y: y - oldY}\n  );\n  return {x, y, old_x: oldX, old_y: oldY, d_x: x - oldX, d_y: y - oldY};\n};\n\n/**\n* Set the background of the editor (NOT the actual document).\n* @function module:svgcanvas.SvgCanvas#setBackground\n* @param {string} color - String with fill color to apply\n* @param {string} url - URL or path to image to use\n* @returns {undefined}\n*/\nthis.setBackground = function (color, url) {\n  const bg = getElem('canvasBackground');\n  const border = $(bg).find('rect')[0];\n  let bgImg = getElem('background_image');\n  border.setAttribute('fill', color);\n  if (url) {\n    if (!bgImg) {\n      bgImg = svgdoc.createElementNS(NS.SVG, 'image');\n      assignAttributes(bgImg, {\n        id: 'background_image',\n        width: '100%',\n        height: '100%',\n        preserveAspectRatio: 'xMinYMin',\n        style: 'pointer-events:none'\n      });\n    }\n    setHref(bgImg, url);\n    bg.append(bgImg);\n  } else if (bgImg) {\n    bgImg.remove();\n  }\n};\n\n/**\n* Select the next/previous element within the current layer.\n* @function module:svgcanvas.SvgCanvas#cycleElement\n* @param {boolean} next - true = next and false = previous element\n* @fires module:svgcanvas.SvgCanvas#event:selected\n* @returns {undefined}\n*/\nthis.cycleElement = function (next) {\n  let num;\n  const curElem = selectedElements[0];\n  let elem = false;\n  const allElems = getVisibleElements(currentGroup || getCurrentDrawing().getCurrentLayer());\n  if (!allElems.length) { return; }\n  if (isNullish(curElem)) {\n    num = next ? allElems.length - 1 : 0;\n    elem = allElems[num];\n  } else {\n    let i = allElems.length;\n    while (i--) {\n      if (allElems[i] === curElem) {\n        num = next ? i - 1 : i + 1;\n        if (num >= allElems.length) {\n          num = 0;\n        } else if (num < 0) {\n          num = allElems.length - 1;\n        }\n        elem = allElems[num];\n        break;\n      }\n    }\n  }\n  selectOnly([elem], true);\n  call('selected', selectedElements);\n};\n\nthis.clear();\n\n/**\n* @interface module:svgcanvas.PrivateMethods\n* @type {PlainObject}\n* @property {module:svgcanvas~addCommandToHistory} addCommandToHistory\n* @property {module:history.HistoryCommand} BatchCommand\n* @property {module:history.HistoryCommand} ChangeElementCommand\n* @property {module:utilities.decode64} decode64\n* @property {module:utilities.dropXMLInteralSubset} dropXMLInteralSubset\n* @property {module:utilities.encode64} encode64\n* @property {module:svgcanvas~ffClone} ffClone\n* @property {module:svgcanvas~findDuplicateGradient} findDuplicateGradient\n* @property {module:utilities.getPathBBox} getPathBBox\n* @property {module:units.getTypeMap} getTypeMap\n* @property {module:draw.identifyLayers} identifyLayers\n* @property {module:history.HistoryCommand} InsertElementCommand\n* @property {module:browser.isChrome} isChrome\n* @property {module:math.isIdentity} isIdentity\n* @property {module:browser.isIE} isIE\n* @property {module:svgcanvas~logMatrix} logMatrix\n* @property {module:history.HistoryCommand} MoveElementCommand\n* @property {module:namespaces.NS} NS\n* @property {module:utilities.preventClickDefault} preventClickDefault\n* @property {module:history.HistoryCommand} RemoveElementCommand\n* @property {module:SVGTransformList.SVGEditTransformList} SVGEditTransformList\n* @property {module:utilities.text2xml} text2xml\n* @property {module:math.transformBox} transformBox\n* @property {module:math.transformPoint} transformPoint\n* @property {module:utilities.walkTree} walkTree\n*/\n/**\n* @deprecated getPrivateMethods\n* Since all methods are/should be public somehow, this function should be removed;\n*  we might require `import` in place of this in the future once ES6 Modules\n*  widespread\n\n* Being able to access private methods publicly seems wrong somehow,\n* but currently appears to be the best way to allow testing and provide\n* access to them to plugins.\n* @function module:svgcanvas.SvgCanvas#getPrivateMethods\n* @returns {module:svgcanvas.PrivateMethods}\n*/\nthis.getPrivateMethods = function () {\n  const obj = {\n    addCommandToHistory,\n    BatchCommand,\n    ChangeElementCommand,\n    decode64,\n    dropXMLInteralSubset,\n    encode64,\n    ffClone,\n    findDefs,\n    findDuplicateGradient,\n    getElem,\n    getPathBBox,\n    getTypeMap,\n    getUrlFromAttr,\n    identifyLayers: draw.identifyLayers,\n    InsertElementCommand,\n    isChrome,\n    isIdentity,\n    isIE,\n    logMatrix,\n    MoveElementCommand,\n    NS,\n    preventClickDefault,\n    RemoveElementCommand,\n    SVGEditTransformList,\n    text2xml,\n    transformBox,\n    transformPoint,\n    walkTree\n  };\n  return obj;\n};\n  } // End constructor\n} // End class\n\nexport default SvgCanvas;\n","/**\n * @module jQueryPluginDBox\n */\n/**\n* @param {external:jQuery} $\n* @param {PlainObject} [strings]\n* @param {PlainObject} [strings.ok]\n* @param {PlainObject} [strings.cancel]\n* @returns {external:jQuery}\n*/\nexport default function jQueryPluginDBox ($, strings = {ok: 'Ok', cancel: 'Cancel'}) {\n  // This sets up alternative dialog boxes. They mostly work the same way as\n  // their UI counterparts, expect instead of returning the result, a callback\n  // needs to be included that returns the result as its first parameter.\n  // In the future we may want to add additional types of dialog boxes, since\n  // they should be easy to handle this way.\n  $('#dialog_container').draggable({\n    cancel: '#dialog_content, #dialog_buttons *',\n    containment: 'window'\n  }).css('position', 'absolute');\n\n  const box = $('#dialog_box'),\n    btnHolder = $('#dialog_buttons'),\n    dialogContent = $('#dialog_content');\n\n  /**\n  * Resolves to `false` (if cancelled), for prompts and selects\n  * without checkboxes, it resolves to the value of the form control. For other\n  * types without checkboxes, it resolves to `true`. For checkboxes, it resolves\n  * to an object with the `response` key containing the same value as the previous\n  * mentioned (string or `true`) and a `checked` (boolean) property.\n  * @typedef {Promise} module:jQueryPluginDBox.PromiseResult\n  */\n  /**\n  * @typedef {PlainObject} module:jQueryPluginDBox.SelectOption\n  * @property {string} text\n  * @property {string} value\n  */\n  /**\n  * @typedef {PlainObject} module:jQueryPluginDBox.CheckboxInfo\n  * @property {string} label Label for the checkbox\n  * @property {string} value Value of the checkbox\n  * @property {string} tooltip Tooltip on the checkbox label\n  * @property {boolean} checked Whether the checkbox is checked by default\n  */\n  /**\n   * Triggered upon a change of value for the select pull-down.\n   * @callback module:jQueryPluginDBox.SelectChangeListener\n   * @returns {undefined}\n   */\n  /**\n  * @param {\"alert\"|\"prompt\"|\"select\"|\"process\"} type\n  * @param {string} msg\n  * @param {string} [defaultVal]\n  * @param {module:jQueryPluginDBox.SelectOption[]} [opts]\n  * @param {module:jQueryPluginDBox.SelectChangeListener} [changeListener]\n  * @param {module:jQueryPluginDBox.CheckboxInfo} [checkbox]\n  * @returns {jQueryPluginDBox.PromiseResult}\n  */\n  function dbox (type, msg, defaultVal, opts, changeListener, checkbox) {\n    dialogContent.html('<p>' + msg.replace(/\\n/g, '</p><p>') + '</p>')\n      .toggleClass('prompt', (type === 'prompt'));\n    btnHolder.empty();\n\n    const ok = $('<input type=\"button\" value=\"' + strings.ok + '\">').appendTo(btnHolder);\n\n    return new Promise((resolve, reject) => { // eslint-disable-line promise/avoid-new\n      if (type !== 'alert') {\n        $('<input type=\"button\" value=\"' + strings.cancel + '\">')\n          .appendTo(btnHolder)\n          .click(function () {\n            box.hide();\n            resolve(false);\n          });\n      }\n\n      let ctrl, chkbx;\n      if (type === 'prompt') {\n        ctrl = $('<input type=\"text\">').prependTo(btnHolder);\n        ctrl.val(defaultVal || '');\n        ctrl.bind('keydown', 'return', function () { ok.click(); });\n      } else if (type === 'select') {\n        const div = $('<div style=\"text-align:center;\">');\n        ctrl = $('<select>').appendTo(div);\n        if (checkbox) {\n          const label = $('<label>').text(checkbox.label);\n          chkbx = $('<input type=\"checkbox\">').appendTo(label);\n          chkbx.val(checkbox.value);\n          if (checkbox.tooltip) {\n            label.attr('title', checkbox.tooltip);\n          }\n          chkbx.prop('checked', Boolean(checkbox.checked));\n          div.append($('<div>').append(label));\n        }\n        $.each(opts || [], function (opt, val) {\n          if (typeof val === 'object') {\n            ctrl.append($('<option>').val(val.value).html(val.text));\n          } else {\n            ctrl.append($('<option>').html(val));\n          }\n        });\n        dialogContent.append(div);\n        if (defaultVal) {\n          ctrl.val(defaultVal);\n        }\n        if (changeListener) {\n          ctrl.bind('change', 'return', changeListener);\n        }\n        ctrl.bind('keydown', 'return', function () { ok.click(); });\n      } else if (type === 'process') {\n        ok.hide();\n      }\n\n      box.show();\n\n      ok.click(function () {\n        box.hide();\n        const response = (type === 'prompt' || type === 'select') ? ctrl.val() : true;\n        if (chkbx) {\n          resolve({response, checked: chkbx.prop('checked')});\n          return;\n        }\n        resolve(response);\n      }).focus();\n\n      if (type === 'prompt' || type === 'select') {\n        ctrl.focus();\n      }\n    });\n  }\n\n  /**\n  * @param {string} msg Message to alert\n  * @returns {jQueryPluginDBox.PromiseResult}\n  */\n  $.alert = function (msg) {\n    return dbox('alert', msg);\n  };\n  /**\n  * @param {string} msg Message for which to ask confirmation\n  * @returns {jQueryPluginDBox.PromiseResult}\n  */\n  $.confirm = function (msg) {\n    return dbox('confirm', msg);\n  };\n  /**\n  * @param {string} msg Message to indicate upon cancelable indicator\n  * @returns {jQueryPluginDBox.PromiseResult}\n  */\n  $.process_cancel = function (msg) {\n    return dbox('process', msg);\n  };\n  /**\n  * @param {string} msg Message to accompany the prompt\n  * @param {string} [defaultText=''] The default text to show for the prompt\n  * @returns {jQueryPluginDBox.PromiseResult}\n  */\n  $.prompt = function (msg, defaultText = '') {\n    return dbox('prompt', msg, defaultText);\n  };\n  $.select = function (msg, opts, changeListener, txt, checkbox) {\n    return dbox('select', msg, txt, opts, changeListener, checkbox);\n  };\n  return $;\n}\n"],"names":["jQueryPluginSVG","$","proxied","fn","attr","key","value","len","this","length","call","i","elem","namespaceURI","undefined","setAttribute","Array","isArray","obj","j","aname","getAttribute","isNaN","_typeof","Object","entries","name","val","window","SVGPathSeg","type","typeAsLetter","owningPathSegList","pathSegType","pathSegTypeAsLetter","_owningPathSegList","segmentChanged","prototype","classname","PATHSEG_UNKNOWN","PATHSEG_CLOSEPATH","PATHSEG_MOVETO_ABS","PATHSEG_MOVETO_REL","PATHSEG_LINETO_ABS","PATHSEG_LINETO_REL","PATHSEG_CURVETO_CUBIC_ABS","PATHSEG_CURVETO_CUBIC_REL","PATHSEG_CURVETO_QUADRATIC_ABS","PATHSEG_CURVETO_QUADRATIC_REL","PATHSEG_ARC_ABS","PATHSEG_ARC_REL","PATHSEG_LINETO_HORIZONTAL_ABS","PATHSEG_LINETO_HORIZONTAL_REL","PATHSEG_LINETO_VERTICAL_ABS","PATHSEG_LINETO_VERTICAL_REL","PATHSEG_CURVETO_CUBIC_SMOOTH_ABS","PATHSEG_CURVETO_CUBIC_SMOOTH_REL","PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS","PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL","SVGPathSegClosePath","SVGPathSegMovetoAbs","x","y","_x","_y","defineProperties","get","set","_segmentChanged","enumerable","SVGPathSegMovetoRel","SVGPathSegLinetoAbs","SVGPathSegLinetoRel","SVGPathSegCurvetoCubicAbs","x1","y1","x2","y2","_x1","_y1","_x2","_y2","SVGPathSegCurvetoCubicRel","SVGPathSegCurvetoQuadraticAbs","SVGPathSegCurvetoQuadraticRel","SVGPathSegArcAbs","r1","r2","angle","largeArcFlag","sweepFlag","_r1","_r2","_angle","_largeArcFlag","_sweepFlag","SVGPathSegArcRel","SVGPathSegLinetoHorizontalAbs","defineProperty","SVGPathSegLinetoHorizontalRel","SVGPathSegLinetoVerticalAbs","SVGPathSegLinetoVerticalRel","SVGPathSegCurvetoCubicSmoothAbs","SVGPathSegCurvetoCubicSmoothRel","SVGPathSegCurvetoQuadraticSmoothAbs","SVGPathSegCurvetoQuadraticSmoothRel","SVGPathElement","createSVGPathSegClosePath","createSVGPathSegMovetoAbs","createSVGPathSegMovetoRel","createSVGPathSegLinetoAbs","createSVGPathSegLinetoRel","createSVGPathSegCurvetoCubicAbs","createSVGPathSegCurvetoCubicRel","createSVGPathSegCurvetoQuadraticAbs","createSVGPathSegCurvetoQuadraticRel","createSVGPathSegArcAbs","createSVGPathSegArcRel","createSVGPathSegLinetoHorizontalAbs","createSVGPathSegLinetoHorizontalRel","createSVGPathSegLinetoVerticalAbs","createSVGPathSegLinetoVerticalRel","createSVGPathSegCurvetoCubicSmoothAbs","createSVGPathSegCurvetoCubicSmoothRel","createSVGPathSegCurvetoQuadraticSmoothAbs","createSVGPathSegCurvetoQuadraticSmoothRel","getPathSegAtLength","distance","isFinite","Error","measurementElement","document","createElementNS","lastPathSegment","pathSegList","numberOfItems","removeItem","getTotalLength","SVGPathSegList","pathElement","_pathElement","_list","_parsePath","_mutationObserverConfig","attributes","attributeFilter","_pathElementMutationObserver","MutationObserver","_updateListFromPathMutations","bind","observe","takeRecords","mutationRecords","hasPathMutations","forEach","record","attributeName","disconnect","_pathSegArrayAsString","pathSeg","_writeListToPath","_checkPathSynchronizedToList","newItem","index","_checkValidIndex","clone","splice","item","push","string","Builder","Source","_string","_currentIndex","_endIndex","_previousCommand","_skipOptionalSpaces","character","_isCurrentSpace","charAt","lookahead","_pathSegTypeFromChar","previousCommand","hasMoreData","command","peekSegmentType","exponent","integer","frac","decimal","sign","expsign","startIndex","startIntPartIndex","scanIntPartIndex","multiplier","number","_skipOptionalSpacesOrDelimiter","flag","flagChar","_nextCommandHelper","_parseNumber","points","arcAngle","arcLarge","_parseArcFlag","arcSweep","builder","source","initialCommandIsMoveTo","parseSegment","appendSegment","pathSegArray","first","_asPathString","_pathSegList","normalizedPathSegList","animatedPathSegList","animatedNormalizedPathSegList","rect","NS","HTML","MATH","SE","SVG","XLINK","XML","XMLNS","getReverseNS","reverseNS","URI","toLowerCase","jQuery","userAgent","Boolean","createSVGRect","navigator","svg","isOpera_","opera","isWebkit_","includes","isGecko_","isIE_","isChrome_","isTouch_","supportsSelectors_","querySelector","supportsXpath_","evaluate","supportsPathReplaceItem_","path","seglist","seg","replaceItem","err","supportsPathInsertItemBefore_","insertItemBefore","supportsGoodTextCharPos_","svgroot","svgcontent","documentElement","append","text","textContent","getStartPositionOfChar","remove","supportsPathBBox_","bbox","getBBox","height","supportsHVLineContainerBBox_","path2","g","width","supportsNonScalingStroke_","retValue","cloneNode","alert","style","vectorEffect","supportsNativeSVGTransformLists_","rxform","transform","baseVal","t1","createSVGTransform","appendItem","getItem","SVGTransform","matrix","a","b","c","d","e","f","isOpera","isWebkit","isGecko","isIE","isChrome","supportsHVLineContainerBBox","supportsNonScalingStroke","transformToString","xform","m","join","cx","cy","K","elementContainer_","listMap_","SVGTransformList","_elem","_xforms","_update","tstr","_init","str","re","match","replace","bits","split","valBits","valArr","letters","mtx","createSVGMatrix","values","parseFloat","fname","toUpperCase","slice","_this","_removeFromOtherLists","some","tl","code","newxforms","removeElementFromListMap","id","getTransformList","t","gradientTransform","patternTransform","wAttrs","hAttrs","typeMap_","getTypeMap","shortFloat","digits","getRoundDigits","toFixed","Number","convertUnit","unit","getBaseUnit","setUnitAttr","convertToNum","substr","num","getWidth","getHeight","Math","sqrt","HistoryEventTypes","BEFORE_APPLY","AFTER_APPLY","BEFORE_UNAPPLY","AFTER_UNAPPLY","Command","MoveElementCommand","oldNextSibling","oldParent","tagName","newNextSibling","nextSibling","newParent","parentNode","handler","handleHistoryEvent","insertBefore","InsertElementCommand","parent","_this2","removeChild","RemoveElementCommand","isNullish","console","log","ChangeElementCommand","attrs","newValues","oldValues","getHref","bChangedTransform","_this5","setHref","removeAttribute","getRotationAngle","rotate","_this6","BatchCommand","stack","apply","unapply","elems","cmd","thisElems","elements","UndoManager","historyEventHandler","handler_","undoStackPointer","undoStack","undoChangeStackPointer","undoableChangeStack","getText","attrName","p","changeset","batchCmd","changes","addSubCommand","transformPoint","isIdentity","matrixMultiply","args","reduceRight","prev","m1","multiply","abs","hasMatrixTransform","tlist","transformBox","l","w","h","tr","bl","br","minx","min","maxx","max","miny","aabox","transformListToTransform","createSVGTransformFromMatrix","parseInt","temp","mtom","getMatrix","snapToAngle","snap","PI","dx","dy","atan2","dist","snapangle","round","cos","sin","rectsIntersect","segData","uiStrings","setUiStrings","strs","assign","ui","pathFuncs","linkControlPts","pathData","editorContext_","init","editorContext","each","s","newseg","list","arr","curSeg","clear","getGripPt","altPt","pth","out","currentZoom","getCurrentZoom","getPointFromGrip","pt","imatrix","addPointGrip","pointGripContainer","getGripContainer","pointGrip","getElem","atts","display","r","fill","stroke","cursor","pathNodeTooltip","assignAttributes","appendChild","dblclick","setSegType","addCtrlGrip","pathCtrlPtTooltip","getCtrlLine","ctrlLine","getControlPoints","cpt","segItems","segs","gpt","replacePathSeg","pts","segList","getSegSelector","update","segItem","segLine","map","prop","point","smoothControlPoints","ct1","ct2","nct1","getSVGRoot","createSVGPoint","nct2","anglea","angleb","newAnglea","newAngleb","angleBetween","angleDiff","Segment","selected","ctrlpts","ptgrip","segsel","hasOwnProperty","showCtrlPts","selectCtrls","getPointGrip","full","curPts","next","nextPts","mate","itm","anum","newType","Path","selected_pts","find","first_seg","segment","startI","nextSeg","prevSeg","startSeg","addGrip","newX","newY","p0x","p1x","p2x","p01x","p12x","p0y","p1y","p2y","p01y","p12y","show","pos","indexOf","select","eachSeg","last_d","selectPt","move","moveCtrl","dragctrl","setLinked","storeD","selPt","cur","curX","curY","prevX","prevY","olditem","old","diffX","diffY","setType","endChanges","ctrlNum","clearSelection","addPtsToSelection","inverse","resetD","indexes","sort","grips","closedSubpath","subpathIsClosed","clsd","newcx","newcy","oldcx","oldcy","getPath_","removePath_","getRotVals","theta","recalcRotatedPath","currentPath","oldbox","oldbbox","box","rvals","cVals1","cVals2","Rnc","setRotate","pathMap","convertPath","toRel","curx","cury","lastM","letter","pathDSegment","morePoints","lastPoint","pnt","newPoint","firstCtrl","subpath","hasMoved","pathActions","mouseDown","evt","mouseTarget","startX","startY","getCurrentMode","curPt","target","cur_pt","dragging","shiftKey","removePtFromSelection","startsWith","parts","rubberBox","getRubberBox","setRubberBox","selectorManager","getRubberBandBox","mouseX","mouseY","stretchy","getGridSnapping","snapToGrid","drawnPath","getDrawnPath","FUZZ","clickOnPoint","px","py","getId","sSeg","newpath","absX","absY","endseg","setDrawnPath","setStarted","remapElement","newD","origD","toEditMode","contains","getContainer","getMouseTarget","last","lastx","lasty","xya","dAttr","addSVGElementFromJson","element","curStyles","getNextId","opacity","getOpacity","mouseMove","mpt","movePts","rbb","ptBb","sel","pointGrip1","pointGrip2","ptX","ptY","altX","altY","lastX","lastY","mouseUp","keep","lastPt","toSelectMode","setCurrentMode","utilsGetBBox","selPath","addToSelection","addSubPath","on","reorient","getSelectedElements","resetOrientation","addCommandToHistory","nodeName","n","bb","attrVal","grad","getRefElem","pt1","pt2","gCoords","newgrad","findDefs","reorientGrads","zoomChange","getNodePoint","linkControlPoints","linkPoints","clonePathNode","selPts","nums","addSeg","opencloseSubPath","zSeg","openPt","startItem","closer","deletePathNode","canDeleteNodes","deleteSeg","cleanup","remItems","count","nprev","prevType","canvas","deleteSelectedElements","cp","smoothPolylineIntoPath","N","curpos","prevCtlPt","end","newpts","prevArr","v","moveNode","newValue","diff","fixEnd","KEYSTR","visElemsArr","domdoc_","domcontainer_","svgroot_","dropXMLInteralSubset","toXml","encode64","input","encodeUTF8","btoa","output","floor","chr1","charCodeAt","chr2","chr3","enc1","enc2","enc3","enc4","decode64","atob","decodeUTF8","String","fromCharCode","argString","decodeURIComponent","escape","unescape","encodeURIComponent","dataURLToObjectURL","dataurl","Uint8Array","Blob","URL","createObjectURL","mime","bstr","u8arr","blob","text2xml","sXML","dXML","DOMParser","ActiveXObject","async","loadXML","parseFromString","e2","walkTree","cbFn","nodeType","childNodes","getUrlFromAttr","substring","getAttributeNS","setAttributeNS","svgElement","getSVGContent","defs","getElementsByTagNameNS","ownerDocument","firstChild","getPathBBox","tot","bounds","start","P0","getCalc","P1","P2","P3","calc","b2ac","t2","groupBBFix","ret","copy","ref","data","matched","children","filter","issue","getStrokedBBox","geSelectedElements","elname","extent","getExtentOfChar","getComputedTextLength","fo","closest","getPathDFromSegments","pathSegments","singleChar","getPathDFromElement","rx","ry","getExtraAttributesForConvertToPath","getBBoxOfElementAsPath","eltrans","before","getBBoxWithTransform","getRotationAngleFromTransformList","hasMatrixXForm","goodBb","hasAMatrixTransform","angleModulo90","bBoxCanBeOptimizedOverNativeGetBBox","getStrokeOffsetForBBox","sw","fullBb","maxX","maxY","minX","minY","offset","curBb","getVisibleElements","parentElement","contentElems","reverse","getStrokedBBoxDefaultVisible","toRad","singleNodeValue","suspendLength","unitCheck","ns","cleanupElement","defaults","stepSize","getSnappingStep","preventClickDefault","img","click","preventDefault","Layer","group","svgElem","name_","group_","svgdoc","layerTitle","after","addLayerClass","visible","expected","child","hrService","previousName","title","getTitleElement","empty","changeElement","classes","CLASS_NAME","CLASS_REGEX","test","RegExp","HistoryRecordingService","undoManager","undoManager_","currentBatchCommand_","batchCommandStack_","batchCommand","pop","addCommand_","NO_HISTORY","visElems","RandomizeModes","LET_DOCUMENT_DECIDE","ALWAYS_RANDOMIZE","NEVER_RANDOMIZE","randIds","disabledElems","historyRecordingService","canvas_","undoMgr","getNewLayerName","existingLayerNames","Drawing","optIdPrefix","svgElem_","obj_num","idPrefix","releasedNums","all_layers","layer_map","current_layer","nonce_","setNonce","random","oldObjNum","restoreOldObjNum","getElem_","front","getNumLayers","getName","getGroup","layer","finalName","oldName","setName","newpos","oldpos","layerCount","currentGroup","refGroup","identifyLayers","setCurrentLayer","getLayerName","prevGroup","startBatchCommand","layerNextSibling","removeElement","localName","moveElement","removeGroup","endBatchCommand","mergeLayer","deactivate","activate","oldLayerGroup","numchildren","orphans","layernames","childgroups","querySelectorAll","appendChildren","keys","insertElement","ch","copyElem","layerName","isVisible","bVisible","setVisible","setOpacity","el","that","newEl","fixedD","nodeValue","utilCopyElem","randomizeIds","enableRandomization","currentDrawing","getNonce","clearNonce","leaveContext","getCurrentDrawing","createLayer","newLayer","cloneLayer","deleteCurrentLayer","currentLayer","getCurrentLayer","result","renameCurrentLayer","newName","drawing","setCurrentLayerName","setCurrentLayerPosition","newPos","setLayerVisibility","prevVisibility","getLayerVisibility","oldDisplay","moveSelectedToLayer","getLayerByName","selElems","oldLayer","changeSVGContent","mergeAllLayers","orig","elData","setCurrentGroup","setContext","parentsUntil","andSelf","siblings","opac","getCurrentGroup","REVERSE_NS","svgWhiteList_","circle","clipPath","desc","ellipse","feGaussianBlur","foreignObject","image","line","linearGradient","marker","mask","metadata","pattern","polygon","polyline","radialGradient","stop","switch","symbol","textPath","tspan","use","annotation","maction","math","menclose","merror","mfrac","mi","mmultiscripts","mn","mo","mover","mpadded","mphantom","mprescripts","mroot","mrow","mspace","msqrt","mstyle","msub","msubsup","msup","mtable","mtd","mtext","mtr","munder","munderover","none","semantics","svgWhiteListNS_","elt","attNS","att","sanitizeSvg","node","doc","allowedAttrs","allowedAttrsNS","seAttrs","attrLocalName","attrNsURI","removeAttributeNS","props","styleAttrName","trim","styleAttrVal","href","hasChildNodes","addScriptAtts","script","importSetGlobal","url","glob","global","returnDefault","svgEditor","modules","importModule","importScript","Promise","all","u","resolve","reject","createElement","scriptOnError","destructor","scriptOnLoad","removeEventListener","src","defer","addEventListener","head","vector","toString","revokeObjectURL","absURL","toAbsoluteURL","loader","context_","svgFactory_","config_","selectorManager_","remap","scalew","scaleh","doSnapping","finishUp","o","getDrawing","elName","chlist","mt","setMatrix","existing","tNew","tbox","gsvg","pstr","firstseg","currentpt","dstr","updateClipPath","tx","ty","cpXform","newxlate","setTranslate","recalculateDimensions","k","noi","mxs","mNew","oldcenter","newcenter","initial","extend","getStartTransform","gangle","rm","firstM","oldStartTransform","operation","tm","sm","tmn","childTlist","setStartTransform","e2t","t2n","s2","translateOrigin","scale","translateBack","setScale","T_M","mInv","M2","clipPathsDone","uses","useElem","usexlate","newRot","em","e2m","avg","roldt","rold","rnew","rnewInv","extrat","paint","gtlist","gmatrix","mStr","oldxlate","meq","meqInv","tspanChanges","gripRadius","Selector","selectedElement","locked","selectorGroup","createSVGElement","selectorRect","gripCoords","nw","ne","se","reset","resize","bShow","selectorGripsGroup","hasGrips","updateGripCursors","selectedBox","mgr","selectedGrips","selectorGrips","strokedBbox","nbox","nbax","nbay","nbaw","nbah","rot","svgRoot","rotm","maxy","dir","coords","rotateGripConnector","rotateGrip","dirArr","steps","shift","gripElement","SelectorManager","selectorParentGroup","rubberBandBox","selectors","selectorMap","initGroup","grip","imgPath","dimensions","canvasbg","overflow","svgContent","showGrips","hstry","postError","container","config","curConfig","show_outside_canvas","selectNew","importNode","clearSvgContentElement","xmlns","appendTo","comment","createComment","idprefix","setIdPrefix","current_drawing_","draw","allProperties","shape","initFill","color","fill_paint","fill_opacity","initStroke","stroke_paint","stroke_opacity","stroke_width","stroke_dasharray","stroke_linejoin","stroke_linecap","initOpacity","font_size","font_family","curShape","selectedElements","getJsonFromSvgElement","retval","createTextNode","namespace","baseUnit","elementContainer","body","inch","ex","in","cm","mm","pc","unitsInit","getElement","saveOptions","round_digits","getSelectedElems","pathModule","getDOMDocument","getDOMContainer","snappingStep","gridSnapping","coordsInit","recalculateInit","startTransform","nsMap","eventType","EventTypes","cmdType","isApply","restoreRefElems","setUseData","stdDeviation","setBlurOffsets","getZoom","svgFactory","selectInit","jsonMap","ev","arg","events","noCall","releaseSelector","elemsToAdd","requestSelector","compareDocumentPosition","correspondingUseElement","started","rb","closed_subpath","currentMode","dp","refAttrs","opacAni","begin","dur","removedElements","childs","getElementsByTagName","encodableImages","importIds","curText","extensions","lastGoodImgUrl","currentResizeMode","curProperties","justSelected","curBBoxes","lastClickPoint","runExtension","action","vars","runExtensions","returnArray","nameFilter","ext","addExtension","extInitFunc","jq","importLocale","TypeError","argObj","getPrivateMethods","nonce","extObj","getIntersectionList","rubberBBox","resultList","getVisibleElementsAndBBoxes","groupSvgElem","replaceWith","prepareSvg","newDoc","ffClone","setRotationAngle","preventUndo","oldTransform","center","newTransform","changeSelectedAttribute","recalculateAllSelectedDimensions","isEmpty","logMatrix","rootSctm","selectOnly","removeFromSelection","elemsToRemove","newSelectedItems","selectAllInCurrentLayer","parameter","freehand","rStartX","rStartY","initBbox","sumDistance","controllPoint2","controllPoint1","bSpline","nextPos","getBsplinePoint","spline","p0","p1","p2","p3","t3","mousedown","spaceKey","button","rightClick","altKey","cloneSelectedElements","getScreenCTM","pageX","pageY","realX","realY","griptype","slist","delayedStroke","iswebkit","ele","_stroke","setTimeout","newImage","strokeW","textActions","beginUndoableChange","extResult","event","start_x","start_y","mousemove","newList","intElem","foundInd","hasMatrix","left","top","sy","sx","square","rad","STEP_COUNT","mouse_x","mouse_y","pushGroupProperties","mouseup","tempJustSelected","factor","commaIndex","res","finishUndoableChange","addedNew","cAni","aniDur","beginElement","to","releaseId","setMode","originalEvent","workarea","rulerwidth","showRulers","editorFullW","editorFullH","editorW","editorH","workareaViewW","workareaViewH","wOffset","wOffsetLeft","wOffsetTop","delta","wheelDelta","detail","wZoom","hZoom","ceil","zoomlevel","topLeftOld","newCtr","setZoom","canvg","curtext","textinput","selblock","blinker","textbb","allowDbl","chardata","setCursor","focus","arguments","selectionEnd","selectionStart","charbb","setSelectionRange","setInterval","startPt","ptToScreen","endPt","visibility","setSelection","skipInput","startbb","endbb","getIndexFromPoint","charpos","getCharNumAtPosition","setCursorFromPoint","setEndSelectionFromPoint","i1","i2","screenToPt","xIn","yIn","selectAll","unbind","selectWord","ept","css","selectElem","clearInterval","blur","setInputElem","inputElem","getEndPositionOfChar","contentW","removeUnusedDefElems","defelemUses","numRemoved","alen","allEls","allLen","defelems","defelem","getIssues","issues","issueCodes","issueList","exportNoBlur","exportNoforeignObject","exportNoDashArray","content","getContext","exportNoText","descr","svgCanvasToString","nakedSvgs","svgToString","indent","unitRe","getResolution","nsuris","uri","attrNames","mozAttrs","images","bOneLine","embedImage","Image","load","response","status","xhr","cvs","drawImage","urldata","toDataURL","statusText","setGoodImage","open","save","opts","rasterExport","imgType","quality","exportWindowName","mimeType","canvgPath","hide","contentH","bloburl","dataURLType","datauri","done","avoidEvent","toBlob","exportPDF","outputType","jsPDF","modularVersion","jspdfPath","orientation","format","docTitle","getDocumentTitle","setProperties","addSVG","getSvgString","uniquifyElems","ids","refElems","oldid","hrefs","attrnode","getAttributeNode","refid","newid","ownerElement","hreffers","hreffer","refElem","convertGradients","fillStrokeElems","convertToGroup","ts","$elem","unwrap","removeData","vb","hasMore","dupeGrads","walkTreePost","setSvgString","xmlString","firstElementChild","oldzoom","adoptNode","pa","percs","dim","importSvgString","useEl","uid","useExisting","parents","innerw","innerh","innervb","canvash","dr","propVal","cg","resetUndoStack","getContentElem","getRootElem","zoom","getSnapToGrid","getVersion","notification","strings","ok","cancel","draggable","containment","btnHolder","dialogContent","dbox","msg","defaultVal","changeListener","checkbox","html","toggleClass","ctrl","chkbx","prependTo","div","label","tooltip","checked","opt","confirm","process_cancel","prompt","txt","jQueryPluginDBox","common","setConfig","getTitle","setGroupTitle","prepend","tsNextSibling","setDocumentTitle","newTitle","oldTitle","getEditorNS","add","setResolution","visEls","moveSelectedElements","viewBox","getOffset","setBBoxZoom","spacer","calcZoom","newzoom","selectedElems","zoomLevel","getMode","getColor","setColor","addNonG","changeSelectedAttributeNoUndo","setGradient","duplicateGrad","findDuplicateGradient","existingGrads","radAttrs","og","gradAttrs","ogAttrs","stops","ostops","ostop","setPaint","jGraduate","Paint","setPaintOpacity","alpha","solidColor","setStrokePaint","setFillPaint","getStrokeWidth","setStrokeWidth","setStrokeAttr","getStyle","getFillOpacity","getStrokeOpacity","getPaintOpacity","getBlur","curCommand","filterHidden","finishChange","bCmd","setBlurNoUndo","setBlur","filterElem","stdDev","complete","elemId","newblur","getBold","setBold","getItalic","setItalic","getFontFamily","setFontFamily","setFontColor","getFontColor","getFontSize","setFontSize","setTextContent","setImageURL","setsize","curHref","setLinkURL","parentsA","setRectRadius","makeHyperlink","groupSelectedElements","removeHyperlink","ungroupSelectedElement","convertToPath","noXYElems","oldval","newrot","selectedCopy","cutSelectedElements","copySelectedElements","localStorage","setItem","JSON","stringify","enableContextMenuItems","pasteElements","clipb","parse","pasted","changedIDs","checkIDs","extChanges","removeID","clipBoardItem","ctrX","ctrY","urlArg","cmdStr","undoable","gfilter","gblur","glist","gattrs","newOpac","cblur","origCblur","suffix","chtlist","rgm","rcm","cangle","cbox","ceqm","coldc","sangle","trm","oldxform","newxform","chm","chmInv","gm","anchor","gNextSibling","moveToTopSelectedElement","moveToBottomSelectedElement","moveUpDownSelected","foundCur","toArray","constructor","copiedElements","alignSelectedElements","relativeTo","bboxes","MAX_VALUE","MIN_VALUE","curwidth","curheight","updateCanvas","bg","oldX","oldY","bgImg","new_x","new_y","old_x","old_y","d_x","d_y","setBackground","border","preserveAspectRatio","cycleElement","curElem","allElems","SVGEditTransformList"],"mappings":"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"}
\ No newline at end of file
diff --git a/rollup.config.js b/rollup.config.js
index 6ee7718b..02b8f69b 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -73,6 +73,23 @@ export default [
   getRollupObject({minifying: true, format: 'es'}),
   getRollupObject({minifying: false, format: 'es'}),
   // **/
+  ...[true, false].map((min) => {
+    return {
+      input: 'editor/svgcanvas.js',
+      output: {
+        format: 'iife',
+        sourcemap: min,
+        name: 'SvgCanvas',
+        file: `dist/svgcanvas-iife${min ? '.min' : ''}.js`
+      },
+      plugins: [
+        babel({
+          plugins: ['transform-object-rest-spread']
+        }),
+        min ? terser() : null
+      ]
+    };
+  }),
   ...extensionLocaleFiles.map(([dir, file]) => {
     const lang = file.replace(/\.js$/, '').replace(/-/g, '_');
     return {