@myoc/element 0.19.517 → 0.19.519

package/dist/dev/index.js

@@ -3869,11 +3869,11 @@ import {
 } from "@excalidraw/common";
 import {
   degreesToRadians,
-  lineSegment as lineSegment7,
+  lineSegment as lineSegment6,
   pointDistance as pointDistance7,
-  pointFrom as pointFrom14,
+  pointFrom as pointFrom13,
   pointFromArray as pointFromArray3,
-  pointRotateRads as pointRotateRads13
+  pointRotateRads as pointRotateRads12
 } from "@excalidraw/math";
 
 // ../utils/src/shape.ts
@@ -4215,9 +4215,9 @@ function ae(e, t = {}) {
 
 // src/shape.ts
 import {
-  pointFrom as pointFrom13,
+  pointFrom as pointFrom12,
   pointDistance as pointDistance6,
-  pointRotateRads as pointRotateRads12
+  pointRotateRads as pointRotateRads11
 } from "@excalidraw/math";
 import {
   ROUGHNESS,
@@ -4233,9 +4233,9 @@ import {
 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,
@@ -4716,11 +4716,11 @@ var getFlipAdjustedCropPosition = (element, natural = false) => {
 init_define_import_meta_env();
 import {
   pointCenter as pointCenter2,
-  pointFrom as pointFrom11,
-  pointRotateRads as pointRotateRads10,
+  pointFrom as pointFrom10,
+  pointRotateRads as pointRotateRads9,
   pointsEqual as pointsEqual6,
   pointDistance as pointDistance5,
-  vectorFromPoint as vectorFromPoint9,
+  vectorFromPoint as vectorFromPoint8,
   curveLength,
   curvePointAtLength
 } from "@excalidraw/math";
@@ -10338,10 +10338,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) {
+  const EPSILON = 1e-4;
+  if (Math.abs(fixedPoint[0] - 0.5) < EPSILON || Math.abs(fixedPoint[1] - 0.5) < EPSILON) {
     return fixedPoint.map(
-      (ratio) => Math.abs(ratio - 0.5) < EPSILON2 ? 0.5001 : ratio
+      (ratio) => Math.abs(ratio - 0.5) < EPSILON ? 0.5001 : ratio
     );
   }
   return fixedPoint;
@@ -10707,52 +10707,15 @@ init_define_import_meta_env();
 // src/selection.ts
 init_define_import_meta_env();
 import { arrayToMap as arrayToMap5, isShallowEqual } from "@excalidraw/common";
-import {
-  lineSegment as lineSegment5,
-  pointFrom as pointFrom10,
-  pointRotateRads as pointRotateRads9
-} from "@excalidraw/math";
 
 // src/frame.ts
 init_define_import_meta_env();
 import { arrayToMap as arrayToMap4 } from "@excalidraw/common";
-import { isPointWithinBounds as isPointWithinBounds2, pointFrom as pointFrom9 } from "@excalidraw/math";
-
-// ../utils/src/bbox.ts
-init_define_import_meta_env();
 import {
-  vectorCross as vectorCross3,
-  vectorFromPoint as vectorFromPoint8
+  isPointWithinBounds as isPointWithinBounds2,
+  pointFrom as pointFrom9,
+  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 = vectorFromPoint8(l2[1], l2[0]);
-  const p2 = vectorFromPoint8(p, l2[0]);
-  const r = vectorCross3(p1, p2);
-  return Math.abs(r) < EPSILON;
-}
-function isPointRightOfLine(l2, p) {
-  const p1 = vectorFromPoint8(l2[1], l2[0]);
-  const p2 = vectorFromPoint8(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/fractionalIndex.ts
 init_define_import_meta_env();
@@ -11025,7 +10988,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;
@@ -11598,197 +11561,14 @@ 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;
-    }
-    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 (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 = pointRotateRads9(
-            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 = [
-          pointRotateRads9(
-            pointFrom10(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[1]
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads9(
-            pointFrom10(
-              nonRotatedElementBounds[2],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads9(
-            pointFrom10(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[3]
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads9(
-            pointFrom10(
-              nonRotatedElementBounds[0],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2
-            ),
-            center,
-            element.angle
-          )
-        ].some((point) => {
-          return pointInsideBounds(
-            pointRotateRads9(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));
+  return elementsOverlappingBBox({
+    elements,
+    bounds: selectionBounds,
+    elementsMap,
+    type: boxSelectionMode,
+    shouldIgnoreElementFromSelection,
+    excludeElementsInFrames
+  });
 };
 var getVisibleAndNonSelectedElements = (elements, selectedElements, appState, elementsMap) => {
   const selectedElementsSet = new Set(
@@ -12559,7 +12339,7 @@ var getNormalizedPoints = ({
   const offsetY = points[0][1];
   return {
     points: points.map((p) => {
-      return pointFrom11(p[0] - offsetX, p[1] - offsetY);
+      return pointFrom10(p[0] - offsetX, p[1] - offsetY);
     }),
     offsetX,
     offsetY
@@ -12588,7 +12368,7 @@ var LinearElementEditor = class _LinearElementEditor {
   pointerDownState;
   constructor(element, elementsMap, isEditing = false) {
     this.elementId = element.id;
-    if (!pointsEqual6(element.points[0], pointFrom11(0, 0))) {
+    if (!pointsEqual6(element.points[0], pointFrom10(0, 0))) {
       console.error("Linear element is not normalized", Error().stack);
       mutateElement(
         element,
@@ -12687,11 +12467,11 @@ var LinearElementEditor = class _LinearElementEditor {
         element,
         elementsMap,
         pivotPoint,
-        pointFrom11(scenePointerX, scenePointerY),
+        pointFrom10(scenePointerX, scenePointerY),
         event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
         customLineAngle
       );
-      const target = pointFrom11(
+      const target = pointFrom10(
         width + pivotPoint[0],
         height + pivotPoint[1]
       );
@@ -12768,7 +12548,7 @@ var LinearElementEditor = class _LinearElementEditor {
         ...linearElementEditor.initialState,
         altFocusPoint: !linearElementEditor.initialState.altFocusPoint && startBindingElement && updates?.suggestedBinding?.element.id !== startBindingElement.id ? projectFixedPointOntoDiagonal(
           element,
-          pointFrom11(element.x, element.y),
+          pointFrom10(element.x, element.y),
           startBindingElement,
           "start",
           elementsMap,
@@ -12830,11 +12610,11 @@ var LinearElementEditor = class _LinearElementEditor {
         element,
         elementsMap,
         pivotPoint,
-        pointFrom11(scenePointerX, scenePointerY),
+        pointFrom10(scenePointerX, scenePointerY),
         event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
         customLineAngle
       );
-      const target = pointFrom11(
+      const target = pointFrom10(
         width + pivotPoint[0],
         height + pivotPoint[1]
       );
@@ -12928,7 +12708,7 @@ var LinearElementEditor = class _LinearElementEditor {
         altFocusPoint: !linearElementEditor.initialState.altFocusPoint && // We only set it once per arrow drag
         isBindingElement(element) && altFocusPointBindableElement ? projectFixedPointOntoDiagonal(
           element,
-          pointFrom11(element.x, element.y),
+          pointFrom10(element.x, element.y),
           altFocusPointBindableElement,
           "start",
           elementsMap,
@@ -13072,11 +12852,11 @@ var LinearElementEditor = class _LinearElementEditor {
     const existingSegmentMidpointHitCoords = linearElementEditor.segmentMidPointHoveredCoords;
     if (existingSegmentMidpointHitCoords) {
       const distance3 = pointDistance5(
-        pointFrom11(
+        pointFrom10(
           existingSegmentMidpointHitCoords[0],
           existingSegmentMidpointHitCoords[1]
         ),
-        pointFrom11(scenePointer.x, scenePointer.y)
+        pointFrom10(scenePointer.x, scenePointer.y)
       );
       if (distance3 <= threshold) {
         return existingSegmentMidpointHitCoords;
@@ -13092,7 +12872,7 @@ var LinearElementEditor = class _LinearElementEditor {
       if (midPoints[index] !== null) {
         const distance3 = pointDistance5(
           midPoints[index],
-          pointFrom11(scenePointer.x, scenePointer.y)
+          pointFrom10(scenePointer.x, scenePointer.y)
         );
         if (distance3 <= threshold) {
           return midPoints[index];
@@ -13134,7 +12914,7 @@ var LinearElementEditor = class _LinearElementEditor {
         "Invalid segment index while calculating elbow arrow mid point"
       );
       const p = pointCenter2(element.points[index - 1], element.points[index]);
-      return pointFrom11(element.x + p[0], element.y + p[1]);
+      return pointFrom10(element.x + p[0], element.y + p[1]);
     }
     const [lines, curves] = deconstructLinearOrFreeDrawElement(
       element,
@@ -13202,7 +12982,7 @@ var LinearElementEditor = class _LinearElementEditor {
       appState,
       elementsMap
     );
-    const point = pointFrom11(scenePointer.x, scenePointer.y);
+    const point = pointFrom10(scenePointer.x, scenePointer.y);
     let segmentMidpointIndex = null;
     if (segmentMidpoint) {
       segmentMidpointIndex = _LinearElementEditor.getSegmentMidPointIndex(
@@ -13261,12 +13041,12 @@ var LinearElementEditor = class _LinearElementEditor {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, elementsMap);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
-    const targetPoint = clickedPointIndex > -1 && pointRotateRads10(
-      pointFrom11(
+    const targetPoint = clickedPointIndex > -1 && pointRotateRads9(
+      pointFrom10(
         element.x + element.points[clickedPointIndex][0],
         element.y + element.points[clickedPointIndex][1]
       ),
-      pointFrom11(cx, cy),
+      pointFrom10(cx, cy),
       element.angle
     );
     const nextSelectedPointsIndices = clickedPointIndex > -1 || event.shiftKey ? event.shiftKey || linearElementEditor.selectedPointsIndices?.includes(clickedPointIndex) ? normalizeSelectedPoints([
@@ -13333,10 +13113,10 @@ var LinearElementEditor = class _LinearElementEditor {
         element,
         elementsMap,
         anchor,
-        pointFrom11(scenePointerX, scenePointerY),
+        pointFrom10(scenePointerX, scenePointerY),
         event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize()
       );
-      newPoint = pointFrom11(width + anchor[0], height + anchor[1]);
+      newPoint = pointFrom10(width + anchor[0], height + anchor[1]);
     } else {
       newPoint = _LinearElementEditor.createPointAt(
         element,
@@ -13373,9 +13153,9 @@ var LinearElementEditor = class _LinearElementEditor {
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
     const { x, y } = element;
-    return pointRotateRads10(
-      pointFrom11(x + p[0], y + p[1]),
-      pointFrom11(cx, cy),
+    return pointRotateRads9(
+      pointFrom10(x + p[0], y + p[1]),
+      pointFrom10(cx, cy),
       element.angle
     );
   }
@@ -13386,9 +13166,9 @@ var LinearElementEditor = class _LinearElementEditor {
     const cy = (y1 + y2) / 2;
     return element.points.map((p) => {
       const { x, y } = element;
-      return pointRotateRads10(
-        pointFrom11(x + p[0], y + p[1]),
-        pointFrom11(cx, cy),
+      return pointRotateRads9(
+        pointFrom10(x + p[0], y + p[1]),
+        pointFrom10(cx, cy),
         element.angle
       );
     });
@@ -13396,18 +13176,18 @@ var LinearElementEditor = class _LinearElementEditor {
   static getPointAtIndexGlobalCoordinates(element, indexMaybeFromEnd, elementsMap) {
     const index = indexMaybeFromEnd < 0 ? element.points.length + indexMaybeFromEnd : indexMaybeFromEnd;
     const [, , , , cx, cy] = getElementAbsoluteCoords2(element, elementsMap);
-    const center = pointFrom11(cx, cy);
+    const center = pointFrom10(cx, cy);
     const p = element.points[index];
     const { x, y } = element;
-    return p ? pointRotateRads10(
-      pointFrom11(x + p[0], y + p[1]),
+    return p ? pointRotateRads9(
+      pointFrom10(x + p[0], y + p[1]),
       center,
       element.angle
-    ) : pointRotateRads10(pointFrom11(x, y), center, element.angle);
+    ) : pointRotateRads9(pointFrom10(x, y), center, element.angle);
   }
   static pointFromAbsoluteCoords(element, absoluteCoords, elementsMap) {
     if (isElbowArrow(element)) {
-      return pointFrom11(
+      return pointFrom10(
         absoluteCoords[0] - element.x,
         absoluteCoords[1] - element.y
       );
@@ -13415,12 +13195,12 @@ var LinearElementEditor = class _LinearElementEditor {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, elementsMap);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
-    const [x, y] = pointRotateRads10(
-      pointFrom11(absoluteCoords[0], absoluteCoords[1]),
-      pointFrom11(cx, cy),
+    const [x, y] = pointRotateRads9(
+      pointFrom10(absoluteCoords[0], absoluteCoords[1]),
+      pointFrom10(cx, cy),
       -element.angle
     );
-    return pointFrom11(x - element.x, y - element.y);
+    return pointFrom10(x - element.x, y - element.y);
   }
   static getPointIndexUnderCursor(element, elementsMap, zoom, x, y) {
     const pointHandles = _LinearElementEditor.getPointsGlobalCoordinates(
@@ -13430,7 +13210,7 @@ var LinearElementEditor = class _LinearElementEditor {
     let idx = pointHandles.length;
     while (--idx > -1) {
       const p = pointHandles[idx];
-      if (pointDistance5(pointFrom11(x, y), pointFrom11(p[0], p[1])) * zoom.value < // +1px to account for outline stroke
+      if (pointDistance5(pointFrom10(x, y), pointFrom10(p[0], p[1])) * zoom.value < // +1px to account for outline stroke
       _LinearElementEditor.POINT_HANDLE_SIZE + 1) {
         return idx;
       }
@@ -13442,12 +13222,12 @@ var LinearElementEditor = class _LinearElementEditor {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords2(element, elementsMap);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
-    const [rotatedX, rotatedY] = pointRotateRads10(
-      pointFrom11(pointerOnGrid[0], pointerOnGrid[1]),
-      pointFrom11(cx, cy),
+    const [rotatedX, rotatedY] = pointRotateRads9(
+      pointFrom10(pointerOnGrid[0], pointerOnGrid[1]),
+      pointFrom10(cx, cy),
       -element.angle
     );
-    return pointFrom11(rotatedX - element.x, rotatedY - element.y);
+    return pointFrom10(rotatedX - element.x, rotatedY - element.y);
   }
   /**
    * Normalizes line points so that the start point is at [0,0]. This is
@@ -13496,7 +13276,7 @@ var LinearElementEditor = class _LinearElementEditor {
           pointAddedToEnd = true;
         }
         acc.push(
-          nextPoint ? pointFrom11((p[0] + nextPoint[0]) / 2, (p[1] + nextPoint[1]) / 2) : pointFrom11(p[0], p[1])
+          nextPoint ? pointFrom10((p[0] + nextPoint[0]) / 2, (p[1] + nextPoint[1]) / 2) : pointFrom10(p[0], p[1])
         );
         nextSelectedIndices.push(indexCursor + 1);
         ++indexCursor;
@@ -13512,7 +13292,7 @@ var LinearElementEditor = class _LinearElementEditor {
         /* @__PURE__ */ new Map([
           [
             element.points.length - 1,
-            { point: pointFrom11(lastPoint[0] + 30, lastPoint[1] + 30) }
+            { point: pointFrom10(lastPoint[0] + 30, lastPoint[1] + 30) }
           ]
         ])
       );
@@ -13532,7 +13312,7 @@ var LinearElementEditor = class _LinearElementEditor {
     });
     const isPolygon = isLineElement(element) && element.polygon;
     if (isPolygon && (isUncommittedPoint || pointIndices.includes(0) || pointIndices.includes(element.points.length - 1))) {
-      nextPoints[0] = pointFrom11(
+      nextPoints[0] = pointFrom10(
         nextPoints[nextPoints.length - 1][0],
         nextPoints[nextPoints.length - 1][1]
       );
@@ -13553,7 +13333,7 @@ var LinearElementEditor = class _LinearElementEditor {
   static addPoints(element, scene, addedPoints) {
     const nextPoints = [...element.points, ...addedPoints];
     if (isLineElement(element) && element.polygon) {
-      nextPoints[0] = pointFrom11(
+      nextPoints[0] = pointFrom10(
         nextPoints[nextPoints.length - 1][0],
         nextPoints[nextPoints.length - 1][1]
       );
@@ -13578,7 +13358,7 @@ var LinearElementEditor = class _LinearElementEditor {
       const lastPointUpdate = pointUpdates.get(points.length - 1);
       if (firstPointUpdate) {
         pointUpdates.set(points.length - 1, {
-          point: pointFrom11(
+          point: pointFrom10(
             firstPointUpdate.point[0],
             firstPointUpdate.point[1]
           ),
@@ -13586,12 +13366,12 @@ var LinearElementEditor = class _LinearElementEditor {
         });
       } else if (lastPointUpdate) {
         pointUpdates.set(0, {
-          point: pointFrom11(lastPointUpdate.point[0], lastPointUpdate.point[1]),
+          point: pointFrom10(lastPointUpdate.point[0], lastPointUpdate.point[1]),
           isDragging: lastPointUpdate.isDragging
         });
       }
     }
-    const updatedOriginPoint = pointUpdates.get(0)?.point ?? pointFrom11(0, 0);
+    const updatedOriginPoint = pointUpdates.get(0)?.point ?? pointFrom10(0, 0);
     const [offsetX, offsetY] = updatedOriginPoint;
     const nextPoints = isElbowArrow(element) ? [
       pointUpdates.get(0)?.point ?? points[0],
@@ -13601,7 +13381,7 @@ var LinearElementEditor = class _LinearElementEditor {
       if (otherUpdates?.moveMidPointsWithElement && idx !== 0 && idx !== points.length - 1 && !pointUpdates.has(idx)) {
         return current;
       }
-      return pointFrom11(
+      return pointFrom10(
         current[0] - offsetX,
         current[1] - offsetY
       );
@@ -13638,7 +13418,7 @@ var LinearElementEditor = class _LinearElementEditor {
     const origin = linearElementEditor.initialState.origin;
     const dist = pointDistance5(
       origin,
-      pointFrom11(pointerCoords.x, pointerCoords.y)
+      pointFrom10(pointerCoords.x, pointerCoords.y)
     );
     if (!appState.selectedLinearElement?.isEditing && dist < DRAGGING_THRESHOLD / appState.zoom.value) {
       return false;
@@ -13708,9 +13488,9 @@ var LinearElementEditor = class _LinearElementEditor {
       const prevCenterY = (prevCoords[1] + prevCoords[3]) / 2;
       const dX = prevCenterX - nextCenterX;
       const dY = prevCenterY - nextCenterY;
-      const rotatedOffset = pointRotateRads10(
-        pointFrom11(offsetX, offsetY),
-        pointFrom11(dX, dY),
+      const rotatedOffset = pointRotateRads9(
+        pointFrom10(offsetX, offsetY),
+        pointFrom10(dX, dY),
         element.angle
       );
       scene.mutateElement(element, {
@@ -13745,9 +13525,9 @@ var LinearElementEditor = class _LinearElementEditor {
       gridY,
       customLineAngle
     );
-    return pointRotateRads10(
-      pointFrom11(width, height),
-      pointFrom11(0, 0),
+    return pointRotateRads9(
+      pointFrom10(width, height),
+      pointFrom10(0, 0),
       -element.angle
     );
   }
@@ -13793,34 +13573,34 @@ var LinearElementEditor = class _LinearElementEditor {
     );
     const boundTextX2 = boundTextX1 + boundTextElement.width;
     const boundTextY2 = boundTextY1 + boundTextElement.height;
-    const centerPoint = pointFrom11(cx, cy);
-    const topLeftRotatedPoint = pointRotateRads10(
-      pointFrom11(x1, y1),
+    const centerPoint = pointFrom10(cx, cy);
+    const topLeftRotatedPoint = pointRotateRads9(
+      pointFrom10(x1, y1),
       centerPoint,
       element.angle
     );
-    const topRightRotatedPoint = pointRotateRads10(
-      pointFrom11(x2, y1),
+    const topRightRotatedPoint = pointRotateRads9(
+      pointFrom10(x2, y1),
       centerPoint,
       element.angle
     );
-    const counterRotateBoundTextTopLeft = pointRotateRads10(
-      pointFrom11(boundTextX1, boundTextY1),
+    const counterRotateBoundTextTopLeft = pointRotateRads9(
+      pointFrom10(boundTextX1, boundTextY1),
       centerPoint,
       -element.angle
     );
-    const counterRotateBoundTextTopRight = pointRotateRads10(
-      pointFrom11(boundTextX2, boundTextY1),
+    const counterRotateBoundTextTopRight = pointRotateRads9(
+      pointFrom10(boundTextX2, boundTextY1),
       centerPoint,
       -element.angle
     );
-    const counterRotateBoundTextBottomLeft = pointRotateRads10(
-      pointFrom11(boundTextX1, boundTextY2),
+    const counterRotateBoundTextBottomLeft = pointRotateRads9(
+      pointFrom10(boundTextX1, boundTextY2),
       centerPoint,
       -element.angle
     );
-    const counterRotateBoundTextBottomRight = pointRotateRads10(
-      pointFrom11(boundTextX2, boundTextY2),
+    const counterRotateBoundTextBottomRight = pointRotateRads9(
+      pointFrom10(boundTextX2, boundTextY2),
       centerPoint,
       -element.angle
     );
@@ -13898,7 +13678,7 @@ var LinearElementEditor = class _LinearElementEditor {
     if (index && index > 0 && index < element.points.length) {
       const isHorizontal = headingIsHorizontal(
         vectorToHeading(
-          vectorFromPoint9(element.points[index], element.points[index - 1])
+          vectorFromPoint8(element.points[index], element.points[index - 1])
         )
       );
       const fixedSegments = (element.fixedSegments ?? []).reduce(
@@ -13910,11 +13690,11 @@ var LinearElementEditor = class _LinearElementEditor {
       );
       fixedSegments[index] = {
         index,
-        start: pointFrom11(
+        start: pointFrom10(
           !isHorizontal ? x - element.x : element.points[index - 1][0],
           isHorizontal ? y - element.y : element.points[index - 1][1]
         ),
-        end: pointFrom11(
+        end: pointFrom10(
           !isHorizontal ? x - element.x : element.points[index][0],
           isHorizontal ? y - element.y : element.points[index][1]
         )
@@ -13926,7 +13706,7 @@ var LinearElementEditor = class _LinearElementEditor {
       scene.mutateElement(element, {
         fixedSegments: nextFixedSegments
       });
-      const point = pointFrom11(
+      const point = pointFrom10(
         element.x + (element.fixedSegments[offset].start[0] + element.fixedSegments[offset].end[0]) / 2,
         element.y + (element.fixedSegments[offset].start[1] + element.fixedSegments[offset].end[1]) / 2
       );
@@ -13967,7 +13747,7 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
       return [
         pointIndex,
         {
-          point: pointFrom11(point[0] + deltaX, point[1] + deltaY),
+          point: pointFrom10(point[0] + deltaX, point[1] + deltaY),
           isDragging: true
         }
       ];
@@ -14006,7 +13786,7 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
           midPoint: app.state.isMidpointSnappingEnabled ? snapToMid(
             suggestedBindingElement,
             elementsMap,
-            pointFrom11(
+            pointFrom10(
               scenePointerX - linearElementEditor.pointerOffset.x,
               scenePointerY - linearElementEditor.pointerOffset.y
             )
@@ -14086,7 +13866,7 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
       updates.suggestedBinding = start2.element ? {
         element: start2.element,
         midPoint: getSnapOutlineMidPoint(
-          pointFrom11(
+          pointFrom10(
             scenePointerX - linearElementEditor.pointerOffset.x,
             scenePointerY - linearElementEditor.pointerOffset.y
           ),
@@ -14117,7 +13897,7 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
       updates.suggestedBinding = end.element ? {
         element: end.element,
         midPoint: getSnapOutlineMidPoint(
-          pointFrom11(
+          pointFrom10(
             scenePointerX - linearElementEditor.pointerOffset.x,
             scenePointerY - linearElementEditor.pointerOffset.y
           ),
@@ -14130,11 +13910,11 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
   } else if (endIsDragged) {
     updates.suggestedBinding = app.state.suggestedBinding;
   }
-  const offsetStartLocalPoint = startIsDragged ? pointFrom11(
+  const offsetStartLocalPoint = startIsDragged ? pointFrom10(
     element.points[0][0] + deltaX,
     element.points[0][1] + deltaY
   ) : element.points[0];
-  const offsetEndLocalPoint = endIsDragged ? pointFrom11(
+  const offsetEndLocalPoint = endIsDragged ? pointFrom10(
     element.points[element.points.length - 1][0] + deltaX,
     element.points[element.points.length - 1][1] + deltaY
   ) : element.points[element.points.length - 1];
@@ -14383,7 +14163,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);
@@ -14491,7 +14274,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;
@@ -14639,7 +14425,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");
         }
@@ -14842,7 +14631,7 @@ function getFreedrawOutlineAsSegments(element, points, elementsMap) {
     },
     elementsMap
   );
-  const center = pointFrom12(
+  const center = pointFrom11(
     (bounds[0] + bounds[2]) / 2,
     (bounds[1] + bounds[3]) / 2
   );
@@ -14850,10 +14639,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
           )
@@ -14862,17 +14651,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
           ),
@@ -14967,7 +14756,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) {
@@ -14977,7 +14766,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;
       }
@@ -14987,7 +14776,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;
     }
@@ -15062,8 +14851,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) {
@@ -15248,26 +15040,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]
             ),
@@ -15276,30 +15068,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]
               ),
@@ -15307,7 +15099,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()
         };
       });
@@ -15322,8 +15114,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]
             ),
@@ -15332,30 +15124,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]
               ),
@@ -15363,7 +15155,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()
         };
       });
@@ -15464,7 +15256,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
@@ -15628,14 +15420,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":
@@ -15644,7 +15436,7 @@ var getElementShape = (element, elementsMap) => {
       const [, , , , cx, cy] = getElementAbsoluteCoords2(element, elementsMap);
       return getFreedrawShape(
         element,
-        pointFrom13(cx, cy),
+        pointFrom12(cx, cy),
         shouldTestInside(element)
       );
     }
@@ -15663,9 +15455,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]
       );
@@ -15758,9 +15550,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
           )
         )
@@ -15774,24 +15566,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);
@@ -15808,24 +15600,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);
@@ -15879,7 +15671,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(
@@ -15891,9 +15683,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++;
@@ -15904,9 +15696,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++;
@@ -15930,10 +15722,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;
       }
@@ -15941,7 +15733,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") {
@@ -15956,16 +15748,16 @@ 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) => {
@@ -15973,9 +15765,9 @@ var _isRectanguloidElement = (element) => {
 };
 var getRotatedSides = (sides, center, angle) => {
   return sides.map((side) => {
-    return lineSegment7(
-      pointRotateRads13(side[0], center, angle),
-      pointRotateRads13(side[1], center, angle)
+    return lineSegment6(
+      pointRotateRads12(side[0], center, angle),
+      pointRotateRads12(side[1], center, angle)
     );
   });
 };
@@ -15985,14 +15777,14 @@ var getSegmentsOnCurve = (curve4, center, angle) => {
   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
         ),
-        pointRotateRads13(
-          pointFrom14(points[i + 1][0], points[i + 1][1]),
+        pointRotateRads12(
+          pointFrom13(points[i + 1][0], points[i + 1][1]),
           center,
           angle
         )
@@ -16003,7 +15795,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
   );
@@ -16017,12 +15809,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) => {
@@ -16100,7 +15892,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") {
@@ -16108,9 +15900,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;
@@ -16201,17 +15993,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;
@@ -16238,26 +16030,26 @@ var getArrowheadPoints = (element, shape, position, arrowhead, offsetMultiplier
   }
   const angle = getArrowheadAngle(arrowhead);
   if (arrowhead === "cardinality_many" || arrowhead === "cardinality_one_or_many") {
-    const [x32, y32] = pointRotateRads13(
-      pointFrom14(tx, ty),
-      pointFrom14(xs, ys),
+    const [x32, y32] = pointRotateRads12(
+      pointFrom13(tx, ty),
+      pointFrom13(xs, ys),
       degreesToRadians(-angle)
     );
-    const [x42, y42] = pointRotateRads13(
-      pointFrom14(tx, ty),
-      pointFrom14(xs, ys),
+    const [x42, y42] = pointRotateRads12(
+      pointFrom13(tx, ty),
+      pointFrom13(xs, ys),
       degreesToRadians(angle)
     );
     return [xs, ys, x32, y32, x42, y42];
   }
-  const [x3, y3] = pointRotateRads13(
-    pointFrom14(xs, ys),
-    pointFrom14(tx, ty),
+  const [x3, y3] = pointRotateRads12(
+    pointFrom13(xs, ys),
+    pointFrom13(tx, ty),
     -angle * Math.PI / 180
   );
-  const [x4, y4] = pointRotateRads13(
-    pointFrom14(xs, ys),
-    pointFrom14(tx, ty),
+  const [x4, y4] = pointRotateRads12(
+    pointFrom13(xs, ys),
+    pointFrom13(tx, ty),
     degreesToRadians(angle)
   );
   if (arrowhead === "diamond" || arrowhead === "diamond_outline") {
@@ -16265,16 +16057,16 @@ var getArrowheadPoints = (element, shape, position, arrowhead, offsetMultiplier
     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)
       );
     }
@@ -16303,9 +16095,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];
@@ -16328,9 +16120,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);
@@ -16441,8 +16233,8 @@ var getClosestElementBounds = (elements, from) => {
   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)
+      pointFrom13((x1 + x2) / 2, (y1 + y2) / 2),
+      pointFrom13(from.x, from.y)
     );
     if (distance3 < minDistance) {
       minDistance = distance3;
@@ -16478,7 +16270,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
 );
@@ -16492,23 +16284,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
   );
@@ -16540,19 +16332,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 = arrayToMap7(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
@@ -20936,7 +20933,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) => {
@@ -21216,7 +21213,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();
@@ -21404,7 +21401,7 @@ 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 pointDistance8, pointFrom as pointFrom15 } from "@excalidraw/math";
 import { invariant as invariant12 } from "@excalidraw/common";
 var isFocusPointVisible = (focusPoint, arrow, bindableElement, elementsMap, appState, startOrEnd, ignoreOverlap = false) => {
   if (isElbowArrow(arrow) || !isBindingEnabled(appState) || arrow.points.length !== 2) {
@@ -21516,7 +21513,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
   );
@@ -21599,7 +21596,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
   );
@@ -21702,7 +21699,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);
@@ -22008,8 +22005,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,
@@ -22197,7 +22194,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,
@@ -22238,7 +22235,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,
@@ -22275,9 +22272,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) ? {
@@ -22326,44 +22323,44 @@ var getResizeOffsetXY = (transformHandleType, selectedElements, elementsMap, x,
   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),
+  [x, y] = pointRotateRads13(
+    pointFrom16(x, y),
+    pointFrom16(cx, cy),
     -angle
   );
   switch (transformHandleType) {
     case "n":
-      return pointRotateRads14(
-        pointFrom17(x - (x1 + x2) / 2, y - y1),
-        pointFrom17(0, 0),
+      return pointRotateRads13(
+        pointFrom16(x - (x1 + x2) / 2, y - y1),
+        pointFrom16(0, 0),
         angle
       );
     case "s":
-      return pointRotateRads14(
-        pointFrom17(x - (x1 + x2) / 2, y - y2),
-        pointFrom17(0, 0),
+      return pointRotateRads13(
+        pointFrom16(x - (x1 + x2) / 2, y - y2),
+        pointFrom16(0, 0),
         angle
       );
     case "w":
-      return pointRotateRads14(
-        pointFrom17(x - x1, y - (y1 + y2) / 2),
-        pointFrom17(0, 0),
+      return pointRotateRads13(
+        pointFrom16(x - x1, y - (y1 + y2) / 2),
+        pointFrom16(0, 0),
         angle
       );
     case "e":
-      return pointRotateRads14(
-        pointFrom17(x - x2, y - (y1 + y2) / 2),
-        pointFrom17(0, 0),
+      return pointRotateRads13(
+        pointFrom16(x - x2, y - (y1 + y2) / 2),
+        pointFrom16(0, 0),
         angle
       );
     case "nw":
-      return pointRotateRads14(pointFrom17(x - x1, y - y1), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x1, y - y1), pointFrom16(0, 0), angle);
     case "ne":
-      return pointRotateRads14(pointFrom17(x - x2, y - y1), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x2, y - y1), pointFrom16(0, 0), angle);
     case "sw":
-      return pointRotateRads14(pointFrom17(x - x1, y - y2), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x1, y - y2), pointFrom16(0, 0), angle);
     case "se":
-      return pointRotateRads14(pointFrom17(x - x2, y - y2), pointFrom17(0, 0), angle);
+      return pointRotateRads13(pointFrom16(x - x2, y - y2), pointFrom16(0, 0), angle);
     default:
       return [0, 0];
   }
@@ -22526,10 +22523,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,
@@ -22552,7 +22549,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) {
@@ -22628,11 +22625,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
   );
@@ -23002,9 +22999,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
@@ -23015,7 +23012,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,
@@ -23056,9 +23053,9 @@ var OMIT_SIDES_FOR_LINE_BACKSLASH = {
   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),
+  const [xx, yy] = pointRotateRads14(
+    pointFrom17(x + width / 2, y + height / 2),
+    pointFrom17(cx, cy),
     angle
   );
   return [xx - width / 2, yy - height / 2, width, height];
@@ -23272,14 +23269,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
         )) {
@@ -23328,14 +23325,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
       )) {
@@ -23392,10 +23389,10 @@ 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);
+  const topLeft = pointRotateRads15(pointFrom18(x1, y1), center, angle);
+  const topRight = pointRotateRads15(pointFrom18(x2, y1), center, angle);
+  const bottomLeft = pointRotateRads15(pointFrom18(x1, y2), center, angle);
+  const bottomRight = pointRotateRads15(pointFrom18(x2, y2), center, angle);
   return {
     n: [topLeft, topRight],
     e: [topRight, bottomRight],
@@ -25999,7 +25996,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,
@@ -26281,7 +26278,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;
@@ -26293,7 +26290,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"
         });
@@ -26673,6 +26670,7 @@ export {
   elementWithCanvasCache,
   elementsAreInFrameBounds,
   elementsAreInSameGroup,
+  elementsOverlappingBBox,
   embeddableURLValidator,
   excludeElementsInFramesFromSelection,
   filterElementsEligibleAsFrameChildren,