@joint/core 4.1.3 → 4.2.0-alpha.1

package/dist/vectorizer.js

@@ -1,21 +1,21 @@
-/*! JointJS v4.1.3 (2025-02-04) - JavaScript diagramming library
-
+/*! JointJS v4.2.0-alpha.1 (2025-09-25) - JavaScript diagramming library
 
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
+
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
     typeof define === 'function' && define.amd ? define(factory) :
-    (global = global || self, global.V = factory());
-}(this, function () { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.V = factory());
+})(this, (function () { 'use strict';
 
     // Declare shorthands to the most used math functions.
     const {
-      round,
+      round: round$3,
       floor,
-      PI
+      PI: PI$1
     } = Math;
     const scale = {
       // Return the `value` from the `domain` interval scaled to the `range` interval.
@@ -29,15 +29,15 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       return angle % 360 + (angle < 0 ? 360 : 0);
     };
     const snapToGrid = function (value, gridSize) {
-      return gridSize * round(value / gridSize);
+      return gridSize * round$3(value / gridSize);
     };
     const toDeg = function (rad) {
-      return 180 * rad / PI % 360;
+      return 180 * rad / PI$1 % 360;
     };
     const toRad = function (deg, over360) {
       over360 = over360 || false;
       deg = over360 ? deg : deg % 360;
-      return deg * PI / 180;
+      return deg * PI$1 / 180;
     };
 
     // Return a random integer from the interval [min,max], inclusive.
@@ -56,10 +56,11 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
     };
 
     // @return the bearing (cardinal direction) of the line. For example N, W, or SE.
+    // @returns {String} One of the following bearings : NE, E, SE, S, SW, W, NW, N.
     const {
-      cos,
-      sin,
-      atan2
+      cos: cos$2,
+      sin: sin$2,
+      atan2: atan2$1
     } = Math;
     const bearing = function (p, q) {
       var lat1 = toRad(p.y);
@@ -67,9 +68,9 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       var lon1 = p.x;
       var lon2 = q.x;
       var dLon = toRad(lon2 - lon1);
-      var y = sin(dLon) * cos(lat2);
-      var x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon);
-      var brng = toDeg(atan2(y, x));
+      var y = sin$2(dLon) * cos$2(lat2);
+      var x = cos$2(lat1) * sin$2(lat2) - sin$2(lat1) * cos$2(lat2) * cos$2(dLon);
+      var brng = toDeg(atan2$1(y, x));
       var bearings = ['NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'N'];
       var index = brng - 22.5;
       if (index < 0) index += 360;
@@ -112,16 +113,16 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         * `Point(Point(10, 20))`
     */
     const {
-      abs,
+      abs: abs$2,
       cos: cos$1,
       sin: sin$1,
-      sqrt,
-      min,
-      max,
-      atan2: atan2$1,
-      round: round$1,
-      pow,
-      PI: PI$1
+      sqrt: sqrt$2,
+      min: min$3,
+      max: max$3,
+      atan2,
+      round: round$2,
+      pow: pow$3,
+      PI
     } = Math;
     const Point = function (x, y) {
       if (!(this instanceof Point)) {
@@ -145,8 +146,8 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
     // @param {point} [optional] Origin.
     Point.fromPolar = function (distance, angle, origin) {
       origin = new Point(origin);
-      var x = abs(distance * cos$1(angle));
-      var y = abs(distance * sin$1(angle));
+      var x = abs$2(distance * cos$1(angle));
+      var y = abs$2(distance * sin$1(angle));
       var deg = normalizeAngle(toDeg(angle));
       if (deg < 90) {
         y = -y;
@@ -187,8 +188,8 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         if (r.containsPoint(this)) {
           return this;
         }
-        this.x = min(max(this.x, r.x), r.x + r.width);
-        this.y = min(max(this.y, r.y), r.y + r.height);
+        this.x = min$3(max$3(this.x, r.x), r.x + r.width);
+        this.y = min$3(max$3(this.y, r.y), r.y + r.height);
         return this;
       },
       // Compute the angle between vector from me to p1 and the vector from me to p2.
@@ -254,11 +255,11 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         return new Point((1 - t) * x + t * p.x, (1 - t) * y + t * p.y);
       },
       magnitude: function () {
-        return sqrt(this.x * this.x + this.y * this.y) || 0.01;
+        return sqrt$2(this.x * this.x + this.y * this.y) || 0.01;
       },
       // Returns a manhattan (taxi-cab) distance between me and point `p`.
       manhattanDistance: function (p) {
-        return abs(p.x - this.x) + abs(p.y - this.y);
+        return abs$2(p.x - this.x) + abs$2(p.y - this.y);
       },
       // Move point on line starting from ref ending at me by
       // distance distance.
@@ -315,12 +316,12 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
               f = 1000;
               break;
             default:
-              f = pow(10, precision);
+              f = pow$3(10, precision);
               break;
           }
         }
-        this.x = round$1(this.x * f) / f;
-        this.y = round$1(this.y * f) / f;
+        this.x = round$2(this.x * f) / f;
+        this.y = round$2(this.y * f) / f;
         return this;
       },
       // Scale point with origin.
@@ -347,13 +348,13 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         // Invert the y-axis.
         var y = -(p.y - this.y);
         var x = p.x - this.x;
-        var rad = atan2$1(y, x); // defined for all 0 corner cases
+        var rad = atan2(y, x); // defined for all 0 corner cases
 
         // Correction for III. and IV. quadrant.
         if (rad < 0) {
-          rad = 2 * PI$1 + rad;
+          rad = 2 * PI + rad;
         }
