@svgedit/svgcanvas 7.2.4 → 7.2.7

package/dist/svgcanvas.js

@@ -1520,7 +1520,7 @@ function _mergeNamespaces(n, m) {
 class Paint {
   /**
    * @param {module:jGraduate.jGraduatePaintOptions} [opt]
-  */
+   */
   constructor(opt) {
     const options = opt || {};
     this.alpha = isNaN(options.alpha) ? 100 : options.alpha;
@@ -1571,8 +1571,9 @@ class Paint {
       this.type = 'linearGradient';
       this.solidColor = null;
       this.radialGradient = null;
-      if (options.linearGradient.hasAttribute('xlink:href')) {
-        const xhref = document.getElementById(options.linearGradient.getAttribute('xlink:href').substr(1));
+      const hrefAttr = options.linearGradient.getAttribute('href') || options.linearGradient.getAttribute('xlink:href');
+      if (hrefAttr) {
+        const xhref = document.getElementById(hrefAttr.replace(/^#/, ''));
         this.linearGradient = xhref.cloneNode(true);
       } else {
         this.linearGradient = options.linearGradient.cloneNode(true);
@@ -1582,8 +1583,9 @@ class Paint {
       this.type = 'radialGradient';
       this.solidColor = null;
       this.linearGradient = null;
-      if (options.radialGradient.hasAttribute('xlink:href')) {
-        const xhref = document.getElementById(options.radialGradient.getAttribute('xlink:href').substr(1));
+      const hrefAttr = options.radialGradient.getAttribute('href') || options.radialGradient.getAttribute('xlink:href');
+      if (hrefAttr) {
+        const xhref = document.getElementById(hrefAttr.replace(/^#/, ''));
         this.radialGradient = xhref.cloneNode(true);
       } else {
         this.radialGradient = options.radialGradient.cloneNode(true);
@@ -2584,21 +2586,22 @@ const getUrlFromAttr = function (attrVal) {
 /**
  * @function module:utilities.getHref
  * @param {Element} elem
- * @returns {string} The given element's `xlink:href` value
+ * @returns {string} The given element's `href` value
  */
 let getHref = function (elem) {
-  return elem.getAttributeNS(NS.XLINK, 'href');
+  // Prefer 'href', fallback to 'xlink:href'
+  return elem.getAttribute('href') || elem.getAttributeNS(NS.XLINK, 'href');
 };
 
 /**
- * Sets the given element's `xlink:href` value.
+ * Sets the given element's `href` value.
  * @function module:utilities.setHref
  * @param {Element} elem
  * @param {string} val
  * @returns {void}
  */
 let setHref = function (elem, val) {
-  elem.setAttributeNS(NS.XLINK, 'xlink:href', val);
+  elem.setAttribute('href', val);
 };
 
 /**
@@ -2773,8 +2776,7 @@ const getPathDFromElement = function (elem) {
         const h = b.height;
         num = 4 - num; // Why? Because!
 
-        d = !rx && !ry
-        // Regular rect
+        d = !rx && !ry // Regular rect
         ? getPathDFromSegments([['M', [x, y]], ['L', [x + w, y]], ['L', [x + w, y + h]], ['L', [x, y + h]], ['L', [x, y]], ['Z', []]]) : 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;
       }
@@ -3738,7 +3740,7 @@ let BatchCommand$4 = class BatchCommand extends Command {
   */
   unapply(handler) {
     super.unapply(handler, () => {
-      this.stack.reverse().forEach(stackItem => {
+      [...this.stack].reverse().forEach(stackItem => {
         console.assert(stackItem, 'stack item should not be null');
         stackItem && stackItem.unapply(handler);
       });
@@ -4975,7 +4977,7 @@ class Path {
  */
 
 let svgCanvas$g = null;
-let path$1 = null;
+let path$2 = null;
 
 /**
 * @function module:path-actions.init
@@ -5357,7 +5359,7 @@ const pathActionsMethod = function () {
           }));
           // set stretchy line to first point
           stretchy.setAttribute('d', ['M', mouseX, mouseY, mouseX, mouseY].join(' '));
-          index = subpath ? path$1.segs.length : 0;
+          index = subpath ? path$2.segs.length : 0;
           svgCanvas$g.addPointGrip(index, mouseX, mouseY);
         } else {
           // determine if we clicked on an existing point
@@ -5414,18 +5416,18 @@ const pathActionsMethod = function () {
             svgCanvas$g.setDrawnPath(null);
             svgCanvas$g.setStarted(false);
             if (subpath) {
-              if (path$1.matrix) {
-                svgCanvas$g.remapElement(newpath, {}, path$1.matrix.inverse());
+              if (path$2.matrix) {
+                svgCanvas$g.remapElement(newpath, {}, path$2.matrix.inverse());
               }
               const newD = newpath.getAttribute('d');
-              const origD = path$1.elem.getAttribute('d');
-              path$1.elem.setAttribute('d', origD + newD);
+              const origD = path$2.elem.getAttribute('d');
+              path$2.elem.setAttribute('d', origD + newD);
               newpath.parentNode.removeChild(newpath);
-              if (path$1.matrix) {
+              if (path$2.matrix) {
                 svgCanvas$g.recalcRotatedPath();
               }
-              pathActionsMethod.toEditMode(path$1.elem);
-              path$1.selectPt();
+              pathActionsMethod.toEditMode(path$2.elem);
+              path$2.selectPt();
               return false;
             }
             // else, create a new point, update path element
@@ -5458,7 +5460,7 @@ const pathActionsMethod = function () {
             stretchy.setAttribute('d', ['M', x, y, x, y].join(' '));
             index = num;
             if (subpath) {
-              index += path$1.segs.length;
+              index += path$2.segs.length;
             }
             svgCanvas$g.addPointGrip(index, x, y);
           }
@@ -5468,42 +5470,42 @@ const pathActionsMethod = function () {
       }
 
       // TODO: Make sure currentPath isn't null at this point
-      if (!path$1) {
+      if (!path$2) {
         return undefined;
       }
-      path$1.storeD();
+      path$2.storeD();
       ({
         id
       } = evt.target);
       let curPt;
       if (id.substr(0, 14) === 'pathpointgrip_') {
         // Select this point
-        curPt = path$1.cur_pt = Number.parseInt(id.substr(14));
-        path$1.dragging = [startX, startY];
-        const seg = path$1.segs[curPt];
+        curPt = path$2.cur_pt = Number.parseInt(id.substr(14));
+        path$2.dragging = [startX, startY];
+        const seg = path$2.segs[curPt];
 
         // only clear selection if shift is not pressed (otherwise, add
         // node to selection)
         if (!evt.shiftKey) {
-          if (path$1.selected_pts.length <= 1 || !seg.selected) {
-            path$1.clearSelection();
+          if (path$2.selected_pts.length <= 1 || !seg.selected) {
+            path$2.clearSelection();
           }
-          path$1.addPtsToSelection(curPt);
+          path$2.addPtsToSelection(curPt);
         } else if (seg.selected) {
-          path$1.removePtFromSelection(curPt);
+          path$2.removePtFromSelection(curPt);
         } else {
-          path$1.addPtsToSelection(curPt);
+          path$2.addPtsToSelection(curPt);
         }
       } else if (id.startsWith('ctrlpointgrip_')) {
-        path$1.dragging = [startX, startY];
+        path$2.dragging = [startX, startY];
         const parts = id.split('_')[1].split('c');
         curPt = Number(parts[0]);
         const ctrlNum = Number(parts[1]);
-        path$1.selectPt(curPt, ctrlNum);
+        path$2.selectPt(curPt, ctrlNum);
       }
 
       // Start selection box
-      if (!path$1.dragging) {
+      if (!path$2.dragging) {
         let rubberBox = svgCanvas$g.getRubberBox();
         if (!rubberBox) {
           rubberBox = svgCanvas$g.setRubberBox(svgCanvas$g.selectorManager.getRubberBandBox());
@@ -5599,26 +5601,26 @@ const pathActionsMethod = function () {
         return;
       }
       // if we are dragging a point, let's move it
-      if (path$1.dragging) {
+      if (path$2.dragging) {
         const pt = svgCanvas$g.getPointFromGrip({
-          x: path$1.dragging[0],
-          y: path$1.dragging[1]
-        }, path$1);
+          x: path$2.dragging[0],
+          y: path$2.dragging[1]
+        }, path$2);
         const mpt = svgCanvas$g.getPointFromGrip({
           x: mouseX,
           y: mouseY
-        }, path$1);
+        }, path$2);
         const diffX = mpt.x - pt.x;
         const diffY = mpt.y - pt.y;
-        path$1.dragging = [mouseX, mouseY];
-        if (path$1.dragctrl) {
-          path$1.moveCtrl(diffX, diffY);
+        path$2.dragging = [mouseX, mouseY];
+        if (path$2.dragctrl) {
+          path$2.moveCtrl(diffX, diffY);
         } else {
-          path$1.movePts(diffX, diffY);
+          path$2.movePts(diffX, diffY);
         }
       } else {
-        path$1.selected_pts = [];
-        path$1.eachSeg(function (_i) {
+        path$2.selected_pts = [];
+        path$2.eachSeg(function (_i) {
           const seg = this;
           if (!seg.next && !seg.prev) {
             return;
@@ -5638,7 +5640,7 @@ const pathActionsMethod = function () {
           this.select(sel);
           // Note that addPtsToSelection is not being run
           if (sel) {
-            path$1.selected_pts.push(seg.index);
+            path$2.selected_pts.push(seg.index);
           }
         });
       }
@@ -5674,16 +5676,16 @@ const pathActionsMethod = function () {
 
       // Edit mode
       const rubberBox = svgCanvas$g.getRubberBox();
-      if (path$1.dragging) {
-        const lastPt = path$1.cur_pt;
-        path$1.dragging = false;
-        path$1.dragctrl = false;
-        path$1.update();
+      if (path$2.dragging) {
+        const lastPt = path$2.cur_pt;
+        path$2.dragging = false;
+        path$2.dragctrl = false;
+        path$2.update();
         if (hasMoved) {
-          path$1.endChanges('Move path point(s)');
+          path$2.endChanges('Move path point(s)');
         }
         if (!evt.shiftKey && !hasMoved) {
-          path$1.selectPt(lastPt);
+          path$2.selectPt(lastPt);
         }
       } else if (rubberBox?.getAttribute('display') !== 'none') {
         // Done with multi-node-select
@@ -5704,12 +5706,12 @@ const pathActionsMethod = function () {
     * @returns {void}
     */
     toEditMode(element) {
-      path$1 = svgCanvas$g.getPath_(element);
+      path$2 = svgCanvas$g.getPath_(element);
       svgCanvas$g.setCurrentMode('pathedit');
       svgCanvas$g.clearSelection();
-      path$1.setPathContext();
-      path$1.show(true).update();
-      path$1.oldbbox = getBBox(path$1.elem);
+      path$2.setPathContext();
+      path$2.show(true).update();
+      path$2.oldbbox = getBBox(path$2.elem);
       subpath = false;
     },
     /**
@@ -5718,13 +5720,13 @@ const pathActionsMethod = function () {
     * @returns {void}
     */
     toSelectMode(elem) {
-      const selPath = elem === path$1.elem;
+      const selPath = elem === path$2.elem;
       svgCanvas$g.setCurrentMode('select');
-      path$1.setPathContext();
-      path$1.show(false);
+      path$2.setPathContext();
+      path$2.show(false);
       currentPath = false;
       svgCanvas$g.clearSelection();
-      if (path$1.matrix) {
+      if (path$2.matrix) {
         // Rotated, so may need to re-calculate the center
         svgCanvas$g.recalcRotatedPath();
       }
@@ -5745,7 +5747,7 @@ const pathActionsMethod = function () {
         subpath = true;
       } else {
         pathActionsMethod.clear(true);
-        pathActionsMethod.toEditMode(path$1.elem);
+        pathActionsMethod.toEditMode(path$2.elem);
       }
     },
     /**
@@ -5813,8 +5815,8 @@ const pathActionsMethod = function () {
       } else if (svgCanvas$g.getCurrentMode() === 'pathedit') {
         this.toSelectMode();
       }
-      if (path$1) {
-        path$1.init().show(false);
+      if (path$2) {
+        path$2.init().show(false);
       }
     },
     /**
@@ -5869,7 +5871,7 @@ const pathActionsMethod = function () {
     */
     zoomChange() {
       if (svgCanvas$g.getCurrentMode() === 'pathedit') {
-        path$1.update();
+        path$2.update();
       }
     },
     /**
@@ -5882,8 +5884,8 @@ const pathActionsMethod = function () {
     * @returns {module:path.NodePoint}
     */
     getNodePoint() {
-      const selPt = path$1.selected_pts.length ? path$1.selected_pts[0] : 1;
-      const seg = path$1.segs[selPt];
+      const selPt = path$2.selected_pts.length ? path$2.selected_pts[0] : 1;
+      const seg = path$2.segs[selPt];
       return {
         x: seg.item.x,
         y: seg.item.y,
@@ -5901,33 +5903,33 @@ const pathActionsMethod = function () {
     * @returns {void}
     */
     clonePathNode() {
-      path$1.storeD();
-      const selPts = path$1.selected_pts;
+      path$2.storeD();
+      const selPts = path$2.selected_pts;
       // const {segs} = path;
 
       let i = selPts.length;
       const nums = [];
       while (i--) {
         const pt = selPts[i];
-        path$1.addSeg(pt);
+        path$2.addSeg(pt);
         nums.push(pt + i);
         nums.push(pt + i + 1);
       }
-      path$1.init().addPtsToSelection(nums);
-      path$1.endChanges('Clone path node(s)');
+      path$2.init().addPtsToSelection(nums);
+      path$2.endChanges('Clone path node(s)');
     },
     /**
     * @returns {void}
     */
     opencloseSubPath() {
-      const selPts = path$1.selected_pts;
+      const selPts = path$2.selected_pts;
       // Only allow one selected node for now
       if (selPts.length !== 1) {
         return;
       }
       const {
         elem
-      } = path$1;
+      } = path$2;
       const list = elem.pathSegList;
 
       // const len = list.numberOfItems;
@@ -5937,7 +5939,7 @@ const pathActionsMethod = function () {
       let startItem = null;
 
       // Check if subpath is already open
-      path$1.eachSeg(function (i) {
+      path$2.eachSeg(function (i) {
         if (this.type === 2 && i <= index) {
           startItem = this.item;
         }
@@ -5958,7 +5960,7 @@ const pathActionsMethod = function () {
       });
       if (!openPt) {
         // Single path, so close last seg
-        openPt = path$1.segs.length - 1;
+        openPt = path$2.segs.length - 1;
       }
       if (openPt !== false) {
         // Close this path
@@ -5966,14 +5968,14 @@ const pathActionsMethod = function () {
         // Create a line going to the previous "M"
         const newseg = elem.createSVGPathSegLinetoAbs(startItem.x, startItem.y);
         const closer = elem.createSVGPathSegClosePath();
-        if (openPt === path$1.segs.length - 1) {
+        if (openPt === path$2.segs.length - 1) {
           list.appendItem(newseg);
           list.appendItem(closer);
         } else {
           list.insertItemBefore(closer, openPt);
           list.insertItemBefore(newseg, openPt);
         }
-        path$1.init().selectPt(openPt + 1);
+        path$2.init().selectPt(openPt + 1);
         return;
       }
 
@@ -5983,11 +5985,11 @@ const pathActionsMethod = function () {
       // 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
 
-      const seg = path$1.segs[index];
+      const seg = path$2.segs[index];
       if (seg.mate) {
         list.removeItem(index); // Removes last "L"
         list.removeItem(index); // Removes the "Z"
-        path$1.init().selectPt(index - 1);
+        path$2.init().selectPt(index - 1);
         return;
       }
       let lastM;
@@ -6021,7 +6023,7 @@ const pathActionsMethod = function () {
 
       // i = index; // i is local here, so has no effect; what was the intent for this?
 
-      path$1.init().selectPt(0);
+      path$2.init().selectPt(0);
     },
     /**
     * @returns {void}
@@ -6030,17 +6032,17 @@ const pathActionsMethod = function () {
       if (!pathActionsMethod.canDeleteNodes) {
         return;
       }
-      path$1.storeD();
-      const selPts = path$1.selected_pts;
+      path$2.storeD();
+      const selPts = path$2.selected_pts;
       let i = selPts.length;
       while (i--) {
         const pt = selPts[i];
-        path$1.deleteSeg(pt);
+        path$2.deleteSeg(pt);
       }
 
       // Cleanup
       const cleanup = function () {
-        const segList = path$1.elem.pathSegList;
+        const segList = path$2.elem.pathSegList;
         let len = segList.numberOfItems;
         const remItems = function (pos, count) {
           while (count--) {
@@ -6084,21 +6086,21 @@ const pathActionsMethod = function () {
       cleanup();
 
       // Completely delete a path with 1 or 0 segments
-      if (path$1.elem.pathSegList.numberOfItems <= 1) {
-        pathActionsMethod.toSelectMode(path$1.elem);
+      if (path$2.elem.pathSegList.numberOfItems <= 1) {
+        pathActionsMethod.toSelectMode(path$2.elem);
         svgCanvas$g.canvas.deleteSelectedElements();
         return;
       }
-      path$1.init();
-      path$1.clearSelection();
+      path$2.init();
+      path$2.clearSelection();
 
       // TODO: Find right way to select point now
       // path.selectPt(selPt);
       if (window.opera) {
         // Opera repaints incorrectly
-        path$1.elem.setAttribute('d', path$1.elem.getAttribute('d'));
+        path$2.elem.setAttribute('d', path$2.elem.getAttribute('d'));
       }
-      path$1.endChanges('Delete path node(s)');
+      path$2.endChanges('Delete path node(s)');
     },
     // Can't seem to use `@borrows` here, so using `@see`
     /**
@@ -6113,7 +6115,7 @@ const pathActionsMethod = function () {
     * @returns {void}
     */
     setSegType(v) {
-      path$1?.setSegType(v);
+      path$2?.setSegType(v);
     },
     /**
     * @param {string} attr
@@ -6121,21 +6123,21 @@ const pathActionsMethod = function () {
     * @returns {void}
     */
     moveNode(attr, newValue) {
-      const selPts = path$1.selected_pts;
+      const selPts = path$2.selected_pts;
       if (!selPts.length) {
         return;
       }
-      path$1.storeD();
+      path$2.storeD();
 
       // Get first selected point
-      const seg = path$1.segs[selPts[0]];
+      const seg = path$2.segs[selPts[0]];
       const diff = {
         x: 0,
         y: 0
       };
       diff[attr] = newValue - seg.item[attr];
       seg.move(diff.x, diff.y);
-      path$1.endChanges('Move path point');
+      path$2.endChanges('Move path point');
     },
     /**
     * @param {Element} elem
@@ -6243,7 +6245,7 @@ const setLinkControlPoints = lcp => {
  * @type {null|module:path.Path}
  * @memberof module:path
 */
-let path = null;
+let path$1 = null;
 
 /**
 * @external MouseEvent
@@ -6412,10 +6414,10 @@ const init$g = canvas => {
     return uiStrings;
   };
   svgCanvas$f.getPathObj = () => {
-    return path;
+    return path$1;
   };
   svgCanvas$f.setPathObj = obj => {
-    path = obj;
+    path$1 = obj;
   };
   svgCanvas$f.getPathFuncs = () => {
     return pathFuncs;
@@ -6646,13 +6648,13 @@ const getRotVals = (x, y) => {
 * @returns {void}
 */
 const recalcRotatedPath = () => {
-  const currentPath = path.elem;
+  const currentPath = path$1.elem;
   angle = getRotationAngle(currentPath, true);
   if (!angle) {
     return;
   }
   // selectedBBoxes[0] = path.oldbbox;
-  const oldbox = path.oldbbox; // selectedBBoxes[0],
+  const oldbox = path$1.oldbbox; // selectedBBoxes[0],
   oldcx = oldbox.x + oldbox.width / 2;
   oldcy = oldbox.y + oldbox.height / 2;
   const box = getBBox(currentPath);
@@ -6999,7 +7001,7 @@ var pathModule = /*#__PURE__*/Object.freeze({
     getPointGrip: getPointGrip,
     getSegSelector: getSegSelector,
     init: init$g,
-    get path () { return path; },
+    get path () { return path$1; },
     pathActions: pathActions,
     ptObjToArr: ptObjToArr,
     recalcRotatedPath: recalcRotatedPath,
@@ -10618,9 +10620,18 @@ const mouseUpEvent = evt => {
         const elem = selectedElements[0];
         if (elem) {
           elem.removeAttribute('style');
-          walkTree(elem, el => {
-            el.removeAttribute('style');
-          });
+
+          // we don't remove the style elements for contents of foreignObjects
+          // because that is a valid way to style them
+          if (elem.localName === 'foreignObject') {
+            walkTree(elem, el => {
+              el.style.removeProperty('pointer-events');
+            });
+          } else {
+            walkTree(elem, el => {
+              el.removeAttribute('style');
+            });
+          }
         }
       }
       return;
@@ -13086,12 +13097,37 @@ const recalculateDimensions = selected => {
     // Handle rotation transformations
     const angle = getRotationAngle(selected);
     if (angle) {
-      // Include x and y in the rotation center calculation
-      oldcenter = {
-        x: box.x + box.width / 2 + x,
-        y: box.y + box.height / 2 + y
-      };
-      newcenter = transformPoint(box.x + box.width / 2 + x, box.y + box.height / 2 + y, transformListToTransform(tlist).matrix);
+      if (selected.localName === 'image') {
+        // Use the center of the image as the rotation center
+        const xAttr = convertToNum('x', selected.getAttribute('x') || '0');
+        const yAttr = convertToNum('y', selected.getAttribute('y') || '0');
+        const width = convertToNum('width', selected.getAttribute('width') || '0');
+        const height = convertToNum('height', selected.getAttribute('height') || '0');
+        const cx = xAttr + width / 2;
+        const cy = yAttr + height / 2;
+        oldcenter = {
+          x: cx,
+          y: cy
+        };
+        const transform = transformListToTransform(tlist).matrix;
+        newcenter = transformPoint(cx, cy, transform);
+      } else if (selected.localName === 'text') {
+        // Use the center of the bounding box as the rotation center for text
+        const cx = box.x + box.width / 2;
+        const cy = box.y + box.height / 2;
+        oldcenter = {
+          x: cx,
+          y: cy
+        };
+        newcenter = transformPoint(cx, cy, transformListToTransform(tlist).matrix);
+      } else {
+        // Include x and y in the rotation center calculation for other elements
+        oldcenter = {
+          x: box.x + box.width / 2 + x,
+          y: box.y + box.height / 2 + y
+        };
+        newcenter = transformPoint(box.x + box.width / 2 + x, box.y + box.height / 2 + y, transformListToTransform(tlist).matrix);
+      }
 
       // Remove the rotation transform from the list
       for (let i = 0; i < tlist.numberOfItems; ++i) {
@@ -14606,7 +14642,7 @@ const REVERSE_NS = getReverseNS();
 const svgGenericWhiteList = ['class', 'id', 'display', 'transform', 'style'];
 const svgWhiteList_ = {
   // SVG Elements
-  a: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'mask', 'opacity', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'xlink:href', 'xlink:title'],
+  a: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'href', 'mask', 'opacity', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'xlink:href', 'xlink:title'],
   circle: ['clip-path', 'clip-rule', 'cx', 'cy', 'enable-background', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'mask', 'opacity', 'r', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage'],
   clipPath: ['clipPathUnits'],
   defs: [],
@@ -14621,20 +14657,20 @@ const svgWhiteList_ = {
   feMergeNode: ['in'],
   feMorphology: ['in', 'operator', 'radius'],
   feOffset: ['dx', 'in', 'dy', 'result'],
-  filter: ['color-interpolation-filters', 'filterRes', 'filterUnits', 'height', 'primitiveUnits', 'requiredFeatures', 'width', 'x', 'xlink:href', 'y'],
+  filter: ['color-interpolation-filters', 'filterRes', 'filterUnits', 'height', 'href', 'primitiveUnits', 'requiredFeatures', 'width', 'x', 'xlink:href', 'y'],
   foreignObject: ['font-size', 'height', 'opacity', 'requiredFeatures', 'width', 'x', 'y'],
   g: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'font-family', 'font-size', 'font-style', 'font-weight', 'text-anchor'],
-  image: ['clip-path', 'clip-rule', 'filter', 'height', 'mask', 'opacity', 'requiredFeatures', 'systemLanguage', 'width', 'x', 'xlink:href', 'xlink:title', 'y'],
+  image: ['clip-path', 'clip-rule', 'filter', 'height', 'mask', 'opacity', 'requiredFeatures', 'systemLanguage', 'width', 'x', 'href', 'xlink:href', 'xlink:title', 'y'],
   line: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'x1', 'x2', 'y1', 'y2'],
-  linearGradient: ['gradientTransform', 'gradientUnits', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'x1', 'x2', 'xlink:href', 'y1', 'y2'],
+  linearGradient: ['gradientTransform', 'gradientUnits', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'x1', 'x2', 'href', 'xlink:href', 'y1', 'y2'],
   marker: ['markerHeight', 'markerUnits', 'markerWidth', 'orient', 'preserveAspectRatio', 'refX', 'refY', 'se_type', 'systemLanguage', 'viewBox'],
   mask: ['height', 'maskContentUnits', 'maskUnits', 'width', 'x', 'y'],
   metadata: [],
   path: ['clip-path', 'clip-rule', 'd', 'enable-background', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage'],
-  pattern: ['height', 'patternContentUnits', 'patternTransform', 'patternUnits', 'requiredFeatures', 'systemLanguage', 'viewBox', 'width', 'x', 'xlink:href', 'y'],
+  pattern: ['height', 'patternContentUnits', 'patternTransform', 'patternUnits', 'requiredFeatures', 'systemLanguage', 'viewBox', 'width', 'x', 'href', 'xlink:href', 'y'],
   polygon: ['clip-path', 'clip-rule', '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', 'systemLanguage', 'sides', 'shape', 'edge', 'point', 'starRadiusMultiplier', 'r', 'radialshift', 'r2', 'orient', 'cx', 'cy'],
   polyline: ['clip-path', 'clip-rule', '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', 'systemLanguage', 'se:connector'],
-  radialGradient: ['cx', 'cy', 'fx', 'fy', 'gradientTransform', 'gradientUnits', 'r', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'xlink:href'],
+  radialGradient: ['cx', 'cy', 'fx', 'fy', 'gradientTransform', 'gradientUnits', 'r', 'requiredFeatures', 'spreadMethod', 'systemLanguage', 'href', 'xlink:href'],
   rect: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'mask', 'opacity', 'requiredFeatures', 'rx', 'ry', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'width', 'x', 'y'],
   stop: ['offset', 'requiredFeatures', 'stop-opacity', 'systemLanguage', 'stop-color', 'gradientUnits', 'gradientTransform'],
   style: ['type'],
@@ -14642,10 +14678,22 @@ const svgWhiteList_ = {
   switch: ['requiredFeatures', 'systemLanguage'],
   symbol: ['fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'opacity', 'overflow', 'preserveAspectRatio', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'viewBox', 'width', 'height'],
   text: ['clip-path', 'clip-rule', 'dominant-baseline', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'mask', 'opacity', 'requiredFeatures', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'text-anchor', 'letter-spacing', 'word-spacing', 'text-decoration', 'textLength', 'lengthAdjust', 'x', 'xml:space', 'y'],
-  textPath: ['dominant-baseline', 'method', 'requiredFeatures', 'spacing', 'startOffset', 'systemLanguage', 'xlink:href'],
+  textPath: ['dominant-baseline', 'href', 'method', 'requiredFeatures', 'spacing', 'startOffset', 'systemLanguage', 'xlink:href'],
   title: [],
   tspan: ['clip-path', 'clip-rule', 'dx', 'dy', 'dominant-baseline', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'font-family', 'font-size', 'font-style', 'font-weight', 'mask', 'opacity', 'requiredFeatures', 'rotate', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage', 'text-anchor', 'textLength', 'x', 'xml:space', 'y'],
-  use: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'mask', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'width', 'x', 'xlink:href', 'y', 'overflow'],
+  use: ['clip-path', 'clip-rule', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'height', 'href', 'mask', 'stroke', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'width', 'x', 'xlink:href', 'y', 'overflow'],
+  // Filter Primitives
+  feComponentTransfer: ['in', 'result'],
+  feFuncR: ['type', 'tableValues', 'slope', 'intercept', 'amplitude', 'exponent', 'offset'],
+  feFuncG: ['type', 'tableValues', 'slope', 'intercept', 'amplitude', 'exponent', 'offset'],
+  feFuncB: ['type', 'tableValues', 'slope', 'intercept', 'amplitude', 'exponent', 'offset'],
+  feFuncA: ['type', 'tableValues', 'slope', 'intercept', 'amplitude', 'exponent', 'offset'],
+  feConvolveMatrix: ['in', 'order', 'kernelMatrix', 'divisor', 'bias', 'targetX', 'targetY', 'edgeMode', 'kernelUnitLength', 'preserveAlpha'],
+  feDiffuseLighting: ['in', 'surfaceScale', 'diffuseConstant', 'kernelUnitLength', 'lighting-color'],
+  feSpecularLighting: ['in', 'surfaceScale', 'specularConstant', 'specularExponent', 'kernelUnitLength', 'lighting-color'],
+  feDisplacementMap: ['in', 'in2', 'scale', 'xChannelSelector', 'yChannelSelector'],
+  feTurbulence: ['baseFrequency', 'numOctaves', 'result', 'seed', 'stitchTiles', 'type'],
+  feTile: ['in'],
   // MathML Elements
   annotation: ['encoding'],
   'annotation-xml': ['encoding'],
@@ -14663,7 +14711,7 @@ const svgWhiteList_ = {
   mphantom: [],
   mprescripts: [],
   mroot: [],
-  mrow: ['xlink:href', 'xlink:type', 'xmlns:xlink'],
+  mrow: ['href', 'xlink:href', 'xlink:type', 'xmlns:xlink'],
   mspace: ['depth', 'height', 'width'],
   msqrt: [],
   mstyle: ['displaystyle', 'mathbackground', 'mathcolor', 'mathvariant', 'scriptlevel'],
@@ -14677,9 +14725,24 @@ const svgWhiteList_ = {
   munder: [],
   munderover: [],
   none: [],
-  semantics: []
+  semantics: [],
+  // HTML Elements for use in a foreignObject
+  div: [],
+  p: [],
+  li: [],
+  pre: [],
+  ol: [],
+  ul: [],
+  span: [],
+  hr: [],
+  br: [],
+  h1: [],
+  h2: [],
+  h3: [],
+  h4: [],
+  h5: [],
+  h6: []
 };
-/* eslint-enable max-len */
 
 // add generic attributes to all elements of the whitelist
 Object.keys(svgWhiteList_).forEach(element => {
@@ -14747,16 +14810,20 @@ const sanitizeSvg = node => {
       // 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 (attrNsURI !== allowedAttrsNS[attrLocalName] && attrNsURI !== NS.XMLNS && !(attrNsURI === NS.XMLNS && REVERSE_NS[attr.value])) {
-        // Bypassing the whitelist to allow se: and oi: prefixes
-        // We can add specific namepaces on demand for now.
-        // Is there a more appropriate way to do this?
-        if (attrName.startsWith('se:') || attrName.startsWith('oi:') || attrName.startsWith('data-')) {
-          // We should bypass the namespace aswell
-          const seAttrNS = attrName.startsWith('se:') ? NS.SE : attrName.startsWith('oi:') ? NS.OI : null;
-          seAttrs.push([attrName, attr.value, seAttrNS]);
-        } else {
-          console.warn(`sanitizeSvg: attribute ${attrName} in element ${node.nodeName} not in whitelist is removed`);
-          node.removeAttributeNS(attrNsURI, attrLocalName);
+        // Special case: allow href attribute even without namespace if it's in the whitelist
+        const isHrefAttribute = attrLocalName === 'href' && allowedAttrs.includes('href');
+        if (!isHrefAttribute) {
+          // Bypassing the whitelist to allow se: and oi: prefixes
+          // We can add specific namepaces on demand for now.
+          // Is there a more appropriate way to do this?
+          if (attrName.startsWith('se:') || attrName.startsWith('oi:') || attrName.startsWith('data-')) {
+            // We should bypass the namespace aswell
+            const seAttrNS = attrName.startsWith('se:') ? NS.SE : attrName.startsWith('oi:') ? NS.OI : null;
+            seAttrs.push([attrName, attr.value, seAttrNS]);
+          } else {
+            console.warn(`sanitizeSvg: attribute ${attrName} in element ${node.nodeName} not in whitelist is removed: ${node.outerHTML}`);
+            node.removeAttributeNS(attrNsURI, attrLocalName);
+          }
         }
       }
 
@@ -14780,22 +14847,37 @@ const sanitizeSvg = node => {
       node.setAttributeNS(ns, att, val);
     });
 
-    // for some elements that have a xlink:href, ensure the URI refers to a local element
-    // (but not for links)
+    // for some elements that have a xlink:href or href, ensure the URI refers to a local element
+    // (but not for links and other elements where external hrefs are allowed)
     const href = getHref(node);
     if (href && ['filter', 'linearGradient', 'pattern', 'radialGradient', 'textPath', 'use'].includes(node.nodeName) && href[0] !== '#') {
       // remove the attribute (but keep the element)
       setHref(node, '');
-      console.warn(`sanitizeSvg: attribute href in element ${node.nodeName} pointing to a non-local reference (${href}) is removed`);
+      console.warn(`sanitizeSvg: attribute href in element ${node.nodeName} pointing to a non-local reference (${href}) is removed: ${node.outerHTML}`);
       node.removeAttributeNS(NS.XLINK, 'href');
+      node.removeAttribute('href');
     }
 
     // Safari crashes on a <use> without a xlink:href, so we just remove the node here
     if (node.nodeName === 'use' && !getHref(node)) {
-      console.warn(`sanitizeSvg: element ${node.nodeName} without a xlink:href is removed`);
+      console.warn(`sanitizeSvg: element ${node.nodeName} without a xlink:href or href is removed: ${node.outerHTML}`);
       node.remove();
       return;
     }
+    // if the element has attributes pointing to a non-local reference,
+    // need to remove the attribute
+    ['clip-path', 'fill', 'filter', 'marker-end', 'marker-mid', 'marker-start', 'mask', 'stroke'].forEach(attr => {
+      let val = node.getAttribute(attr);
+      if (val) {
+        val = getUrlFromAttr(val);
+        // simply check for first character being a '#'
+        if (val && val[0] !== '#') {
+          node.setAttribute(attr, '');
+          console.warn(`sanitizeSvg: attribute ${attr} in element ${node.nodeName} pointing to a non-local reference (${val}) is removed: ${node.outerHTML}`);
+          node.removeAttribute(attr);
+        }
+      }
+    });
 
     // recurse to children
     i = node.childNodes.length;
@@ -14806,7 +14888,7 @@ const sanitizeSvg = node => {
   } else {
     // remove all children from this node and insert them before this node
     // TODO: in the case of animation elements this will hardly ever be correct
-    console.warn(`sanitizeSvg: element ${node.nodeName} not supported is removed`);
+    console.warn(`sanitizeSvg: element ${node.nodeName} not supported is removed: ${node.outerHTML}`);
     const children = [];
     while (node.hasChildNodes()) {
       children.push(parent.insertBefore(node.firstChild, node));
@@ -15647,7 +15729,7 @@ try {
 /** @license
  *
  * jsPDF - PDF Document creation from JavaScript
- * Version 3.0.0 Built on 2025-02-19T09:26:58.791Z
+ * Version 3.0.1 Built on 2025-03-17T14:19:36.873Z
  *                      CommitID 00000000
  *
  * Copyright (c) 2010-2021 James Hall <james@parall.ax>, https://github.com/MrRio/jsPDF
@@ -17411,8 +17493,7 @@ function E$1(e) {
         E = Math.sin(c);
       p = new Vt(M, E, -E, M, 0, 0);
     } else c && c instanceof Vt && (p = c);
-    S !== x.ADVANCED || p || (p = Yt), void 0 !== (h = i.charSpace || _r) && (v += O(U(h)) + " Tc\n", this.setCharSpace(this.getCharSpace() || 0)), void 0 !== (d = i.horizontalScale) && (v += O(100 * d) + " Tz\n");
-    i.lang;
+    S !== x.ADVANCED || p || (p = Yt), void 0 !== (h = i.charSpace || _r) && (v += O(U(h)) + " Tc\n", this.setCharSpace(this.getCharSpace() || 0)), void 0 !== (d = i.horizontalScale) && (v += O(100 * d) + " Tz\n"), i.lang;
     var D = -1,
       R = void 0 !== i.renderingMode ? i.renderingMode : i.stroke,
       T = g.internal.getCurrentPageInfo().pageContext;
@@ -18064,7 +18145,7 @@ I$1.prototype.lsbFirstWord = function (t) {
   return 0 === i;
 }, E$1.API = {
   events: []
-}, E$1.version = "3.0.0";
+}, E$1.version = "3.0.1";
 var q$1 = E$1.API,
   D$1 = 1,
   R$1 = function (t) {
@@ -19655,17 +19736,10 @@ function _t(t) {
       return 0 === t.length && (e = false), t.length % 4 != 0 && (e = false), false === /^[A-Za-z0-9+/]+$/.test(t.substr(0, t.length - 2)) && (e = false), false === /^[A-Za-z0-9/][A-Za-z0-9+/]|[A-Za-z0-9+/]=|==$/.test(t.substr(-2)) && (e = false), e;
     },
     L = e.__addimage__.extractImageFromDataUrl = function (t) {
-      var e = (t = t || "").split("base64,"),
-        r = null;
-      if (2 === e.length) {
-        var n = /^data:(\w*\/\w*);*(charset=(?!charset=)[\w=-]*)*;*$/.exec(e[0]);
-        Array.isArray(n) && (r = {
-          mimeType: n[1],
-          charset: n[2],
-          data: e[1]
-        });
-      }
-      return r;
+      if (null == t) return null;
+      if (!(t = t.trim()).startsWith("data:")) return null;
+      var e = t.indexOf(",");
+      return e < 0 ? null : t.substring(0, e).trim().endsWith("base64") ? t.substring(e + 1) : null;
     },
     A = e.__addimage__.supportsArrayBuffer = function () {
       return "undefined" != typeof ArrayBuffer && "undefined" != typeof Uint8Array;
@@ -19712,19 +19786,19 @@ function _t(t) {
       return s;
     },
     k = e.__addimage__.convertBase64ToBinaryString = function (t, e) {
-      var r;
       e = "boolean" != typeof e || e;
-      var n,
-        i = "";
+      var r,
+        n = "";
       if ("string" == typeof t) {
-        n = null !== (r = L(t)) ? r.data : t;
+        var i;
+        r = null !== (i = L(t)) && void 0 !== i ? i : t;
         try {
-          i = u$2(n);
+          n = u$2(r);
         } catch (t) {
-          if (e) throw N(n) ? new Error("atob-Error in jsPDF.convertBase64ToBinaryString " + t.message) : new Error("Supplied Data is not a valid base64-String jsPDF.convertBase64ToBinaryString ");
+          if (e) throw N(r) ? new Error("atob-Error in jsPDF.convertBase64ToBinaryString " + t.message) : new Error("Supplied Data is not a valid base64-String jsPDF.convertBase64ToBinaryString ");
         }
       }
-      return i;
+      return n;
     };
   e.getImageProperties = function (t) {
     var n,
@@ -20733,10 +20807,12 @@ var Ut$1,
       set: function (t) {
         var e;
         if (this.ctx.font = t, null !== (e = /^\s*(?=(?:(?:[-a-z]+\s*){0,2}(italic|oblique))?)(?=(?:(?:[-a-z]+\s*){0,2}(small-caps))?)(?=(?:(?:[-a-z]+\s*){0,2}(bold(?:er)?|lighter|[1-9]00))?)(?:(?:normal|\1|\2|\3)\s*){0,3}((?:xx?-)?(?:small|large)|medium|smaller|larger|[.\d]+(?:\%|in|[cem]m|ex|p[ctx]))(?:\s*\/\s*(normal|[.\d]+(?:\%|in|[cem]m|ex|p[ctx])))?\s*([-_,\"\'\sa-z]+?)\s*$/i.exec(t))) {
-          var r = e[1],
-            n = (e[2], e[3]),
-            i = e[4],
-            a = (e[5], e[6]),
+          var r = e[1];
+          e[2];
+          var n = e[3],
+            i = e[4];
+          e[5];
+          var a = e[6],
             o = /^([.\d]+)((?:%|in|[cem]m|ex|p[ctx]))$/i.exec(i)[2];
           i = "px" === o ? Math.floor(parseFloat(i) * this.pdf.internal.scaleFactor) : "em" === o ? Math.floor(parseFloat(i) * this.pdf.getFontSize()) : Math.floor(parseFloat(i) * this.pdf.internal.scaleFactor), this.pdf.setFontSize(i);
           var s = function (t) {
@@ -22418,8 +22494,7 @@ function Zt(t) {
     i = t[e++],
     a = i >> 7,
     o = 1 << (7 & i) + 1;
-  t[e++];
-  t[e++];
+  t[e++], t[e++];
   var s = null,
     c = null;
   a && (s = e, c = o, e += 3 * o);
@@ -25101,42 +25176,34 @@ function ee(t) {
         for (var i = 0; i < n; i++) if (t[e + i] != r.charCodeAt(i)) return true;
         return false;
       }(t, e, "RIFF", 4)) {
-        var s, c;
-        l(t, e += 4);
-        for (e += 8; e < t.length;) {
-          var f = u(t, e),
-            d = l(t, e += 4);
+        for (l(t, e += 4), e += 8; e < t.length;) {
+          var s = u(t, e),
+            c = l(t, e += 4);
           e += 4;
-          var p = d + (1 & d);
-          switch (f) {
+          var f = c + (1 & c);
+          switch (s) {
             case "VP8 ":
             case "VP8L":
-              void 0 === r.frames[n] && (r.frames[n] = {});
-              (v = r.frames[n]).src_off = i ? o : e - 8, v.src_size = a + d + 8, n++, i && (i = false, a = 0, o = 0);
+              void 0 === r.frames[n] && (r.frames[n] = {}), (g = r.frames[n]).src_off = i ? o : e - 8, g.src_size = a + c + 8, n++, i && (i = false, a = 0, o = 0);
               break;
             case "VP8X":
-              (v = r.header = {}).feature_flags = t[e];
-              var g = e + 4;
-              v.canvas_width = 1 + h(t, g);
-              g += 3;
-              v.canvas_height = 1 + h(t, g);
-              g += 3;
+              (g = r.header = {}).feature_flags = t[e];
+              var d = e + 4;
+              g.canvas_width = 1 + h(t, d), d += 3, g.canvas_height = 1 + h(t, d), d += 3;
               break;
             case "ALPH":
-              i = true, a = p + 8, o = e - 8;
+              i = true, a = f + 8, o = e - 8;
               break;
             case "ANIM":
-              (v = r.header).bgcolor = l(t, e);
-              g = e + 4;
-              v.loop_count = (s = t)[(c = g) + 0] << 0 | s[c + 1] << 8;
-              g += 2;
+              (g = r.header).bgcolor = l(t, e), d = e + 4, g.loop_count = (m = t)[(v = d) + 0] << 0 | m[v + 1] << 8, d += 2;
               break;
             case "ANMF":
-              var m, v;
-              (v = r.frames[n] = {}).offset_x = 2 * h(t, e), e += 3, v.offset_y = 2 * h(t, e), e += 3, v.width = 1 + h(t, e), e += 3, v.height = 1 + h(t, e), e += 3, v.duration = h(t, e), e += 3, m = t[e++], v.dispose = 1 & m, v.blend = m >> 1 & 1;
+              var p, g;
+              (g = r.frames[n] = {}).offset_x = 2 * h(t, e), e += 3, g.offset_y = 2 * h(t, e), e += 3, g.width = 1 + h(t, e), e += 3, g.height = 1 + h(t, e), e += 3, g.duration = h(t, e), e += 3, p = t[e++], g.dispose = 1 & p, g.blend = p >> 1 & 1;
           }
-          "ANMF" != f && (e += p);
+          "ANMF" != s && (e += f);
         }
+        var m, v;
         return r;
       }
     }(m, 0);
@@ -26552,9 +26619,11 @@ function (t) {
       isInputVisual: true
     });
   t.API.events.push(["postProcessText", function (t) {
-    var e = t.text,
-      n = (t.x, t.y, t.options || {}),
-      i = (t.mutex, n.lang, []);
+    var e = t.text;
+    t.x, t.y;
+    var n = t.options || {};
+    t.mutex, n.lang;
+    var i = [];
     if (n.isInputVisual = "boolean" != typeof n.isInputVisual || n.isInputVisual, r.setOptions(n), "[object Array]" === Object.prototype.toString.call(e)) {
       var a = 0;
       for (i = [], a = 0; a < e.length; a += 1) "[object Array]" === Object.prototype.toString.call(e[a]) ? i.push([r.doBidiReorder(e[a][0]), e[a][1], e[a][2]]) : i.push([r.doBidiReorder(e[a])]);
@@ -27571,6 +27640,7 @@ function requirePath_parse() {
       for (i = need_params; i > 0; i--) {
         if (is_arc && (i === 3 || i === 4)) scanFlag(state);else scanParam(state);
         if (state.err.length) {
+          finalizeSegment(state);
           return;
         }
         state.data.push(state.param);
@@ -27612,9 +27682,7 @@ function requirePath_parse() {
     while (state.index < max && !state.err.length) {
       scanSegment(state);
     }
-    if (state.err.length) {
-      state.result = [];
-    } else if (state.result.length) {
+    if (state.result.length) {
       if ('mM'.indexOf(state.result[0][0]) < 0) {
         state.err = 'SvgPath: string should start with `M` or `m`';
         state.result = [];
@@ -28262,24 +28330,38 @@ function requireSvgpath$1() {
   // Convert processed SVG Path back to string
   //
   SvgPath.prototype.toString = function () {
-    var elements = [],
-      skipCmd,
-      cmd;
+    var result = '',
+      prevCmd = '',
+      cmdSkipped = false;
     this.__evaluateStack();
-    for (var i = 0; i < this.segments.length; i++) {
-      // remove repeating commands names
-      cmd = this.segments[i][0];
-      skipCmd = i > 0 && cmd !== 'm' && cmd !== 'M' && cmd === this.segments[i - 1][0];
-      elements = elements.concat(skipCmd ? this.segments[i].slice(1) : this.segments[i]);
-    }
-    return elements.join(' ')
-    // Optimizations: remove spaces around commands & before `-`
-    //
-    // We could also remove leading zeros for `0.5`-like values,
-    // but their count is too small to spend time for.
-    .replace(/ ?([achlmqrstvz]) ?/gi, '$1').replace(/ \-/g, '-')
-    // workaround for FontForge SVG importing bug
-    .replace(/zm/g, 'z m');
+    for (var i = 0, len = this.segments.length; i < len; i++) {
+      var segment = this.segments[i];
+      var cmd = segment[0];
+
+      // Command not repeating => store
+      if (cmd !== prevCmd || cmd === 'm' || cmd === 'M') {
+        // workaround for FontForge SVG importing bug, keep space between "z m".
+        if (cmd === 'm' && prevCmd === 'z') result += ' ';
+        result += cmd;
+        cmdSkipped = false;
+      } else {
+        cmdSkipped = true;
+      }
+
+      // Store segment params
+      for (var pos = 1; pos < segment.length; pos++) {
+        var val = segment[pos];
+        // Space can be skipped
+        // 1. After command (always)
+        // 2. For negative value (with '-' at start)
+        if (pos === 1) {
+          if (cmdSkipped && val >= 0) result += ' ';
+        } else if (val >= 0) result += ' ';
+        result += val;
+      }
+      prevCmd = cmd;
+    }
+    return result;
   };
 
   // Translate path to (x [, y])
@@ -29268,7 +29350,7 @@ var p$1 = function () {
       });
     }, t;
   }(),
-  b = function () {
+  y$1 = function () {
     function e(t) {
       this.renderedElements = {}, this.idMap = t, this.idPrefix = String(e.instanceCounter++);
     }
@@ -29296,7 +29378,7 @@ var p$1 = function () {
       }).join("|")), this.idPrefix + "|" + t + "|" + r;
     }, e.instanceCounter = 0, e;
   }();
-function y$1(t, e) {
+function b(t, e) {
   return Math.atan2(e[1] - t[1], e[0] - t[0]);
 }
 var v$1 = 2 / 3;
@@ -29413,8 +29495,8 @@ var E = function () {
   I = function (t, e, r, i) {
     void 0 === i && (i = false), this.id = t, this.anchor = e, this.angle = r, this.isStartMarker = i;
   },
-  H = /url\(["']?#([^"']+)["']?\)/,
-  R = {
+  R = /url\(["']?#([^"']+)["']?\)/,
+  H = {
     bottom: "bottom",
     "text-bottom": "bottom",
     top: "top",
@@ -29434,7 +29516,7 @@ function W(t, e) {
   return (r = t && t.toString().match(/^([\-0-9.]+)em$/)) ? parseFloat(r[1]) * e : (r = t && t.toString().match(/^([\-0-9.]+)(px|)$/)) ? parseFloat(r[1]) : 0;
 }
 function V(t) {
-  return R[t] || "alphabetic";
+  return H[t] || "alphabetic";
 }
 function j(t) {
   for (var e, r = [], i = /[+-]?(?:(?:\d+\.?\d*)|(?:\d*\.?\d+))(?:[eE][+-]?\d+)?/g; e = i.exec(t);) r.push(parseFloat(e[0]));
@@ -29503,14 +29585,14 @@ function $(t, e, r, i, n, a, s, o) {
     m = a / p,
     g = t.getAttribute("preserveAspectRatio");
   if (g) {
-    var b = g.split(" ");
-    "defer" === b[0] && (b = b.slice(1)), l = b[0], u = b[1] || "meet";
+    var y = g.split(" ");
+    "defer" === y[0] && (y = y.slice(1)), l = y[0], u = y[1] || "meet";
   } else l = "xMidYMid", u = "meet";
   if ("none" !== l && ("meet" === u ? d = m = Math.min(d, m) : "slice" === u && (d = m = Math.max(d, m))), o) return s.pdf.Matrix(d, 0, 0, m, 0, 0);
-  var y = r - h * d,
+  var b = r - h * d,
     v = i - f * m;
-  l.indexOf("xMid") >= 0 ? y += (n - c * d) / 2 : l.indexOf("xMax") >= 0 && (y += n - c * d), l.indexOf("YMid") >= 0 ? v += (a - p * m) / 2 : l.indexOf("YMax") >= 0 && (v += a - p * m);
-  var x = s.pdf.Matrix(1, 0, 0, 1, y, v),
+  l.indexOf("xMid") >= 0 ? b += (n - c * d) / 2 : l.indexOf("xMax") >= 0 && (b += n - c * d), l.indexOf("YMid") >= 0 ? v += (a - p * m) / 2 : l.indexOf("YMax") >= 0 && (v += a - p * m);
+  var x = s.pdf.Matrix(1, 0, 0, 1, b, v),
     S = s.pdf.Matrix(d, 0, 0, m, 0, 0);
   return s.pdf.matrixMult(S, x);
 }
@@ -29740,7 +29822,7 @@ var K = function () {
     }, t;
   }();
 function at(t, e) {
-  var r = H.exec(t);
+  var r = R.exec(t);
   if (r) {
     var i = r[1],
       n = e.refsHandler.get(i);
@@ -29783,10 +29865,10 @@ function st(t, r, i) {
     g.ok && (t.attributeState.stroke = new d(g));
   }
   m && t.attributeState.stroke instanceof d && (t.attributeState.contextStroke = t.attributeState.stroke.color), l && t.attributeState.fill instanceof d && (t.attributeState.contextFill = t.attributeState.fill.color);
-  var b = N$1(n, t.styleSheets, "stroke-linecap");
-  b && (t.attributeState.strokeLinecap = b);
-  var y = N$1(n, t.styleSheets, "stroke-linejoin");
-  y && (t.attributeState.strokeLinejoin = y);
+  var y = N$1(n, t.styleSheets, "stroke-linecap");
+  y && (t.attributeState.strokeLinecap = y);
+  var b = N$1(n, t.styleSheets, "stroke-linejoin");
+  b && (t.attributeState.strokeLinejoin = b);
   var v = N$1(n, t.styleSheets, "stroke-dasharray");
   if (v) {
     var x = parseInt(N$1(n, t.styleSheets, "stroke-dashoffset") || "0");
@@ -29847,7 +29929,7 @@ function ot(t, e, r) {
   t.attributeState.fontWeight === e.attributeState.fontWeight && t.attributeState.fontStyle === e.attributeState.fontStyle || (o = X(t.attributeState.fontStyle, t.attributeState.fontWeight)), void 0 === s && void 0 === o || (void 0 === s && (s = U.hasOwnProperty(t.attributeState.fontFamily) ? U[t.attributeState.fontFamily] : t.attributeState.fontFamily), t.pdf.setFont(s, o)), t.attributeState.fontSize !== e.attributeState.fontSize && t.pdf.setFontSize(t.attributeState.fontSize * t.pdf.internal.scaleFactor);
 }
 function lt(t, e, r) {
-  var i = H.exec(t);
+  var i = R.exec(t);
   if (i) {
     var n = i[1];
     return r.refsHandler.get(n) || void 0;
@@ -29980,7 +30062,7 @@ var ht = function (t) {
               d = i && t > 0 && !(1 === t && s[t - 1] instanceof T$1),
               m = s[t - 1] || null;
             if (m instanceof T$1 || m instanceof F || m instanceof A) {
-              if (e instanceof A) c && a.addMarker(new I(r, [m.x, m.y], y$1(f ? [f.x, f.y] : [m.x, m.y], [e.x1, e.y1]), true)), p && a.addMarker(new I(n, [e.x, e.y], y$1([e.x2, e.y2], [e.x, e.y]))), d && (l = w([m.x, m.y], [e.x1, e.y1]), l = m instanceof T$1 ? l : S(k(o, l)), a.addMarker(new I(i, [m.x, m.y], Math.atan2(l[1], l[0])))), o = w([e.x2, e.y2], [e.x, e.y]);else if (e instanceof T$1 || e instanceof F) {
+              if (e instanceof A) c && a.addMarker(new I(r, [m.x, m.y], b(f ? [f.x, f.y] : [m.x, m.y], [e.x1, e.y1]), true)), p && a.addMarker(new I(n, [e.x, e.y], b([e.x2, e.y2], [e.x, e.y]))), d && (l = w([m.x, m.y], [e.x1, e.y1]), l = m instanceof T$1 ? l : S(k(o, l)), a.addMarker(new I(i, [m.x, m.y], Math.atan2(l[1], l[0])))), o = w([e.x2, e.y2], [e.x, e.y]);else if (e instanceof T$1 || e instanceof F) {
                 if (l = w([m.x, m.y], [e.x, e.y]), c) {
                   var g = f ? w([f.x, f.y], [e.x, e.y]) : l;
                   a.addMarker(new I(r, [m.x, m.y], Math.atan2(g[1], g[0]), true));
@@ -30003,8 +30085,8 @@ var ht = function (t) {
               }
             } else {
               u = e instanceof T$1 && e;
-              var b = s[t + 1];
-              (b instanceof T$1 || b instanceof F || b instanceof A) && (h = w([u.x, u.y], [b.x, b.y]));
+              var y = s[t + 1];
+              (y instanceof T$1 || y instanceof F || y instanceof A) && (h = w([u.x, u.y], [y.x, y.y]));
             }
           }, p = 0; p < s.length; p++) c(p);
       }
@@ -30018,7 +30100,7 @@ var ht = function (t) {
     }, e;
   }(ft);
 function pt(t) {
-  var e = H.exec(t);
+  var e = R.exec(t);
   return e && e[1] || void 0;
 }
 var dt = function (t) {
@@ -30097,17 +30179,17 @@ var dt = function (t) {
   gt = function (t, e) {
     this.width = t, this.height = e;
   },
-  bt = function (t) {
+  yt = function (t) {
     function e() {
       return null !== t && t.apply(this, arguments) || this;
     }
     return u$1(e, t), e.prototype.renderCore = function (t) {
       return f$1(this, void 0, void 0, function () {
-        var r, i, n, a, s, o, l, u, h, f, p, d, b;
+        var r, i, n, a, s, o, l, u, h, f, p, d, y;
         return c$2(this, function (c) {
           switch (c.label) {
             case 0:
-              return r = parseFloat, (i = this.element.getAttribute("href") || this.element.getAttribute("xlink:href")) ? (n = i.substring(1), a = t.refsHandler.get(n), s = B(a.element, "symbol,svg") && a.element.hasAttribute("viewBox"), o = r(N$1(this.element, t.styleSheets, "x") || "0"), l = r(N$1(this.element, t.styleSheets, "y") || "0"), u = void 0, h = void 0, s ? (u = r(N$1(this.element, t.styleSheets, "width") || N$1(a.element, t.styleSheets, "width") || "0"), h = r(N$1(this.element, t.styleSheets, "height") || N$1(a.element, t.styleSheets, "height") || "0"), o += r(N$1(a.element, t.styleSheets, "x") || "0"), l += r(N$1(a.element, t.styleSheets, "y") || "0"), p = j(a.element.getAttribute("viewBox")), f = $(a.element, p, o, l, u, h, t)) : f = t.pdf.Matrix(1, 0, 0, 1, o, l), d = m$2.getContextColors(t, true), b = new g(t.pdf, {
+              return r = parseFloat, (i = this.element.getAttribute("href") || this.element.getAttribute("xlink:href")) ? (n = i.substring(1), a = t.refsHandler.get(n), s = B(a.element, "symbol,svg") && a.element.hasAttribute("viewBox"), o = r(N$1(this.element, t.styleSheets, "x") || "0"), l = r(N$1(this.element, t.styleSheets, "y") || "0"), u = void 0, h = void 0, s ? (u = r(N$1(this.element, t.styleSheets, "width") || N$1(a.element, t.styleSheets, "width") || "0"), h = r(N$1(this.element, t.styleSheets, "height") || N$1(a.element, t.styleSheets, "height") || "0"), o += r(N$1(a.element, t.styleSheets, "x") || "0"), l += r(N$1(a.element, t.styleSheets, "y") || "0"), p = j(a.element.getAttribute("viewBox")), f = $(a.element, p, o, l, u, h, t)) : f = t.pdf.Matrix(1, 0, 0, 1, o, l), d = m$2.getContextColors(t, true), y = new g(t.pdf, {
                 refsHandler: t.refsHandler,
                 styleSheets: t.styleSheets,
                 withinUse: true,
@@ -30116,7 +30198,7 @@ var dt = function (t) {
                 textMeasure: t.textMeasure,
                 attributeState: Object.assign(m$2.default(), d)
               }), [4, t.refsHandler.getRendered(n, d, function (t) {
-                return e.renderReferencedNode(t, n, b);
+                return e.renderReferencedNode(t, n, y);
               })]) : [2];
             case 1:
               return c.sent(), t.pdf.saveGraphicsState(), t.pdf.setCurrentTransformationMatrix(t.transform), s && "visible" !== N$1(a.element, t.styleSheets, "overflow") && (t.pdf.rect(o, l, u, h), t.pdf.clip().discardPath()), t.pdf.doFormObject(t.refsHandler.generateKey(n, d), f), t.pdf.restoreGraphicsState(), [2];
@@ -30149,7 +30231,7 @@ var dt = function (t) {
       return t.pdf.unitMatrix;
     }, e;
   }(ft),
-  yt = function (t) {
+  bt = function (t) {
     function e(e, r) {
       return t.call(this, false, e, r) || this;
     }
@@ -30266,27 +30348,27 @@ var Tt = function () {
           o.push(n);
           var g = t.resolveRelativePositionAttribute(n, "dx");
           null !== g && (d += W(g, a.attributeState.fontSize));
-          var b = t.resolveRelativePositionAttribute(n, "dy");
-          null !== b && (m += W(b, a.attributeState.fontSize));
+          var y = t.resolveRelativePositionAttribute(n, "dy");
+          null !== y && (m += W(y, a.attributeState.fontSize));
         }
         l[i] = d, u[i] = m, h = d + s.width + s.length * r, f = m, c = Math.min(c, d), p = Math.max(p, h);
       }
-      var y = 0;
+      var b = 0;
       switch (this.textAnchor) {
         case "start":
-          y = 0;
+          b = 0;
           break;
         case "middle":
-          y = (p - c) / 2;
+          b = (p - c) / 2;
           break;
         case "end":
-          y = p - c;
+          b = p - c;
       }
       for (i = 0; i < this.textNodes.length; i++) if (n = this.textNodes[i], a = this.contexts[i], "#text" === n.nodeName || "hidden" !== a.attributeState.visibility) {
         e.pdf.saveGraphicsState(), ot(a, e, n);
         var v = a.attributeState.alignmentBaseline,
           x = St(a.attributeState);
-        e.pdf.text(this.texts[i], l[i] - y, u[i], {
+        e.pdf.text(this.texts[i], l[i] - b, u[i], {
           baseline: V(v),
           angle: e.transform,
           renderingMode: "fill" === x ? void 0 : x,
@@ -30322,15 +30404,15 @@ var Tt = function () {
             var m = f,
               g = m.getAttribute("x");
             if (null !== g) {
-              var b = W(g, s);
-              n = new Tt(this, N$1(m, r.styleSheets, "text-anchor") || r.attributeState.textAnchor, b, 0), i.push({
+              var y = W(g, s);
+              n = new Tt(this, N$1(m, r.styleSheets, "text-anchor") || r.attributeState.textAnchor, y, 0), i.push({
                 type: "y",
                 chunk: n
               });
             }
-            var y = m.getAttribute("y");
-            if (null !== y) {
-              var v = W(y, s);
+            var b = m.getAttribute("y");
+            if (null !== b) {
+              var v = W(b, s);
               n = new Tt(this, N$1(m, r.styleSheets, "text-anchor") || r.attributeState.textAnchor, 0, v), i.push({
                 type: "x",
                 chunk: n
@@ -30344,31 +30426,31 @@ var Tt = function () {
       return u;
     }, e.prototype.renderCore = function (t) {
       return f$1(this, void 0, void 0, function () {
-        var e, r, i, n, a, s, o, l, u, h, f, p, d, m, g, b, y, v, x, S, w, k, M;
+        var e, r, i, n, a, s, o, l, u, h, f, p, d, m, g, y, b, v, x, S, w, k, M;
         return c$2(this, function (c) {
           if (t.pdf.saveGraphicsState(), e = 0, r = 0, i = 1, n = t.pdf.getFontSize(), a = W(this.element.getAttribute("x"), n), s = W(this.element.getAttribute("y"), n), o = W(this.element.getAttribute("dx"), n), l = W(this.element.getAttribute("dy"), n), u = parseFloat(this.element.getAttribute("textLength") || "0"), h = t.attributeState.visibility, 0 === this.element.childElementCount) f = this.element.textContent || "", p = function (t, e) {
             return t = kt(t = wt(t)), "default" === e.xmlSpace && (t = Mt(t = t.trim())), t;
-          }(f, t.attributeState), d = Ct(this.element, p, t), e = t.textMeasure.getTextOffset(d, t.attributeState), u > 0 && (m = t.textMeasure.measureTextWidth(d, t.attributeState), "default" === t.attributeState.xmlSpace && f.match(/^\s/) && (i = 0), r = (u - m) / (d.length - i) || 0), "visible" === h && (g = t.attributeState.alignmentBaseline, b = St(t.attributeState), t.pdf.text(d, a + o - e, s + l, {
+          }(f, t.attributeState), d = Ct(this.element, p, t), e = t.textMeasure.getTextOffset(d, t.attributeState), u > 0 && (m = t.textMeasure.measureTextWidth(d, t.attributeState), "default" === t.attributeState.xmlSpace && f.match(/^\s/) && (i = 0), r = (u - m) / (d.length - i) || 0), "visible" === h && (g = t.attributeState.alignmentBaseline, y = St(t.attributeState), t.pdf.text(d, a + o - e, s + l, {
             baseline: V(g),
             angle: t.transform,
-            renderingMode: "fill" === b ? void 0 : b,
+            renderingMode: "fill" === y ? void 0 : y,
             charSpace: 0 === r ? void 0 : r
           }), this.boundingBox = [a + o - e, s + l + .1 * n, t.textMeasure.measureTextWidth(d, t.attributeState), n]);else {
-            for (y = [], v = new Tt(this, t.attributeState.textAnchor, a + o, s + l), y.push({
+            for (b = [], v = new Tt(this, t.attributeState.textAnchor, a + o, s + l), b.push({
               type: "",
               chunk: v
-            }), x = this.processTSpans(this, this.element, t, y, v, {
+            }), x = this.processTSpans(this, this.element, t, b, v, {
               prevText: " ",
               prevContext: t
-            }), i = x ? 0 : 1, S = true, w = y.length - 1; w >= 0; w--) S && (S = y[w].chunk.rightTrimText());
-            u > 0 && (k = 0, M = 0, y.forEach(function (e) {
+            }), i = x ? 0 : 1, S = true, w = b.length - 1; w >= 0; w--) S && (S = b[w].chunk.rightTrimText());
+            u > 0 && (k = 0, M = 0, b.forEach(function (e) {
               var r = e.chunk;
               r.measureText(t), r.textMeasures.forEach(function (t) {
                 var e = t.width,
                   r = t.length;
                 k += e, M += r;
               });
-            }), r = (u - k) / (M - i)), y.reduce(function (e, i) {
+            }), r = (u - k) / (M - i)), b.reduce(function (e, i) {
               var n = i.type,
                 a = i.chunk;
               return "x" === n ? a.setX(e[0]) : "y" === n && a.setY(e[1]), a.put(t, r);
@@ -30451,14 +30533,14 @@ var Tt = function () {
     }
     return u$1(e, t), e.prototype.renderCore = function (t) {
       return f$1(this, void 0, void 0, function () {
-        var r, i, n, a, s, o, l, u, h, f, p, d, m, y, v, x, S, w;
+        var r, i, n, a, s, o, l, u, h, f, p, d, m, b, v, x, S, w;
         return c$2(this, function (c) {
           switch (c.label) {
             case 0:
               return this.imageLoadingPromise ? (t.pdf.setCurrentTransformationMatrix(t.transform), r = parseFloat(N$1(this.element, t.styleSheets, "width") || "0"), i = parseFloat(N$1(this.element, t.styleSheets, "height") || "0"), n = parseFloat(N$1(this.element, t.styleSheets, "x") || "0"), a = parseFloat(N$1(this.element, t.styleSheets, "y") || "0"), !isFinite(r) || r <= 0 || !isFinite(i) || i <= 0 ? [2] : [4, this.imageLoadingPromise]) : [2];
             case 1:
               return s = c.sent(), o = s.data, 0 !== (l = s.format).indexOf("svg") ? [3, 3] : (u = new DOMParser(), h = u.parseFromString(o, "image/svg+xml").firstElementChild, (!(f = this.element.getAttribute("preserveAspectRatio")) || f.indexOf("defer") < 0 || !h.getAttribute("preserveAspectRatio")) && h.setAttribute("preserveAspectRatio", f || ""), h.setAttribute("x", String(n)), h.setAttribute("y", String(a)), h.setAttribute("width", String(r)), h.setAttribute("height", String(i)), [4, Gt(h, p = {}).render(new g(t.pdf, {
-                refsHandler: new b(p),
+                refsHandler: new y$1(p),
                 styleSheets: t.styleSheets,
                 viewport: new gt(r, i),
                 svg2pdfParameters: t.svg2pdfParameters,
@@ -30471,7 +30553,7 @@ var Tt = function () {
             case 4:
               return c.trys.push([4, 6,, 7]), [4, e.getImageDimensions(d)];
             case 5:
-              return m = c.sent(), y = m[0], v = m[1], x = [0, 0, y, v], S = $(this.element, x, n, a, r, i, t), t.pdf.setCurrentTransformationMatrix(S), t.pdf.addImage(d, "", 0, 0, y, v), [3, 7];
+              return m = c.sent(), b = m[0], v = m[1], x = [0, 0, b, v], S = $(this.element, x, n, a, r, i, t), t.pdf.setCurrentTransformationMatrix(S), t.pdf.addImage(d, "", 0, 0, b, v), [3, 7];
             case 6:
               return w = c.sent(), "object" == typeof console && console.warn && console.warn("Could not load image ".concat(this.imageUrl, ". \n").concat(w)), [3, 7];
             case 7:
@@ -30652,13 +30734,13 @@ var Tt = function () {
       return this.getR(t);
     }, e;
   }(vt),
-  Ht = function (t) {
+  Rt = function (t) {
     function e(e, r) {
       return t.call(this, false, e, r) || this;
     }
     return u$1(e, t), e;
   }(Nt),
-  Rt = function (t) {
+  Ht = function (t) {
     function e() {
       return null !== t && t.apply(this, arguments) || this;
     }
@@ -30766,7 +30848,7 @@ var Tt = function () {
     }, e.prototype.isOutermostSvg = function (t) {
       return t.svg2pdfParameters.element === this.element;
     }, e;
-  }(Rt),
+  }(Ht),
   Wt = function (t) {
     function e() {
       return null !== t && t.apply(this, arguments) || this;
@@ -30776,7 +30858,7 @@ var Tt = function () {
     }, e.prototype.computeNodeTransformCore = function (t) {
       return t.pdf.unitMatrix;
     }, e;
-  }(Rt),
+  }(Ht),
   Vt = function (t) {
     function e() {
       return null !== t && t.apply(this, arguments) || this;
@@ -30803,12 +30885,12 @@ var Tt = function () {
     }
     return u$1(e, t), e.prototype.apply = function (t) {
       return f$1(this, void 0, void 0, function () {
-        var e, r, i;
-        return c$2(this, function (n) {
-          switch (n.label) {
+        var e, r, i, n, a;
+        return c$2(this, function (s) {
+          switch (s.label) {
             case 0:
               if (!this.isVisible(true, t)) return [2];
-              e = t.pdf.matrixMult(this.computeNodeTransform(t), t.transform), t.pdf.setCurrentTransformationMatrix(e), r = 0, i = this.children, n.label = 1;
+              e = t.pdf.matrixMult(this.computeNodeTransform(t), t.transform), t.pdf.setCurrentTransformationMatrix(e), r = 0, i = this.children, s.label = 1;
             case 1:
               return r < i.length ? [4, i[r].render(new g(t.pdf, {
                 refsHandler: t.refsHandler,
@@ -30819,11 +30901,11 @@ var Tt = function () {
                 textMeasure: t.textMeasure
               }))] : [3, 4];
             case 2:
-              n.sent(), n.label = 3;
+              s.sent(), s.label = 3;
             case 3:
               return r++, [3, 1];
             case 4:
-              return t.pdf.clip().discardPath(), t.pdf.setCurrentTransformationMatrix(e.inversed()), [2];
+              return n = this.children.length > 0 && !!N$1(this.children[0].element, t.styleSheets, "clip-rule"), a = n ? this.getClipRuleAttr(this.children[0].element, t.styleSheets) : this.getClipRuleAttr(this.element, t.styleSheets), t.pdf.clip(a).discardPath(), t.pdf.setCurrentTransformationMatrix(e.inversed()), [2];
           }
         });
       });
@@ -30831,6 +30913,8 @@ var Tt = function () {
       return q(t, this);
     }, e.prototype.isVisible = function (t, e) {
       return L(this, t, e);
+    }, e.prototype.getClipRuleAttr = function (t, e) {
+      return "evenodd" === N$1(t, e, "clip-rule") ? "evenodd" : void 0;
     }, e;
   }(J);
 function Gt(e, r) {
@@ -30882,13 +30966,13 @@ function Gt(e, r) {
       i = new Ot(e, n);
       break;
     case "polyline":
-      i = new Ht(e, n);
+      i = new Rt(e, n);
       break;
     case "radialgradient":
       i = new et(e, n);
       break;
     case "rect":
-      i = new yt(e, n);
+      i = new bt(e, n);
       break;
     case "svg":
       i = new Dt(e, n);
@@ -30900,7 +30984,7 @@ function Gt(e, r) {
       i = new Ft(e, n);
       break;
     case "use":
-      i = new bt(e, n);
+      i = new yt(e, n);
       break;
     default:
       i = new Lt(e, n);
@@ -31053,11 +31137,11 @@ var Ut = function () {
   }();
 function Yt(t, e) {
   return f$1(this, arguments, void 0, function (t, e, r) {
-    var i, n, a, s, o, l, u, f, p, d, m, y, v, x;
+    var i, n, a, s, o, l, u, f, p, d, m, b, v, x;
     return void 0 === r && (r = {}), c$2(this, function (c) {
       switch (c.label) {
         case 0:
-          return i = null !== (y = r.x) && void 0 !== y ? y : 0, n = null !== (v = r.y) && void 0 !== v ? v : 0, a = null !== (x = r.loadExternalStyleSheets) && void 0 !== x && x, o = new b(s = {}), [4, (l = new Ut(t, a)).load()];
+          return i = null !== (b = r.x) && void 0 !== b ? b : 0, n = null !== (v = r.y) && void 0 !== v ? v : 0, a = null !== (x = r.loadExternalStyleSheets) && void 0 !== x && x, o = new y$1(s = {}), [4, (l = new Ut(t, a)).load()];
         case 1:
           return c.sent(), u = new gt(e.internal.pageSize.getWidth(), e.internal.pageSize.getHeight()), f = h$1(h$1({}, r), {
             element: t
@@ -31191,7 +31275,7 @@ const svgToString = (elem, indent) => {
       out.push(' ');
     }
     out.push('<');
-    out.push(elem.nodeName);
+    out.push(elem.localName);
     if (elem.id === 'svgcontent') {
       // Process root element separately
       const res = svgCanvas$2.getResolution();
@@ -31364,7 +31448,7 @@ const svgToString = (elem, indent) => {
         }
       }
       out.push('</');
-      out.push(elem.nodeName);
+      out.push(elem.localName);
       out.push('>');
     } else {
       out.push('/>');
@@ -31440,7 +31524,8 @@ const setSvgString = (xmlString, preventUndo) => {
             // const url = decodeURIComponent(m.groups.url);
             const iimg = new Image();
             iimg.addEventListener('load', () => {
-              image.setAttributeNS(NS.XLINK, 'xlink:href', url);
+              // Set the href attribute to the data URL
+              setHref(image, val);
             });
             iimg.src = url;
           }
@@ -31822,7 +31907,7 @@ const convertImagesToBase64 = async svgElement => {
         const reader = new FileReader();
         return new Promise(resolve => {
           reader.onload = () => {
-            img.setAttribute('xlink:href', reader.result);
+            setHref(img, reader.result);
             resolve();
           };
           reader.readAsDataURL(blob);
@@ -43636,10 +43721,10 @@ function requireSharedStore () {
 	var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
 	(store.versions || (store.versions = [])).push({
-	  version: '3.41.0',
+	  version: '3.43.0',
 	  mode: IS_PURE ? 'pure' : 'global',
 	  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
-	  license: 'https://github.com/zloirock/core-js/blob/v3.41.0/LICENSE',
+	  license: 'https://github.com/zloirock/core-js/blob/v3.43.0/LICENSE',
 	  source: 'https://github.com/zloirock/core-js'
 	});
 	return sharedStore.exports;
@@ -43707,7 +43792,7 @@ function requireUid () {
 
 	var id = 0;
 	var postfix = Math.random();
-	var toString = uncurryThis(1.0.toString);
+	var toString = uncurryThis(1.1.toString);
 
 	uid = function (key) {
 	  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
@@ -44644,6 +44729,18 @@ function requireEnvironmentIsNode () {
 	return environmentIsNode;
 }
 
+var path;
+var hasRequiredPath;
+
+function requirePath () {
+	if (hasRequiredPath) return path;
+	hasRequiredPath = 1;
+	var globalThis = requireGlobalThis();
+
+	path = globalThis;
+	return path;
+}
+
 var functionUncurryThisAccessor;
 var hasRequiredFunctionUncurryThisAccessor;
 
@@ -45507,6 +45604,7 @@ function requireEs_promise_constructor () {
 	var IS_PURE = requireIsPure();
 	var IS_NODE = requireEnvironmentIsNode();
 	var globalThis = requireGlobalThis();
+	var path = requirePath();
 	var call = requireFunctionCall();
 	var defineBuiltIn = requireDefineBuiltIn();
 	var setPrototypeOf = requireObjectSetPrototypeOf();
@@ -45790,6 +45888,8 @@ function requireEs_promise_constructor () {
 	  Promise: PromiseConstructor
 	});
 
+	PromiseWrapper = path.Promise;
+
 	setToStringTag(PromiseConstructor, PROMISE, false, true);
 	setSpecies(PROMISE);
 	return es_promise_constructor;
@@ -45938,7 +46038,7 @@ function requireIterate () {
 	  var iterator, iterFn, index, length, result, next, step;
 
 	  var stop = function (condition) {
-	    if (iterator) iteratorClose(iterator, 'normal', condition);
+	    if (iterator) iteratorClose(iterator, 'normal');
 	    return new Result(true, condition);
 	  };
 
@@ -46827,6 +46927,85 @@ function requireAdvanceStringIndex () {
 	return advanceStringIndex;
 }
 
+var regexpFlagsDetection;
+var hasRequiredRegexpFlagsDetection;
+
+function requireRegexpFlagsDetection () {
+	if (hasRequiredRegexpFlagsDetection) return regexpFlagsDetection;
+	hasRequiredRegexpFlagsDetection = 1;
+	var globalThis = requireGlobalThis();
+	var fails = requireFails();
+
+	// babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
+	var RegExp = globalThis.RegExp;
+
+	var FLAGS_GETTER_IS_CORRECT = !fails(function () {
+	  var INDICES_SUPPORT = true;
+	  try {
+	    RegExp('.', 'd');
+	  } catch (error) {
+	    INDICES_SUPPORT = false;
+	  }
+
+	  var O = {};
+	  // modern V8 bug
+	  var calls = '';
+	  var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
+
+	  var addGetter = function (key, chr) {
+	    // eslint-disable-next-line es/no-object-defineproperty -- safe
+	    Object.defineProperty(O, key, { get: function () {
+	      calls += chr;
+	      return true;
+	    } });
+	  };
+
+	  var pairs = {
+	    dotAll: 's',
+	    global: 'g',
+	    ignoreCase: 'i',
+	    multiline: 'm',
+	    sticky: 'y'
+	  };
+
+	  if (INDICES_SUPPORT) pairs.hasIndices = 'd';
+
+	  for (var key in pairs) addGetter(key, pairs[key]);
+
+	  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	  var result = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get.call(O);
+
+	  return result !== expected || calls !== expected;
+	});
+
+	regexpFlagsDetection = { correct: FLAGS_GETTER_IS_CORRECT };
+	return regexpFlagsDetection;
+}
+
+var regexpGetFlags;
+var hasRequiredRegexpGetFlags;
+
+function requireRegexpGetFlags () {
+	if (hasRequiredRegexpGetFlags) return regexpGetFlags;
+	hasRequiredRegexpGetFlags = 1;
+	var call = requireFunctionCall();
+	var hasOwn = requireHasOwnProperty();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var regExpFlagsDetection = requireRegexpFlagsDetection();
+	var regExpFlagsGetterImplementation = requireRegexpFlags();
+
+	var RegExpPrototype = RegExp.prototype;
+
+	regexpGetFlags = regExpFlagsDetection.correct ? function (it) {
+	  return it.flags;
+	} : function (it) {
+	  return (!regExpFlagsDetection.correct && isPrototypeOf(RegExpPrototype, it) && !hasOwn(it, 'flags'))
+	    ? call(regExpFlagsGetterImplementation, it)
+	    : it.flags;
+	};
+	return regexpGetFlags;
+}
+
 var regexpExecAbstract;
 var hasRequiredRegexpExecAbstract;
 
@@ -46862,16 +47041,20 @@ function requireEs_string_match () {
 	if (hasRequiredEs_string_match) return es_string_match;
 	hasRequiredEs_string_match = 1;
 	var call = requireFunctionCall();
+	var uncurryThis = requireFunctionUncurryThis();
 	var fixRegExpWellKnownSymbolLogic = requireFixRegexpWellKnownSymbolLogic();
 	var anObject = requireAnObject();
-	var isNullOrUndefined = requireIsNullOrUndefined();
+	var isObject = requireIsObject();
 	var toLength = requireToLength();
 	var toString = requireToString();
 	var requireObjectCoercible = requireRequireObjectCoercible();
 	var getMethod = requireGetMethod();
 	var advanceStringIndex = requireAdvanceStringIndex();
+	var getRegExpFlags = requireRegexpGetFlags();
 	var regExpExec = requireRegexpExecAbstract();
 
+	var stringIndexOf = uncurryThis(''.indexOf);
+
 	// @@match logic
 	fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) {
 	  return [
@@ -46879,7 +47062,7 @@ function requireEs_string_match () {
 	    // https://tc39.es/ecma262/#sec-string.prototype.match
 	    function match(regexp) {
 	      var O = requireObjectCoercible(this);
-	      var matcher = isNullOrUndefined(regexp) ? undefined : getMethod(regexp, MATCH);
+	      var matcher = isObject(regexp) ? getMethod(regexp, MATCH) : undefined;
 	      return matcher ? call(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString(O));
 	    },
 	    // `RegExp.prototype[@@match]` method
@@ -46891,9 +47074,11 @@ function requireEs_string_match () {
 
 	      if (res.done) return res.value;
 
-	      if (!rx.global) return regExpExec(rx, S);
+	      var flags = toString(getRegExpFlags(rx));
 
-	      var fullUnicode = rx.unicode;
+	      if (stringIndexOf(flags, 'g') === -1) return regExpExec(rx, S);
+
+	      var fullUnicode = stringIndexOf(flags, 'u') !== -1;
 	      rx.lastIndex = 0;
 	      var A = [];
 	      var n = 0;
@@ -46981,7 +47166,7 @@ function requireEs_string_replace () {
 	var fails = requireFails();
 	var anObject = requireAnObject();
 	var isCallable = requireIsCallable();
-	var isNullOrUndefined = requireIsNullOrUndefined();
+	var isObject = requireIsObject();
 	var toIntegerOrInfinity = requireToIntegerOrInfinity();
 	var toLength = requireToLength();
 	var toString = requireToString();
@@ -46989,6 +47174,7 @@ function requireEs_string_replace () {
 	var advanceStringIndex = requireAdvanceStringIndex();
 	var getMethod = requireGetMethod();
 	var getSubstitution = requireGetSubstitution();
+	var getRegExpFlags = requireRegexpGetFlags();
 	var regExpExec = requireRegexpExecAbstract();
 	var wellKnownSymbol = requireWellKnownSymbol();
 
@@ -47039,7 +47225,7 @@ function requireEs_string_replace () {
 	    // https://tc39.es/ecma262/#sec-string.prototype.replace
 	    function replace(searchValue, replaceValue) {
 	      var O = requireObjectCoercible(this);
-	      var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);
+	      var replacer = isObject(searchValue) ? getMethod(searchValue, REPLACE) : undefined;
 	      return replacer
 	        ? call(replacer, searchValue, O, replaceValue)
 	        : call(nativeReplace, toString(O), searchValue, replaceValue);
@@ -47062,10 +47248,11 @@ function requireEs_string_replace () {
 	      var functionalReplace = isCallable(replaceValue);
 	      if (!functionalReplace) replaceValue = toString(replaceValue);
 
-	      var global = rx.global;
+	      var flags = toString(getRegExpFlags(rx));
+	      var global = stringIndexOf(flags, 'g') !== -1;
 	      var fullUnicode;
 	      if (global) {
-	        fullUnicode = rx.unicode;
+	        fullUnicode = stringIndexOf(flags, 'u') !== -1;
 	        rx.lastIndex = 0;
 	      }
 
@@ -47871,7 +48058,7 @@ function requireEs_string_split () {
 	var uncurryThis = requireFunctionUncurryThis();
 	var fixRegExpWellKnownSymbolLogic = requireFixRegexpWellKnownSymbolLogic();
 	var anObject = requireAnObject();
-	var isNullOrUndefined = requireIsNullOrUndefined();
+	var isObject = requireIsObject();
 	var requireObjectCoercible = requireRequireObjectCoercible();
 	var speciesConstructor = requireSpeciesConstructor();
 	var advanceStringIndex = requireAdvanceStringIndex();
@@ -47919,7 +48106,7 @@ function requireEs_string_split () {
 	    // https://tc39.es/ecma262/#sec-string.prototype.split
 	    function split(separator, limit) {
 	      var O = requireObjectCoercible(this);
-	      var splitter = isNullOrUndefined(separator) ? undefined : getMethod(separator, SPLIT);
+	      var splitter = isObject(separator) ? getMethod(separator, SPLIT) : undefined;
 	      return splitter
 	        ? call(splitter, separator, O, limit)
 	        : call(internalSplit, toString(O), separator, limit);
@@ -48693,7 +48880,7 @@ function p(t, r, e, i) {
     h = 3 * n;
   return Math.abs(s) < a ? [-h / u] : function (t, r, e) {
     var i = t * t / 4 - r;
-    if (i < -1e-6) return [];
+    if (i < -e) return [];
     if (i <= e) return [-t / 2];
     var a = Math.sqrt(i);
     return [-t / 2 - a, -t / 2 + a];
@@ -49103,27 +49290,6 @@ var O,
 
 var es_regexp_toString = {};
 
-var regexpGetFlags;
-var hasRequiredRegexpGetFlags;
-
-function requireRegexpGetFlags () {
-	if (hasRequiredRegexpGetFlags) return regexpGetFlags;
-	hasRequiredRegexpGetFlags = 1;
-	var call = requireFunctionCall();
-	var hasOwn = requireHasOwnProperty();
-	var isPrototypeOf = requireObjectIsPrototypeOf();
-	var regExpFlags = requireRegexpFlags();
-
-	var RegExpPrototype = RegExp.prototype;
-
-	regexpGetFlags = function (R) {
-	  var flags = R.flags;
-	  return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R)
-	    ? call(regExpFlags, R) : flags;
-	};
-	return regexpGetFlags;
-}
-
 var hasRequiredEs_regexp_toString;
 
 function requireEs_regexp_toString () {
@@ -49347,13 +49513,13 @@ function processImageDataRGBA(imageData, topX, topY, width, height, radius) {
     stackIn = stackStart;
     stackOut = stackEnd;
     for (var x = 0; x < width; x++) {
-      var paInitial = aSum * mulSum >> shgSum;
+      var paInitial = aSum * mulSum >>> shgSum;
       pixels[yi + 3] = paInitial;
       if (paInitial !== 0) {
         var _a2 = 255 / paInitial;
-        pixels[yi] = (rSum * mulSum >> shgSum) * _a2;
-        pixels[yi + 1] = (gSum * mulSum >> shgSum) * _a2;
-        pixels[yi + 2] = (bSum * mulSum >> shgSum) * _a2;
+        pixels[yi] = (rSum * mulSum >>> shgSum) * _a2;
+        pixels[yi + 1] = (gSum * mulSum >>> shgSum) * _a2;
+        pixels[yi + 2] = (bSum * mulSum >>> shgSum) * _a2;
       } else {
         pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;
       }
@@ -49442,12 +49608,12 @@ function processImageDataRGBA(imageData, topX, topY, width, height, radius) {
     stackOut = stackEnd;
     for (var _y = 0; _y < height; _y++) {
       var _p2 = yi << 2;
-      pixels[_p2 + 3] = _pa = _aSum * mulSum >> shgSum;
+      pixels[_p2 + 3] = _pa = _aSum * mulSum >>> shgSum;
       if (_pa > 0) {
         _pa = 255 / _pa;
-        pixels[_p2] = (_rSum * mulSum >> shgSum) * _pa;
-        pixels[_p2 + 1] = (_gSum * mulSum >> shgSum) * _pa;
-        pixels[_p2 + 2] = (_bSum * mulSum >> shgSum) * _pa;
+        pixels[_p2] = (_rSum * mulSum >>> shgSum) * _pa;
+        pixels[_p2 + 1] = (_gSum * mulSum >>> shgSum) * _pa;
+        pixels[_p2 + 2] = (_bSum * mulSum >>> shgSum) * _pa;
       } else {
         pixels[_p2] = pixels[_p2 + 1] = pixels[_p2 + 2] = 0;
       }
@@ -50863,9 +51029,9 @@ class Element {
     this.document = document;
     this.node = node;
     this.captureTextNodes = captureTextNodes;
-    this.attributes = {};
-    this.styles = {};
-    this.stylesSpecificity = {};
+    this.attributes = Object.create(null);
+    this.styles = Object.create(null);
+    this.stylesSpecificity = Object.create(null);
     this.animationFrozen = false;
     this.animationFrozenValue = '';
     this.parent = null;
@@ -52288,9 +52454,9 @@ class TextElement extends RenderedElement {
     var isRTL = false; // we treat RTL like LTR
 
     var shift = 0;
-    if (textAnchor === 'start' && true || textAnchor === 'end' && isRTL) {
+    if (textAnchor === 'start' && !isRTL || textAnchor === 'end' && isRTL) {
       shift = firstElement.x - this.minX;
-    } else if (textAnchor === 'end' && true || textAnchor === 'start' && isRTL) {
+    } else if (textAnchor === 'end' && !isRTL || textAnchor === 'start' && isRTL) {
       shift = firstElement.x - this.maxX;
     } else {
       shift = firstElement.x - (this.minX + this.maxX) / 2;
@@ -53263,7 +53429,7 @@ class FontElement extends Element {
   constructor(document, node, captureTextNodes) {
     super(document, node, captureTextNodes);
     this.type = 'font';
-    this.glyphs = {};
+    this.glyphs = Object.create(null);
     this.horizAdvX = this.getAttribute('horiz-adv-x').getNumber();
     var {
       definitions
@@ -53292,7 +53458,7 @@ class FontElement extends Element {
               this.isRTL = true;
               this.isArabic = true;
               if (typeof this.glyphs[glyph.unicode] === 'undefined') {
-                this.glyphs[glyph.unicode] = {};
+                this.glyphs[glyph.unicode] = Object.create(null);
               }
               this.glyphs[glyph.unicode][glyph.arabicForm] = glyph;
             } else {
@@ -54777,9 +54943,9 @@ class Document {
       anonymousCrossOrigin
     } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     this.canvg = canvg;
-    this.definitions = {};
-    this.styles = {};
-    this.stylesSpecificity = {};
+    this.definitions = Object.create(null);
+    this.styles = Object.create(null);
+    this.stylesSpecificity = Object.create(null);
     this.images = [];
     this.fonts = [];
     this.emSizeStack = [];