@excalidraw/element 0.18.0-0457ac9 → 0.18.0-063e025

package/dist/dev/index.js

@@ -230,9 +230,9 @@ init_define_import_meta_env();
 function rotatePoints(points, center, degrees) {
   if (points && points.length) {
     const [cx, cy] = center;
-    const angle = Math.PI / 180 * degrees;
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
+    const angle2 = Math.PI / 180 * degrees;
+    const cos = Math.cos(angle2);
+    const sin = Math.sin(angle2);
     for (const p of points) {
       const [x, y] = p;
       p[0] = (x - cx) * cos - (y - cy) * sin + cx;
@@ -249,21 +249,21 @@ function areSamePoints(p1, p2) {
   return p1[0] === p2[0] && p1[1] === p2[1];
 }
 function hachureLines(polygons, hachureGap, hachureAngle, hachureStepOffset = 1) {
-  const angle = hachureAngle;
+  const angle2 = hachureAngle;
   const gap = Math.max(hachureGap, 0.1);
   const polygonList = polygons[0] && polygons[0][0] && typeof polygons[0][0] === "number" ? [polygons] : polygons;
   const rotationCenter = [0, 0];
-  if (angle) {
+  if (angle2) {
     for (const polygon3 of polygonList) {
-      rotatePoints(polygon3, rotationCenter, angle);
+      rotatePoints(polygon3, rotationCenter, angle2);
     }
   }
   const lines = straightHachureLines(polygonList, gap, hachureStepOffset);
-  if (angle) {
+  if (angle2) {
     for (const polygon3 of polygonList) {
-      rotatePoints(polygon3, rotationCenter, -angle);
+      rotatePoints(polygon3, rotationCenter, -angle2);
     }
-    rotateLines(lines, rotationCenter, -angle);
+    rotateLines(lines, rotationCenter, -angle2);
   }
   return lines;
 }
@@ -374,7 +374,7 @@ function straightHachureLines(polygons, gap, hachureStepOffset) {
 // ../../node_modules/roughjs/bin/fillers/scan-line-hachure.js
 function polygonHachureLines(polygonList, o) {
   var _a;
-  const angle = o.hachureAngle + 90;
+  const angle2 = o.hachureAngle + 90;
   let gap = o.hachureGap;
   if (gap < 0) {
     gap = o.strokeWidth * 4;
@@ -386,7 +386,7 @@ function polygonHachureLines(polygonList, o) {
       skipOffset = gap;
     }
   }
-  return hachureLines(polygonList, gap, angle, skipOffset || 1);
+  return hachureLines(polygonList, gap, angle2, skipOffset || 1);
 }
 
 // ../../node_modules/roughjs/bin/fillers/hachure-filler.js
@@ -924,7 +924,7 @@ function normalize(segments) {
       case "A": {
         const r1 = Math.abs(data[0]);
         const r2 = Math.abs(data[1]);
-        const angle = data[2];
+        const angle2 = data[2];
         const largeArcFlag = data[3];
         const sweepFlag = data[4];
         const x = data[5];
@@ -935,7 +935,7 @@ function normalize(segments) {
           cy = y;
         } else {
           if (cx !== x || cy !== y) {
-            const curves = arcToCubicCurves(cx, cy, x, y, r1, r2, angle, largeArcFlag, sweepFlag);
+            const curves = arcToCubicCurves(cx, cy, x, y, r1, r2, angle2, largeArcFlag, sweepFlag);
             curves.forEach(function(curve4) {
               out.push({ key: "C", data: curve4 });
             });
@@ -963,8 +963,8 @@ function rotate(x, y, angleRad) {
   const Y = x * Math.sin(angleRad) + y * Math.cos(angleRad);
   return [X, Y];
 }
-function arcToCubicCurves(x1, y1, x2, y2, r1, r2, angle, largeArcFlag, sweepFlag, recursive) {
-  const angleRad = degToRad(angle);
+function arcToCubicCurves(x1, y1, x2, y2, r1, r2, angle2, largeArcFlag, sweepFlag, recursive) {
+  const angleRad = degToRad(angle2);
   let params = [];
   let f1 = 0, f2 = 0, cx = 0, cy = 0;
   if (recursive) {
@@ -1021,7 +1021,7 @@ function arcToCubicCurves(x1, y1, x2, y2, r1, r2, angle, largeArcFlag, sweepFlag
     }
     x2 = cx + r1 * Math.cos(f2);
     y2 = cy + r2 * Math.sin(f2);
-    params = arcToCubicCurves(x2, y2, x2old, y2old, r1, r2, angle, 0, sweepFlag, [f2, f2old, cx, cy]);
+    params = arcToCubicCurves(x2, y2, x2old, y2old, r1, r2, angle2, 0, sweepFlag, [f2, f2old, cx, cy]);
   }
   df = f2 - f1;
   const c1 = Math.cos(f1);
@@ -1227,8 +1227,8 @@ function patternFillArc(x, y, width, height, start, stop, o) {
   }
   const increment = (stp - strt) / o.curveStepCount;
   const points = [];
-  for (let angle = strt; angle <= stp; angle = angle + increment) {
-    points.push([cx + rx * Math.cos(angle), cy + ry * Math.sin(angle)]);
+  for (let angle2 = strt; angle2 <= stp; angle2 = angle2 + increment) {
+    points.push([cx + rx * Math.cos(angle2), cy + ry * Math.sin(angle2)]);
   }
   points.push([cx + rx * Math.cos(stp), cy + ry * Math.sin(stp)]);
   points.push([cx, cy]);
@@ -1414,10 +1414,10 @@ function _computeEllipsePoints(increment, cx, cy, rx, ry, offset, overlap, o) {
       cx + rx * Math.cos(-increment),
       cy + ry * Math.sin(-increment)
     ]);
-    for (let angle = 0; angle <= Math.PI * 2; angle = angle + increment) {
+    for (let angle2 = 0; angle2 <= Math.PI * 2; angle2 = angle2 + increment) {
       const p = [
-        cx + rx * Math.cos(angle),
-        cy + ry * Math.sin(angle)
+        cx + rx * Math.cos(angle2),
+        cy + ry * Math.sin(angle2)
       ];
       corePoints.push(p);
       allPoints.push(p);
@@ -1437,10 +1437,10 @@ function _computeEllipsePoints(increment, cx, cy, rx, ry, offset, overlap, o) {
       _offsetOpt(offset, o) + cy + 0.9 * ry * Math.sin(radOffset - increment)
     ]);
     const endAngle = Math.PI * 2 + radOffset - 0.01;
-    for (let angle = radOffset; angle < endAngle; angle = angle + increment) {
+    for (let angle2 = radOffset; angle2 < endAngle; angle2 = angle2 + increment) {
       const p = [
-        _offsetOpt(offset, o) + cx + rx * Math.cos(angle),
-        _offsetOpt(offset, o) + cy + ry * Math.sin(angle)
+        _offsetOpt(offset, o) + cx + rx * Math.cos(angle2),
+        _offsetOpt(offset, o) + cy + ry * Math.sin(angle2)
       ];
       corePoints.push(p);
       allPoints.push(p);
@@ -1467,10 +1467,10 @@ function _arc(increment, cx, cy, rx, ry, strt, stp, offset, o) {
     _offsetOpt(offset, o) + cx + 0.9 * rx * Math.cos(radOffset - increment),
     _offsetOpt(offset, o) + cy + 0.9 * ry * Math.sin(radOffset - increment)
   ]);
-  for (let angle = radOffset; angle <= stp; angle = angle + increment) {
+  for (let angle2 = radOffset; angle2 <= stp; angle2 = angle2 + increment) {
     points.push([
-      _offsetOpt(offset, o) + cx + rx * Math.cos(angle),
-      _offsetOpt(offset, o) + cy + ry * Math.sin(angle)
+      _offsetOpt(offset, o) + cx + rx * Math.cos(angle2),
+      _offsetOpt(offset, o) + cy + ry * Math.sin(angle2)
     ]);
   }
   points.push([
@@ -2267,11 +2267,10 @@ import {
 } from "@excalidraw/common";
 import {
   degreesToRadians,
-  lineSegment as lineSegment7,
-  pointDistance as pointDistance7,
-  pointFrom as pointFrom14,
+  lineSegment as lineSegment6,
+  pointFrom as pointFrom13,
   pointFromArray as pointFromArray3,
-  pointRotateRads as pointRotateRads13
+  pointRotateRads as pointRotateRads12
 } from "@excalidraw/math";
 
 // ../utils/src/shape.ts
@@ -2296,24 +2295,24 @@ import {
 } from "@excalidraw/math";
 import { getElementAbsoluteCoords } from "@excalidraw/element";
 var getPolygonShape = (element) => {
-  const { angle, width, height, x, y } = element;
+  const { angle: angle2, width, height, x, y } = element;
   const cx = x + width / 2;
   const cy = y + height / 2;
   const center = pointFrom(cx, cy);
   let data;
   if (element.type === "diamond") {
     data = polygon2(
-      pointRotateRads(pointFrom(cx, y), center, angle),
-      pointRotateRads(pointFrom(x + width, cy), center, angle),
-      pointRotateRads(pointFrom(cx, y + height), center, angle),
-      pointRotateRads(pointFrom(x, cy), center, angle)
+      pointRotateRads(pointFrom(cx, y), center, angle2),
+      pointRotateRads(pointFrom(x + width, cy), center, angle2),
+      pointRotateRads(pointFrom(cx, y + height), center, angle2),
+      pointRotateRads(pointFrom(x, cy), center, angle2)
     );
   } else {
     data = polygon2(
-      pointRotateRads(pointFrom(x, y), center, angle),
-      pointRotateRads(pointFrom(x + width, y), center, angle),
-      pointRotateRads(pointFrom(x + width, y + height), center, angle),
-      pointRotateRads(pointFrom(x, y + height), center, angle)
+      pointRotateRads(pointFrom(x, y), center, angle2),
+      pointRotateRads(pointFrom(x + width, y), center, angle2),
+      pointRotateRads(pointFrom(x + width, y + height), center, angle2),
+      pointRotateRads(pointFrom(x, y + height), center, angle2)
     );
   }
   return {
@@ -2322,12 +2321,12 @@ var getPolygonShape = (element) => {
   };
 };
 var getEllipseShape = (element) => {
-  const { width, height, angle, x, y } = element;
+  const { width, height, angle: angle2, x, y } = element;
   return {
     type: "ellipse",
     data: {
       center: pointFrom(x + width / 2, y + height / 2),
-      angle,
+      angle: angle2,
       halfWidth: width / 2,
       halfHeight: height / 2
     }
@@ -2611,11 +2610,367 @@ function ae(e, t = {}) {
   return ce(me(e, t), t);
 }
 
+// ../laser-pointer/src/index.ts
+init_define_import_meta_env();
+
+// ../laser-pointer/src/state.ts
+init_define_import_meta_env();
+
+// ../laser-pointer/src/math.ts
+init_define_import_meta_env();
+function add([ax, ay, ar], [bx, by, br]) {
+  return [ax + bx, ay + by, ar + br];
+}
+function sub([ax, ay, ar], [bx, by, br]) {
+  return [ax - bx, ay - by, ar - br];
+}
+function smul([x, y, r], s) {
+  return [x * s, y * s, r * s];
+}
+function norm([x, y, r]) {
+  return [x / Math.sqrt(x ** 2 + y ** 2), y / Math.sqrt(x ** 2 + y ** 2), r];
+}
+function rot([x, y, r], rad) {
+  return [
+    Math.cos(rad) * x - Math.sin(rad) * y,
+    Math.sin(rad) * x + Math.cos(rad) * y,
+    r
+  ];
+}
+function plerp(a2, b2, t) {
+  return add(a2, smul(sub(b2, a2), t));
+}
+function angle(p, p1, p2) {
+  return Math.atan2(p2[1] - p[1], p2[0] - p[0]) - Math.atan2(p1[1] - p[1], p1[0] - p[0]);
+}
+function normAngle(a2) {
+  return Math.atan2(Math.sin(a2), Math.cos(a2));
+}
+function mag([x, y]) {
+  return Math.sqrt(x ** 2 + y ** 2);
+}
+function dist([ax, ay], [bx, by]) {
+  return Math.sqrt((bx - ax) ** 2 + (by - ay) ** 2);
+}
+function runLength(ps) {
+  if (ps.length < 2) {
+    return 0;
+  }
+  let len = 0;
+  for (let i = 1; i <= ps.length - 1; i++) {
+    len += dist(ps[i - 1], ps[i]);
+  }
+  len += dist(ps[ps.length - 2], ps[ps.length - 1]);
+  return len;
+}
+var clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+function distancePointToSegment(p3, p1, p2) {
+  const sMag = dist(p1, p2);
+  if (sMag === 0) {
+    return dist(p3, p1);
+  }
+  const u = clamp(
+    ((p3[0] - p1[0]) * (p2[0] - p1[0]) + (p3[1] - p1[1]) * (p2[1] - p1[1])) / sMag ** 2,
+    0,
+    1
+  );
+  const pi = [
+    p1[0] + u * (p2[0] - p1[0]),
+    p1[1] + u * (p2[1] - p1[1]),
+    p3[2]
+  ];
+  return dist(pi, p3);
+}
+
+// ../laser-pointer/src/simplify.ts
+init_define_import_meta_env();
+function douglasPeucker(points, epsilon) {
+  if (epsilon === 0) {
+    return points;
+  }
+  if (points.length <= 2) {
+    return points;
+  }
+  const first = points[0];
+  const last = points[points.length - 1];
+  const [maxDistance, maxIndex] = points.reduce(
+    ([maxDistance2, maxIndex2], point, index) => {
+      const distance3 = distancePointToSegment(point, first, last);
+      return distance3 > maxDistance2 ? [distance3, index] : [maxDistance2, maxIndex2];
+    },
+    [0, -1]
+  );
+  if (maxDistance >= epsilon) {
+    const maxIndexPoint = points[maxIndex];
+    return [
+      ...douglasPeucker(
+        [first, ...points.slice(1, maxIndex), maxIndexPoint],
+        epsilon
+      ).slice(0, -1),
+      maxIndexPoint,
+      ...douglasPeucker(
+        [maxIndexPoint, ...points.slice(maxIndex, -1), last],
+        epsilon
+      ).slice(1)
+    ];
+  }
+  return [first, last];
+}
+
+// ../laser-pointer/src/state.ts
+var LaserPointer = class _LaserPointer {
+  static defaults = {
+    size: 2,
+    streamline: 0.45,
+    simplify: 0.1,
+    simplifyPhase: "output",
+    keepHead: false,
+    sizeMapping: () => 1
+  };
+  static constants = {
+    cornerDetectionMaxAngle: 75,
+    cornerDetectionVariance: (s) => s > 35 ? 0.5 : 1,
+    maxTailLength: 50
+  };
+  options;
+  constructor(options) {
+    this.options = Object.assign({}, _LaserPointer.defaults, options);
+  }
+  originalPoints = [];
+  stablePoints = [];
+  tailPoints = [];
+  isFresh = true;
+  get lastPoint() {
+    return this.tailPoints[this.tailPoints.length - 1] ?? this.stablePoints[this.stablePoints.length - 1];
+  }
+  addPoint(point) {
+    const lastPoint = this.originalPoints[this.originalPoints.length - 1];
+    if (lastPoint && lastPoint[0] === point[0] && lastPoint[1] === point[1]) {
+      return;
+    }
+    this.originalPoints.push(point);
+    if (this.isFresh) {
+      this.isFresh = false;
+      this.stablePoints.push(point);
+      return;
+    }
+    if (this.options.streamline > 0) {
+      point = plerp(this.lastPoint, point, 1 - this.options.streamline);
+    }
+    this.tailPoints.push(point);
+    if (runLength(this.tailPoints) > _LaserPointer.constants.maxTailLength) {
+      this.stabilizeTail();
+    }
+  }
+  close() {
+    this.stabilizeTail();
+  }
+  stabilizeTail() {
+    if (this.options.simplify > 0 && this.options.simplifyPhase === "tail") {
+      throw new Error("Not implemented yet");
+    } else {
+      this.stablePoints.push(...this.tailPoints);
+      this.tailPoints = [];
+    }
+  }
+  getSize(sizeOverride, pressure, index, totalLength, runningLength) {
+    return (sizeOverride ?? this.options.size) * this.options.sizeMapping({
+      pressure,
+      runningLength,
+      currentIndex: index,
+      totalLength
+    });
+  }
+  getStrokeOutline(sizeOverride) {
+    if (this.isFresh) {
+      return [];
+    }
+    let points = [...this.stablePoints, ...this.tailPoints];
+    if (this.options.simplify > 0 && this.options.simplifyPhase === "input") {
+      points = douglasPeucker(points, this.options.simplify);
+    }
+    const len = points.length;
+    if (len === 0) {
+      return [];
+    }
+    if (len === 1) {
+      const c = points[0];
+      const size = this.getSize(sizeOverride, c[2], 0, len, 0);
+      if (size < 0.5) {
+        return [];
+      }
+      const ps = [];
+      for (let theta = 0; theta <= Math.PI * 2; theta += Math.PI / 16) {
+        ps.push(add(c, smul(rot([1, 0, 0], theta), size)));
+      }
+      ps.push(
+        add(
+          c,
+          smul(
+            [1, 0, 0],
+            this.getSize(sizeOverride, c[2], 0, len, 0)
+          )
+        )
+      );
+      return ps;
+    }
+    if (len === 2) {
+      const c = points[0];
+      const n = points[1];
+      const cSize = this.getSize(sizeOverride, c[2], 0, len, 0);
+      const nSize = this.getSize(sizeOverride, n[2], 0, len, 0);
+      if (cSize < 0.5 || nSize < 0.5) {
+        return [];
+      }
+      const ps = [];
+      const pAngle = angle(c, [c[0], c[1] - 100, c[2]], n);
+      for (let theta = pAngle; theta <= Math.PI + pAngle; theta += Math.PI / 16) {
+        ps.push(add(c, smul(rot([1, 0, 0], theta), cSize)));
+      }
+      for (let theta = Math.PI + pAngle; theta <= Math.PI * 2 + pAngle; theta += Math.PI / 16) {
+        ps.push(add(n, smul(rot([1, 0, 0], theta), nSize)));
+      }
+      ps.push(ps[0]);
+      return ps;
+    }
+    const forwardPoints = [];
+    const backwardPoints = [];
+    let speed = 0;
+    let prevSpeed = 0;
+    let visibleStartIndex = 0;
+    let runningLength = 0;
+    for (let i = 1; i < len - 1; i++) {
+      const p = points[i - 1];
+      const c = points[i];
+      const n = points[i + 1];
+      const pressure = c[2];
+      const d = dist(p, c);
+      runningLength += d;
+      speed = prevSpeed + (d - prevSpeed) * 0.2;
+      const cSize = this.getSize(sizeOverride, pressure, i, len, runningLength);
+      if (cSize === 0) {
+        visibleStartIndex = i + 1;
+        continue;
+      }
+      const dirPC = norm(sub(p, c));
+      const dirNC = norm(sub(n, c));
+      const p1dirPC = rot(dirPC, Math.PI / 2);
+      const p2dirPC = rot(dirPC, -Math.PI / 2);
+      const p1dirNC = rot(dirNC, Math.PI / 2);
+      const p2dirNC = rot(dirNC, -Math.PI / 2);
+      const p1PC = add(c, smul(p1dirPC, cSize));
+      const p2PC = add(c, smul(p2dirPC, cSize));
+      const p1NC = add(c, smul(p1dirNC, cSize));
+      const p2NC = add(c, smul(p2dirNC, cSize));
+      const ftdir = add(p1dirPC, p2dirNC);
+      const btdir = add(p2dirPC, p1dirNC);
+      const paPC = add(
+        c,
+        smul(mag(ftdir) === 0 ? dirPC : norm(ftdir), cSize)
+      );
+      const paNC = add(
+        c,
+        smul(mag(btdir) === 0 ? dirNC : norm(btdir), cSize)
+      );
+      const cAngle = normAngle(angle(c, p, n));
+      const D_ANGLE = _LaserPointer.constants.cornerDetectionMaxAngle / 180 * Math.PI * _LaserPointer.constants.cornerDetectionVariance(speed);
+      if (Math.abs(cAngle) < D_ANGLE) {
+        const tAngle = Math.abs(normAngle(Math.PI - cAngle));
+        if (tAngle === 0) {
+          continue;
+        }
+        if (cAngle < 0) {
+          backwardPoints.push(p2PC, paNC);
+          for (let theta = 0; theta <= tAngle; theta += tAngle / 4) {
+            forwardPoints.push(add(c, rot(smul(p1dirPC, cSize), theta)));
+          }
+          for (let theta = tAngle; theta >= 0; theta -= tAngle / 4) {
+            backwardPoints.push(add(c, rot(smul(p1dirPC, cSize), theta)));
+          }
+          backwardPoints.push(paNC, p1NC);
+        } else {
+          forwardPoints.push(p1PC, paPC);
+          for (let theta = 0; theta <= tAngle; theta += tAngle / 4) {
+            backwardPoints.push(
+              add(c, rot(smul(p1dirPC, -cSize), -theta))
+            );
+          }
+          for (let theta = tAngle; theta >= 0; theta -= tAngle / 4) {
+            forwardPoints.push(
+              add(c, rot(smul(p1dirPC, -cSize), -theta))
+            );
+          }
+          forwardPoints.push(paPC, p2NC);
+        }
+      } else {
+        forwardPoints.push(paPC);
+        backwardPoints.push(paNC);
+      }
+      prevSpeed = speed;
+    }
+    if (visibleStartIndex >= len - 2) {
+      if (this.options.keepHead) {
+        const c = points[len - 1];
+        const ps = [];
+        for (let theta = 0; theta <= Math.PI * 2; theta += Math.PI / 16) {
+          ps.push(
+            add(
+              c,
+              smul(rot([1, 0, 0], theta), this.options.size)
+            )
+          );
+        }
+        ps.push(add(c, smul([1, 0, 0], this.options.size)));
+        return ps;
+      }
+      return [];
+    }
+    const first = points[visibleStartIndex];
+    const second = points[visibleStartIndex + 1];
+    const penultimate = points[len - 2];
+    const ultimate = points[len - 1];
+    const dirFS = norm(sub(second, first));
+    const dirPU = norm(sub(penultimate, ultimate));
+    const ppdirFS = rot(dirFS, -Math.PI / 2);
+    const ppdirPU = rot(dirPU, Math.PI / 2);
+    const startCapSize = this.getSize(sizeOverride, first[2], 0, len, 0);
+    const startCap = [];
+    const endCapSize = this.options.keepHead ? this.options.size : this.getSize(sizeOverride, penultimate[2], len - 2, len, runningLength);
+    const endCap = [];
+    if (startCapSize > 0.1) {
+      for (let theta = 0; theta <= Math.PI; theta += Math.PI / 16) {
+        startCap.unshift(
+          add(first, rot(smul(ppdirFS, startCapSize), -theta))
+        );
+      }
+      startCap.unshift(add(first, smul(ppdirFS, -startCapSize)));
+    } else {
+      startCap.push(first);
+    }
+    for (let theta = 0; theta <= Math.PI * 3; theta += Math.PI / 16) {
+      endCap.push(add(ultimate, rot(smul(ppdirPU, -endCapSize), -theta)));
+    }
+    const strokeOutline = [
+      ...startCap,
+      ...forwardPoints,
+      ...endCap.reverse(),
+      ...backwardPoints.reverse()
+    ];
+    if (startCap.length > 0) {
+      strokeOutline.push(startCap[0]);
+    }
+    if (this.options.simplify > 0 && this.options.simplifyPhase === "output") {
+      return douglasPeucker(strokeOutline, this.options.simplify);
+    }
+    return strokeOutline;
+  }
+};
+
 // src/shape.ts
 import {
-  pointFrom as pointFrom13,
+  pointFrom as pointFrom12,
   pointDistance as pointDistance6,
-  pointRotateRads as pointRotateRads12
+  pointRotateRads as pointRotateRads11
 } from "@excalidraw/math";
 import {
   ROUGHNESS,
@@ -2624,16 +2979,17 @@ import {
   assertNever as assertNever2,
   COLOR_PALETTE,
   LINE_POLYGON_POINT_MERGE_DISTANCE,
-  applyDarkModeFilter as applyDarkModeFilter2
+  applyDarkModeFilter as applyDarkModeFilter2,
+  DEFAULT_STROKE_STREAMLINE
 } from "@excalidraw/common";
 
 // src/renderElement.ts
 init_define_import_meta_env();
 import {
   isRightAngleRads,
-  lineSegment as lineSegment6,
-  pointFrom as pointFrom12,
-  pointRotateRads as pointRotateRads11
+  lineSegment as lineSegment5,
+  pointFrom as pointFrom11,
+  pointRotateRads as pointRotateRads10
 } from "@excalidraw/math";
 import {
   BOUND_TEXT_PADDING as BOUND_TEXT_PADDING3,
@@ -2664,7 +3020,7 @@ import {
   vectorAdd as vectorAdd2,
   vectorScale as vectorScale2,
   pointFromVector as pointFromVector2,
-  clamp,
+  clamp as clamp2,
   isCloseTo
 } from "@excalidraw/math";
 var MINIMAL_CROP_SIZE = 10;
@@ -2698,7 +3054,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
   let changeInHeight = pointerY - element.y;
   let changeInWidth = pointerX - element.x;
   if (transformHandle.includes("n")) {
-    nextHeight = clamp(
+    nextHeight = clamp2(
       element.height - changeInHeight,
       MINIMAL_CROP_SIZE,
       isFlippedByY ? uncroppedHeight - croppedTop : element.height + croppedTop
@@ -2706,7 +3062,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
   }
   if (transformHandle.includes("s")) {
     changeInHeight = pointerY - element.y - element.height;
-    nextHeight = clamp(
+    nextHeight = clamp2(
       element.height + changeInHeight,
       MINIMAL_CROP_SIZE,
       isFlippedByY ? element.height + croppedTop : uncroppedHeight - croppedTop
@@ -2714,14 +3070,14 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
   }
   if (transformHandle.includes("e")) {
     changeInWidth = pointerX - element.x - element.width;
-    nextWidth = clamp(
+    nextWidth = clamp2(
       element.width + changeInWidth,
       MINIMAL_CROP_SIZE,
       isFlippedByX ? element.width + croppedLeft : uncroppedWidth - croppedLeft
     );
   }
   if (transformHandle.includes("w")) {
-    nextWidth = clamp(
+    nextWidth = clamp2(
       element.width - changeInWidth,
       MINIMAL_CROP_SIZE,
       isFlippedByX ? uncroppedWidth - croppedLeft : element.width + croppedLeft
@@ -2761,7 +3117,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
         const distanceToLeft = croppedLeft + element.width / 2;
         const distanceToRight = uncroppedWidth - croppedLeft - element.width / 2;
         const MAX_WIDTH = Math.min(distanceToLeft, distanceToRight) * 2;
-        nextWidth = clamp(
+        nextWidth = clamp2(
           nextHeight * widthAspectRatio,
           MINIMAL_CROP_SIZE,
           MAX_WIDTH
@@ -2779,7 +3135,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
         const distanceToLeft = croppedLeft + element.width / 2;
         const distanceToRight = uncroppedWidth - croppedLeft - element.width / 2;
         const MAX_WIDTH = Math.min(distanceToLeft, distanceToRight) * 2;
-        nextWidth = clamp(
+        nextWidth = clamp2(
           nextHeight * widthAspectRatio,
           MINIMAL_CROP_SIZE,
           MAX_WIDTH
@@ -2797,7 +3153,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
         const distanceToTop = croppedTop + element.height / 2;
         const distanceToBottom = uncroppedHeight - croppedTop - element.height / 2;
         const MAX_HEIGHT = Math.min(distanceToTop, distanceToBottom) * 2;
-        nextHeight = clamp(
+        nextHeight = clamp2(
           nextWidth / widthAspectRatio,
           MINIMAL_CROP_SIZE,
           MAX_HEIGHT
@@ -2815,7 +3171,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
         const distanceToTop = croppedTop + element.height / 2;
         const distanceToBottom = uncroppedHeight - croppedTop - element.height / 2;
         const MAX_HEIGHT = Math.min(distanceToTop, distanceToBottom) * 2;
-        nextHeight = clamp(
+        nextHeight = clamp2(
           nextWidth / widthAspectRatio,
           MINIMAL_CROP_SIZE,
           MAX_HEIGHT
@@ -2832,7 +3188,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
       if (widthAspectRatio) {
         if (changeInWidth > -changeInHeight) {
           const MAX_HEIGHT = isFlippedByY ? uncroppedHeight - croppedTop : croppedTop + element.height;
-          nextHeight = clamp(
+          nextHeight = clamp2(
             nextWidth / widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_HEIGHT
@@ -2840,7 +3196,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
           nextWidth = nextHeight * widthAspectRatio;
         } else {
           const MAX_WIDTH = isFlippedByX ? croppedLeft + element.width : uncroppedWidth - croppedLeft;
-          nextWidth = clamp(
+          nextWidth = clamp2(
             nextHeight * widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_WIDTH
@@ -2855,7 +3211,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
       if (widthAspectRatio) {
         if (changeInWidth < changeInHeight) {
           const MAX_HEIGHT = isFlippedByY ? uncroppedHeight - croppedTop : croppedTop + element.height;
-          nextHeight = clamp(
+          nextHeight = clamp2(
             nextWidth / widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_HEIGHT
@@ -2863,7 +3219,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
           nextWidth = nextHeight * widthAspectRatio;
         } else {
           const MAX_WIDTH = isFlippedByX ? uncroppedWidth - croppedLeft : croppedLeft + element.width;
-          nextWidth = clamp(
+          nextWidth = clamp2(
             nextHeight * widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_WIDTH
@@ -2878,7 +3234,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
       if (widthAspectRatio) {
         if (changeInWidth > changeInHeight) {
           const MAX_HEIGHT = isFlippedByY ? croppedTop + element.height : uncroppedHeight - croppedTop;
-          nextHeight = clamp(
+          nextHeight = clamp2(
             nextWidth / widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_HEIGHT
@@ -2886,7 +3242,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
           nextWidth = nextHeight * widthAspectRatio;
         } else {
           const MAX_WIDTH = isFlippedByX ? croppedLeft + element.width : uncroppedWidth - croppedLeft;
-          nextWidth = clamp(
+          nextWidth = clamp2(
             nextHeight * widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_WIDTH
@@ -2901,7 +3257,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
       if (widthAspectRatio) {
         if (-changeInWidth > changeInHeight) {
           const MAX_HEIGHT = isFlippedByY ? croppedTop + element.height : uncroppedHeight - croppedTop;
-          nextHeight = clamp(
+          nextHeight = clamp2(
             nextWidth / widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_HEIGHT
@@ -2909,7 +3265,7 @@ var cropElement = (element, elementsMap, transformHandle, naturalWidth, naturalH
           nextWidth = nextHeight * widthAspectRatio;
         } else {
           const MAX_WIDTH = isFlippedByX ? uncroppedWidth - croppedLeft : croppedLeft + element.width;
-          nextWidth = clamp(
+          nextWidth = clamp2(
             nextHeight * widthAspectRatio,
             MINIMAL_CROP_SIZE,
             MAX_WIDTH
@@ -2977,17 +3333,17 @@ var recomputeOrigin = (stateAtCropStart, transformHandle, width, height, shouldM
       newTopLeft[1] = startCenter[1] - newBoundsHeight / 2;
     }
   }
-  const angle = stateAtCropStart.angle;
-  const rotatedTopLeft = pointRotateRads2(newTopLeft, startCenter, angle);
+  const angle2 = stateAtCropStart.angle;
+  const rotatedTopLeft = pointRotateRads2(newTopLeft, startCenter, angle2);
   const newCenter = [
     newTopLeft[0] + Math.abs(newBoundsWidth) / 2,
     newTopLeft[1] + Math.abs(newBoundsHeight) / 2
   ];
-  const rotatedNewCenter = pointRotateRads2(newCenter, startCenter, angle);
+  const rotatedNewCenter = pointRotateRads2(newCenter, startCenter, angle2);
   newTopLeft = pointRotateRads2(
     rotatedTopLeft,
     rotatedNewCenter,
-    -angle
+    -angle2
   );
   const newOrigin = [...newTopLeft];
   newOrigin[0] += stateAtCropStart.x - newBoundsX1;
@@ -3149,7 +3505,7 @@ import {
 } from "@excalidraw/common";
 import {
   PRECISION as PRECISION2,
-  clamp as clamp3,
+  clamp as clamp4,
   lineSegment as lineSegment4,
   pointDistance as pointDistance4,
   pointDistanceSq,
@@ -4695,8 +5051,8 @@ var computeBoundTextPosition = (container, boundTextElement, elementsMap) => {
   } else {
     x = containerCoords.x + (maxContainerWidth / 2 - boundTextElement.width / 2);
   }
-  const angle = container.angle ?? 0;
-  if (angle !== 0) {
+  const angle2 = container.angle ?? 0;
+  if (angle2 !== 0) {
     const contentCenter = pointFrom4(
       containerCoords.x + maxContainerWidth / 2,
       containerCoords.y + maxContainerHeight / 2
@@ -4705,7 +5061,7 @@ var computeBoundTextPosition = (container, boundTextElement, elementsMap) => {
       x + boundTextElement.width / 2,
       y + boundTextElement.height / 2
     );
-    const [rx, ry] = pointRotateRads4(textCenter, contentCenter, angle);
+    const [rx, ry] = pointRotateRads4(textCenter, contentCenter, angle2);
     return {
       x: rx - boundTextElement.width / 2,
       y: ry - boundTextElement.height / 2
@@ -4722,7 +5078,13 @@ var getBoundTextElement = (element, elementsMap) => {
   }
   const boundTextElementId = getBoundTextElementId(element);
   if (boundTextElementId) {
-    return elementsMap.get(boundTextElementId) || null;
+    const boundTextElement = elementsMap.get(boundTextElementId) || null;
+    if (boundTextElement && !isNonDeletedElement(boundTextElement)) {
+      console.error(
+        "[NONDELETED][INVARIANT] Bound text element `isDeleted: true` which is not expected."
+      );
+    }
+    return boundTextElement;
   }
   return null;
 };
@@ -4962,6 +5324,7 @@ var hasBackground = (type) => type === "rectangle" || type === "iframe" || type
 var hasStrokeColor = (type) => type === "rectangle" || type === "ellipse" || type === "diamond" || type === "freedraw" || type === "arrow" || type === "line" || type === "text" || type === "embeddable";
 var hasStrokeWidth = (type) => type === "rectangle" || type === "iframe" || type === "embeddable" || type === "ellipse" || type === "diamond" || type === "freedraw" || type === "arrow" || type === "line";
 var hasStrokeStyle = (type) => type === "rectangle" || type === "iframe" || type === "embeddable" || type === "ellipse" || type === "diamond" || type === "arrow" || type === "line";
+var hasFreedrawMode = (type) => type === "freedraw";
 var canChangeRoundness = (type) => type === "rectangle" || type === "iframe" || type === "embeddable" || type === "line" || type === "diamond" || type === "image";
 var toolIsArrow = (type) => type === "arrow";
 var canHaveArrowheads = (type) => type === "arrow";
@@ -5030,8 +5393,8 @@ var hitElementItself = ({
   cachedHit = result;
   return result;
 };
-var isPointInRotatedBounds = (point, bounds, angle, tolerance = 0) => {
-  const adjustedPoint = angle === 0 ? point : pointRotateRads6(point, getCenterForBounds(bounds), -angle);
+var isPointInRotatedBounds = (point, bounds, angle2, tolerance = 0) => {
+  const adjustedPoint = angle2 === 0 ? point : pointRotateRads6(point, getCenterForBounds(bounds), -angle2);
   return isPointWithinBounds(
     pointFrom5(bounds[0] - tolerance, bounds[1] - tolerance),
     adjustedPoint,
@@ -5207,7 +5570,7 @@ var intersectElementWithLineSegment = (element, elementsMap, line2, offset = 0,
       );
   }
 };
-var curveIntersections = (curves, segment, intersections, center, angle, onlyFirst = false) => {
+var curveIntersections = (curves, segment, intersections, center, angle2, onlyFirst = false) => {
   for (const c of curves) {
     const b1 = getCubicBezierCurveBound(c[0], c[1], c[2], c[3]);
     const b2 = [
@@ -5222,7 +5585,7 @@ var curveIntersections = (curves, segment, intersections, center, angle, onlyFir
     const hits = curveIntersectLineSegment(c, segment);
     if (hits.length > 0) {
       for (const j of hits) {
-        intersections.push(pointRotateRads6(j, center, angle));
+        intersections.push(pointRotateRads6(j, center, angle2));
       }
       if (onlyFirst) {
         return intersections;
@@ -5231,11 +5594,11 @@ var curveIntersections = (curves, segment, intersections, center, angle, onlyFir
   }
   return intersections;
 };
-var lineIntersections = (lines, segment, intersections, center, angle, onlyFirst = false) => {
+var lineIntersections = (lines, segment, intersections, center, angle2, onlyFirst = false) => {
   for (const l2 of lines) {
     const intersection = lineSegmentIntersectionPoints2(l2, segment);
     if (intersection) {
-      intersections.push(pointRotateRads6(intersection, center, angle));
+      intersections.push(pointRotateRads6(intersection, center, angle2));
       if (onlyFirst) {
         return intersections;
       }
@@ -5381,7 +5744,7 @@ var isPointInElement = (point, element, elementsMap) => {
 };
 var isBindableElementInsideOtherBindable = (innerElement, outerElement, elementsMap) => {
   const getCornerPoints = (element, offset2) => {
-    const { x, y, width, height, angle } = element;
+    const { x, y, width, height, angle: angle2 } = element;
     const center = elementCenterPoint(element, elementsMap);
     if (element.type === "diamond") {
       const [topX, topY, rightX, rightY, bottomX, bottomY, leftX, leftY] = getDiamondPoints(element);
@@ -5395,7 +5758,7 @@ var isBindableElementInsideOtherBindable = (innerElement, outerElement, elements
         pointFrom5(x + leftX - offset2, y + leftY)
         // left
       ];
-      return corners2.map((corner) => pointRotateRads6(corner, center, angle));
+      return corners2.map((corner) => pointRotateRads6(corner, center, angle2));
     }
     if (element.type === "ellipse") {
       const cx = x + width / 2;
@@ -5412,7 +5775,7 @@ var isBindableElementInsideOtherBindable = (innerElement, outerElement, elements
         pointFrom5(cx - rx - offset2, cy)
         // left
       ];
-      return corners2.map((corner) => pointRotateRads6(corner, center, angle));
+      return corners2.map((corner) => pointRotateRads6(corner, center, angle2));
     }
     const corners = [
       pointFrom5(x - offset2, y - offset2),
@@ -5424,7 +5787,7 @@ var isBindableElementInsideOtherBindable = (innerElement, outerElement, elements
       pointFrom5(x - offset2, y + height + offset2)
       // bottom-left
     ];
-    return corners.map((corner) => pointRotateRads6(corner, center, angle));
+    return corners.map((corner) => pointRotateRads6(corner, center, angle2));
   };
   const offset = -1 * Math.max(innerElement.width, innerElement.height) / 20;
   const innerCorners = getCornerPoints(innerElement, offset);
@@ -5650,7 +6013,7 @@ import {
 // src/elbowArrow.ts
 init_define_import_meta_env();
 import {
-  clamp as clamp2,
+  clamp as clamp3,
   pointDistance as pointDistance3,
   pointFrom as pointFrom7,
   pointScaleFromOrigin as pointScaleFromOrigin2,
@@ -6994,12 +7357,12 @@ var normalizeArrowElementUpdate = (global2, nextFixedSegments, startIsSpecial, e
     );
   }
   points = points.map(
-    ([x, y]) => pointFrom7(clamp2(x, -1e6, 1e6), clamp2(y, -1e6, 1e6))
+    ([x, y]) => pointFrom7(clamp3(x, -1e6, 1e6), clamp3(y, -1e6, 1e6))
   );
   return {
     points,
-    x: clamp2(offsetX, -1e6, 1e6),
-    y: clamp2(offsetY, -1e6, 1e6),
+    x: clamp3(offsetX, -1e6, 1e6),
+    y: clamp3(offsetY, -1e6, 1e6),
     fixedSegments: (nextFixedSegments?.length ?? 0) > 0 ? nextFixedSegments : null,
     ...getSizeFromPoints(points),
     startIsSpecial,
@@ -7205,13 +7568,14 @@ var BASE_BINDING_GAP = 5;
 var BASE_BINDING_GAP_ELBOW = 5;
 var BASE_ARROW_MIN_LENGTH = 10;
 var FOCUS_POINT_SIZE = 10 / 1.5;
+var MIN_BINDABLE_SIZE = 1;
 var getBindingGap = (bindTarget, opts) => {
   return (opts.elbowed ? BASE_BINDING_GAP_ELBOW : BASE_BINDING_GAP) + bindTarget.strokeWidth / 2;
 };
 var maxBindingDistance_simple = (zoom) => {
   const BASE_BINDING_DISTANCE = Math.max(BASE_BINDING_GAP, 15);
   const zoomValue = zoom?.value && zoom.value < 1 ? zoom.value : 1;
-  return clamp3(
+  return clamp4(
     // reducing zoom impact so that the diff between binding distance and
     // binding gap is kept to minimum when possible
     BASE_BINDING_DISTANCE / (zoomValue * 1.5),
@@ -7438,7 +7802,9 @@ var bindingStrategyForSimpleArrowEndpointDragging_complex = (point, currentBindi
   const isOverlapping = oppositeBinding ? getAllHoveredElementAtPoint(point, elements, elementsMap).some(
     (el) => el.id === oppositeBinding.elementId
   ) : false;
-  const oppositeElement = oppositeBinding ? elementsMap.get(oppositeBinding.elementId) : null;
+  const oppositeElement = oppositeBinding ? elementsMap.get(
+    oppositeBinding.elementId
+  ) : null;
   const otherIsTransparent = isOverlapping && oppositeElement ? isTransparent2(oppositeElement.backgroundColor) : false;
   const isNested = hit && oppositeElement && isBindableElementInsideOtherBindable(oppositeElement, hit, elementsMap);
   if (globalBindMode === "inside" || globalBindMode === "skip") {
@@ -7523,10 +7889,12 @@ var getBindingStrategyForDraggingBindingElementEndpoints_simple = (arrow, draggi
   const endDragged = draggingPoints.has(endIdx);
   let start = { mode: void 0 };
   let end = { mode: void 0 };
-  invariant7(
-    arrow.points.length > 1,
-    "Do not attempt to bind linear elements with a single point"
-  );
+  if (arrow.points.length < 2) {
+    console.error(
+      "Attempting to bind a linear element with less than 2 points"
+    );
+    return { start: { mode: void 0 }, end: { mode: void 0 } };
+  }
   if (!startDragged && !endDragged) {
     return { start, end };
   }
@@ -7687,10 +8055,12 @@ var getBindingStrategyForDraggingBindingElementEndpoints_complex = (arrow, dragg
   const endDragged = draggingPoints.has(endIdx);
   let start = { mode: void 0 };
   let end = { mode: void 0 };
-  invariant7(
-    arrow.points.length > 1,
-    "Do not attempt to bind linear elements with a single point"
-  );
+  if (arrow.points.length < 2) {
+    console.error(
+      "Attempting to bind a linear element with less than 2 points"
+    );
+    return { start: { mode: void 0 }, end: { mode: void 0 } };
+  }
   if (!startDragged && !endDragged) {
     return { start, end };
   }
@@ -7856,7 +8226,12 @@ var updateBoundElements = (changedElement, scene, options) => {
     });
   }
   const visitor = (element) => {
-    if (!isArrowElement(element) || element.isDeleted) {
+    if (element && !isNonDeletedElement(element)) {
+      console.error(
+        "[NONDELETED][INVARIANT] updateBoundElements(): `isDeleted: true` in visitor"
+      );
+    }
+    if (!isArrowElement(element) || !isNonDeletedElement(element)) {
       return;
     }
     if (!doesNeedUpdate(element, changedElement)) {
@@ -7910,7 +8285,9 @@ var updateArrowBindings = (latestElement, startOrEnd, elementsMap, scene, appSta
     "Elbow arrows not supported for indirect updates"
   );
   const binding = latestElement[startOrEnd];
-  const bindableElement = binding && elementsMap.get(binding.elementId);
+  const bindableElement = binding && elementsMap.get(
+    binding.elementId
+  );
   const point = LinearElementEditor.getPointAtIndexGlobalCoordinates(
     latestElement,
     startOrEnd === "startBinding" ? 0 : -1,
@@ -8175,12 +8552,12 @@ var avoidRectangularCorner = (arrowElement, bindTarget, elementsMap, p) => {
   return p;
 };
 var snapToMid = (bindTarget, elementsMap, p, tolerance = 0.05, arrowElement) => {
-  const { x, y, width, height, angle } = bindTarget;
+  const { x, y, width, height, angle: angle2 } = bindTarget;
   const center = elementCenterPoint(bindTarget, elementsMap, -0.1, -0.1);
-  const nonRotated = pointRotateRads8(p, center, -angle);
+  const nonRotated = pointRotateRads8(p, center, -angle2);
   const bindingGap = arrowElement ? getBindingGap(bindTarget, arrowElement) : 0;
-  const verticalThreshold = clamp3(tolerance * height, 5, 80);
-  const horizontalThreshold = clamp3(tolerance * width, 5, 80);
+  const verticalThreshold = clamp4(tolerance * height, 5, 80);
+  const horizontalThreshold = clamp4(tolerance * width, 5, 80);
   if (pointDistance4(center, nonRotated) < bindingGap) {
     return void 0;
   }
@@ -8188,25 +8565,25 @@ var snapToMid = (bindTarget, elementsMap, p, tolerance = 0.05, arrowElement) =>
     return pointRotateRads8(
       pointFrom8(x - bindingGap, center[1]),
       center,
-      angle
+      angle2
     );
   } else if (nonRotated[1] <= y + height / 2 && nonRotated[0] > center[0] - horizontalThreshold && nonRotated[0] < center[0] + horizontalThreshold) {
     return pointRotateRads8(
       pointFrom8(center[0], y - bindingGap),
       center,
-      angle
+      angle2
     );
   } else if (nonRotated[0] >= x + width / 2 && nonRotated[1] > center[1] - verticalThreshold && nonRotated[1] < center[1] + verticalThreshold) {
     return pointRotateRads8(
       pointFrom8(x + width + bindingGap, center[1]),
       center,
-      angle
+      angle2
     );
   } else if (nonRotated[1] >= y + height / 2 && nonRotated[0] > center[0] - horizontalThreshold && nonRotated[0] < center[0] + horizontalThreshold) {
     return pointRotateRads8(
       pointFrom8(center[0], y + height + bindingGap),
       center,
-      angle
+      angle2
     );
   } else if (bindTarget.type === "diamond") {
     const distance3 = bindingGap;
@@ -8227,16 +8604,16 @@ var snapToMid = (bindTarget, elementsMap, p, tolerance = 0.05, arrowElement) =>
       y + 3 * height / 4 + distance3
     );
     if (pointDistance4(topLeft, nonRotated) < Math.max(horizontalThreshold, verticalThreshold)) {
-      return pointRotateRads8(topLeft, center, angle);
+      return pointRotateRads8(topLeft, center, angle2);
     }
     if (pointDistance4(topRight, nonRotated) < Math.max(horizontalThreshold, verticalThreshold)) {
-      return pointRotateRads8(topRight, center, angle);
+      return pointRotateRads8(topRight, center, angle2);
     }
     if (pointDistance4(bottomLeft, nonRotated) < Math.max(horizontalThreshold, verticalThreshold)) {
-      return pointRotateRads8(bottomLeft, center, angle);
+      return pointRotateRads8(bottomLeft, center, angle2);
     }
     if (pointDistance4(bottomRight, nonRotated) < Math.max(horizontalThreshold, verticalThreshold)) {
-      return pointRotateRads8(bottomRight, center, angle);
+      return pointRotateRads8(bottomRight, center, angle2);
     }
   }
   return void 0;
@@ -8394,10 +8771,14 @@ var calculateFixedPointForElbowArrowBinding = (linearElement, hoveredElement, st
     globalMidPoint,
     -hoveredElement.angle
   );
+  if (hoveredElement.width < MIN_BINDABLE_SIZE || hoveredElement.height < MIN_BINDABLE_SIZE) {
+    return { fixedPoint: normalizeFixedPoint([0.5, 0.5]) };
+  }
+  const sizeFloor = getBindingGap(hoveredElement, linearElement);
   return {
     fixedPoint: normalizeFixedPoint([
-      (nonRotatedSnappedGlobalPoint[0] - hoveredElement.x) / Math.max(hoveredElement.width, PRECISION2),
-      (nonRotatedSnappedGlobalPoint[1] - hoveredElement.y) / Math.max(hoveredElement.height, PRECISION2)
+      (nonRotatedSnappedGlobalPoint[0] - hoveredElement.x) / Math.max(hoveredElement.width, sizeFloor),
+      (nonRotatedSnappedGlobalPoint[1] - hoveredElement.y) / Math.max(hoveredElement.height, sizeFloor)
     ])
   };
 };
@@ -8413,8 +8794,12 @@ var calculateFixedPointForNonElbowArrowBinding = (linearElement, hoveredElement,
     elementCenter,
     -hoveredElement.angle
   );
-  const fixedPointX = (nonRotatedPoint[0] - hoveredElement.x) / Math.max(hoveredElement.width, PRECISION2);
-  const fixedPointY = (nonRotatedPoint[1] - hoveredElement.y) / Math.max(hoveredElement.height, PRECISION2);
+  if (hoveredElement.width < MIN_BINDABLE_SIZE || hoveredElement.height < MIN_BINDABLE_SIZE) {
+    return { fixedPoint: normalizeFixedPoint([0.5, 0.5]) };
+  }
+  const sizeFloor = getBindingGap(hoveredElement, linearElement);
+  const fixedPointX = (nonRotatedPoint[0] - hoveredElement.x) / Math.max(hoveredElement.width, sizeFloor);
+  const fixedPointY = (nonRotatedPoint[1] - hoveredElement.y) / Math.max(hoveredElement.height, sizeFloor);
   return {
     fixedPoint: normalizeFixedPoint([fixedPointX, fixedPointY])
   };
@@ -8739,17 +9124,21 @@ var getArrowLocalFixedPoints = (arrow, elementsMap) => {
 var isFixedPoint = (fixedPoint) => {
   return Array.isArray(fixedPoint) && fixedPoint.length === 2 && fixedPoint.every((coord) => Number.isFinite(coord));
 };
+var FIXED_POINT_BOUND = 10;
 var normalizeFixedPoint = (fixedPoint) => {
   if (!isFixedPoint(fixedPoint)) {
     return [0.5001, 0.5001];
   }
-  const EPSILON2 = 1e-4;
-  if (Math.abs(fixedPoint[0] - 0.5) < EPSILON2 || Math.abs(fixedPoint[1] - 0.5) < EPSILON2) {
-    return fixedPoint.map(
-      (ratio) => Math.abs(ratio - 0.5) < EPSILON2 ? 0.5001 : ratio
+  const EPSILON = 1e-4;
+  const clamped = fixedPoint.map(
+    (ratio) => clamp4(ratio, -FIXED_POINT_BOUND, FIXED_POINT_BOUND)
+  );
+  if (Math.abs(clamped[0] - 0.5) < EPSILON || Math.abs(clamped[1] - 0.5) < EPSILON) {
+    return clamped.map(
+      (ratio) => Math.abs(ratio - 0.5) < EPSILON ? 0.5001 : ratio
     );
   }
-  return fixedPoint;
+  return clamped;
 };
 var getShapeType = (element) => {
   if (element.type === "ellipse" || element.type === "diamond") {
@@ -8806,11 +9195,11 @@ var getShapeSideAdaptive = (fixedPoint, shapeType) => {
   const [x, y] = fixedPoint;
   const centerX = x - 0.5;
   const centerY = y - 0.5;
-  let angle = Math.atan2(centerY, centerX);
-  if (angle < 0) {
-    angle += 2 * Math.PI;
+  let angle2 = Math.atan2(centerY, centerX);
+  if (angle2 < 0) {
+    angle2 += 2 * Math.PI;
   }
-  const degrees = angle * 180 / Math.PI;
+  const degrees = angle2 * 180 / Math.PI;
   const config = SHAPE_CONFIGS[shapeType];
   const boundaries = getSectorBoundaries(config);
   for (const boundary of boundaries) {
@@ -8965,33 +9354,33 @@ var getBindingSideMidPoint = (binding, elementsMap) => {
         break;
       }
       case "top-right": {
-        const angle = -Math.PI / 4;
-        const ellipseX = radiusX * Math.cos(angle);
-        const ellipseY = radiusY * Math.sin(angle);
+        const angle2 = -Math.PI / 4;
+        const ellipseX = radiusX * Math.cos(angle2);
+        const ellipseY = radiusY * Math.sin(angle2);
         x = ellipseCenterX + ellipseX + OFFSET * 0.707;
         y = ellipseCenterY + ellipseY - OFFSET * 0.707;
         break;
       }
       case "bottom-right": {
-        const angle = Math.PI / 4;
-        const ellipseX = radiusX * Math.cos(angle);
-        const ellipseY = radiusY * Math.sin(angle);
+        const angle2 = Math.PI / 4;
+        const ellipseX = radiusX * Math.cos(angle2);
+        const ellipseY = radiusY * Math.sin(angle2);
         x = ellipseCenterX + ellipseX + OFFSET * 0.707;
         y = ellipseCenterY + ellipseY + OFFSET * 0.707;
         break;
       }
       case "bottom-left": {
-        const angle = 3 * Math.PI / 4;
-        const ellipseX = radiusX * Math.cos(angle);
-        const ellipseY = radiusY * Math.sin(angle);
+        const angle2 = 3 * Math.PI / 4;
+        const ellipseX = radiusX * Math.cos(angle2);
+        const ellipseY = radiusY * Math.sin(angle2);
         x = ellipseCenterX + ellipseX - OFFSET * 0.707;
         y = ellipseCenterY + ellipseY + OFFSET * 0.707;
         break;
       }
       case "top-left": {
-        const angle = -3 * Math.PI / 4;
-        const ellipseX = radiusX * Math.cos(angle);
-        const ellipseY = radiusY * Math.sin(angle);
+        const angle2 = -3 * Math.PI / 4;
+        const ellipseX = radiusX * Math.cos(angle2);
+        const ellipseY = radiusY * Math.sin(angle2);
         x = ellipseCenterX + ellipseX - OFFSET * 0.707;
         y = ellipseCenterY + ellipseY - OFFSET * 0.707;
         break;
@@ -10187,11 +10576,11 @@ var LinearElementEditor = class _LinearElementEditor {
       return false;
     }
     const origin = linearElementEditor.initialState.origin;
-    const dist = pointDistance5(
+    const dist2 = pointDistance5(
       origin,
       pointFrom9(pointerCoords.x, pointerCoords.y)
     );
-    if (!appState.selectedLinearElement?.isEditing && dist < DRAGGING_THRESHOLD / appState.zoom.value) {
+    if (!appState.selectedLinearElement?.isEditing && dist2 < DRAGGING_THRESHOLD / appState.zoom.value) {
       return false;
     }
     return true;
@@ -10757,52 +11146,15 @@ var determineCustomLinearAngle = (pivotPoint, draggedPoint) => Math.atan2(dragge
 // src/frame.ts
 init_define_import_meta_env();
 import { arrayToMap as arrayToMap5 } from "@excalidraw/common";
-import { isPointWithinBounds as isPointWithinBounds2, pointFrom as pointFrom11 } from "@excalidraw/math";
-
-// ../utils/src/bbox.ts
-init_define_import_meta_env();
 import {
-  vectorCross as vectorCross3,
-  vectorFromPoint as vectorFromPoint9
+  isPointWithinBounds as isPointWithinBounds2,
+  pointFrom as pointFrom10,
+  segmentsIntersectAt as segmentsIntersectAt2
 } from "@excalidraw/math";
-function getBBox(line2) {
-  return [
-    Math.min(line2[0][0], line2[1][0]),
-    Math.min(line2[0][1], line2[1][1]),
-    Math.max(line2[0][0], line2[1][0]),
-    Math.max(line2[0][1], line2[1][1])
-  ];
-}
-function doBBoxesIntersect(a2, b2) {
-  return a2[0] <= b2[2] && a2[2] >= b2[0] && a2[1] <= b2[3] && a2[3] >= b2[1];
-}
-var EPSILON = 1e-6;
-function isPointOnLine(l2, p) {
-  const p1 = vectorFromPoint9(l2[1], l2[0]);
-  const p2 = vectorFromPoint9(p, l2[0]);
-  const r = vectorCross3(p1, p2);
-  return Math.abs(r) < EPSILON;
-}
-function isPointRightOfLine(l2, p) {
-  const p1 = vectorFromPoint9(l2[1], l2[0]);
-  const p2 = vectorFromPoint9(p, l2[0]);
-  return vectorCross3(p1, p2) < 0;
-}
-function isLineSegmentTouchingOrCrossingLine(a2, b2) {
-  return isPointOnLine(a2, b2[0]) || isPointOnLine(a2, b2[1]) || (isPointRightOfLine(a2, b2[0]) ? !isPointRightOfLine(a2, b2[1]) : isPointRightOfLine(a2, b2[1]));
-}
-function doLineSegmentsIntersect(a2, b2) {
-  return doBBoxesIntersect(getBBox(a2), getBBox(b2)) && isLineSegmentTouchingOrCrossingLine(a2, b2) && isLineSegmentTouchingOrCrossingLine(b2, a2);
-}
 
 // src/selection.ts
 init_define_import_meta_env();
 import { arrayToMap as arrayToMap3, isShallowEqual as isShallowEqual2 } from "@excalidraw/common";
-import {
-  lineSegment as lineSegment5,
-  pointFrom as pointFrom10,
-  pointRotateRads as pointRotateRads10
-} from "@excalidraw/math";
 
 // src/groups.ts
 init_define_import_meta_env();
@@ -11074,7 +11426,9 @@ var getSelectedElementsByGroup = (selectedElements, elementsMap, appState) => {
       addToGroupsMap(element, selectedGroupId);
     }
   });
-  return Array.from(groups.values()).concat(Array.from(elements.values()));
+  return Array.from(groups.values()).concat(
+    Array.from(elements.values())
+  );
 };
 
 // src/selection.ts
@@ -11108,248 +11462,71 @@ var getElementsWithinSelection = (elements, selection, elementsMap, excludeEleme
     selectionX2,
     selectionY2
   ];
-  const selectionEdges = [
-    lineSegment5(
-      pointFrom10(selectionX1, selectionY1),
-      pointFrom10(selectionX2, selectionY1)
-    ),
-    lineSegment5(
-      pointFrom10(selectionX2, selectionY1),
-      pointFrom10(selectionX2, selectionY2)
-    ),
-    lineSegment5(
-      pointFrom10(selectionX2, selectionY2),
-      pointFrom10(selectionX1, selectionY2)
-    ),
-    lineSegment5(
-      pointFrom10(selectionX1, selectionY2),
-      pointFrom10(selectionX1, selectionY1)
-    )
-  ];
-  const framesInSelection = excludeElementsInFrames ? /* @__PURE__ */ new Set() : null;
-  const groups = {};
-  const elementsInSelection = /* @__PURE__ */ new Set();
-  for (const element of elements) {
-    if (shouldIgnoreElementFromSelection(element)) {
-      continue;
+  return elementsOverlappingBBox({
+    elements,
+    bounds: selectionBounds,
+    elementsMap,
+    type: boxSelectionMode,
+    shouldIgnoreElementFromSelection,
+    excludeElementsInFrames
+  });
+};
+var getVisibleAndNonSelectedElements = (elements, selectedElements, appState, elementsMap) => {
+  const selectedElementsSet = new Set(
+    selectedElements.map((element) => element.id)
+  );
+  return elements.filter((element) => {
+    const isVisible = isElementInViewport(
+      element,
+      appState.width,
+      appState.height,
+      appState,
+      elementsMap
+    );
+    return !selectedElementsSet.has(element.id) && isVisible;
+  });
+};
+var isSomeElementSelected = function() {
+  let lastElements = null;
+  let lastSelectedElementIds = null;
+  let isSelected = null;
+  const ret = (elements, appState) => {
+    if (isSelected != null && elements === lastElements && appState.selectedElementIds === lastSelectedElementIds) {
+      return isSelected;
     }
-    const groupId = element.groupIds.at(-1);
-    if (groupId) {
-      if (!groups[groupId]) {
-        groups[groupId] = [];
+    isSelected = elements.some(
+      (element) => appState.selectedElementIds[element.id]
+    );
+    lastElements = elements;
+    lastSelectedElementIds = appState.selectedElementIds;
+    return isSelected;
+  };
+  ret.clearCache = () => {
+    lastElements = null;
+    lastSelectedElementIds = null;
+    isSelected = null;
+  };
+  return ret;
+}();
+var getSelectedElements = (elements, appState, opts) => {
+  const addedElements = /* @__PURE__ */ new Set();
+  const selectedElements = [];
+  for (const element of elements.values()) {
+    if (appState.selectedElementIds[element.id]) {
+      if (isNonDeletedElement(element)) {
+        selectedElements.push(element);
+        addedElements.add(element.id);
+      } else {
+        console.error(
+          "[NONDELETED][INVARIANT] getSelectedElements skipping deleted selected element which should not be in the selection"
+        );
       }
-      groups[groupId].push(element);
+      continue;
     }
-    const strokeWidth = element.strokeWidth;
-    let labelAABB = null;
-    let elementAABB = getElementBounds(element, elementsMap);
-    elementAABB = [
-      elementAABB[0] - strokeWidth / 2,
-      elementAABB[1] - strokeWidth / 2,
-      elementAABB[2] + strokeWidth / 2,
-      elementAABB[3] + strokeWidth / 2
-    ];
-    const boundTextElement = isArrowElement(element) && getBoundTextElement(element, elementsMap);
-    if (boundTextElement) {
-      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
-        element,
-        boundTextElement,
-        elementsMap
-      );
-      labelAABB = [
-        x,
-        y,
-        x + boundTextElement.width,
-        y + boundTextElement.height
-      ];
-    }
-    const associatedFrame = getContainingFrame(element, elementsMap);
-    if (associatedFrame && elementOverlapsWithFrame(element, associatedFrame, elementsMap)) {
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
-      elementAABB = [
-        Math.max(elementAABB[0], frameAABB[0]),
-        Math.max(elementAABB[1], frameAABB[1]),
-        Math.min(elementAABB[2], frameAABB[2]),
-        Math.min(elementAABB[3], frameAABB[3])
-      ];
-      labelAABB = labelAABB ? [
-        Math.max(labelAABB[0], frameAABB[0]),
-        Math.max(labelAABB[1], frameAABB[1]),
-        Math.min(labelAABB[2], frameAABB[2]),
-        Math.min(labelAABB[3], frameAABB[3])
-      ] : null;
-    }
-    const commonAABB2 = labelAABB ? [
-      Math.min(labelAABB[0], elementAABB[0]),
-      Math.min(labelAABB[1], elementAABB[1]),
-      Math.max(labelAABB[2], elementAABB[2]),
-      Math.max(labelAABB[3], elementAABB[3])
-    ] : elementAABB;
-    if (boundsContainBounds(selectionBounds, commonAABB2)) {
-      if (framesInSelection && isFrameLikeElement(element)) {
-        framesInSelection.add(element.id);
-      }
-      elementsInSelection.add(element);
-      continue;
-    }
-    if (boxSelectionMode === "overlap" && labelAABB && doBoundsIntersect(selectionBounds, labelAABB)) {
-      elementsInSelection.add(element);
-      continue;
-    }
-    if (boxSelectionMode === "overlap" && doBoundsIntersect(selectionBounds, elementAABB)) {
-      let hasIntersection = false;
-      if (isLinearElement(element) || isFreeDrawElement(element)) {
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = element.points.some((point) => {
-          const rotatedPoint = pointRotateRads10(
-            pointFrom10(element.x + point[0], element.y + point[1]),
-            center,
-            element.angle
-          );
-          return pointInsideBounds(rotatedPoint, selectionBounds);
-        });
-      } else {
-        const nonRotatedElementBounds = getElementBounds(
-          element,
-          elementsMap,
-          true
-        );
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = [
-          pointRotateRads10(
-            pointFrom10(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[1]
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads10(
-            pointFrom10(
-              nonRotatedElementBounds[2],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads10(
-            pointFrom10(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[3]
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads10(
-            pointFrom10(
-              nonRotatedElementBounds[0],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2
-            ),
-            center,
-            element.angle
-          )
-        ].some((point) => {
-          return pointInsideBounds(
-            pointRotateRads10(point, center, element.angle),
-            selectionBounds
-          );
-        });
-      }
-      if (!hasIntersection) {
-        hasIntersection = selectionEdges.some(
-          (selectionEdge) => intersectElementWithLineSegment(
-            element,
-            elementsMap,
-            selectionEdge,
-            strokeWidth / 2,
-            true
-            // Stop at first hit for better performance
-          ).length > 0
-        );
-      }
-      if (hasIntersection) {
-        if (framesInSelection && isFrameLikeElement(element)) {
-          framesInSelection.add(element.id);
-        }
-        elementsInSelection.add(element);
-        continue;
-      }
-    }
-  }
-  if (framesInSelection) {
-    elementsInSelection.forEach((element) => {
-      if (element.frameId && framesInSelection.has(element.frameId)) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-  if (boxSelectionMode === "overlap") {
-    Array.from(elementsInSelection).forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
-    });
-  } else if (boxSelectionMode === "contain") {
-    elementsInSelection.forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-      if (group && !group.every((groupElement) => elementsInSelection.has(groupElement))) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-  return elements.filter((element) => elementsInSelection.has(element));
-};
-var getVisibleAndNonSelectedElements = (elements, selectedElements, appState, elementsMap) => {
-  const selectedElementsSet = new Set(
-    selectedElements.map((element) => element.id)
-  );
-  return elements.filter((element) => {
-    const isVisible = isElementInViewport(
-      element,
-      appState.width,
-      appState.height,
-      appState,
-      elementsMap
-    );
-    return !selectedElementsSet.has(element.id) && isVisible;
-  });
-};
-var isSomeElementSelected = function() {
-  let lastElements = null;
-  let lastSelectedElementIds = null;
-  let isSelected = null;
-  const ret = (elements, appState) => {
-    if (isSelected != null && elements === lastElements && appState.selectedElementIds === lastSelectedElementIds) {
-      return isSelected;
-    }
-    isSelected = elements.some(
-      (element) => appState.selectedElementIds[element.id]
-    );
-    lastElements = elements;
-    lastSelectedElementIds = appState.selectedElementIds;
-    return isSelected;
-  };
-  ret.clearCache = () => {
-    lastElements = null;
-    lastSelectedElementIds = null;
-    isSelected = null;
-  };
-  return ret;
-}();
-var getSelectedElements = (elements, appState, opts) => {
-  const addedElements = /* @__PURE__ */ new Set();
-  const selectedElements = [];
-  for (const element of elements.values()) {
-    if (appState.selectedElementIds[element.id]) {
-      selectedElements.push(element);
-      addedElements.add(element.id);
-      continue;
-    }
-    if (opts?.includeBoundTextElement && isBoundToContainer(element) && appState.selectedElementIds[element?.containerId]) {
-      selectedElements.push(element);
-      addedElements.add(element.id);
-      continue;
+    if (opts?.includeBoundTextElement && isBoundToContainer(element) && appState.selectedElementIds[element?.containerId]) {
+      selectedElements.push(element);
+      addedElements.add(element.id);
+      continue;
     }
   }
   if (opts?.includeElementsInFrames) {
@@ -11686,7 +11863,7 @@ function isElementIntersectingFrame(element, frame, elementsMap) {
   const elementLineSegments = getElementLineSegments(element, elementsMap);
   const intersecting = frameLineSegments.some(
     (frameLineSegment) => elementLineSegments.some(
-      (elementLineSegment) => doLineSegmentsIntersect(frameLineSegment, elementLineSegment)
+      (elementLineSegment) => segmentsIntersectAt2(frameLineSegment, elementLineSegment)
     )
   );
   return intersecting;
@@ -11722,9 +11899,9 @@ var elementOverlapsWithFrame = (element, frame, elementsMap) => {
 var isCursorInFrame = (cursorCoords, frame, elementsMap) => {
   const [fx1, fy1, fx2, fy2] = getElementAbsoluteCoords2(frame, elementsMap);
   return isPointWithinBounds2(
-    pointFrom11(fx1, fy1),
-    pointFrom11(cursorCoords.x, cursorCoords.y),
-    pointFrom11(fx2, fy2)
+    pointFrom10(fx1, fy1),
+    pointFrom10(cursorCoords.x, cursorCoords.y),
+    pointFrom10(fx2, fy2)
   );
 };
 var groupsAreAtLeastIntersectingTheFrame = (elements, groupIds, frame) => {
@@ -11831,8 +12008,11 @@ var getElementsInResizingFrame = (allElements, frame, appState, elementsMap) =>
   const newGroupElementsCompletelyInFrame = Array.from(
     elementsCompletelyInFrame
   ).filter((element) => element.groupIds.length > 0);
+  const nonDeletedNewGroupElementsCompletelyInFrame = getNonDeletedElements(
+    newGroupElementsCompletelyInFrame
+  );
   const groupIds = selectGroupsFromGivenElements(
-    newGroupElementsCompletelyInFrame,
+    nonDeletedNewGroupElementsCompletelyInFrame,
     appState
   );
   for (const [id, isSelected] of Object.entries(groupIds)) {
@@ -11974,9 +12154,6 @@ var addElementsToFrame = (allElements, elementsToAdd, frame) => {
     if (isFrameLikeElement(element) || element.frameId && otherFrames.has(element.frameId)) {
       continue;
     }
-    if (element.frameId && element.frameId !== frame.id) {
-      continue;
-    }
     finalElementsToAdd.add(element);
     const boundTextElement = getBoundTextElement(element, elementsMap);
     if (boundTextElement && !finalElementsToAdd.has(boundTextElement)) {
@@ -12303,43 +12480,6 @@ var generateElementCanvas = (element, elementsMap, zoom, renderConfig, appState)
   const rc = rough_default.canvas(canvas);
   drawElementOnCanvas(element, rc, context, renderConfig);
   context.restore();
-  const boundTextElement = getBoundTextElement(element, elementsMap);
-  const boundTextCanvas = document.createElement("canvas");
-  const boundTextCanvasContext = boundTextCanvas.getContext("2d");
-  if (isArrowElement(element) && boundTextElement) {
-    const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, elementsMap);
-    const maxDim = Math.max(distance2(x1, x2), distance2(y1, y2));
-    boundTextCanvas.width = maxDim * window.devicePixelRatio * scale + padding * scale * 10;
-    boundTextCanvas.height = maxDim * window.devicePixelRatio * scale + padding * scale * 10;
-    boundTextCanvasContext.translate(
-      boundTextCanvas.width / 2,
-      boundTextCanvas.height / 2
-    );
-    boundTextCanvasContext.rotate(element.angle);
-    boundTextCanvasContext.drawImage(
-      canvas,
-      -canvas.width / 2,
-      -canvas.height / 2,
-      canvas.width,
-      canvas.height
-    );
-    const [, , , , boundTextCx, boundTextCy] = getElementAbsoluteCoords2(
-      boundTextElement,
-      elementsMap
-    );
-    boundTextCanvasContext.rotate(-element.angle);
-    const offsetX = (boundTextCanvas.width - canvas.width) / 2;
-    const offsetY = (boundTextCanvas.height - canvas.height) / 2;
-    const shiftX = boundTextCanvas.width / 2 - (boundTextCx - x1) * window.devicePixelRatio * scale - offsetX - padding * scale;
-    const shiftY = boundTextCanvas.height / 2 - (boundTextCy - y1) * window.devicePixelRatio * scale - offsetY - padding * scale;
-    boundTextCanvasContext.translate(-shiftX, -shiftY);
-    boundTextCanvasContext.clearRect(
-      -(boundTextElement.width / 2 + BOUND_TEXT_PADDING3) * window.devicePixelRatio * scale,
-      -(boundTextElement.height / 2 + BOUND_TEXT_PADDING3) * window.devicePixelRatio * scale,
-      (boundTextElement.width + BOUND_TEXT_PADDING3 * 2) * window.devicePixelRatio * scale,
-      (boundTextElement.height + BOUND_TEXT_PADDING3 * 2) * window.devicePixelRatio * scale
-    );
-  }
   return {
     element,
     canvas,
@@ -12348,10 +12488,7 @@ var generateElementCanvas = (element, elementsMap, zoom, renderConfig, appState)
     zoomValue: zoom.value,
     canvasOffsetX,
     canvasOffsetY,
-    boundTextElementVersion: getBoundTextElement(element, elementsMap)?.version || null,
     containingFrameOpacity: getContainingFrame(element, elementsMap)?.opacity || 100,
-    boundTextCanvas,
-    angle: element.angle,
     imageCrop: isImageElement(element) ? element.crop : null
   };
 };
@@ -12408,7 +12545,10 @@ var drawElementOnCanvas = (element, rc, context, renderConfig) => {
       const shapes = ShapeCache.generateElementShape(element, renderConfig);
       for (const shape of shapes) {
         if (typeof shape === "string") {
-          context.fillStyle = renderConfig.theme === THEME.DARK ? applyDarkModeFilter(element.strokeColor) : element.strokeColor;
+          context.fillStyle = applyDarkModeFilter(
+            element.strokeColor,
+            renderConfig.theme === THEME.DARK
+          );
           context.fill(new Path2D(shape));
         } else {
           rc.draw(shape);
@@ -12516,7 +12656,10 @@ var drawElementOnCanvas = (element, rc, context, renderConfig) => {
         context.canvas.setAttribute("dir", rtl ? "rtl" : "ltr");
         context.save();
         context.font = getFontString3(element);
-        context.fillStyle = renderConfig.theme === THEME.DARK ? applyDarkModeFilter(element.strokeColor) : element.strokeColor;
+        context.fillStyle = applyDarkModeFilter(
+          element.strokeColor,
+          renderConfig.theme === THEME.DARK
+        );
         context.textAlign = element.textAlign;
         const lines = element.text.replace(/\r\n?/g, "\n").split("\n");
         const horizontalOffset = element.textAlign === "center" ? element.width / 2 : element.textAlign === "right" ? element.width : 0;
@@ -12553,15 +12696,9 @@ var generateElementWithCanvas = (element, elementsMap, renderConfig, appState) =
   };
   const prevElementWithCanvas = elementWithCanvasCache.get(element);
   const shouldRegenerateBecauseZoom = prevElementWithCanvas && prevElementWithCanvas.zoomValue !== zoom.value && !appState?.shouldCacheIgnoreZoom;
-  const boundTextElement = getBoundTextElement(element, elementsMap);
-  const boundTextElementVersion = boundTextElement?.version || null;
   const imageCrop = isImageElement(element) ? element.crop : null;
   const containingFrameOpacity = getContainingFrame(element, elementsMap)?.opacity || 100;
-  if (!prevElementWithCanvas || shouldRegenerateBecauseZoom || prevElementWithCanvas.theme !== appState.theme || prevElementWithCanvas.boundTextElementVersion !== boundTextElementVersion || prevElementWithCanvas.imageCrop !== imageCrop || prevElementWithCanvas.containingFrameOpacity !== containingFrameOpacity || // since we rotate the canvas when copying from cached canvas, we don't
-  // regenerate the cached canvas. But we need to in case of labels which are
-  // cached alongside the arrow, and we want the labels to remain unrotated
-  // with respect to the arrow.
-  isArrowElement(element) && boundTextElement && element.angle !== prevElementWithCanvas.angle) {
+  if (!prevElementWithCanvas || shouldRegenerateBecauseZoom || prevElementWithCanvas.theme !== appState.theme || prevElementWithCanvas.imageCrop !== imageCrop || prevElementWithCanvas.containingFrameOpacity !== containingFrameOpacity) {
     const elementWithCanvas = generateElementCanvas(
       element,
       elementsMap,
@@ -12580,7 +12717,6 @@ var generateElementWithCanvas = (element, elementsMap, renderConfig, appState) =
 var drawElementFromCanvas = (elementWithCanvas, context, renderConfig, appState, allElementsMap) => {
   const element = elementWithCanvas.element;
   const padding = getCanvasPadding(element);
-  const zoom = elementWithCanvas.scale;
   const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, allElementsMap);
   const cx = ((x1 + x2) / 2 + appState.scrollX) * window.devicePixelRatio;
   const cy = ((y1 + y2) / 2 + appState.scrollY) * window.devicePixelRatio;
@@ -12588,48 +12724,51 @@ var drawElementFromCanvas = (elementWithCanvas, context, renderConfig, appState,
   context.scale(1 / window.devicePixelRatio, 1 / window.devicePixelRatio);
   const boundTextElement = getBoundTextElement(element, allElementsMap);
   if (isArrowElement(element) && boundTextElement) {
-    const offsetX = (elementWithCanvas.boundTextCanvas.width - elementWithCanvas.canvas.width) / 2;
-    const offsetY = (elementWithCanvas.boundTextCanvas.height - elementWithCanvas.canvas.height) / 2;
-    context.translate(cx, cy);
-    context.drawImage(
-      elementWithCanvas.boundTextCanvas,
-      -(x2 - x1) / 2 * window.devicePixelRatio - offsetX / zoom - padding,
-      -(y2 - y1) / 2 * window.devicePixelRatio - offsetY / zoom - padding,
-      elementWithCanvas.boundTextCanvas.width / zoom,
-      elementWithCanvas.boundTextCanvas.height / zoom
+    const [, , , , boundTextCx, boundTextCy] = getElementAbsoluteCoords2(
+      boundTextElement,
+      allElementsMap
     );
-  } else {
-    context.translate(cx, cy);
-    context.rotate(element.angle);
-    if ("scale" in elementWithCanvas.element && !isPendingImageElement(element, renderConfig)) {
-      context.scale(
-        elementWithCanvas.element.scale[0],
-        elementWithCanvas.element.scale[1]
-      );
-    }
-    context.translate(-cx, -cy);
-    context.drawImage(
-      elementWithCanvas.canvas,
-      (x1 + appState.scrollX) * window.devicePixelRatio - padding * elementWithCanvas.scale / elementWithCanvas.scale,
-      (y1 + appState.scrollY) * window.devicePixelRatio - padding * elementWithCanvas.scale / elementWithCanvas.scale,
-      elementWithCanvas.canvas.width / elementWithCanvas.scale,
-      elementWithCanvas.canvas.height / elementWithCanvas.scale
+    const outerHalf = Math.max(distance2(x1, x2), distance2(y1, y2)) * window.devicePixelRatio + padding * 10;
+    context.beginPath();
+    context.rect(cx - outerHalf, cy - outerHalf, outerHalf * 2, outerHalf * 2);
+    context.rect(
+      (boundTextCx - boundTextElement.width / 2 - BOUND_TEXT_PADDING3 + appState.scrollX) * window.devicePixelRatio,
+      (boundTextCy - boundTextElement.height / 2 - BOUND_TEXT_PADDING3 + appState.scrollY) * window.devicePixelRatio,
+      (boundTextElement.width + BOUND_TEXT_PADDING3 * 2) * window.devicePixelRatio,
+      (boundTextElement.height + BOUND_TEXT_PADDING3 * 2) * window.devicePixelRatio
+    );
+    context.clip("evenodd");
+  }
+  context.translate(cx, cy);
+  context.rotate(element.angle);
+  if ("scale" in elementWithCanvas.element && !isPendingImageElement(element, renderConfig)) {
+    context.scale(
+      elementWithCanvas.element.scale[0],
+      elementWithCanvas.element.scale[1]
+    );
+  }
+  context.translate(-cx, -cy);
+  context.drawImage(
+    elementWithCanvas.canvas,
+    (x1 + appState.scrollX) * window.devicePixelRatio - padding * elementWithCanvas.scale / elementWithCanvas.scale,
+    (y1 + appState.scrollY) * window.devicePixelRatio - padding * elementWithCanvas.scale / elementWithCanvas.scale,
+    elementWithCanvas.canvas.width / elementWithCanvas.scale,
+    elementWithCanvas.canvas.height / elementWithCanvas.scale
+  );
+  if (define_import_meta_env_default.VITE_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX === "true" && hasBoundTextElement(element)) {
+    const textElement = getBoundTextElement(
+      element,
+      allElementsMap
+    );
+    const coords = getContainerCoords(element);
+    context.strokeStyle = "#c92a2a";
+    context.lineWidth = 3;
+    context.strokeRect(
+      (coords.x + appState.scrollX) * window.devicePixelRatio,
+      (coords.y + appState.scrollY) * window.devicePixelRatio,
+      getBoundTextMaxWidth(element, textElement) * window.devicePixelRatio,
+      getBoundTextMaxHeight(element, textElement) * window.devicePixelRatio
     );
-    if (define_import_meta_env_default.VITE_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX === "true" && hasBoundTextElement(element)) {
-      const textElement = getBoundTextElement(
-        element,
-        allElementsMap
-      );
-      const coords = getContainerCoords(element);
-      context.strokeStyle = "#c92a2a";
-      context.lineWidth = 3;
-      context.strokeRect(
-        (coords.x + appState.scrollX) * window.devicePixelRatio,
-        (coords.y + appState.scrollY) * window.devicePixelRatio,
-        getBoundTextMaxWidth(element, textElement) * window.devicePixelRatio,
-        getBoundTextMaxHeight(element, textElement) * window.devicePixelRatio
-      );
-    }
   }
   context.restore();
 };
@@ -12664,7 +12803,10 @@ var renderElement = (element, elementsMap, allElementsMap, rc, context, renderCo
         );
         context.fillStyle = "rgba(0, 0, 200, 0.04)";
         context.lineWidth = FRAME_STYLE.strokeWidth / appState.zoom.value;
-        context.strokeStyle = appState.theme === THEME.DARK ? applyDarkModeFilter(FRAME_STYLE.strokeColor) : FRAME_STYLE.strokeColor;
+        context.strokeStyle = applyDarkModeFilter(
+          FRAME_STYLE.strokeColor,
+          appState.theme === THEME.DARK
+        );
         if (isMagicFrameElement(element)) {
           context.strokeStyle = appState.theme === THEME.LIGHT ? "#7affd7" : applyDarkModeFilter("#1d8264");
         }
@@ -12730,8 +12872,10 @@ var renderElement = (element, elementsMap, allElementsMap, rc, context, renderCo
     case "embeddable": {
       if (renderConfig.isExporting) {
         const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, elementsMap);
-        const cx = (x1 + x2) / 2 + appState.scrollX;
-        const cy = (y1 + y2) / 2 + appState.scrollY;
+        const centerX = (x1 + x2) / 2;
+        const centerY = (y1 + y2) / 2;
+        const cx = centerX + appState.scrollX;
+        const cy = centerY + appState.scrollY;
         let shiftX = (x2 - x1) / 2 - (element.x - x1);
         let shiftY = (y2 - y1) / 2 - (element.y - y1);
         if (isTextElement(element)) {
@@ -12750,46 +12894,26 @@ var renderElement = (element, elementsMap, allElementsMap, rc, context, renderCo
         context.translate(cx, cy);
         const boundTextElement = getBoundTextElement(element, elementsMap);
         if (isArrowElement(element) && boundTextElement) {
-          const tempCanvas = document.createElement("canvas");
-          const tempCanvasContext = tempCanvas.getContext("2d");
-          const maxDim = Math.max(distance2(x1, x2), distance2(y1, y2));
-          const padding = getCanvasPadding(element);
-          tempCanvas.width = maxDim * appState.exportScale + padding * 10 * appState.exportScale;
-          tempCanvas.height = maxDim * appState.exportScale + padding * 10 * appState.exportScale;
-          tempCanvasContext.translate(
-            tempCanvas.width / 2,
-            tempCanvas.height / 2
-          );
-          tempCanvasContext.scale(appState.exportScale, appState.exportScale);
           shiftX = element.width / 2 - (element.x - x1);
           shiftY = element.height / 2 - (element.y - y1);
-          tempCanvasContext.rotate(element.angle);
-          const tempRc = rough_default.canvas(tempCanvas);
-          tempCanvasContext.translate(-shiftX, -shiftY);
-          drawElementOnCanvas(element, tempRc, tempCanvasContext, renderConfig);
-          tempCanvasContext.translate(shiftX, shiftY);
-          tempCanvasContext.rotate(-element.angle);
           const [, , , , boundTextCx, boundTextCy] = getElementAbsoluteCoords2(
             boundTextElement,
             elementsMap
           );
-          const boundTextShiftX = (x1 + x2) / 2 - boundTextCx;
-          const boundTextShiftY = (y1 + y2) / 2 - boundTextCy;
-          tempCanvasContext.translate(-boundTextShiftX, -boundTextShiftY);
-          tempCanvasContext.clearRect(
-            -boundTextElement.width / 2,
-            -boundTextElement.height / 2,
-            boundTextElement.width,
-            boundTextElement.height
-          );
-          context.scale(1 / appState.exportScale, 1 / appState.exportScale);
-          context.drawImage(
-            tempCanvas,
-            -tempCanvas.width / 2,
-            -tempCanvas.height / 2,
-            tempCanvas.width,
-            tempCanvas.height
-          );
+          const holeX = boundTextCx - centerX - boundTextElement.width / 2 - BOUND_TEXT_PADDING3;
+          const holeY = boundTextCy - centerY - boundTextElement.height / 2 - BOUND_TEXT_PADDING3;
+          const holeWidth = boundTextElement.width + BOUND_TEXT_PADDING3 * 2;
+          const holeHeight = boundTextElement.height + BOUND_TEXT_PADDING3 * 2;
+          const outerHalf = Math.max(distance2(x1, x2), distance2(y1, y2)) + getCanvasPadding(element) * 10;
+          context.save();
+          context.beginPath();
+          context.rect(-outerHalf, -outerHalf, outerHalf * 2, outerHalf * 2);
+          context.rect(holeX, holeY, holeWidth, holeHeight);
+          context.clip("evenodd");
+          context.rotate(element.angle);
+          context.translate(-shiftX, -shiftY);
+          drawElementOnCanvas(element, rc, context, renderConfig);
+          context.restore();
         } else {
           context.rotate(element.angle);
           if (element.type === "image") {
@@ -12825,7 +12949,10 @@ var renderElement = (element, elementsMap, allElementsMap, rc, context, renderCo
           context.save();
           context.globalAlpha = 0.1;
           const uncroppedElementCanvas = generateElementCanvas(
-            getUncroppedImageElement(elementWithCanvas.element, elementsMap),
+            getUncroppedImageElement(
+              elementWithCanvas.element,
+              elementsMap
+            ),
             allElementsMap,
             appState.zoom,
             renderConfig,
@@ -12867,7 +12994,7 @@ function getFreedrawOutlineAsSegments(element, points, elementsMap) {
     },
     elementsMap
   );
-  const center = pointFrom12(
+  const center = pointFrom11(
     (bounds[0] + bounds[2]) / 2,
     (bounds[1] + bounds[3]) / 2
   );
@@ -12875,10 +13002,10 @@ function getFreedrawOutlineAsSegments(element, points, elementsMap) {
   return points.slice(2).reduce(
     (acc, curr) => {
       acc.push(
-        lineSegment6(
+        lineSegment5(
           acc[acc.length - 1][1],
-          pointRotateRads11(
-            pointFrom12(curr[0] + element.x, curr[1] + element.y),
+          pointRotateRads10(
+            pointFrom11(curr[0] + element.x, curr[1] + element.y),
             center,
             element.angle
           )
@@ -12887,17 +13014,17 @@ function getFreedrawOutlineAsSegments(element, points, elementsMap) {
       return acc;
     },
     [
-      lineSegment6(
-        pointRotateRads11(
-          pointFrom12(
+      lineSegment5(
+        pointRotateRads10(
+          pointFrom11(
             points[0][0] + element.x,
             points[0][1] + element.y
           ),
           center,
           element.angle
         ),
-        pointRotateRads11(
-          pointFrom12(
+        pointRotateRads10(
+          pointFrom11(
             points[1][0] + element.x,
             points[1][1] + element.y
           ),
@@ -12992,7 +13119,7 @@ var generateRoughOptions = (element, continuousPath = false, isDarkMode = false)
     fillWeight: element.strokeWidth / 2,
     hachureGap: element.strokeWidth * 4,
     roughness: adjustRoughness(element),
-    stroke: isDarkMode ? applyDarkModeFilter2(element.strokeColor) : element.strokeColor,
+    stroke: applyDarkModeFilter2(element.strokeColor, isDarkMode),
     preserveVertices: continuousPath || element.roughness < ROUGHNESS.cartoonist
   };
   switch (element.type) {
@@ -13002,7 +13129,7 @@ var generateRoughOptions = (element, continuousPath = false, isDarkMode = false)
     case "diamond":
     case "ellipse": {
       options.fillStyle = element.fillStyle;
-      options.fill = isTransparent3(element.backgroundColor) ? void 0 : isDarkMode ? applyDarkModeFilter2(element.backgroundColor) : element.backgroundColor;
+      options.fill = isTransparent3(element.backgroundColor) ? void 0 : applyDarkModeFilter2(element.backgroundColor, isDarkMode);
       if (element.type === "ellipse") {
         options.curveFitting = 1;
       }
@@ -13012,7 +13139,7 @@ var generateRoughOptions = (element, continuousPath = false, isDarkMode = false)
     case "freedraw": {
       if (isPathALoop(element.points)) {
         options.fillStyle = element.fillStyle;
-        options.fill = element.backgroundColor === "transparent" ? void 0 : isDarkMode ? applyDarkModeFilter2(element.backgroundColor) : element.backgroundColor;
+        options.fill = element.backgroundColor === "transparent" ? void 0 : applyDarkModeFilter2(element.backgroundColor, isDarkMode);
       }
       return options;
     }
@@ -13087,8 +13214,11 @@ var getArrowheadShapes = (element, shape, position, arrowhead, generator, option
   if (arrowhead === null) {
     return [];
   }
-  const strokeColor = isDarkMode ? applyDarkModeFilter2(element.strokeColor) : element.strokeColor;
-  const backgroundFillColor = isDarkMode ? applyDarkModeFilter2(canvasBackgroundColor) : canvasBackgroundColor;
+  const strokeColor = applyDarkModeFilter2(element.strokeColor, isDarkMode);
+  const backgroundFillColor = applyDarkModeFilter2(
+    canvasBackgroundColor,
+    isDarkMode
+  );
   const cardinalityOneOrManyOffset = -0.25;
   const cardinalityZeroCircleScale = 0.8;
   switch (arrowhead) {
@@ -13273,26 +13403,26 @@ var generateLinearCollisionShape = (element, elementsMap) => {
   switch (element.type) {
     case "line":
     case "arrow": {
-      const points = element.points.length ? element.points : [pointFrom13(0, 0)];
+      const points = element.points.length ? element.points : [pointFrom12(0, 0)];
       if (isElbowArrow(element)) {
         return generator.path(generateElbowArrowShape(points, 16), options).sets[0].ops;
       } else if (!element.roundness) {
         return points.map((point, idx) => {
-          const p = pointRotateRads12(
-            pointFrom13(element.x + point[0], element.y + point[1]),
+          const p = pointRotateRads11(
+            pointFrom12(element.x + point[0], element.y + point[1]),
             center,
             element.angle
           );
           return {
             op: idx === 0 ? "move" : "lineTo",
-            data: pointFrom13(p[0] - element.x, p[1] - element.y)
+            data: pointFrom12(p[0] - element.x, p[1] - element.y)
           };
         });
       }
       return generator.curve(points, options).sets[0].ops.slice(0, element.points.length).map((op, i) => {
         if (i === 0) {
-          const p = pointRotateRads12(
-            pointFrom13(
+          const p = pointRotateRads11(
+            pointFrom12(
               element.x + op.data[0],
               element.y + op.data[1]
             ),
@@ -13301,30 +13431,30 @@ var generateLinearCollisionShape = (element, elementsMap) => {
           );
           return {
             op: "move",
-            data: pointFrom13(p[0] - element.x, p[1] - element.y)
+            data: pointFrom12(p[0] - element.x, p[1] - element.y)
           };
         }
         return {
           op: "bcurveTo",
           data: [
-            pointRotateRads12(
-              pointFrom13(
+            pointRotateRads11(
+              pointFrom12(
                 element.x + op.data[0],
                 element.y + op.data[1]
               ),
               center,
               element.angle
             ),
-            pointRotateRads12(
-              pointFrom13(
+            pointRotateRads11(
+              pointFrom12(
                 element.x + op.data[2],
                 element.y + op.data[3]
               ),
               center,
               element.angle
             ),
-            pointRotateRads12(
-              pointFrom13(
+            pointRotateRads11(
+              pointFrom12(
                 element.x + op.data[4],
                 element.y + op.data[5]
               ),
@@ -13332,7 +13462,7 @@ var generateLinearCollisionShape = (element, elementsMap) => {
               element.angle
             )
           ].map(
-            (p) => pointFrom13(p[0] - element.x, p[1] - element.y)
+            (p) => pointFrom12(p[0] - element.x, p[1] - element.y)
           ).flat()
         };
       });
@@ -13347,8 +13477,8 @@ var generateLinearCollisionShape = (element, elementsMap) => {
       );
       return generator.curve(simplifiedPoints, options).sets[0].ops.slice(0, element.points.length).map((op, i) => {
         if (i === 0) {
-          const p = pointRotateRads12(
-            pointFrom13(
+          const p = pointRotateRads11(
+            pointFrom12(
               element.x + op.data[0],
               element.y + op.data[1]
             ),
@@ -13357,30 +13487,30 @@ var generateLinearCollisionShape = (element, elementsMap) => {
           );
           return {
             op: "move",
-            data: pointFrom13(p[0] - element.x, p[1] - element.y)
+            data: pointFrom12(p[0] - element.x, p[1] - element.y)
           };
         }
         return {
           op: "bcurveTo",
           data: [
-            pointRotateRads12(
-              pointFrom13(
+            pointRotateRads11(
+              pointFrom12(
                 element.x + op.data[0],
                 element.y + op.data[1]
               ),
               center,
               element.angle
             ),
-            pointRotateRads12(
-              pointFrom13(
+            pointRotateRads11(
+              pointFrom12(
                 element.x + op.data[2],
                 element.y + op.data[3]
               ),
               center,
               element.angle
             ),
-            pointRotateRads12(
-              pointFrom13(
+            pointRotateRads11(
+              pointFrom12(
                 element.x + op.data[4],
                 element.y + op.data[5]
               ),
@@ -13388,7 +13518,7 @@ var generateLinearCollisionShape = (element, elementsMap) => {
               element.angle
             )
           ].map(
-            (p) => pointFrom13(p[0] - element.x, p[1] - element.y)
+            (p) => pointFrom12(p[0] - element.x, p[1] - element.y)
           ).flat()
         };
       });
@@ -13489,7 +13619,7 @@ var _generateElementShape = (element, generator, {
     case "arrow": {
       let shape;
       const options = generateRoughOptions(element, false, isDarkMode);
-      const points = element.points.length ? element.points : [pointFrom13(0, 0)];
+      const points = element.points.length ? element.points : [pointFrom12(0, 0)];
       if (isElbowArrow(element)) {
         if (!points.every(
           (point) => Math.abs(point[0]) <= 1e6 && Math.abs(point[1]) <= 1e6
@@ -13653,14 +13783,14 @@ var getElementShape = (element, elementsMap) => {
       return shouldTestInside(element) ? getClosedCurveShape(
         element,
         roughShape,
-        pointFrom13(element.x, element.y),
+        pointFrom12(element.x, element.y),
         element.angle,
-        pointFrom13(cx, cy)
+        pointFrom12(cx, cy)
       ) : getCurveShape(
         roughShape,
-        pointFrom13(element.x, element.y),
+        pointFrom12(element.x, element.y),
         element.angle,
-        pointFrom13(cx, cy)
+        pointFrom12(cx, cy)
       );
     }
     case "ellipse":
@@ -13669,7 +13799,7 @@ var getElementShape = (element, elementsMap) => {
       const [, , , , cx, cy] = getElementAbsoluteCoords2(element, elementsMap);
       return getFreedrawShape(
         element,
-        pointFrom13(cx, cy),
+        pointFrom12(cx, cy),
         shouldTestInside(element)
       );
     }
@@ -13688,9 +13818,9 @@ var toggleLinePolygonState = (element, nextPolygonState) => {
       firstPoint[1] - lastPoint[1]
     );
     if (distance3 > LINE_POLYGON_POINT_MERGE_DISTANCE || updatedPoints.length < 4) {
-      updatedPoints.push(pointFrom13(firstPoint[0], firstPoint[1]));
+      updatedPoints.push(pointFrom12(firstPoint[0], firstPoint[1]));
     } else {
-      updatedPoints[updatedPoints.length - 1] = pointFrom13(
+      updatedPoints[updatedPoints.length - 1] = pointFrom12(
         firstPoint[0],
         firstPoint[1]
       );
@@ -13707,19 +13837,46 @@ var getFreeDrawSvgPath = (element) => {
     getFreedrawOutlinePoints(element)
   );
 };
-var getFreedrawOutlinePoints = (element) => {
-  const inputPoints = element.simulatePressure ? element.points : element.points.length ? element.points.map(([x, y], i) => [x, y, element.pressures[i]]) : [[0, 0, 0.5]];
+var VARIABLE_WIDTH_FREEDRAW = {
+  /** Stroke size relative to `strokeWidth` for pressure-sensitive strokes. */
+  SIZE_FACTOR: 4.25,
+  THINNING: 0.6,
+  SMOOTHING: 0.5
+};
+var CONSTANT_WIDTH_FREEDRAW = {
+  /** Stroke size relative to `strokeWidth` for uniform (laser) strokes. */
+  SIZE_FACTOR: 1.4
+};
+var getFreedrawStreamline = (element) => element.strokeOptions?.streamline ?? DEFAULT_STROKE_STREAMLINE;
+var getVariableWidthFreedrawOutline = (element) => {
+  const inputPoints = element.simulatePressure ? element.points : element.points.length ? element.points.map(
+    ([x, y], i) => [x, y, element.pressures[i]]
+  ) : [[0, 0, 0.5]];
   return ae(inputPoints, {
     simulatePressure: element.simulatePressure,
-    size: element.strokeWidth * 4.25,
-    thinning: 0.6,
-    smoothing: 0.5,
-    streamline: 0.5,
+    size: element.strokeWidth * VARIABLE_WIDTH_FREEDRAW.SIZE_FACTOR,
+    thinning: VARIABLE_WIDTH_FREEDRAW.THINNING,
+    smoothing: VARIABLE_WIDTH_FREEDRAW.SMOOTHING,
+    streamline: getFreedrawStreamline(element),
     easing: (t) => Math.sin(t * Math.PI / 2),
     // https://easings.net/#easeOutSine
     last: true
   });
 };
+var createLaserPointer = (element) => new LaserPointer({
+  size: element.strokeWidth * CONSTANT_WIDTH_FREEDRAW.SIZE_FACTOR,
+  streamline: getFreedrawStreamline(element),
+  simplify: 0,
+  sizeMapping: (details) => Math.max(0.1, details.pressure)
+});
+var getConstantWidthFreedrawOutline = (element) => {
+  const laserPointer = createLaserPointer(element);
+  element.points.map(([x, y]) => laserPointer.addPoint([x, y, 1]));
+  return laserPointer.getStrokeOutline().map(([x, y]) => [x, y]);
+};
+var getFreedrawOutlinePoints = (element) => {
+  return element.strokeOptions?.variability === "constant" ? getConstantWidthFreedrawOutline(element) : getVariableWidthFreedrawOutline(element);
+};
 var med = (A2, B2) => {
   return [(A2[0] + B2[0]) / 2, (A2[1] + B2[1]) / 2];
 };
@@ -13783,9 +13940,9 @@ var ElementBounds = class _ElementBounds {
     if (isFreeDrawElement(element)) {
       const [minX, minY, maxX, maxY] = getBoundsFromPoints(
         element.points.map(
-          ([x, y]) => pointRotateRads13(
-            pointFrom14(x, y),
-            pointFrom14(cx - element.x, cy - element.y),
+          ([x, y]) => pointRotateRads12(
+            pointFrom13(x, y),
+            pointFrom13(cx - element.x, cy - element.y),
             element.angle
           )
         )
@@ -13799,24 +13956,24 @@ var ElementBounds = class _ElementBounds {
     } else if (isLinearElement(element)) {
       bounds = getLinearElementRotatedBounds(element, cx, cy, elementsMap);
     } else if (element.type === "diamond") {
-      const [x11, y11] = pointRotateRads13(
-        pointFrom14(cx, y1),
-        pointFrom14(cx, cy),
+      const [x11, y11] = pointRotateRads12(
+        pointFrom13(cx, y1),
+        pointFrom13(cx, cy),
         element.angle
       );
-      const [x12, y12] = pointRotateRads13(
-        pointFrom14(cx, y2),
-        pointFrom14(cx, cy),
+      const [x12, y12] = pointRotateRads12(
+        pointFrom13(cx, y2),
+        pointFrom13(cx, cy),
         element.angle
       );
-      const [x22, y22] = pointRotateRads13(
-        pointFrom14(x1, cy),
-        pointFrom14(cx, cy),
+      const [x22, y22] = pointRotateRads12(
+        pointFrom13(x1, cy),
+        pointFrom13(cx, cy),
         element.angle
       );
-      const [x21, y21] = pointRotateRads13(
-        pointFrom14(x2, cy),
-        pointFrom14(cx, cy),
+      const [x21, y21] = pointRotateRads12(
+        pointFrom13(x2, cy),
+        pointFrom13(cx, cy),
         element.angle
       );
       const minX = Math.min(x11, x12, x22, x21);
@@ -13833,24 +13990,24 @@ var ElementBounds = class _ElementBounds {
       const hh = Math.hypot(h * cos, w * sin);
       bounds = [cx - ww, cy - hh, cx + ww, cy + hh];
     } else {
-      const [x11, y11] = pointRotateRads13(
-        pointFrom14(x1, y1),
-        pointFrom14(cx, cy),
+      const [x11, y11] = pointRotateRads12(
+        pointFrom13(x1, y1),
+        pointFrom13(cx, cy),
         element.angle
       );
-      const [x12, y12] = pointRotateRads13(
-        pointFrom14(x1, y2),
-        pointFrom14(cx, cy),
+      const [x12, y12] = pointRotateRads12(
+        pointFrom13(x1, y2),
+        pointFrom13(cx, cy),
         element.angle
       );
-      const [x22, y22] = pointRotateRads13(
-        pointFrom14(x2, y2),
-        pointFrom14(cx, cy),
+      const [x22, y22] = pointRotateRads12(
+        pointFrom13(x2, y2),
+        pointFrom13(cx, cy),
         element.angle
       );
-      const [x21, y21] = pointRotateRads13(
-        pointFrom14(x2, y1),
-        pointFrom14(cx, cy),
+      const [x21, y21] = pointRotateRads12(
+        pointFrom13(x2, y1),
+        pointFrom13(cx, cy),
         element.angle
       );
       const minX = Math.min(x11, x12, x22, x21);
@@ -13904,7 +14061,7 @@ var getElementLineSegments = (element, elementsMap) => {
     element,
     elementsMap
   );
-  const center = pointFrom14(cx, cy);
+  const center = pointFrom13(cx, cy);
   if (shape.type === "polycurve") {
     const curves = shape.data;
     const pointsOnCurves = curves.map(
@@ -13916,9 +14073,9 @@ var getElementLineSegments = (element, elementsMap) => {
         let i = 0;
         while (i < points.length - 1) {
           segments.push(
-            lineSegment7(
-              pointFrom14(points[i][0], points[i][1]),
-              pointFrom14(points[i + 1][0], points[i + 1][1])
+            lineSegment6(
+              pointFrom13(points[i][0], points[i][1]),
+              pointFrom13(points[i + 1][0], points[i + 1][1])
             )
           );
           i++;
@@ -13929,9 +14086,9 @@ var getElementLineSegments = (element, elementsMap) => {
       let i = 0;
       while (i < points.length - 1) {
         segments.push(
-          lineSegment7(
-            pointFrom14(points[i][0], points[i][1]),
-            pointFrom14(points[i + 1][0], points[i + 1][1])
+          lineSegment6(
+            pointFrom13(points[i][0], points[i][1]),
+            pointFrom13(points[i + 1][0], points[i + 1][1])
           )
         );
         i++;
@@ -13955,10 +14112,10 @@ var getElementLineSegments = (element, elementsMap) => {
       const container = getContainerElement(element, elementsMap);
       if (container && isLinearElement(container)) {
         const segments2 = [
-          lineSegment7(pointFrom14(x1, y1), pointFrom14(x2, y1)),
-          lineSegment7(pointFrom14(x2, y1), pointFrom14(x2, y2)),
-          lineSegment7(pointFrom14(x2, y2), pointFrom14(x1, y2)),
-          lineSegment7(pointFrom14(x1, y2), pointFrom14(x1, y1))
+          lineSegment6(pointFrom13(x1, y1), pointFrom13(x2, y1)),
+          lineSegment6(pointFrom13(x2, y1), pointFrom13(x2, y2)),
+          lineSegment6(pointFrom13(x2, y2), pointFrom13(x1, y2)),
+          lineSegment6(pointFrom13(x1, y2), pointFrom13(x1, y1))
         ];
         return segments2;
       }
@@ -13966,7 +14123,7 @@ var getElementLineSegments = (element, elementsMap) => {
     const points = shape.data;
     const segments = [];
     for (let i = 0; i < points.length - 1; i++) {
-      segments.push(lineSegment7(points[i], points[i + 1]));
+      segments.push(lineSegment6(points[i], points[i + 1]));
     }
     return segments;
   } else if (shape.type === "ellipse") {
@@ -13981,45 +14138,45 @@ var getElementLineSegments = (element, elementsMap) => {
     [cx, y2],
     [x1, cy],
     [x2, cy]
-  ].map((point) => pointRotateRads13(point, center, element.angle));
+  ].map((point) => pointRotateRads12(point, center, element.angle));
   return [
-    lineSegment7(nw, ne),
-    lineSegment7(sw, se2),
-    lineSegment7(nw, sw),
-    lineSegment7(ne, se2),
-    lineSegment7(nw, e),
-    lineSegment7(sw, e),
-    lineSegment7(ne, w),
-    lineSegment7(se2, w)
+    lineSegment6(nw, ne),
+    lineSegment6(sw, se2),
+    lineSegment6(nw, sw),
+    lineSegment6(ne, se2),
+    lineSegment6(nw, e),
+    lineSegment6(sw, e),
+    lineSegment6(ne, w),
+    lineSegment6(se2, w)
   ];
 };
 var _isRectanguloidElement = (element) => {
   return element != null && (element.type === "rectangle" || element.type === "image" || element.type === "iframe" || element.type === "embeddable" || element.type === "frame" || element.type === "magicframe" || element.type === "text" && !element.containerId);
 };
-var getRotatedSides = (sides, center, angle) => {
+var getRotatedSides = (sides, center, angle2) => {
   return sides.map((side) => {
-    return lineSegment7(
-      pointRotateRads13(side[0], center, angle),
-      pointRotateRads13(side[1], center, angle)
+    return lineSegment6(
+      pointRotateRads12(side[0], center, angle2),
+      pointRotateRads12(side[1], center, angle2)
     );
   });
 };
-var getSegmentsOnCurve = (curve4, center, angle) => {
+var getSegmentsOnCurve = (curve4, center, angle2) => {
   const points = pointsOnBezierCurves(curve4, 10);
   let i = 0;
   const segments = [];
   while (i < points.length - 1) {
     segments.push(
-      lineSegment7(
-        pointRotateRads13(
-          pointFrom14(points[i][0], points[i][1]),
+      lineSegment6(
+        pointRotateRads12(
+          pointFrom13(points[i][0], points[i][1]),
           center,
-          angle
+          angle2
         ),
-        pointRotateRads13(
-          pointFrom14(points[i + 1][0], points[i + 1][1]),
+        pointRotateRads12(
+          pointFrom13(points[i + 1][0], points[i + 1][1]),
           center,
-          angle
+          angle2
         )
       )
     );
@@ -14028,7 +14185,7 @@ var getSegmentsOnCurve = (curve4, center, angle) => {
   return segments;
 };
 var getSegmentsOnEllipse = (ellipse4) => {
-  const center = pointFrom14(
+  const center = pointFrom13(
     ellipse4.x + ellipse4.width / 2,
     ellipse4.y + ellipse4.height / 2
   );
@@ -14042,12 +14199,12 @@ var getSegmentsOnEllipse = (ellipse4) => {
     const t = i * deltaT;
     const x = center[0] + a2 * Math.cos(t);
     const y = center[1] + b2 * Math.sin(t);
-    points.push(pointRotateRads13(pointFrom14(x, y), center, ellipse4.angle));
+    points.push(pointRotateRads12(pointFrom13(x, y), center, ellipse4.angle));
   }
   for (let i = 0; i < points.length - 1; i++) {
-    segments.push(lineSegment7(points[i], points[i + 1]));
+    segments.push(lineSegment6(points[i], points[i + 1]));
   }
-  segments.push(lineSegment7(points[points.length - 1], points[0]));
+  segments.push(lineSegment6(points[points.length - 1], points[0]));
   return segments;
 };
 var getRectangleBoxAbsoluteCoords = (boxSceneCoords) => {
@@ -14125,7 +14282,7 @@ var getCubicBezierCurveBound = (p0, p1, p2, p3) => {
   return [minX, minY, maxX, maxY];
 };
 var getMinMaxXYFromCurvePathOps = (ops, transformXY) => {
-  let currentP = pointFrom14(0, 0);
+  let currentP = pointFrom13(0, 0);
   const { minX, minY, maxX, maxY } = ops.reduce(
     (limits, { op, data }) => {
       if (op === "move") {
@@ -14133,9 +14290,9 @@ var getMinMaxXYFromCurvePathOps = (ops, transformXY) => {
         invariant10(p != null, "Op data is not a point");
         currentP = p;
       } else if (op === "bcurveTo") {
-        const _p1 = pointFrom14(data[0], data[1]);
-        const _p2 = pointFrom14(data[2], data[3]);
-        const _p3 = pointFrom14(data[4], data[5]);
+        const _p1 = pointFrom13(data[0], data[1]);
+        const _p2 = pointFrom13(data[2], data[3]);
+        const _p3 = pointFrom13(data[4], data[5]);
         const p1 = transformXY ? transformXY(_p1) : _p1;
         const p2 = transformXY ? transformXY(_p2) : _p2;
         const p3 = transformXY ? transformXY(_p3) : _p3;
@@ -14226,17 +14383,17 @@ var getArrowheadPoints = (element, shape, position, arrowhead, offsetMultiplier
   const index = position === "start" ? 1 : ops.length - 1;
   const data = ops[index].data;
   invariant10(data.length === 6, "Op data length is not 6");
-  const p3 = pointFrom14(data[4], data[5]);
-  const p2 = pointFrom14(data[2], data[3]);
-  const p1 = pointFrom14(data[0], data[1]);
+  const p3 = pointFrom13(data[4], data[5]);
+  const p2 = pointFrom13(data[2], data[3]);
+  const p1 = pointFrom13(data[0], data[1]);
   const prevOp = ops[index - 1];
-  let p0 = pointFrom14(0, 0);
+  let p0 = pointFrom13(0, 0);
   if (prevOp.op === "move") {
     const p = pointFromArray3(prevOp.data);
     invariant10(p != null, "Op data is not a point");
     p0 = p;
   } else if (prevOp.op === "bcurveTo") {
-    p0 = pointFrom14(prevOp.data[4], prevOp.data[5]);
+    p0 = pointFrom13(prevOp.data[4], prevOp.data[5]);
   }
   const equation = (t, idx) => Math.pow(1 - t, 3) * p3[idx] + 3 * t * Math.pow(1 - t, 2) * p2[idx] + 3 * Math.pow(t, 2) * (1 - t) * p1[idx] + p0[idx] * Math.pow(t, 3);
   const [x2, y2] = position === "start" ? p0 : p3;
@@ -14261,45 +14418,45 @@ var getArrowheadPoints = (element, shape, position, arrowhead, offsetMultiplier
     const diameter = Math.hypot(ys - ty, xs - tx) + element.strokeWidth - 2;
     return [tx, ty, diameter];
   }
-  const angle = getArrowheadAngle(arrowhead);
+  const angle2 = getArrowheadAngle(arrowhead);
   if (arrowhead === "cardinality_many" || arrowhead === "cardinality_one_or_many") {
-    const [x32, y32] = pointRotateRads13(
-      pointFrom14(tx, ty),
-      pointFrom14(xs, ys),
-      degreesToRadians(-angle)
+    const [x32, y32] = pointRotateRads12(
+      pointFrom13(tx, ty),
+      pointFrom13(xs, ys),
+      degreesToRadians(-angle2)
     );
-    const [x42, y42] = pointRotateRads13(
-      pointFrom14(tx, ty),
-      pointFrom14(xs, ys),
-      degreesToRadians(angle)
+    const [x42, y42] = pointRotateRads12(
+      pointFrom13(tx, ty),
+      pointFrom13(xs, ys),
+      degreesToRadians(angle2)
     );
     return [xs, ys, x32, y32, x42, y42];
   }
-  const [x3, y3] = pointRotateRads13(
-    pointFrom14(xs, ys),
-    pointFrom14(tx, ty),
-    -angle * Math.PI / 180
+  const [x3, y3] = pointRotateRads12(
+    pointFrom13(xs, ys),
+    pointFrom13(tx, ty),
+    -angle2 * Math.PI / 180
   );
-  const [x4, y4] = pointRotateRads13(
-    pointFrom14(xs, ys),
-    pointFrom14(tx, ty),
-    degreesToRadians(angle)
+  const [x4, y4] = pointRotateRads12(
+    pointFrom13(xs, ys),
+    pointFrom13(tx, ty),
+    degreesToRadians(angle2)
   );
   if (arrowhead === "diamond" || arrowhead === "diamond_outline") {
     let ox;
     let oy;
     if (position === "start") {
       const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];
-      [ox, oy] = pointRotateRads13(
-        pointFrom14(tx + minSize * 2, ty),
-        pointFrom14(tx, ty),
+      [ox, oy] = pointRotateRads12(
+        pointFrom13(tx + minSize * 2, ty),
+        pointFrom13(tx, ty),
         Math.atan2(py - ty, px - tx)
       );
     } else {
       const [px, py] = element.points.length > 1 ? element.points[element.points.length - 2] : [0, 0];
-      [ox, oy] = pointRotateRads13(
-        pointFrom14(tx - minSize * 2, ty),
-        pointFrom14(tx, ty),
+      [ox, oy] = pointRotateRads12(
+        pointFrom13(tx - minSize * 2, ty),
+        pointFrom13(tx, ty),
         Math.atan2(ty - py, tx - px)
       );
     }
@@ -14328,9 +14485,9 @@ var getLinearElementRotatedBounds = (element, cx, cy, elementsMap) => {
   const boundTextElement = getBoundTextElement(element, elementsMap);
   if (element.points.length < 2) {
     const [pointX, pointY] = element.points[0];
-    const [x, y] = pointRotateRads13(
-      pointFrom14(element.x + pointX, element.y + pointY),
-      pointFrom14(cx, cy),
+    const [x, y] = pointRotateRads12(
+      pointFrom13(element.x + pointX, element.y + pointY),
+      pointFrom13(cx, cy),
       element.angle
     );
     let coords2 = [x, y, x, y];
@@ -14353,9 +14510,9 @@ var getLinearElementRotatedBounds = (element, cx, cy, elementsMap) => {
   const cachedShape = ShapeCache.get(element, null)?.[0];
   const shape = cachedShape ?? generateLinearElementShape(element);
   const ops = getCurvePathOps(shape);
-  const transformXY = ([x, y]) => pointRotateRads13(
-    pointFrom14(element.x + x, element.y + y),
-    pointFrom14(cx, cy),
+  const transformXY = ([x, y]) => pointRotateRads12(
+    pointFrom13(element.x + x, element.y + y),
+    pointFrom13(cx, cy),
     element.angle
   );
   const res = getMinMaxXYFromCurvePathOps(ops, transformXY);
@@ -14456,26 +14613,6 @@ var getElementPointsCoords = (element, points) => {
     maxY + element.y
   ];
 };
-var getClosestElementBounds = (elements, from) => {
-  if (!elements.length) {
-    return [0, 0, 0, 0];
-  }
-  let minDistance = Infinity;
-  let closestElement = elements[0];
-  const elementsMap = arrayToMap6(elements);
-  elements.forEach((element) => {
-    const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
-    const distance3 = pointDistance7(
-      pointFrom14((x1 + x2) / 2, (y1 + y2) / 2),
-      pointFrom14(from.x, from.y)
-    );
-    if (distance3 < minDistance) {
-      minDistance = distance3;
-      closestElement = element;
-    }
-  });
-  return getElementBounds(closestElement, elementsMap);
-};
 var getCommonBoundingBox = (elements) => {
   const [minX, minY, maxX, maxY] = getCommonBounds(elements);
   return {
@@ -14503,7 +14640,7 @@ var getVisibleSceneBounds = ({
     -scrollY + height / zoom.value
   ];
 };
-var getCenterForBounds = (bounds) => pointFrom14(
+var getCenterForBounds = (bounds) => pointFrom13(
   bounds[0] + (bounds[2] - bounds[0]) / 2,
   bounds[1] + (bounds[3] - bounds[1]) / 2
 );
@@ -14517,23 +14654,23 @@ var aabbForElement = (element, elementsMap, offset) => {
     midY: element.y + element.height / 2
   };
   const center = elementCenterPoint(element, elementsMap);
-  const [topLeftX, topLeftY] = pointRotateRads13(
-    pointFrom14(bbox.minX, bbox.minY),
+  const [topLeftX, topLeftY] = pointRotateRads12(
+    pointFrom13(bbox.minX, bbox.minY),
     center,
     element.angle
   );
-  const [topRightX, topRightY] = pointRotateRads13(
-    pointFrom14(bbox.maxX, bbox.minY),
+  const [topRightX, topRightY] = pointRotateRads12(
+    pointFrom13(bbox.maxX, bbox.minY),
     center,
     element.angle
   );
-  const [bottomRightX, bottomRightY] = pointRotateRads13(
-    pointFrom14(bbox.maxX, bbox.maxY),
+  const [bottomRightX, bottomRightY] = pointRotateRads12(
+    pointFrom13(bbox.maxX, bbox.maxY),
     center,
     element.angle
   );
-  const [bottomLeftX, bottomLeftY] = pointRotateRads13(
-    pointFrom14(bbox.minX, bbox.maxY),
+  const [bottomLeftX, bottomLeftY] = pointRotateRads12(
+    pointFrom13(bbox.minX, bbox.maxY),
     center,
     element.angle
   );
@@ -14565,19 +14702,224 @@ var doBoundsIntersect = (bounds1, bounds2) => {
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 var boundsContainBounds = (outerBounds, innerBounds) => [
-  pointFrom14(innerBounds[0], innerBounds[1]),
-  pointFrom14(innerBounds[0], innerBounds[3]),
-  pointFrom14(innerBounds[2], innerBounds[1]),
-  pointFrom14(innerBounds[2], innerBounds[3])
+  pointFrom13(innerBounds[0], innerBounds[1]),
+  pointFrom13(innerBounds[0], innerBounds[3]),
+  pointFrom13(innerBounds[2], innerBounds[1]),
+  pointFrom13(innerBounds[2], innerBounds[3])
 ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
+var elementsOverlappingBBox = ({
+  elements,
+  elementsMap,
+  bounds,
+  type,
+  excludeElementsInFrames,
+  shouldIgnoreElementFromSelection: shouldIgnoreElementFromSelection2
+}) => {
+  if (!elementsMap) {
+    elementsMap = arrayToMap6(elements);
+  }
+  const selectionBounds = isExcalidrawElement(bounds) ? getElementBounds(bounds, elementsMap) : bounds;
+  const [selectionX1, selectionY1, selectionX2, selectionY2] = selectionBounds;
+  const selectionEdges = [
+    lineSegment6(
+      pointFrom13(selectionX1, selectionY1),
+      pointFrom13(selectionX2, selectionY1)
+    ),
+    lineSegment6(
+      pointFrom13(selectionX2, selectionY1),
+      pointFrom13(selectionX2, selectionY2)
+    ),
+    lineSegment6(
+      pointFrom13(selectionX2, selectionY2),
+      pointFrom13(selectionX1, selectionY2)
+    ),
+    lineSegment6(
+      pointFrom13(selectionX1, selectionY2),
+      pointFrom13(selectionX1, selectionY1)
+    )
+  ];
+  const framesInSelection = excludeElementsInFrames ? /* @__PURE__ */ new Set() : null;
+  const groups = {};
+  const elementsInSelection = /* @__PURE__ */ new Set();
+  for (const element of elements) {
+    if (shouldIgnoreElementFromSelection2?.(element)) {
+      continue;
+    }
+    const groupId = element.groupIds.at(-1);
+    if (groupId) {
+      if (!groups[groupId]) {
+        groups[groupId] = [];
+      }
+      groups[groupId].push(element);
+    }
+    const strokeWidth = element.strokeWidth;
+    let labelAABB = null;
+    let elementAABB = getElementBounds(element, elementsMap);
+    elementAABB = [
+      elementAABB[0] - strokeWidth / 2,
+      elementAABB[1] - strokeWidth / 2,
+      elementAABB[2] + strokeWidth / 2,
+      elementAABB[3] + strokeWidth / 2
+    ];
+    const boundTextElement = isArrowElement(element) && getBoundTextElement(element, elementsMap);
+    if (boundTextElement) {
+      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
+        element,
+        boundTextElement,
+        elementsMap
+      );
+      labelAABB = [
+        x,
+        y,
+        x + boundTextElement.width,
+        y + boundTextElement.height
+      ];
+    }
+    const associatedFrame = getContainingFrame(element, elementsMap);
+    if (associatedFrame && elementOverlapsWithFrame(element, associatedFrame, elementsMap)) {
+      const frameAABB = getElementBounds(associatedFrame, elementsMap);
+      elementAABB = [
+        Math.max(elementAABB[0], frameAABB[0]),
+        Math.max(elementAABB[1], frameAABB[1]),
+        Math.min(elementAABB[2], frameAABB[2]),
+        Math.min(elementAABB[3], frameAABB[3])
+      ];
+      labelAABB = labelAABB ? [
+        Math.max(labelAABB[0], frameAABB[0]),
+        Math.max(labelAABB[1], frameAABB[1]),
+        Math.min(labelAABB[2], frameAABB[2]),
+        Math.min(labelAABB[3], frameAABB[3])
+      ] : null;
+    }
+    const commonAABB2 = labelAABB ? [
+      Math.min(labelAABB[0], elementAABB[0]),
+      Math.min(labelAABB[1], elementAABB[1]),
+      Math.max(labelAABB[2], elementAABB[2]),
+      Math.max(labelAABB[3], elementAABB[3])
+    ] : elementAABB;
+    if (boundsContainBounds(selectionBounds, commonAABB2)) {
+      if (framesInSelection && isFrameLikeElement(element)) {
+        framesInSelection.add(element.id);
+      }
+      elementsInSelection.add(element);
+      continue;
+    }
+    if (type === "overlap" && labelAABB && doBoundsIntersect(selectionBounds, labelAABB)) {
+      elementsInSelection.add(element);
+      continue;
+    }
+    if (type === "overlap" && doBoundsIntersect(selectionBounds, elementAABB)) {
+      let hasIntersection = false;
+      if (isLinearElement(element) || isFreeDrawElement(element)) {
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = element.points.some((point) => {
+          const rotatedPoint = pointRotateRads12(
+            pointFrom13(element.x + point[0], element.y + point[1]),
+            center,
+            element.angle
+          );
+          return pointInsideBounds(rotatedPoint, selectionBounds);
+        });
+      } else {
+        const nonRotatedElementBounds = getElementBounds(
+          element,
+          elementsMap,
+          true
+        );
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = [
+          pointRotateRads12(
+            pointFrom13(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[1]
+            ),
+            center,
+            element.angle
+          ),
+          pointRotateRads12(
+            pointFrom13(
+              nonRotatedElementBounds[2],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2
+            ),
+            center,
+            element.angle
+          ),
+          pointRotateRads12(
+            pointFrom13(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[3]
+            ),
+            center,
+            element.angle
+          ),
+          pointRotateRads12(
+            pointFrom13(
+              nonRotatedElementBounds[0],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2
+            ),
+            center,
+            element.angle
+          )
+        ].some((point) => {
+          return pointInsideBounds(
+            pointRotateRads12(point, center, element.angle),
+            selectionBounds
+          );
+        });
+      }
+      if (!hasIntersection) {
+        hasIntersection = selectionEdges.some(
+          (selectionEdge) => intersectElementWithLineSegment(
+            element,
+            elementsMap,
+            selectionEdge,
+            strokeWidth / 2,
+            true
+            // Stop at first hit for better performance
+          ).length > 0
+        );
+      }
+      if (hasIntersection) {
+        if (framesInSelection && isFrameLikeElement(element)) {
+          framesInSelection.add(element.id);
+        }
+        elementsInSelection.add(element);
+        continue;
+      }
+    }
+  }
+  if (framesInSelection) {
+    elementsInSelection.forEach((element) => {
+      if (element.frameId && framesInSelection.has(element.frameId)) {
+        elementsInSelection.delete(element);
+      }
+    });
+  }
+  if (type === "overlap") {
+    Array.from(elementsInSelection).forEach((element) => {
+      const groupId = element.groupIds.at(-1);
+      const group = groupId ? groups[groupId] : null;
+      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
+    });
+  } else if (type === "contain") {
+    elementsInSelection.forEach((element) => {
+      const groupId = element.groupIds.at(-1);
+      const group = groupId ? groups[groupId] : null;
+      if (group && !group.every((groupElement) => elementsInSelection.has(groupElement))) {
+        elementsInSelection.delete(element);
+      }
+    });
+  }
+  return elements.filter((element) => elementsInSelection.has(element));
+};
 var elementCenterPoint = (element, elementsMap, xOffset = 0, yOffset = 0) => {
   if (isLinearElement(element) || isFreeDrawElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, elementsMap);
-    const [x3, y3] = pointFrom14((x1 + x2) / 2, (y1 + y2) / 2);
-    return pointFrom14(x3 + xOffset, y3 + yOffset);
+    const [x3, y3] = pointFrom13((x1 + x2) / 2, (y1 + y2) / 2);
+    return pointFrom13(x3 + xOffset, y3 + yOffset);
   }
   const [x, y] = getCenterForBounds(getElementBounds(element, elementsMap));
-  return pointFrom14(x + xOffset, y + yOffset);
+  return pointFrom13(x + xOffset, y + yOffset);
 };
 
 // src/sizeHelpers.ts
@@ -14648,18 +14990,18 @@ var getPerfectElementSize = (elementType, width, height) => {
 var getLockedLinearCursorAlignSize = (originX, originY, x, y, customAngle) => {
   let width = x - originX;
   let height = y - originY;
-  const angle = Math.atan2(height, width);
-  let lockedAngle = Math.round(angle / SHIFT_LOCKING_ANGLE) * SHIFT_LOCKING_ANGLE;
+  const angle2 = Math.atan2(height, width);
+  let lockedAngle = Math.round(angle2 / SHIFT_LOCKING_ANGLE) * SHIFT_LOCKING_ANGLE;
   if (customAngle) {
     const lower = Math.floor(customAngle / SHIFT_LOCKING_ANGLE) * SHIFT_LOCKING_ANGLE;
     if (radiansBetweenAngles(
-      angle,
+      angle2,
       lower,
       lower + SHIFT_LOCKING_ANGLE
     )) {
-      if (radiansDifference(angle, customAngle) < SHIFT_LOCKING_ANGLE / 6) {
+      if (radiansDifference(angle2, customAngle) < SHIFT_LOCKING_ANGLE / 6) {
         lockedAngle = customAngle;
-      } else if (normalizeRadians(angle) > normalizeRadians(customAngle)) {
+      } else if (normalizeRadians(angle2) > normalizeRadians(customAngle)) {
         lockedAngle = lower + SHIFT_LOCKING_ANGLE;
       } else {
         lockedAngle = lower;
@@ -14711,7 +15053,7 @@ var alignElements = (selectedElements, alignment, scene, appState) => {
     selectedElements,
     scene.getNonDeletedElementsMap(),
     appState
-  );
+  ).map(getNonDeletedElements);
   const selectionBoundingBox = getCommonBoundingBox(selectedElements);
   return groups.flatMap((group) => {
     const translation = calculateTranslation(
@@ -14913,6 +15255,11 @@ var duplicateElements = (opts) => {
           return acc;
         }
         processedIds.set(element2.id, true);
+        if (!isNonDeletedElement(element2)) {
+          console.error(
+            "[NONDELETED][INVARIANT] Element to duplicate should be non-deleted"
+          );
+        }
         const newElement2 = duplicateElement(
           appState.editingGroupId,
           groupIdMap,
@@ -15768,7 +16115,7 @@ import {
   isTestEnv as isTestEnv6,
   toArray
 } from "@excalidraw/common";
-import { isNonDeletedElement } from "@excalidraw/element";
+import { isNonDeletedElement as isNonDeletedElement2 } from "@excalidraw/element";
 import { isFrameLikeElement as isFrameLikeElement2 } from "@excalidraw/element";
 import { getElementsInGroup as getElementsInGroup2 } from "@excalidraw/element";
 import {
@@ -15778,7 +16125,7 @@ import {
 } from "@excalidraw/element";
 import { getSelectedElements as getSelectedElements2 } from "@excalidraw/element";
 import { mutateElement as mutateElement2 } from "@excalidraw/element";
-var getNonDeletedElements = (allElements) => {
+var getNonDeletedElements2 = (allElements) => {
   const elementsMap = /* @__PURE__ */ new Map();
   const elements = [];
   for (const element of allElements) {
@@ -15893,7 +16240,7 @@ var Scene = class {
   }
   getNonDeletedElement(id) {
     const element = this.getElement(id);
-    if (element && isNonDeletedElement(element)) {
+    if (element && isNonDeletedElement2(element)) {
       return element;
     }
     return null;
@@ -15938,11 +16285,11 @@ var Scene = class {
       }
       this.elementsMap.set(element.id, element);
     });
-    const nonDeletedElements = getNonDeletedElements(this.elements);
+    const nonDeletedElements = getNonDeletedElements2(this.elements);
     this.nonDeletedElements = nonDeletedElements.elements;
     this.nonDeletedElementsMap = nonDeletedElements.elementsMap;
     this.frames = nextFrameLikes;
-    this.nonDeletedFramesLikes = getNonDeletedElements(this.frames).elements;
+    this.nonDeletedFramesLikes = getNonDeletedElements2(this.frames).elements;
     this.triggerUpdate();
   }
   triggerUpdate() {
@@ -17271,9 +17618,14 @@ var ElementsDelta = class _ElementsDelta {
   static redrawBoundArrows(scene, changed) {
     for (const element of changed.values()) {
       if (!element.isDeleted && isBindableElement(element)) {
-        updateBoundElements(element, scene, {
-          changedElements: changed
-        });
+        updateBoundElements(
+          element,
+          // NOTE: Assumed correct, no runtime check for isDeleted due to performance reasons
+          scene,
+          {
+            changedElements: changed
+          }
+        );
       }
     }
   }
@@ -17335,7 +17687,7 @@ var distributeElements = (selectedElements, elementsMap, distribution, appState,
     selectedElements,
     elementsMap,
     appState
-  ).map((group) => [group, getCommonBoundingBox(group)]).sort((a2, b2) => a2[1][mid] - b2[1][mid]);
+  ).map(getNonDeletedElements).map((group) => [group, getCommonBoundingBox(group)]).sort((a2, b2) => a2[1][mid] - b2[1][mid]);
   let span = 0;
   for (const group of groups) {
     span += group[1][extent];
@@ -17692,6 +18044,7 @@ import {
   DEFAULT_FONT_SIZE as DEFAULT_FONT_SIZE3,
   DEFAULT_TEXT_ALIGN,
   DEFAULT_VERTICAL_ALIGN,
+  DEFAULT_STROKE_STREAMLINE as DEFAULT_STROKE_STREAMLINE2,
   VERTICAL_ALIGN as VERTICAL_ALIGN2,
   randomInteger as randomInteger5,
   randomId as randomId3,
@@ -17711,7 +18064,7 @@ var _newElementBase = (type, {
   opacity = DEFAULT_ELEMENT_PROPS.opacity,
   width = 0,
   height = 0,
-  angle = 0,
+  angle: angle2 = 0,
   groupIds = [],
   frameId = null,
   index = null,
@@ -17738,7 +18091,7 @@ var _newElementBase = (type, {
     y,
     width,
     height,
-    angle,
+    angle: angle2,
     strokeColor,
     backgroundColor,
     fillStyle,
@@ -17895,9 +18248,9 @@ var getAdjustedDimensions = (element, elementsMap, nextText) => {
     y: Number.isFinite(y) ? y : element.y
   };
 };
-var adjustXYWithRotation = (sides, x, y, angle, deltaX1, deltaY1, deltaX2, deltaY2) => {
-  const cos = Math.cos(angle);
-  const sin = Math.sin(angle);
+var adjustXYWithRotation = (sides, x, y, angle2, deltaX1, deltaY1, deltaX2, deltaY2) => {
+  const cos = Math.cos(angle2);
+  const sin = Math.sin(angle2);
   if (sides.e && sides.w) {
     x += deltaX1 + deltaX2;
   } else if (sides.e) {
@@ -17945,7 +18298,11 @@ var newFreeDrawElement = (opts) => {
     ..._newElementBase(opts.type, opts),
     points: opts.points || [],
     pressures: opts.pressures || [],
-    simulatePressure: opts.simulatePressure
+    simulatePressure: opts.simulatePressure,
+    strokeOptions: opts.strokeOptions ?? {
+      variability: "variable",
+      streamline: DEFAULT_STROKE_STREAMLINE2
+    }
   };
 };
 var newLinearElement = (opts) => {
@@ -18414,7 +18771,7 @@ var embeddableURLValidator = (url, validateEmbeddable) => {
 // src/flowchart.ts
 init_define_import_meta_env();
 import { KEYS as KEYS2, invariant as invariant11, toBrandedType as toBrandedType2 } from "@excalidraw/common";
-import { pointFrom as pointFrom15 } from "@excalidraw/math";
+import { pointFrom as pointFrom14 } from "@excalidraw/math";
 var VERTICAL_OFFSET = 100;
 var HORIZONTAL_OFFSET = 100;
 var getLinkDirectionFromKey = (key) => {
@@ -18694,7 +19051,7 @@ var createBindingArrow = (startBindingElement, endBindingElement, direction, app
     strokeWidth: startBindingElement.strokeWidth,
     opacity: startBindingElement.opacity,
     roughness: startBindingElement.roughness,
-    points: [pointFrom15(0, 0), pointFrom15(endX, endY)],
+    points: [pointFrom14(0, 0), pointFrom14(endX, endY)],
     elbowed: true
   });
   const elementsMap = scene.getNonDeletedElementsMap();
@@ -18745,7 +19102,8 @@ var createBindingArrow = (startBindingElement, endBindingElement, direction, app
   );
   return {
     ...bindingArrow,
-    ...update
+    ...update,
+    isDeleted: bindingArrow.isDeleted
   };
 };
 var FlowChartNavigator = class {
@@ -18882,12 +19240,13 @@ var isNodeInFlowchart = (element, elementsMap) => {
 
 // src/arrows/focus.ts
 init_define_import_meta_env();
-import { pointDistance as pointDistance8, pointFrom as pointFrom16 } from "@excalidraw/math";
+import { pointDistance as pointDistance7, pointFrom as pointFrom15 } from "@excalidraw/math";
 import { invariant as invariant12 } from "@excalidraw/common";
 
 // src/zindex.ts
 init_define_import_meta_env();
 import { arrayToMap as arrayToMap11, findIndex, findLastIndex as findLastIndex2 } from "@excalidraw/common";
+import { isFiniteNumber } from "@excalidraw/math";
 var isOfTargetFrame = (element, frameId) => {
   return element.frameId === frameId || element.id === frameId;
 };
@@ -18977,7 +19336,12 @@ var getContiguousFrameRangeElements = (allElements, frameId) => {
   return allElements.slice(rangeStart, rangeEnd + 1);
 };
 var moveArrowAboveBindable2 = (point, arrow, elements, elementsMap, scene, hit) => {
-  const hoveredElement = hit ? hit : getHoveredElementForBinding(point, elements, elementsMap);
+  const hoveredElement = hit ? hit : getHoveredElementForBinding(
+    point,
+    // SAFETY: callers that omit `hit` pass non-deleted elements
+    getNonDeletedElements(elements),
+    elementsMap
+  );
   if (!hoveredElement) {
     return elements;
   }
@@ -19067,7 +19431,34 @@ var getTargetElementsMap = (elements, indices) => {
     return acc;
   }, /* @__PURE__ */ new Map());
 };
+var hasSameElementIds = (prevElements, nextElements) => {
+  if (prevElements.length !== nextElements.length) {
+    console.error(
+      "z-index reordering failed: resulting array have different lengths"
+    );
+    return false;
+  }
+  const prevElementIdCounts = /* @__PURE__ */ new Map();
+  for (const element of prevElements) {
+    prevElementIdCounts.set(
+      element.id,
+      (prevElementIdCounts.get(element.id) || 0) + 1
+    );
+  }
+  for (const element of nextElements) {
+    const count = prevElementIdCounts.get(element.id);
+    if (!count) {
+      console.error(
+        "z-index reordering failed: element id mismatch / duplicate ids"
+      );
+      return false;
+    }
+    prevElementIdCounts.set(element.id, count - 1);
+  }
+  return true;
+};
 var shiftElementsByOne = (elements, appState, direction, scene) => {
+  const originalElements = elements;
   const indicesToMove = getIndicesToMove(elements, appState);
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
   let groupedIndices = toContiguousGroups(indicesToMove);
@@ -19112,11 +19503,17 @@ var shiftElementsByOne = (elements, appState, direction, scene) => {
       ...trailingElements
     ];
   });
+  if (!hasSameElementIds(originalElements, elements)) {
+    return originalElements;
+  }
   syncMovedIndices(elements, targetElementsMap);
   return elements;
 };
 var shiftElementsToEnd = (elements, appState, direction, containingFrame, elementsToBeMoved) => {
   const indicesToMove = getIndicesToMove(elements, appState, elementsToBeMoved);
+  if (indicesToMove.length === 0) {
+    return elements;
+  }
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
   const displacedElements = [];
   let leadingIndex;
@@ -19163,6 +19560,12 @@ var shiftElementsToEnd = (elements, appState, direction, containingFrame, elemen
   if (leadingIndex === -1) {
     leadingIndex = 0;
   }
+  const isValidIndex = (index) => {
+    return isFiniteNumber(index) && index >= 0;
+  };
+  if (!isValidIndex(leadingIndex) || !isValidIndex(trailingIndex) || leadingIndex > trailingIndex || indicesToMove.some((index) => index < leadingIndex || index > trailingIndex)) {
+    return elements;
+  }
   for (let index = leadingIndex; index < trailingIndex + 1; index++) {
     if (!indicesToMove.includes(index)) {
       displacedElements.push(elements[index]);
@@ -19182,6 +19585,9 @@ var shiftElementsToEnd = (elements, appState, direction, containingFrame, elemen
     ...targetElements,
     ...trailingElements
   ];
+  if (!hasSameElementIds(elements, nextElements)) {
+    return elements;
+  }
   syncMovedIndices(nextElements, targetElementsMap);
   return nextElements;
 };
@@ -19223,7 +19629,7 @@ function shiftElementsAccountingForFrames(allElements, appState, direction, shif
   );
   for (const [frameId, children] of frameChildrenSets) {
     nextElements = shiftFunction(
-      allElements,
+      nextElements,
       appState,
       direction,
       frameId,
@@ -19273,7 +19679,7 @@ var isFocusPointVisible = (focusPoint, arrow, bindableElement, elementsMap, appS
       associatedPointIdx,
       elementsMap
     );
-    if (pointDistance8(focusPoint, associatedArrowPoint) < FOCUS_POINT_SIZE * 1.5 / appState.zoom.value) {
+    if (pointDistance7(focusPoint, associatedArrowPoint) < FOCUS_POINT_SIZE * 1.5 / appState.zoom.value) {
       return false;
     }
   }
@@ -19282,7 +19688,7 @@ var isFocusPointVisible = (focusPoint, arrow, bindableElement, elementsMap, appS
     startOrEnd === "end" ? arrow.points.length - 1 : 0,
     elementsMap
   );
-  return pointDistance8(focusPoint, arrowPoint) >= FOCUS_POINT_SIZE * 1.5 / appState.zoom.value && hitElementItself({
+  return pointDistance7(focusPoint, arrowPoint) >= FOCUS_POINT_SIZE * 1.5 / appState.zoom.value && hitElementItself({
     element: bindableElement,
     elementsMap,
     point: focusPoint,
@@ -19372,7 +19778,7 @@ var handleFocusPointDrag = (linearElementEditor, elementsMap, pointerCoords, sce
   const isStartBinding = linearElementEditor.draggedFocusPointBinding === "start";
   const binding = isStartBinding ? arrow.startBinding : arrow.endBinding;
   const { x: offsetX, y: offsetY } = linearElementEditor.pointerOffset;
-  const point = pointFrom16(
+  const point = pointFrom15(
     pointerCoords.x - offsetX,
     pointerCoords.y - offsetY
   );
@@ -19455,7 +19861,7 @@ var handleFocusPointDrag = (linearElementEditor, elementsMap, pointerCoords, sce
   }
 };
 var handleFocusPointPointerDown = (arrow, pointerDownState, elementsMap, appState) => {
-  const pointerPos = pointFrom16(
+  const pointerPos = pointFrom15(
     pointerDownState.origin.x,
     pointerDownState.origin.y
   );
@@ -19475,7 +19881,7 @@ var handleFocusPointPointerDown = (arrow, pointerDownState, elementsMap, appStat
         elementsMap,
         appState,
         "start"
-      ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
+      ) && pointDistance7(pointerPos, focusPoint) <= hitThreshold) {
         return {
           hitFocusPoint: "start",
           pointerOffset: {
@@ -19501,7 +19907,7 @@ var handleFocusPointPointerDown = (arrow, pointerDownState, elementsMap, appStat
         elementsMap,
         appState,
         "end"
-      ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
+      ) && pointDistance7(pointerPos, focusPoint) <= hitThreshold) {
         return {
           hitFocusPoint: "end",
           pointerOffset: {
@@ -19558,7 +19964,7 @@ var handleFocusPointPointerUp = (linearElementEditor, scene) => {
 };
 var handleFocusPointHover = (arrow, scenePointerX, scenePointerY, scene, appState) => {
   const elementsMap = scene.getNonDeletedElementsMap();
-  const pointerPos = pointFrom16(scenePointerX, scenePointerY);
+  const pointerPos = pointFrom15(scenePointerX, scenePointerY);
   const hitThreshold = FOCUS_POINT_SIZE * 1.5 / appState.zoom.value;
   if (arrow.startBinding?.elementId) {
     const bindableElement = elementsMap.get(arrow.startBinding.elementId);
@@ -19575,7 +19981,7 @@ var handleFocusPointHover = (arrow, scenePointerX, scenePointerY, scene, appStat
         elementsMap,
         appState,
         "start"
-      ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
+      ) && pointDistance7(pointerPos, focusPoint) <= hitThreshold) {
         return "start";
       }
     }
@@ -19595,7 +20001,7 @@ var handleFocusPointHover = (arrow, scenePointerX, scenePointerY, scene, appStat
         elementsMap,
         appState,
         "end"
-      ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
+      ) && pointDistance7(pointerPos, focusPoint) <= hitThreshold) {
         return "end";
       }
     }
@@ -19779,8 +20185,8 @@ init_define_import_meta_env();
 import {
   pointCenter as pointCenter3,
   normalizeRadians as normalizeRadians2,
-  pointFrom as pointFrom17,
-  pointRotateRads as pointRotateRads14
+  pointFrom as pointFrom16,
+  pointRotateRads as pointRotateRads13
 } from "@excalidraw/math";
 import {
   MIN_FONT_SIZE,
@@ -19892,20 +20298,20 @@ var rotateSingleElement = (element, scene, pointerX, pointerY, shouldRotateWithD
   );
   const cx = (x1 + x2) / 2;
   const cy = (y1 + y2) / 2;
-  let angle;
+  let angle2;
   if (isFrameLikeElement(element)) {
-    angle = 0;
+    angle2 = 0;
   } else {
-    angle = 5 * Math.PI / 2 + Math.atan2(pointerY - cy, pointerX - cx);
+    angle2 = 5 * Math.PI / 2 + Math.atan2(pointerY - cy, pointerX - cx);
     if (shouldRotateWithDiscreteAngle2) {
-      angle = angle + SHIFT_LOCKING_ANGLE2 / 2;
-      angle = angle - angle % SHIFT_LOCKING_ANGLE2;
+      angle2 = angle2 + SHIFT_LOCKING_ANGLE2 / 2;
+      angle2 = angle2 - angle2 % SHIFT_LOCKING_ANGLE2;
     }
-    angle = normalizeRadians2(angle);
+    angle2 = normalizeRadians2(angle2);
   }
   const boundTextElementId = getBoundTextElementId(element);
   let update = {
-    angle
+    angle: angle2
   };
   if (isBindingElement(element)) {
     update = {
@@ -19928,7 +20334,7 @@ var rotateSingleElement = (element, scene, pointerX, pointerY, shouldRotateWithD
         scene.getNonDeletedElementsMap()
       );
       scene.mutateElement(textElement, {
-        angle,
+        angle: angle2,
         x,
         y
       });
@@ -19968,7 +20374,7 @@ var resizeSingleTextElement = (origElement, element, scene, transformHandleType,
     return;
   }
   if (transformHandleType.includes("n") || transformHandleType.includes("s")) {
-    const previousOrigin = pointFrom17(origElement.x, origElement.y);
+    const previousOrigin = pointFrom16(origElement.x, origElement.y);
     const newOrigin = getResizedOrigin(
       previousOrigin,
       origElement.width,
@@ -20009,7 +20415,7 @@ var resizeSingleTextElement = (origElement, element, scene, transformHandleType,
       element.lineHeight
     );
     const newHeight = metrics2.height;
-    const previousOrigin = pointFrom17(origElement.x, origElement.y);
+    const previousOrigin = pointFrom16(origElement.x, origElement.y);
     const newOrigin = getResizedOrigin(
       previousOrigin,
       origElement.width,
@@ -20046,9 +20452,9 @@ var rotateMultipleElements = (originalElements, elements, scene, pointerX, point
       const cx = (x1 + x2) / 2;
       const cy = (y1 + y2) / 2;
       const origAngle = originalElements.get(element.id)?.angle ?? element.angle;
-      const [rotatedCX, rotatedCY] = pointRotateRads14(
-        pointFrom17(cx, cy),
-        pointFrom17(centerX, centerY),
+      const [rotatedCX, rotatedCY] = pointRotateRads13(
+        pointFrom16(cx, cy),
+        pointFrom16(centerX, centerY),
         centerAngle + origAngle - element.angle
       );
       const updates = isElbowArrow(element) ? {
@@ -20096,45 +20502,45 @@ var getResizeOffsetXY = (transformHandleType, selectedElements, elementsMap, x,
   const [x1, y1, x2, y2] = selectedElements.length === 1 ? getElementAbsoluteCoords2(selectedElements[0], elementsMap) : getCommonBounds(selectedElements);
   const cx = (x1 + x2) / 2;
   const cy = (y1 + y2) / 2;
-  const angle = selectedElements.length === 1 ? selectedElements[0].angle : 0;
-  [x, y] = pointRotateRads14(
-    pointFrom17(x, y),
-    pointFrom17(cx, cy),
-    -angle
+  const angle2 = selectedElements.length === 1 ? selectedElements[0].angle : 0;
+  [x, y] = pointRotateRads13(
+    pointFrom16(x, y),
+    pointFrom16(cx, cy),
+    -angle2
   );
   switch (transformHandleType) {
     case "n":
-      return pointRotateRads14(
-        pointFrom17(x - (x1 + x2) / 2, y - y1),
-        pointFrom17(0, 0),
-        angle
+      return pointRotateRads13(
+        pointFrom16(x - (x1 + x2) / 2, y - y1),
+        pointFrom16(0, 0),
+        angle2
       );
     case "s":
-      return pointRotateRads14(
-        pointFrom17(x - (x1 + x2) / 2, y - y2),
-        pointFrom17(0, 0),
-        angle
+      return pointRotateRads13(
+        pointFrom16(x - (x1 + x2) / 2, y - y2),
+        pointFrom16(0, 0),
+        angle2
       );
     case "w":
-      return pointRotateRads14(
-        pointFrom17(x - x1, y - (y1 + y2) / 2),
-        pointFrom17(0, 0),
-        angle
+      return pointRotateRads13(
+        pointFrom16(x - x1, y - (y1 + y2) / 2),
+        pointFrom16(0, 0),
+        angle2
       );
     case "e":
-      return pointRotateRads14(
-        pointFrom17(x - x2, y - (y1 + y2) / 2),
-        pointFrom17(0, 0),
-        angle
+      return pointRotateRads13(
+        pointFrom16(x - x2, y - (y1 + y2) / 2),
+        pointFrom16(0, 0),
+        angle2
       );
     case "nw":
-      return pointRotateRads14(pointFrom17(x - x1, y - y1), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x1, y - y1), pointFrom16(0, 0), angle2);
     case "ne":
-      return pointRotateRads14(pointFrom17(x - x2, y - y1), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x2, y - y1), pointFrom16(0, 0), angle2);
     case "sw":
-      return pointRotateRads14(pointFrom17(x - x1, y - y2), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x1, y - y2), pointFrom16(0, 0), angle2);
     case "se":
-      return pointRotateRads14(pointFrom17(x - x2, y - y2), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x2, y - y2), pointFrom16(0, 0), angle2);
     default:
       return [0, 0];
   }
@@ -20178,7 +20584,7 @@ var getResizeAnchor = (handleDirection, shouldMaintainAspectRatio, shouldResizeF
   }
   return "top-right";
 };
-var getResizedOrigin = (prevOrigin, prevWidth, prevHeight, newWidth, newHeight, angle, handleDirection, shouldMaintainAspectRatio, shouldResizeFromCenter) => {
+var getResizedOrigin = (prevOrigin, prevWidth, prevHeight, newWidth, newHeight, angle2, handleDirection, shouldMaintainAspectRatio, shouldResizeFromCenter) => {
   const anchor = getResizeAnchor(
     handleDirection,
     shouldMaintainAspectRatio,
@@ -20188,23 +20594,23 @@ var getResizedOrigin = (prevOrigin, prevWidth, prevHeight, newWidth, newHeight,
   switch (anchor) {
     case "top-left":
       return {
-        x: x + (prevWidth - newWidth) / 2 + (newWidth - prevWidth) / 2 * Math.cos(angle) + (prevHeight - newHeight) / 2 * Math.sin(angle),
-        y: y + (prevHeight - newHeight) / 2 + (newWidth - prevWidth) / 2 * Math.sin(angle) + (newHeight - prevHeight) / 2 * Math.cos(angle)
+        x: x + (prevWidth - newWidth) / 2 + (newWidth - prevWidth) / 2 * Math.cos(angle2) + (prevHeight - newHeight) / 2 * Math.sin(angle2),
+        y: y + (prevHeight - newHeight) / 2 + (newWidth - prevWidth) / 2 * Math.sin(angle2) + (newHeight - prevHeight) / 2 * Math.cos(angle2)
       };
     case "top-right":
       return {
-        x: x + (prevWidth - newWidth) / 2 * (Math.cos(angle) + 1) + (prevHeight - newHeight) / 2 * Math.sin(angle),
-        y: y + (prevHeight - newHeight) / 2 + (prevWidth - newWidth) / 2 * Math.sin(angle) + (newHeight - prevHeight) / 2 * Math.cos(angle)
+        x: x + (prevWidth - newWidth) / 2 * (Math.cos(angle2) + 1) + (prevHeight - newHeight) / 2 * Math.sin(angle2),
+        y: y + (prevHeight - newHeight) / 2 + (prevWidth - newWidth) / 2 * Math.sin(angle2) + (newHeight - prevHeight) / 2 * Math.cos(angle2)
       };
     case "bottom-left":
       return {
-        x: x + (prevWidth - newWidth) / 2 * (1 - Math.cos(angle)) + (newHeight - prevHeight) / 2 * Math.sin(angle),
-        y: y + (prevHeight - newHeight) / 2 * (Math.cos(angle) + 1) + (newWidth - prevWidth) / 2 * Math.sin(angle)
+        x: x + (prevWidth - newWidth) / 2 * (1 - Math.cos(angle2)) + (newHeight - prevHeight) / 2 * Math.sin(angle2),
+        y: y + (prevHeight - newHeight) / 2 * (Math.cos(angle2) + 1) + (newWidth - prevWidth) / 2 * Math.sin(angle2)
       };
     case "bottom-right":
       return {
-        x: x + (prevWidth - newWidth) / 2 * (Math.cos(angle) + 1) + (newHeight - prevHeight) / 2 * Math.sin(angle),
-        y: y + (prevHeight - newHeight) / 2 * (Math.cos(angle) + 1) + (prevWidth - newWidth) / 2 * Math.sin(angle)
+        x: x + (prevWidth - newWidth) / 2 * (Math.cos(angle2) + 1) + (newHeight - prevHeight) / 2 * Math.sin(angle2),
+        y: y + (prevHeight - newHeight) / 2 * (Math.cos(angle2) + 1) + (prevWidth - newWidth) / 2 * Math.sin(angle2)
       };
     case "center":
       return {
@@ -20213,23 +20619,23 @@ var getResizedOrigin = (prevOrigin, prevWidth, prevHeight, newWidth, newHeight,
       };
     case "east-side":
       return {
-        x: x + (prevWidth - newWidth) / 2 * (Math.cos(angle) + 1),
-        y: y + (prevWidth - newWidth) / 2 * Math.sin(angle) + (prevHeight - newHeight) / 2
+        x: x + (prevWidth - newWidth) / 2 * (Math.cos(angle2) + 1),
+        y: y + (prevWidth - newWidth) / 2 * Math.sin(angle2) + (prevHeight - newHeight) / 2
       };
     case "west-side":
       return {
-        x: x + (prevWidth - newWidth) / 2 * (1 - Math.cos(angle)),
-        y: y + (newWidth - prevWidth) / 2 * Math.sin(angle) + (prevHeight - newHeight) / 2
+        x: x + (prevWidth - newWidth) / 2 * (1 - Math.cos(angle2)),
+        y: y + (newWidth - prevWidth) / 2 * Math.sin(angle2) + (prevHeight - newHeight) / 2
       };
     case "north-side":
       return {
-        x: x + (prevWidth - newWidth) / 2 + (prevHeight - newHeight) / 2 * Math.sin(angle),
-        y: y + (newHeight - prevHeight) / 2 * (Math.cos(angle) - 1)
+        x: x + (prevWidth - newWidth) / 2 + (prevHeight - newHeight) / 2 * Math.sin(angle2),
+        y: y + (newHeight - prevHeight) / 2 * (Math.cos(angle2) - 1)
       };
     case "south-side":
       return {
-        x: x + (prevWidth - newWidth) / 2 + (newHeight - prevHeight) / 2 * Math.sin(angle),
-        y: y + (prevHeight - newHeight) / 2 * (Math.cos(angle) + 1)
+        x: x + (prevWidth - newWidth) / 2 + (newHeight - prevHeight) / 2 * Math.sin(angle2),
+        y: y + (prevHeight - newHeight) / 2 * (Math.cos(angle2) + 1)
       };
   }
 };
@@ -20297,10 +20703,10 @@ var resizeSingleElement = (nextWidth, nextHeight, latestElement, origElement, or
     nextHeight,
     true
   );
-  let previousOrigin = pointFrom17(origElement.x, origElement.y);
+  let previousOrigin = pointFrom16(origElement.x, origElement.y);
   if (isLinearElement(origElement)) {
     const [x1, y1] = getElementBounds(origElement, originalElementsMap);
-    previousOrigin = pointFrom17(x1, y1);
+    previousOrigin = pointFrom16(x1, y1);
   }
   const newOrigin = getResizedOrigin(
     previousOrigin,
@@ -20323,7 +20729,7 @@ var resizeSingleElement = (nextWidth, nextHeight, latestElement, origElement, or
     newOrigin.x += scaledX;
     newOrigin.y += scaledY;
     rescaledPoints.points = rescaledPoints.points.map(
-      (p) => pointFrom17(p[0] - scaledX, p[1] - scaledY)
+      (p) => pointFrom16(p[0] - scaledX, p[1] - scaledY)
     );
   }
   if (nextWidth < 0) {
@@ -20399,11 +20805,11 @@ var getNextSingleWidthAndHeightFromPointer = (latestElement, origElement, handle
     origElement.height,
     true
   );
-  const startTopLeft = pointFrom17(x1, y1);
-  const startBottomRight = pointFrom17(x2, y2);
+  const startTopLeft = pointFrom16(x1, y1);
+  const startBottomRight = pointFrom16(x2, y2);
   const startCenter = pointCenter3(startTopLeft, startBottomRight);
-  const rotatedPointer = pointRotateRads14(
-    pointFrom17(pointerX, pointerY),
+  const rotatedPointer = pointRotateRads13(
+    pointFrom16(pointerX, pointerY),
     startCenter,
     -origElement.angle
   );
@@ -20593,9 +20999,10 @@ var resizeMultipleElements = (selectedElements, elementsMap, handleDirection, sc
         }
       ];
     }, []);
-    boundingBox = getCommonBoundingBox(
-      targetElements.map(({ orig }) => orig).concat(boundTextElements)
-    );
+    boundingBox = getCommonBoundingBox([
+      ...targetElements.map(({ orig }) => orig),
+      ...boundTextElements
+    ]);
   }
   const { minX, minY, maxX, maxY, midX, midY } = boundingBox;
   const width = maxX - minX;
@@ -20651,7 +21058,7 @@ var resizeMultipleElements = (selectedElements, elementsMap, handleDirection, sc
       }
       const width2 = orig.width * scaleX;
       const height2 = orig.height * scaleY;
-      const angle = normalizeRadians2(
+      const angle2 = normalizeRadians2(
         orig.angle * flipFactorX * flipFactorY
       );
       const isLinearOrFreeDraw = isLinearElement(orig) || isFreeDrawElement(orig);
@@ -20672,7 +21079,7 @@ var resizeMultipleElements = (selectedElements, elementsMap, handleDirection, sc
         y,
         width: width2,
         height: height2,
-        angle,
+        angle: angle2,
         ...rescaledPoints
       };
       if (isElbowArrow(orig)) {
@@ -20740,7 +21147,7 @@ var resizeMultipleElements = (selectedElements, elementsMap, handleDirection, sc
       element,
       update: { boundTextFontSize, ...update }
     } of elementsAndUpdates) {
-      const { angle } = update;
+      const { angle: angle2 } = update;
       scene.mutateElement(element, update);
       updateBoundElements(element, scene, {
         simultaneouslyUpdated: elementsToUpdate
@@ -20761,7 +21168,7 @@ var resizeMultipleElements = (selectedElements, elementsMap, handleDirection, sc
       if (boundTextElement && boundTextFontSize) {
         scene.mutateElement(boundTextElement, {
           fontSize: boundTextFontSize,
-          angle: isLinearElement(element) ? void 0 : angle
+          angle: isLinearElement(element) ? void 0 : angle2
         });
         handleBindTextResize(element, scene, handleDirection, true);
       }
@@ -20773,9 +21180,9 @@ var resizeMultipleElements = (selectedElements, elementsMap, handleDirection, sc
 // src/resizeTest.ts
 init_define_import_meta_env();
 import {
-  pointFrom as pointFrom19,
+  pointFrom as pointFrom18,
   pointOnLineSegment,
-  pointRotateRads as pointRotateRads16
+  pointRotateRads as pointRotateRads15
 } from "@excalidraw/math";
 import {
   SIDE_RESIZING_THRESHOLD
@@ -20786,7 +21193,7 @@ init_define_import_meta_env();
 import {
   DEFAULT_TRANSFORM_HANDLE_SPACING
 } from "@excalidraw/common";
-import { pointFrom as pointFrom18, pointRotateRads as pointRotateRads15 } from "@excalidraw/math";
+import { pointFrom as pointFrom17, pointRotateRads as pointRotateRads14 } from "@excalidraw/math";
 var transformHandleSizes = {
   mouse: 8,
   pen: 16,
@@ -20826,11 +21233,11 @@ var OMIT_SIDES_FOR_LINE_BACKSLASH = {
   n: true,
   w: true
 };
-var generateTransformHandle = (x, y, width, height, cx, cy, angle) => {
-  const [xx, yy] = pointRotateRads15(
-    pointFrom18(x + width / 2, y + height / 2),
-    pointFrom18(cx, cy),
-    angle
+var generateTransformHandle = (x, y, width, height, cx, cy, angle2) => {
+  const [xx, yy] = pointRotateRads14(
+    pointFrom17(x + width / 2, y + height / 2),
+    pointFrom17(cx, cy),
+    angle2
   );
   return [xx - width / 2, yy - height / 2, width, height];
 };
@@ -20846,7 +21253,7 @@ var getOmitSidesForEditorInterface = (editorInterface) => {
   }
   return {};
 };
-var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, pointerType, omitSides = {}, margin = 4, spacing = DEFAULT_TRANSFORM_HANDLE_SPACING) => {
+var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle2, zoom, pointerType, omitSides = {}, margin = 4, spacing = DEFAULT_TRANSFORM_HANDLE_SPACING) => {
   const size = transformHandleSizes[pointerType];
   const handleWidth = size / zoom.value;
   const handleHeight = size / zoom.value;
@@ -20864,7 +21271,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
       handleHeight,
       cx,
       cy,
-      angle
+      angle2
     ),
     ne: omitSides.ne ? void 0 : generateTransformHandle(
       x2 + dashedLineMargin - centeringOffset,
@@ -20873,7 +21280,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
       handleHeight,
       cx,
       cy,
-      angle
+      angle2
     ),
     sw: omitSides.sw ? void 0 : generateTransformHandle(
       x1 - dashedLineMargin - handleMarginX + centeringOffset,
@@ -20882,7 +21289,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
       handleHeight,
       cx,
       cy,
-      angle
+      angle2
     ),
     se: omitSides.se ? void 0 : generateTransformHandle(
       x2 + dashedLineMargin - centeringOffset,
@@ -20891,7 +21298,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
       handleHeight,
       cx,
       cy,
-      angle
+      angle2
     ),
     rotation: omitSides.rotation ? void 0 : generateTransformHandle(
       x1 + width / 2 - handleWidth / 2,
@@ -20900,7 +21307,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
       handleHeight,
       cx,
       cy,
-      angle
+      angle2
     )
   };
   const minimumSizeForEightHandles = 5 * transformHandleSizes.mouse / zoom.value;
@@ -20913,7 +21320,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
         handleHeight,
         cx,
         cy,
-        angle
+        angle2
       );
     }
     if (!omitSides.s) {
@@ -20924,7 +21331,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
         handleHeight,
         cx,
         cy,
-        angle
+        angle2
       );
     }
   }
@@ -20937,7 +21344,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
         handleHeight,
         cx,
         cy,
-        angle
+        angle2
       );
     }
     if (!omitSides.e) {
@@ -20948,7 +21355,7 @@ var getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, poin
         handleHeight,
         cx,
         cy,
-        angle
+        angle2
       );
     }
   }
@@ -21043,14 +21450,14 @@ var resizeTest = (element, elementsMap, appState, x, y, zoom, pointerType, edito
       const SPACING = isImageElement(element) ? 0 : SIDE_RESIZING_THRESHOLD / zoom.value;
       const ZOOMED_SIDE_RESIZING_THRESHOLD = SIDE_RESIZING_THRESHOLD / zoom.value;
       const sides = getSelectionBorders(
-        pointFrom19(x1 - SPACING, y1 - SPACING),
-        pointFrom19(x2 + SPACING, y2 + SPACING),
-        pointFrom19(cx, cy),
+        pointFrom18(x1 - SPACING, y1 - SPACING),
+        pointFrom18(x2 + SPACING, y2 + SPACING),
+        pointFrom18(cx, cy),
         element.angle
       );
       for (const [dir, side] of Object.entries(sides)) {
         if (pointOnLineSegment(
-          pointFrom19(x, y),
+          pointFrom18(x, y),
           side,
           ZOOMED_SIDE_RESIZING_THRESHOLD
         )) {
@@ -21099,14 +21506,14 @@ var getTransformHandleTypeFromCoords = ([x1, y1, x2, y2], scenePointerX, scenePo
     const cy = (y1 + y2) / 2;
     const SPACING = SIDE_RESIZING_THRESHOLD / zoom.value;
     const sides = getSelectionBorders(
-      pointFrom19(x1 - SPACING, y1 - SPACING),
-      pointFrom19(x2 + SPACING, y2 + SPACING),
-      pointFrom19(cx, cy),
+      pointFrom18(x1 - SPACING, y1 - SPACING),
+      pointFrom18(x2 + SPACING, y2 + SPACING),
+      pointFrom18(cx, cy),
       0
     );
     for (const [dir, side] of Object.entries(sides)) {
       if (pointOnLineSegment(
-        pointFrom19(scenePointerX, scenePointerY),
+        pointFrom18(scenePointerX, scenePointerY),
         side,
         SPACING
       )) {
@@ -21117,10 +21524,10 @@ var getTransformHandleTypeFromCoords = ([x1, y1, x2, y2], scenePointerX, scenePo
   return false;
 };
 var RESIZE_CURSORS = ["ns", "nesw", "ew", "nwse"];
-var rotateResizeCursor = (cursor, angle) => {
+var rotateResizeCursor = (cursor, angle2) => {
   const index = RESIZE_CURSORS.indexOf(cursor);
   if (index >= 0) {
-    const a2 = Math.round(angle / (Math.PI / 4));
+    const a2 = Math.round(angle2 / (Math.PI / 4));
     cursor = RESIZE_CURSORS[(index + a2) % RESIZE_CURSORS.length];
   }
   return cursor;
@@ -21162,11 +21569,11 @@ var getCursorForResizingElement = (resizingElement) => {
   }
   return cursor ? `${cursor}-resize` : "";
 };
-var getSelectionBorders = ([x1, y1], [x2, y2], center, angle) => {
-  const topLeft = pointRotateRads16(pointFrom19(x1, y1), center, angle);
-  const topRight = pointRotateRads16(pointFrom19(x2, y1), center, angle);
-  const bottomLeft = pointRotateRads16(pointFrom19(x1, y2), center, angle);
-  const bottomRight = pointRotateRads16(pointFrom19(x2, y2), center, angle);
+var getSelectionBorders = ([x1, y1], [x2, y2], center, angle2) => {
+  const topLeft = pointRotateRads15(pointFrom18(x1, y1), center, angle2);
+  const topRight = pointRotateRads15(pointFrom18(x2, y1), center, angle2);
+  const bottomLeft = pointRotateRads15(pointFrom18(x1, y2), center, angle2);
+  const bottomRight = pointRotateRads15(pointFrom18(x2, y2), center, angle2);
   return {
     n: [topLeft, topRight],
     e: [topRight, bottomRight],
@@ -21183,7 +21590,7 @@ var showSelectedShapeActions = (appState, elements) => Boolean(
 
 // src/transform.ts
 init_define_import_meta_env();
-import { pointFrom as pointFrom20 } from "@excalidraw/math";
+import { pointFrom as pointFrom19 } from "@excalidraw/math";
 import {
   DEFAULT_FONT_FAMILY as DEFAULT_FONT_FAMILY3,
   DEFAULT_FONT_SIZE as DEFAULT_FONT_SIZE4,
@@ -21421,7 +21828,9 @@ var ElementStore = class {
     this.excalidrawElements.set(ele.id, ele);
   };
   getElements = () => {
-    return syncInvalidIndices(Array.from(this.excalidrawElements.values()));
+    return syncInvalidIndices(
+      Array.from(this.excalidrawElements.values())
+    );
   };
   getElementsMap = () => {
     return toBrandedType3(
@@ -21465,7 +21874,7 @@ var convertToExcalidrawElements = (elementsSkeleton, opts) => {
         excalidrawElement = newLinearElement({
           width,
           height,
-          points: [pointFrom20(0, 0), pointFrom20(width, height)],
+          points: [pointFrom19(0, 0), pointFrom19(width, height)],
           ...element
         });
         break;
@@ -21477,7 +21886,7 @@ var convertToExcalidrawElements = (elementsSkeleton, opts) => {
           width,
           height,
           endArrowhead: "arrow",
-          points: [pointFrom20(0, 0), pointFrom20(width, height)],
+          points: [pointFrom19(0, 0), pointFrom19(width, height)],
           ...element,
           type: "arrow"
         });
@@ -21764,11 +22173,11 @@ var hashString = (s) => {
   }
   return hash >>> 0;
 };
+var isNonDeletedElement = (element) => !element.isDeleted;
 var getVisibleElements = (elements) => elements.filter(
-  (el) => !el.isDeleted && !isInvisiblySmallElement(el)
+  (el) => isNonDeletedElement(el) && !isInvisiblySmallElement(el)
 );
-var getNonDeletedElements2 = (elements) => elements.filter((element) => !element.isDeleted);
-var isNonDeletedElement2 = (element) => !element.isDeleted;
+var getNonDeletedElements = (elements) => elements.filter(isNonDeletedElement);
 export {
   AppStateDelta,
   BASE_ARROW_MIN_LENGTH,
@@ -21855,6 +22264,7 @@ export {
   elementWithCanvasCache,
   elementsAreInFrameBounds,
   elementsAreInSameGroup,
+  elementsOverlappingBBox,
   embeddableURLValidator,
   excludeElementsInFramesFromSelection,
   filterElementsEligibleAsFrameChildren,
@@ -21883,7 +22293,6 @@ export {
   getBoundTextMaxWidth,
   getBoundsFromPoints,
   getCenterForBounds,
-  getClosestElementBounds,
   getCommonBoundingBox,
   getCommonBounds,
   getCommonFrameId,
@@ -21939,7 +22348,7 @@ export {
   getMinMaxXYFromCurvePathOps,
   getMinTextElementWidth,
   getNewGroupIdsForDuplication,
-  getNonDeletedElements2 as getNonDeletedElements,
+  getNonDeletedElements,
   getNonDeletedGroupIds,
   getNormalizedDimensions,
   getObservedAppState,
@@ -21987,6 +22396,7 @@ export {
   hasBackground,
   hasBoundTextElement,
   hasBoundingBox,
+  hasFreedrawMode,
   hasStrokeColor,
   hasStrokeStyle,
   hasStrokeWidth,
@@ -22043,7 +22453,7 @@ export {
   isMagicFrameElement,
   isMeasureTextSupported,
   isNodeInFlowchart,
-  isNonDeletedElement2 as isNonDeletedElement,
+  isNonDeletedElement,
   isPathALoop,
   isPointInElement,
   isRectangularElement,