-        return 180 * rad / PI$1;
+        return 180 * rad / PI;
       },
       toJSON: function () {
         return {
@@ -367,7 +368,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         o = o && new Point(o) || new Point(0, 0);
         var x = this.x;
         var y = this.y;
-        this.x = sqrt((x - o.x) * (x - o.x) + (y - o.y) * (y - o.y)); // r
+        this.x = sqrt$2((x - o.x) * (x - o.x) + (y - o.y) * (y - o.y)); // r
         this.y = toRad(o.theta(new Point(x, y)));
         return this;
       },
@@ -399,8 +400,8 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
     const point = Point;
 
     const {
-      max: max$1,
-      min: min$1
+      max: max$2,
+      min: min$2
     } = Math;
     const Line = function (p1, p2) {
       if (!(this instanceof Line)) {
@@ -420,10 +421,10 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         return this.start.angleBetween(this.end, horizontalPoint);
       },
       bbox: function () {
-        var left = min$1(this.start.x, this.end.x);
-        var top = min$1(this.start.y, this.end.y);
-        var right = max$1(this.start.x, this.end.x);
-        var bottom = max$1(this.start.y, this.end.y);
+        var left = min$2(this.start.x, this.end.x);
+        var top = min$2(this.start.y, this.end.y);
+        var right = max$2(this.start.x, this.end.x);
+        var bottom = max$2(this.start.y, this.end.y);
         return new Rect(left, top, right - left, bottom - top);
       },
       // @return the bearing (cardinal direction) of the line. For example N, W, or SE.
@@ -444,7 +445,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       // @return {number} the normalized length of the closest point on the line to point `p`
       closestPointNormalizedLength: function (p) {
         var product = this.vector().dot(new Line(this.start, p).vector());
-        var cpNormalizedLength = min$1(1, max$1(0, product / this.squaredLength()));
+        var cpNormalizedLength = min$2(1, max$2(0, product / this.squaredLength()));
 
         // cpNormalizedLength returns `NaN` if this line has zero length
         // we can work with that - if `NaN`, return 0
@@ -650,8 +651,8 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
     const {
       sqrt: sqrt$1,
-      round: round$2,
-      pow: pow$1
+      round: round$1,
+      pow: pow$2
     } = Math;
     const Ellipse = function (c, a, b) {
       if (!(this instanceof Ellipse)) {
@@ -799,14 +800,14 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
               f = 1000;
               break;
             default:
-              f = pow$1(10, precision);
+              f = pow$2(10, precision);
               break;
           }
         }
-        this.x = round$2(this.x * f) / f;
-        this.y = round$2(this.y * f) / f;
-        this.a = round$2(this.a * f) / f;
-        this.b = round$2(this.b * f) / f;
+        this.x = round$1(this.x * f) / f;
+        this.y = round$1(this.y * f) / f;
+        this.a = round$1(this.a * f) / f;
+        this.b = round$1(this.b * f) / f;
         return this;
       },
       /** Compute angle between tangent and x axis
@@ -844,12 +845,12 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
     const {
       abs: abs$1,
-      cos: cos$2,
-      sin: sin$2,
-      min: min$2,
-      max: max$2,
-      round: round$3,
-      pow: pow$2
+      cos,
+      sin,
+      min: min$1,
+      max: max$1,
+      round,
+      pow: pow$1
     } = Math;
     const Rect = function (x, y, w, h) {
       if (!(this instanceof Rect)) {
@@ -870,14 +871,14 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       e = new Ellipse(e);
       return new Rect(e.x - e.a, e.y - e.b, 2 * e.a, 2 * e.b);
     };
-    Rect.fromPointUnion = function () {
-      if (arguments.length === 0) return null;
+    Rect.fromPointUnion = function (...points) {
+      if (points.length === 0) return null;
       const p = new Point();
       let minX, minY, maxX, maxY;
       minX = minY = Infinity;
       maxX = maxY = -Infinity;
-      for (let i = 0; i < arguments.length; i++) {
-        p.update(i < 0 || arguments.length <= i ? undefined : arguments[i]);
+      for (let i = 0; i < points.length; i++) {
+        p.update(points[i]);
         const x = p.x;
         const y = p.y;
         if (x < minX) minX = x;
@@ -887,14 +888,14 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       }
       return new Rect(minX, minY, maxX - minX, maxY - minY);
     };
-    Rect.fromRectUnion = function () {
-      if (arguments.length === 0) return null;
+    Rect.fromRectUnion = function (...rects) {
+      if (rects.length === 0) return null;
       const r = new Rect();
       let minX, minY, maxX, maxY;
       minX = minY = Infinity;
       maxX = maxY = -Infinity;
-      for (let i = 0; i < arguments.length; i++) {
-        r.update(i < 0 || arguments.length <= i ? undefined : arguments[i]);
+      for (let i = 0; i < rects.length; i++) {
+        r.update(rects[i]);
         const x = r.x;
         const y = r.y;
         const mX = x + r.width;
@@ -920,8 +921,8 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
           height
         } = this;
         const theta = toRad(angle);
-        const st = abs$1(sin$2(theta));
-        const ct = abs$1(cos$2(theta));
+        const st = abs$1(sin(theta));
+        const ct = abs$1(cos(theta));
         const w = width * ct + height * st;
         const h = width * st + height * ct;
         this.x += (width - w) / 2;
@@ -1022,9 +1023,9 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
         // No intersection found
         if (rCorner.x <= myOrigin.x || rCorner.y <= myOrigin.y || rOrigin.x >= myCorner.x || rOrigin.y >= myCorner.y) return null;
-        var x = max$2(myOrigin.x, rOrigin.x);
-        var y = max$2(myOrigin.y, rOrigin.y);
-        return new Rect(x, y, min$2(myCorner.x, rCorner.x) - x, min$2(myCorner.y, rCorner.y) - y);
+        var x = max$1(myOrigin.x, rOrigin.x);
+        var y = max$1(myOrigin.y, rOrigin.y);
+        return new Rect(x, y, min$1(myCorner.x, rCorner.x) - x, min$1(myCorner.y, rCorner.y) - y);
       },
       intersectionWithLine: function (line) {
         var r = this;
@@ -1115,13 +1116,13 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
           sy4 = (this.y + this.height - oy) / (p4.y - oy);
         }
         return {
-          sx: min$2(sx1, sx2, sx3, sx4),
-          sy: min$2(sy1, sy2, sy3, sy4)
+          sx: min$1(sx1, sx2, sx3, sx4),
+          sy: min$1(sy1, sy2, sy3, sy4)
         };
       },
       maxRectUniformScaleToFit: function (rect, origin) {
         var scale = this.maxRectScaleToFit(rect, origin);
-        return min$2(scale.sx, scale.sy);
+        return min$1(scale.sx, scale.sy);
       },
       // Move and expand me.
       // @param r {rectangle} representing deltas
@@ -1132,6 +1133,12 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         this.height += r.height || 0;
         return this;
       },
+      moveAroundPoint: function (origin, angle) {
+        const newCenter = this.center().rotate(origin, angle);
+        this.x = newCenter.x - this.width / 2;
+        this.y = newCenter.y - this.height / 2;
+        return this;
+      },
       // Normalize the rectangle; i.e., make it so that it has a non-negative width and height.
       // If width < 0 the function swaps the left and right corners,
       // and it swaps the top and bottom corners if height < 0
@@ -1203,14 +1210,14 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
               f = 1000;
               break;
             default:
-              f = pow$2(10, precision);
+              f = pow$1(10, precision);
               break;
           }
         }
-        this.x = round$3(this.x * f) / f;
-        this.y = round$3(this.y * f) / f;
-        this.width = round$3(this.width * f) / f;
-        this.height = round$3(this.height * f) / f;
+        this.x = round(this.x * f) / f;
+        this.y = round(this.y * f) / f;
+        this.width = round(this.width * f) / f;
+        this.height = round(this.height * f) / f;
         return this;
       },
       // Scale rectangle with origin.
@@ -1800,8 +1807,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         }
         return this;
       },
-      simplify: function () {
-        let opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      simplify: function (opt = {}) {
         const points = this.points;
         if (points.length < 3) return this; // we need at least 3 points
 
@@ -1948,11 +1954,11 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
     });
 
     const {
-      abs: abs$2,
-      sqrt: sqrt$2,
-      min: min$3,
-      max: max$3,
-      pow: pow$3
+      abs,
+      sqrt,
+      min,
+      max,
+      pow
     } = Math;
     const Curve = function (p1, p2, p3, p4) {
       if (!(this instanceof Curve)) {
@@ -2101,9 +2107,9 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
             a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
             c = 3 * y1 - 3 * y0;
           }
-          if (abs$2(a) < 1e-12) {
+          if (abs(a) < 1e-12) {
             // Numerical robustness
-            if (abs$2(b) < 1e-12) {
+            if (abs(b) < 1e-12) {
               // Numerical robustness
               continue;
             }
@@ -2112,7 +2118,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
             continue;
           }
           b2ac = b * b - 4 * c * a;
-          sqrtb2ac = sqrt$2(b2ac);
+          sqrtb2ac = sqrt(b2ac);
           if (b2ac < 0) continue;
           t1 = (-b + sqrtb2ac) / (2 * a);
           if (0 < t1 && t1 < 1) tvalues.push(t1);
@@ -2153,10 +2159,10 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         bounds[0].length = jlen + 2;
         bounds[1].length = jlen + 2;
         points.length = jlen + 2;
-        var left = min$3.apply(null, bounds[0]);
-        var top = min$3.apply(null, bounds[1]);
-        var right = max$3.apply(null, bounds[0]);
-        var bottom = max$3.apply(null, bounds[1]);
+        var left = min.apply(null, bounds[0]);
+        var top = min.apply(null, bounds[1]);
+        var right = max.apply(null, bounds[0]);
+        var bottom = max.apply(null, bounds[1]);
         return new Rect(left, top, right - left, bottom - top);
       },
       clone: function () {
@@ -2230,7 +2236,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
             minSumDist = sumDist;
           }
         }
-        var precisionRatio = pow$3(10, -precision);
+        var precisionRatio = pow(10, -precision);
 
         // recursively divide investigated subdivision:
         // until distance between baselinePoint and closest path endpoint is within 10^(-precision)
@@ -2241,8 +2247,8 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
           // - note that this function is not monotonic = it doesn't converge stably but has "teeth"
           // - the function decreases while one of the endpoints is fixed but "jumps" whenever we switch
           // - this criterion works well for points lying far away from the curve
-          var startPrecisionRatio = distFromStart ? abs$2(distFromStart - distFromEnd) / distFromStart : 0;
-          var endPrecisionRatio = distFromEnd ? abs$2(distFromStart - distFromEnd) / distFromEnd : 0;
+          var startPrecisionRatio = distFromStart ? abs(distFromStart - distFromEnd) / distFromStart : 0;
+          var endPrecisionRatio = distFromEnd ? abs(distFromStart - distFromEnd) / distFromEnd : 0;
           var hasRequiredPrecision = startPrecisionRatio < precisionRatio || endPrecisionRatio < precisionRatio;
 
           // check if we have reached at least one required minimal distance
@@ -2409,7 +2415,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         var isPoint = !this.isDifferentiable();
         if (isPoint) return subdivisions;
         var previousLength = this.endpointDistance();
-        var precisionRatio = pow$3(10, -precision);
+        var precisionRatio = pow(10, -precision);
 
         // special case #2: sine-like curves may have the same observed length in iteration 0 and 1 - skip iteration 1
         // - not a problem for further iterations because cubic curves cannot have more than two local extrema
@@ -2641,7 +2647,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         // e.g. at precision 1, the length may be underestimated by up to 10% and cause this function to return 1
 
         var curveLength = this.length(localOpt);
-        var precisionRatio = pow$3(10, -precision);
+        var precisionRatio = pow(10, -precision);
 
         // recursively divide investigated subdivision:
         // until distance between baselinePoint and closest path endpoint is within 10^(-precision)
@@ -2776,6 +2782,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
     }
 
     // Accepts path data string, array of segments, array of Curves and/or Lines, or a Polyline.
+    // Path created is not guaranteed to be a valid (serializable) path (might not start with an M).
     const Path = function (arg) {
       if (!(this instanceof Path)) {
         return new Path(arg);
@@ -5080,8 +5087,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         }
       });
     }
-    function _polylineWithLine(polyline, line) {
-      let opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    function _polylineWithLine(polyline, line, opt = {}) {
       const {
         interior = false
       } = opt;
@@ -5114,8 +5120,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       }
       return false;
     }
-    function _polylineWithEllipse(polyline, ellipse) {
-      let opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    function _polylineWithEllipse(polyline, ellipse, opt = {}) {
       const {
         start,
         end,
@@ -5168,8 +5173,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         }
       });
     }
-    function _polylineWithPolyline(polyline1, polyline2) {
-      let opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    function _polylineWithPolyline(polyline1, polyline2, opt = {}) {
       const {
         interior = false
       } = opt;
@@ -5261,80 +5265,336 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       return m[0][0] * m[1][1] * m[2][2] - m[0][0] * m[1][2] * m[2][1] - m[0][1] * m[1][0] * m[2][2] + m[0][1] * m[1][2] * m[2][0] + m[0][2] * m[1][0] * m[2][1] - m[0][2] * m[1][1] * m[2][0];
     }
 
-    var _intersection = ({
+    var _intersection = {
+        __proto__: null,
+        ellipseWithEllipse: ellipseWithEllipse,
+        ellipseWithLine: ellipseWithLine,
         exists: exists,
         lineWithLine: lineWithLine,
-        ellipseWithLine: ellipseWithLine,
-        ellipseWithEllipse: ellipseWithEllipse,
-        rectWithLine: rectWithLine,
-        rectWithEllipse: rectWithEllipse,
-        rectWithRect: rectWithRect,
-        polylineWithLine: polylineWithLine,
-        polylineWithEllipse: polylineWithEllipse,
-        polylineWithRect: polylineWithRect,
-        polylineWithPolyline: polylineWithPolyline,
-        polygonWithLine: polygonWithLine,
-        polygonWithEllipse: polygonWithEllipse,
-        polygonWithRect: polygonWithRect,
-        polygonWithPolyline: polygonWithPolyline,
-        polygonWithPolygon: polygonWithPolygon,
-        pathWithLine: pathWithLine,
         pathWithEllipse: pathWithEllipse,
-        pathWithRect: pathWithRect,
-        pathWithPolyline: pathWithPolyline,
+        pathWithLine: pathWithLine,
+        pathWithPath: pathWithPath,
         pathWithPolygon: pathWithPolygon,
-        pathWithPath: pathWithPath
-    });
+        pathWithPolyline: pathWithPolyline,
+        pathWithRect: pathWithRect,
+        polygonWithEllipse: polygonWithEllipse,
+        polygonWithLine: polygonWithLine,
+        polygonWithPolygon: polygonWithPolygon,
+        polygonWithPolyline: polygonWithPolyline,
+        polygonWithRect: polygonWithRect,
+        polylineWithEllipse: polylineWithEllipse,
+        polylineWithLine: polylineWithLine,
+        polylineWithPolyline: polylineWithPolyline,
+        polylineWithRect: polylineWithRect,
+        rectWithEllipse: rectWithEllipse,
+        rectWithLine: rectWithLine,
+        rectWithRect: rectWithRect
+    };
 
     // Geometry library.
+    // -----------------
+
     const intersection = _intersection;
 
-    var g = ({
-        intersection: intersection,
-        scale: scale,
-        normalizeAngle: normalizeAngle,
-        snapToGrid: snapToGrid,
-        toDeg: toDeg,
-        toRad: toRad,
-        random: random,
-        bezier: bezier,
+    var g = {
+        __proto__: null,
         Curve: Curve,
         Ellipse: Ellipse,
-        ellipse: ellipse,
         Line: Line,
-        line: line,
         Path: Path,
         Point: Point,
-        point: point,
-        Polyline: Polyline,
         Polygon: Polygon,
+        Polyline: Polyline,
         Rect: Rect,
+        bezier: bezier,
+        ellipse: ellipse,
+        intersection: intersection,
+        line: line,
+        normalizeAngle: normalizeAngle,
+        point: point,
+        random: random,
         rect: rect,
+        scale: scale,
+        snapToGrid: snapToGrid,
+        toDeg: toDeg,
+        toRad: toRad,
         types: types
-    });
+    };
+
+    const svg = 'http://www.w3.org/2000/svg';
+    const xmlns = 'http://www.w3.org/2000/xmlns/';
+    const xml = 'http://www.w3.org/XML/1998/namespace';
+    const xlink = 'http://www.w3.org/1999/xlink';
+    const xhtml = 'http://www.w3.org/1999/xhtml';
+
+    var ns = {
+        __proto__: null,
+        svg: svg,
+        xhtml: xhtml,
+        xlink: xlink,
+        xml: xml,
+        xmlns: xmlns
+    };
+
+    /**
+     * @constant {boolean}
+     * @description Indicates the environment supports SVG.
+     */
+    const isSVGSupported = typeof window === 'object' && !!window.SVGAngle;
+
+    /**
+     * @constant {string}
+     * @description The version of the SVG document.
+     */
+    const SVG_VERSION = '1.1';
+
+    /**
+     * @constant {SVGSVGElement}
+     * @description The detached SVG document for various internal purposes.
+     * e.g. SVGMatrix has no constructor, so the only way to create it is
+     * to create an SVG document and then call `createSVGMatrix()`.
+     */
+    const internalSVGDocument = isSVGSupported ? createSVGDocument() : null;
+
+    /**
+     * @constant {SVGGElement}
+     * @description The detached SVG group element for various internal purposes.
+     */
+    const internalSVGGroup = isSVGSupported ? createSVGElement('g') : null;
+
+    /**
+     * @returns {SVGSVGElement}
+     * @description Creates an SVG document.
+     */
+    function createSVGDocument() {
+      const svg = createSVGElement('svg');
+      svg.setAttributeNS(xmlns, 'xmlns:xlink', xlink);
+      svg.setAttribute('version', SVG_VERSION);
+      return svg;
+    }
+
+    /**
+     * @param {string} name
+     * @returns {SVGElement}
+     * @description Creates an SVG element with the given name.
+     */
+    function createSVGElement(name) {
+      return document.createElementNS(svg, name);
+    }
+
+    /**
+     * @param {SVGElement} node1
+     * @param {SVGElement} node2
+     * @returns {SVGElement|null}
+     * @description Finds the common ancestor node of two nodes.
+     */
+    function getCommonAncestor(node1, node2) {
+      // Find the common ancestor node of two nodes.
+      let parent = node1;
+      do {
+        if (parent.contains(node2)) return parent;
+        parent = parent.parentNode;
+      } while (parent);
+      return null;
+    }
+
+    /**
+     * @returns {SVGMatrix}
+     * @description Creates an identity matrix.
+     */
+    function createIdentityMatrix() {
+      return internalSVGDocument.createSVGMatrix();
+    }
+
+    /**
+     * @param {Partial<SVGMatrix>} matrixInit
+     * @returns {SVGMatrix}
+     * @description Creates a new SVGMatrix object.
+     * If no matrix is provided, it returns the identity matrix.
+     * If a matrix like object is provided, it sets the matrix values.
+     */
+    function createMatrix(matrixInit = {}) {
+      const matrix = internalSVGDocument.createSVGMatrix();
+      if (!matrixInit) return matrix;
+      if ('a' in matrixInit) matrix.a = matrixInit.a;
+      if ('b' in matrixInit) matrix.b = matrixInit.b;
+      if ('c' in matrixInit) matrix.c = matrixInit.c;
+      if ('d' in matrixInit) matrix.d = matrixInit.d;
+      if ('e' in matrixInit) matrix.e = matrixInit.e;
+      if ('f' in matrixInit) matrix.f = matrixInit.f;
+      return matrix;
+    }
+
+    /**
+     * @returns {SVGTransform}
+     * @description Creates a new SVGTransform object.
+     */
+    function createSVGTransform() {
+      return internalSVGDocument.createSVGTransform();
+    }
+
+    /**
+     * @param {SVGElement} node
+     * @returns {SVGMatrix|null}
+     * @description Returns the transformation matrix of the given node.
+     * If the node has no transformation, it returns null.
+     */
+    function getNodeMatrix(node) {
+      const consolidatedTransformation = node.transform.baseVal.consolidate();
+      return consolidatedTransformation ? consolidatedTransformation.matrix : null;
+    }
+
+    /**
+     * @param {string} transformString
+     * @returns {SVGMatrix}
+     * @description Creates a matrix from the given transform string.
+     */
+    function createMatrixFromTransformString(transformString) {
+      internalSVGGroup.setAttribute('transform', transformString);
+      return getNodeMatrix(internalSVGGroup);
+    }
+
+    /**
+     * @param {SVGElement} node
+     * @param {Partial<SVGMatrix>} matrixInit
+     * @param {boolean} override
+     * @description Sets the transformation matrix of the given node.
+     * We don't use `node.transform.baseVal` here (@see `transformNode`)
+     * for the following reasons:
+     * - Performance: while Chrome performs slightly better, Firefox
+     *   and Safari are significantly slower
+     *   https://www.measurethat.net/Benchmarks/Show/34447/1/overriding-svg-transform-attribute
+     * - Limited support: JSDOM does not support `node.transform.baseVal`
+     */
+    function replaceTransformNode(node, matrixInit) {
+      node.setAttribute('transform', matrixToTransformString(matrixInit));
+    }
+
+    /**
+     * @param {SVGElement} node
+     * @param {Partial<SVGMatrix>} matrixInit
+     * @description Applies a transformation matrix to the given node.
+     * If the node already has a transformation, it appends the new transformation.
+     * If the node has no transformation, it creates a new one.
+     */
+    function transformNode(node, matrixInit) {
+      const transform = createSVGTransform();
+      const matrix = isSVGMatrix(matrixInit) ? matrixInit : createMatrix(matrixInit);
+      transform.setMatrix(matrix);
+      node.transform.baseVal.appendItem(transform);
+    }
+    const MATRIX_TYPE = '[object SVGMatrix]';
+
+    /**
+     * @param {any} obj
+     * @returns {boolean}
+     * @description Checks if the given object is an SVGMatrix.
+     */
+    function isSVGMatrix(obj) {
+      return Object.prototype.toString.call(obj) === MATRIX_TYPE;
+    }
+
+    /**
+     * @param {Partial<SVGMatrix>} matrixInit
+     * @returns {string}
+     * @description Converts a matrix to a transform string.
+     * If no matrix is provided, it returns the identity matrix string.
+     */
+    function matrixToTransformString(matrixInit = {}) {
+      const {
+        a = 1,
+        b = 0,
+        c = 0,
+        d = 1,
+        e = 0,
+        f = 0
+      } = matrixInit;
+      return `matrix(${a},${b},${c},${d},${e},${f})`;
+    }
+
+    /**
+     *
+     * @param {SVGElement} a
+     * @param {SVGElement} b
+     * @returns {SVGMatrix|null}
+     * @description Finds the transformation matrix from `a` to `b`.
+     * It requires that both elements to be visible (in the render tree)
+     * in order to calculate the correct transformation matrix.
+     */
+    function getRelativeTransformation(a, b) {
+      // Different SVG elements, no transformation possible
+      // Note: SVGSVGElement has no `ownerSVGElement`
+      if ((a.ownerSVGElement || a) !== (b.ownerSVGElement || b)) return null;
+      // Get the transformation matrix from `a` to `b`.
+      const am = b.getScreenCTM();
+      if (!am) return null;
+      const bm = a.getScreenCTM();
+      if (!bm) return null;
+      return am.inverse().multiply(bm);
+    }
+
+    /**
+     * @param {SVGElement} a
+     * @param {SVGElement} b
+     * @returns {SVGMatrix|null}
+     * @description Finds the transformation matrix from `a` to `b`.
+     * A safe way to calculate the transformation matrix between two elements.
+     * It does not require the elements to be visible (in the render tree).
+     */
+    function getRelativeTransformationSafe(a, b) {
+      if (a === b) {
+        // No transformation needed
+        return createIdentityMatrix();
+      }
+      const position = a.compareDocumentPosition(b);
+      if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {
+        // `b` is a descendant of `a`
+        return getLinealTransformation(a, b).inverse();
+      } else if (position & Node.DOCUMENT_POSITION_CONTAINS) {
+        // `a` is a descendant of `b`
+        return getLinealTransformation(b, a);
+      }
+      const c = getCommonAncestor(a, b);
+      if (!c) {
+        // No common ancestor
+        return null;
+      }
+      const mca = getLinealTransformation(c, a);
+      const mcb = getLinealTransformation(c, b);
+      return mcb.inverse().multiply(mca);
+    }
+
+    /**
+     * @param {SVGElement} descendant
+     * @param {SVGElement} ancestor
+     * @returns {SVGMatrix}
+     * @description Finds the transformation matrix between the `ancestor` and `descendant`.
+     */
+    function getLinealTransformation(ancestor, descendant) {
+      const transformations = [];
+      let n = descendant;
+      while (n && n.nodeType === Node.ELEMENT_NODE && n !== ancestor) {
+        const nm = getNodeMatrix(n);
+        if (nm) {
+          transformations.unshift(nm);
+        }
+        n = n.parentNode;
+      }
+      return transformations.reduce((m, t) => m.multiply(t), createIdentityMatrix());
+    }
 
     // Vectorizer.
-    const V = function () {
-      var hasSvg = typeof window === 'object' && !!window.SVGAngle;
+    // -----------
 
+    const V = function () {
       // SVG support is required.
-      if (!hasSvg) {
+      if (!isSVGSupported) {
         // Return a function that throws an error when it is used.
         return function () {
           throw new Error('SVG is required to use Vectorizer.');
         };
       }
 
-      // XML namespaces.
-      var ns = {
-        svg: 'http://www.w3.org/2000/svg',
-        xmlns: 'http://www.w3.org/2000/xmlns/',
-        xml: 'http://www.w3.org/XML/1998/namespace',
-        xlink: 'http://www.w3.org/1999/xlink',
-        xhtml: 'http://www.w3.org/1999/xhtml'
-      };
-      var SVGVersion = '1.1';
-
       // Declare shorthands to the most used math functions.
       var math = Math;
       var PI = math.PI;
@@ -5379,7 +5639,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
             }
             el = document.importNode(svgDoc.firstChild, true);
           } else {
-            el = document.createElementNS(ns.svg, el);
+            el = createSVGElement(el);
           }
           V.ensureId(el);
         }
@@ -5402,20 +5662,25 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       });
 
       /**
-       * @param {SVGGElement} toElem
-       * @returns {SVGMatrix}
+       * Calculates the transformation matrix from this element to the target element.
+       * @param {SVGElement|V} target - The target element.
+       * @param {Object} [opt] - Options object for transformation calculation.
+       * @param {boolean} [opt.safe] - Use a safe traversal method to compute the matrix.
+       * @returns {DOMMatrix} The transformation matrix from this element to the target element.
        */
