@svgedit/svgcanvas 7.2.6 → 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,
@@ -13095,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) {
@@ -14615,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: [],
@@ -14630,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'],
@@ -14651,10 +14678,10 @@ 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'],
@@ -14684,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'],
@@ -14783,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);
+          }
         }
       }
 
@@ -14816,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;
@@ -14842,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));
@@ -31478,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;
           }
@@ -31860,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);
@@ -43674,10 +43721,10 @@ function requireSharedStore () {
 	var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
 	(store.versions || (store.versions = [])).push({
-	  version: '3.42.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.42.0/LICENSE',
+	  license: 'https://github.com/zloirock/core-js/blob/v3.43.0/LICENSE',
 	  source: 'https://github.com/zloirock/core-js'
 	});
 	return sharedStore.exports;
@@ -43745,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);
@@ -44682,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;
 
@@ -45545,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();
@@ -45828,6 +45888,8 @@ function requireEs_promise_constructor () {
 	  Promise: PromiseConstructor
 	});
 
+	PromiseWrapper = path.Promise;
+
 	setToStringTag(PromiseConstructor, PROMISE, false, true);
 	setSpecies(PROMISE);
 	return es_promise_constructor;
@@ -45976,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);
 	  };
 
@@ -46865,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;
 
@@ -46900,6 +47041,7 @@ 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 isObject = requireIsObject();
@@ -46908,8 +47050,11 @@ function requireEs_string_match () {
 	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 [
@@ -46929,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));
+
+	      if (stringIndexOf(flags, 'g') === -1) return regExpExec(rx, S);
 
-	      var fullUnicode = rx.unicode;
+	      var fullUnicode = stringIndexOf(flags, 'u') !== -1;
 	      rx.lastIndex = 0;
 	      var A = [];
 	      var n = 0;
@@ -47027,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();
 
@@ -47100,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;
 	      }
 
@@ -48731,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];
@@ -49141,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 () {
@@ -52326,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;