-      VPrototype.getTransformToElement = function (target) {
-        var node = this.node;
-        if (V.isSVGGraphicsElement(target) && V.isSVGGraphicsElement(node)) {
-          var targetCTM = V.toNode(target).getScreenCTM();
-          var nodeCTM = node.getScreenCTM();
-          if (targetCTM && nodeCTM) {
-            return targetCTM.inverse().multiply(nodeCTM);
+      VPrototype.getTransformToElement = function (target, opt) {
+        const node = this.node;
+        const targetNode = V.toNode(target);
+        let m;
+        if (V.isSVGGraphicsElement(targetNode) && V.isSVGGraphicsElement(node)) {
+          if (opt && opt.safe) {
+            // Use the traversal method to get the transformation matrix.
+            m = getRelativeTransformationSafe(node, targetNode);
+          } else {
+            m = getRelativeTransformation(node, targetNode);
           }
         }
-        // Could not get actual transformation matrix
-        return V.createSVGMatrix();
+        return m || createIdentityMatrix();
       };
 
       /**
@@ -5424,15 +5689,19 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
        * @returns {Vectorizer|SVGMatrix} Setter / Getter
        */
       VPrototype.transform = function (matrix, opt) {
-        var node = this.node;
+        const node = this.node;
+
+        // Getter
         if (V.isUndefined(matrix)) {
-          return V.transformStringToMatrix(this.attr('transform'));
+          return getNodeMatrix(node) || createIdentityMatrix();
         }
+
+        // Setter
         if (opt && opt.absolute) {
-          return this.attr('transform', V.matrixToTransformString(matrix));
+          replaceTransformNode(node, matrix);
+        } else {
+          transformNode(node, matrix);
         }
-        var svgTransform = V.createSVGTransform(matrix);
-        node.transform.baseVal.appendItem(svgTransform);
         return this;
       };
       VPrototype.translate = function (tx, ty, opt) {
@@ -5506,7 +5775,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         }
         try {
           box = node.getBBox();
-        } catch (e) {
+        } catch {
           // Fallback for IE.
           box = {
             x: node.clientLeft,
@@ -5552,7 +5821,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         if (!options.recursive) {
           try {
             outputBBox = node.getBBox();
-          } catch (e) {
+          } catch {
             // Fallback for IE.
             outputBBox = {
               x: node.clientLeft,
@@ -5730,11 +5999,18 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       }
       VPrototype.text = function (content, opt) {
         if (content && typeof content !== 'string') throw new Error('Vectorizer: text() expects the first argument to be a string.');
-
-        // Replace all spaces with the Unicode No-break space (http://www.fileformat.info/info/unicode/char/a0/index.htm).
-        // IE would otherwise collapse all spaces into one.
-        content = V.sanitizeText(content);
         opt || (opt = {});
+
+        // Backwards-compatibility: if no content was provided, treat it as an
+        // empty string so that subsequent string operations (e.g. split) do
+        // not throw and behaviour matches the previous implementation that
+        // always sanitised the input.
+        if (content == null) content = '';
+        if (opt.useNoBreakSpace) {
+          // Replace all spaces with the Unicode No-break space (http://www.fileformat.info/info/unicode/char/a0/index.htm).
+          // IE would otherwise collapse all spaces into one.
+          content = V.sanitizeText(content);
+        }
         // Should we allow the text to be selected?
         var displayEmpty = opt.displayEmpty;
         // End of Line character
@@ -5790,7 +6066,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         for (var i = 0, lastI = lines.length - 1; i <= lastI; i++) {
           var dy = lineHeight;
           var lineClassName = 'v-line';
-          var lineNode = doc.createElementNS(ns.svg, 'tspan');
+          var lineNode = doc.createElementNS(svg, 'tspan');
           var line = lines[i];
           var lineMetrics;
           if (line) {
@@ -6104,9 +6380,9 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         try {
           var globalPoint = p.matrixTransform(svg.getScreenCTM().inverse());
           var globalToLocalMatrix = this.getTransformToElement(svg).inverse();
-        } catch (e) {
+        } catch {
           // IE9 throws an exception in odd cases. (`Unexpected call to method or property access`)
-          // We have to make do with the original coordianates.
+          // We have to make do with the original coordinates.
           return p;
         }
         return globalPoint.matrixTransform(globalToLocalMatrix);
@@ -6160,7 +6436,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         // 5. Apply transformations and the scale
         var transform = V.createSVGTransform();
         transform.setMatrix(translateFromOrigin.matrix.multiply(rotateAroundOrigin.matrix.multiply(translateToOrigin.matrix.multiply(ctm.scale(scale.sx, scale.sy)))));
-        this.attr('transform', V.matrixToTransformString(transform.matrix));
+        this.attr('transform', matrixToTransformString(transform.matrix));
         return this;
       };
       VPrototype.animateAlongPath = function (attrs, path) {
@@ -6174,7 +6450,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         this.append(animateMotion);
         try {
           animateMotion.node.beginElement();
-        } catch (e) {
+        } catch {
           // Fallback for IE 9.
           // Run the animation programmatically if FakeSmile (`http://leunen.me/fakesmile/`) present
           if (document.documentElement.getAttribute('smiling') === 'fake') {
@@ -6437,7 +6713,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       // If `content` is passed, it will be used as the SVG content of the `<svg>` root element.
       V.createSvgDocument = function (content) {
         if (content) {
-          const XMLString = `<svg xmlns="${ns.svg}" xmlns:xlink="${ns.xlink}" version="${SVGVersion}">${content}</svg>`;
+          const XMLString = `<svg xmlns="${svg}" xmlns:xlink="${xlink}" version="${SVG_VERSION}">${content}</svg>`;
           const {
             documentElement
           } = V.parseXML(XMLString, {
@@ -6445,10 +6721,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
           });
           return documentElement;
         }
-        const svg = document.createElementNS(ns.svg, 'svg');
-        svg.setAttributeNS(ns.xmlns, 'xmlns:xlink', ns.xlink);
-        svg.setAttribute('version', SVGVersion);
-        return svg;
+        return createSVGDocument();
       };
       V.createSVGStyle = function (stylesheet) {
         const {
@@ -6457,8 +6730,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
           type: 'text/css'
         }, [V.createCDATASection(stylesheet)]);
         return node;
-      }, V.createCDATASection = function () {
-        let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      }, V.createCDATASection = function (data = '') {
         const xml = document.implementation.createDocument(null, 'xml', null);
         return xml.createCDATASection(data);
       };
@@ -6481,6 +6753,9 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       // also exposed so that the programmer can use it in case he needs to. This is useful e.g. in tests
       // when you want to compare the actual DOM text content without having to add the unicode character in
       // the place of all spaces.
+      /**
+       * @deprecated Use regular spaces and rely on xml:space="preserve" instead.
+       */
       V.sanitizeText = function (text) {
         return (text || '').replace(/ /g, '\u00A0');
       };
@@ -6503,7 +6778,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
             parser.async = opt.async;
           }
           xml = parser.parseFromString(data, 'text/xml');
-        } catch (error) {
+        } catch {
           xml = undefined;
         }
         if (!xml || xml.getElementsByTagName('parsererror').length) {
@@ -6519,9 +6794,9 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
       // List of attributes for which not to split camel case words.
       // It contains known SVG attribute names and may be extended with user-defined attribute names.
-      ['baseFrequency', 'baseProfile', 'clipPathUnits', 'contentScriptType', 'contentStyleType', 'diffuseConstant', 'edgeMode', 'externalResourcesRequired', 'filterRes',
+      ['attributeName', 'baseFrequency', 'baseProfile', 'clipPathUnits', 'contentScriptType', 'contentStyleType', 'diffuseConstant', 'edgeMode', 'externalResourcesRequired', 'filterRes',
       // deprecated
-      'filterUnits', 'gradientTransform', 'gradientUnits', 'kernelMatrix', 'kernelUnitLength', 'keyPoints', 'lengthAdjust', 'limitingConeAngle', 'markerHeight', 'markerUnits', 'markerWidth', 'maskContentUnits', 'maskUnits', 'numOctaves', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'refX', 'refY', 'requiredExtensions', 'requiredFeatures', 'specularConstant', 'specularExponent', 'spreadMethod', 'startOffset', 'stdDeviation', 'stitchTiles', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textLength', 'viewBox', 'viewTarget',
+      'filterUnits', 'gradientTransform', 'gradientUnits', 'kernelMatrix', 'kernelUnitLength', 'keyPoints', 'lengthAdjust', 'limitingConeAngle', 'markerHeight', 'markerUnits', 'markerWidth', 'maskContentUnits', 'maskUnits', 'numOctaves', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'refX', 'refY', 'requiredExtensions', 'requiredFeatures', 'repeatCount', 'specularConstant', 'specularExponent', 'spreadMethod', 'startOffset', 'stdDeviation', 'stitchTiles', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textLength', 'viewBox', 'viewTarget',
       // deprecated
       'xChannelSelector', 'yChannelSelector', 'zoomAndPan' // deprecated
       ].forEach(name => _attributeNames[name] = name);
@@ -6588,86 +6863,19 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       // ReDoS mitigation: Use an anchor at the beginning of the match
       // ReDoS mitigation: Avoid backtracking (uses `[^()]+` instead of `.*?`)
       // ReDoS mitigation: Don't match initial `(` inside repeated part
-      // The following regex needs to use /g (= cannot use capturing groups)
-      V.transformRegex = /\b\w+\([^()]+\)/g;
       // The following regexes need to use capturing groups (= cannot use /g)
       V.transformFunctionRegex = /\b(\w+)\(([^()]+)\)/;
       V.transformTranslateRegex = /\btranslate\(([^()]+)\)/;
       V.transformRotateRegex = /\brotate\(([^()]+)\)/;
       V.transformScaleRegex = /\bscale\(([^()]+)\)/;
       V.transformStringToMatrix = function (transform) {
-        // Initialize result matrix as identity matrix
-        let transformationMatrix = V.createSVGMatrix();
-
-        // Note: Multiple transform functions are allowed in `transform` string
-        // `match()` returns `null` if none found
-        const transformMatches = transform && transform.match(V.transformRegex);
-        if (!transformMatches) {
-          // Return identity matrix
-          return transformationMatrix;
-        }
-        const numMatches = transformMatches.length;
-        for (let i = 0; i < numMatches; i++) {
-          const transformMatch = transformMatches[i];
-          // Use same regex as above, but with capturing groups
-          // `match()` returns values of capturing groups as `[1]`, `[2]`
-          const transformFunctionMatch = transformMatch.match(V.transformFunctionRegex);
-          if (transformFunctionMatch) {
-            let sx, sy, tx, ty, angle;
-            let ctm = V.createSVGMatrix();
-            const transformFunction = transformFunctionMatch[1].toLowerCase();
-            const args = transformFunctionMatch[2].split(V.transformSeparatorRegex);
-            switch (transformFunction) {
-              case 'scale':
-                sx = parseFloat(args[0]);
-                sy = args[1] === undefined ? sx : parseFloat(args[1]);
-                ctm = ctm.scaleNonUniform(sx, sy);
-                break;
-              case 'translate':
-                tx = parseFloat(args[0]);
-                ty = parseFloat(args[1]);
-                ctm = ctm.translate(tx, ty);
-                break;
-              case 'rotate':
-                angle = parseFloat(args[0]);
-                tx = parseFloat(args[1]) || 0;
-                ty = parseFloat(args[2]) || 0;
-                if (tx !== 0 || ty !== 0) {
-                  ctm = ctm.translate(tx, ty).rotate(angle).translate(-tx, -ty);
-                } else {
-                  ctm = ctm.rotate(angle);
-                }
-                break;
-              case 'skewx':
-                angle = parseFloat(args[0]);
-                ctm = ctm.skewX(angle);
-                break;
-              case 'skewy':
-                angle = parseFloat(args[0]);
-                ctm = ctm.skewY(angle);
-                break;
-              case 'matrix':
-                ctm.a = parseFloat(args[0]);
-                ctm.b = parseFloat(args[1]);
-                ctm.c = parseFloat(args[2]);
-                ctm.d = parseFloat(args[3]);
-                ctm.e = parseFloat(args[4]);
-                ctm.f = parseFloat(args[5]);
-                break;
-              default:
-                continue;
-            }
-
-            // Multiply current transformation into result matrix
-            transformationMatrix = transformationMatrix.multiply(ctm);
-          }
+        let matrix;
+        if (V.isString(transform)) {
+          matrix = createMatrixFromTransformString(transform);
         }
-        return transformationMatrix;
-      };
-      V.matrixToTransformString = function (matrix) {
-        matrix || (matrix = true);
-        return 'matrix(' + (matrix.a !== undefined ? matrix.a : 1) + ',' + (matrix.b !== undefined ? matrix.b : 0) + ',' + (matrix.c !== undefined ? matrix.c : 0) + ',' + (matrix.d !== undefined ? matrix.d : 1) + ',' + (matrix.e !== undefined ? matrix.e : 0) + ',' + (matrix.f !== undefined ? matrix.f : 0) + ')';
+        return matrix || createIdentityMatrix();
       };
+      V.matrixToTransformString = matrixToTransformString;
       V.parseTransformString = function (transform) {
         var translate, rotate, scale;
         if (transform) {
@@ -6825,31 +7033,24 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
         // IE/Edge does not implement SVGGraphicsElement interface, thus check for `getScreenCTM` below
         return node instanceof SVGElement && typeof node.getScreenCTM === 'function';
       };
-      var svgDocument = V('svg').node;
-      V.createSVGMatrix = function (matrix) {
-        var svgMatrix = svgDocument.createSVGMatrix();
-        for (var component in matrix) {
-          svgMatrix[component] = matrix[component];
-        }
-        return svgMatrix;
-      };
+      V.createSVGMatrix = createMatrix;
       V.createSVGTransform = function (matrix) {
         if (!V.isUndefined(matrix)) {
-          if (!(matrix instanceof SVGMatrix)) {
-            matrix = V.createSVGMatrix(matrix);
+          if (!isSVGMatrix(matrix)) {
+            matrix = createMatrix(matrix);
           }
-          return svgDocument.createSVGTransformFromMatrix(matrix);
+          return internalSVGDocument.createSVGTransformFromMatrix(matrix);
         }
-        return svgDocument.createSVGTransform();
+        return internalSVGDocument.createSVGTransform();
       };
       V.createSVGPoint = function (x, y) {
-        var p = svgDocument.createSVGPoint();
+        var p = internalSVGDocument.createSVGPoint();
         p.x = x;
         p.y = y;
         return p;
       };
       V.transformRect = function (r, matrix) {
-        var p = svgDocument.createSVGPoint();
+        var p = internalSVGDocument.createSVGPoint();
         p.x = r.x;
         p.y = r.y;
         var corner1 = p.matrixTransform(matrix);
@@ -7041,7 +7242,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
       };
       V.convertLineToPathData = function (line) {
         line = V(line);
-        var d = ['M', line.attr('x1'), line.attr('y1'), 'L', line.attr('x2'), line.attr('y2')].join(' ');
+        var d = ['M', line.attr('x1') || '0', line.attr('y1') || '0', 'L', line.attr('x2') || '0', line.attr('y2') || '0'].join(' ');
         return d;
       };
       V.convertPolygonToPathData = function (polygon) {
@@ -7451,10 +7652,6 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
               case 'V':
                 path = ['L'].concat(d.x, path[1]);
                 break;
-              case 'L':
-                break;
-              case 'Z':
-                break;
             }
             return path;
           }
@@ -7509,7 +7706,20 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
           return normalize(pathData).join(',').split(',').join(' ');
         };
       }();
-      V.namespace = ns;
+
+      /**
+       *
+       * @param {SVGElement|V} node1
+       * @param {SVGElement|V} node2
+       * @returns {SVGElement|null}
+       */
+      V.getCommonAncestor = function (node1, node2) {
+        if (!node1 || !node2) return null;
+        return getCommonAncestor(V.toNode(node1), V.toNode(node2));
+      };
+      V.namespace = {
+        ...ns
+      };
       V.g = g;
       return V;
     }();