@excalidraw/element 0.18.0-54a9826 → 0.18.0-60b2758

package/dist/dev/index.js

@@ -2267,7 +2267,7 @@ import {
 } from "@excalidraw/common";
 import {
   degreesToRadians,
-  lineSegment as lineSegment7,
+  lineSegment as lineSegment6,
   pointDistance as pointDistance7,
   pointFrom as pointFrom14,
   pointFromArray as pointFromArray3,
@@ -2631,7 +2631,7 @@ import {
 init_define_import_meta_env();
 import {
   isRightAngleRads,
-  lineSegment as lineSegment6,
+  lineSegment as lineSegment5,
   pointFrom as pointFrom12,
   pointRotateRads as pointRotateRads11
 } from "@excalidraw/math";
@@ -3120,8 +3120,7 @@ import {
   pointDistance as pointDistance5,
   vectorFromPoint as vectorFromPoint8,
   curveLength,
-  curvePointAtLength,
-  lineSegment as lineSegment5
+  curvePointAtLength
 } from "@excalidraw/math";
 import {
   DRAGGING_THRESHOLD,
@@ -3134,6 +3133,7 @@ import {
 } from "@excalidraw/common";
 import {
   deconstructLinearOrFreeDrawElement as deconstructLinearOrFreeDrawElement2,
+  getSnapOutlineMidPoint as getSnapOutlineMidPoint2,
   isPathALoop as isPathALoop2,
   moveArrowAboveBindable,
   projectFixedPointOntoDiagonal as projectFixedPointOntoDiagonal2
@@ -3194,6 +3194,7 @@ import {
   ROUNDNESS as ROUNDNESS2
 } from "@excalidraw/common";
 import {
+  bezierEquation,
   curve as curve3,
   curveCatmullRomCubicApproxPoints,
   curveOffsetPoints,
@@ -3591,11 +3592,7 @@ function deconstructRectanguloidElement(element, offset = 0) {
   setElementShapesCacheEntry(element, shape, offset);
   return shape;
 }
-function deconstructDiamondElement(element, offset = 0) {
-  const cachedShape = getElementShapesCacheEntry(element, offset);
-  if (cachedShape) {
-    return cachedShape;
-  }
+function getDiamondBaseCorners(element, offset = 0) {
   const [topX, topY, rightX, rightY, bottomX, bottomY, leftX, leftY] = getDiamondPoints(element);
   const verticalRadius = element.roundness ? getCornerRadius(Math.abs(topX - leftX), element) : (topX - leftX) * 0.01;
   const horizontalRadius = element.roundness ? getCornerRadius(Math.abs(rightY - topY), element) : (rightY - topY) * 0.01;
@@ -3605,7 +3602,7 @@ function deconstructDiamondElement(element, offset = 0) {
     pointFrom3(element.x + bottomX, element.y + bottomY),
     pointFrom3(element.x + leftX, element.y + leftY)
   ];
-  const baseCorners = [
+  return [
     curve3(
       pointFrom3(
         right[0] - verticalRadius,
@@ -3659,6 +3656,13 @@ function deconstructDiamondElement(element, offset = 0) {
     )
     // TOP
   ];
+}
+function deconstructDiamondElement(element, offset = 0) {
+  const cachedShape = getElementShapesCacheEntry(element, offset);
+  if (cachedShape) {
+    return cachedShape;
+  }
+  const baseCorners = getDiamondBaseCorners(element, offset);
   const corners = baseCorners.map(
     (corner) => curveCatmullRomCubicApproxPoints(curveOffsetPoints(corner, offset))
   );
@@ -3778,20 +3782,90 @@ var getDiagonalsForBindableElement = (element, elementsMap) => {
   );
   return [diagonalOne, diagonalTwo];
 };
-var projectFixedPointOntoDiagonal = (arrow, point, element, startOrEnd, elementsMap) => {
+var getSnapOutlineMidPoint = (point, element, elementsMap, zoom) => {
+  const center = elementCenterPoint(element, elementsMap);
+  const sideMidpoints = element.type === "diamond" ? getDiamondBaseCorners(element).map((curve4) => {
+    const point2 = bezierEquation(curve4, 0.5);
+    const rotatedPoint = pointRotateRads3(point2, center, element.angle);
+    return pointFrom3(rotatedPoint[0], rotatedPoint[1]);
+  }) : [
+    // RIGHT midpoint
+    pointRotateRads3(
+      pointFrom3(
+        element.x + element.width,
+        element.y + element.height / 2
+      ),
+      center,
+      element.angle
+    ),
+    // BOTTOM midpoint
+    pointRotateRads3(
+      pointFrom3(
+        element.x + element.width / 2,
+        element.y + element.height
+      ),
+      center,
+      element.angle
+    ),
+    // LEFT midpoint
+    pointRotateRads3(
+      pointFrom3(element.x, element.y + element.height / 2),
+      center,
+      element.angle
+    ),
+    // TOP midpoint
+    pointRotateRads3(
+      pointFrom3(element.x + element.width / 2, element.y),
+      center,
+      element.angle
+    )
+  ];
+  const candidate = sideMidpoints.find(
+    (midpoint2) => pointDistance2(point, midpoint2) <= maxBindingDistance_simple(zoom) + element.strokeWidth / 2 && !hitElementItself({
+      point,
+      element,
+      threshold: 0,
+      elementsMap,
+      overrideShouldTestInside: true
+    })
+  );
+  return candidate;
+};
+var projectFixedPointOntoDiagonal = (arrow, point, element, startOrEnd, elementsMap, zoom) => {
   invariant2(arrow.points.length >= 2, "Arrow must have at least two points");
   if (arrow.width < 3 && arrow.height < 3) {
     return null;
   }
+  const sideMidPoint = getSnapOutlineMidPoint(
+    point,
+    element,
+    elementsMap,
+    zoom
+  );
+  if (sideMidPoint) {
+    return sideMidPoint;
+  }
   const [diagonalOne, diagonalTwo] = getDiagonalsForBindableElement(
     element,
     elementsMap
   );
-  const a2 = LinearElementEditor.getPointAtIndexGlobalCoordinates(
+  let a2 = LinearElementEditor.getPointAtIndexGlobalCoordinates(
     arrow,
     startOrEnd === "start" ? 1 : arrow.points.length - 2,
     elementsMap
   );
+  if (arrow.points.length === 2) {
+    const otherBinding = startOrEnd === "start" ? arrow.endBinding : arrow.startBinding;
+    const otherBindable = otherBinding && elementsMap.get(otherBinding.elementId);
+    const otherFocusPoint = otherBinding && otherBindable && getGlobalFixedPointForBindableElement(
+      normalizeFixedPoint(otherBinding.fixedPoint),
+      otherBindable,
+      elementsMap
+    );
+    if (otherFocusPoint) {
+      a2 = otherFocusPoint;
+    }
+  }
   const b2 = pointFromVector3(
     vectorScale3(
       vectorFromPoint3(point, a2),
@@ -3802,18 +3876,21 @@ var projectFixedPointOntoDiagonal = (arrow, point, element, startOrEnd, elements
     ),
     a2
   );
-  const intersector = lineSegment2(point, b2);
+  const intersector = lineSegment2(b2, a2);
   const p1 = lineSegmentIntersectionPoints(diagonalOne, intersector);
   const p2 = lineSegmentIntersectionPoints(diagonalTwo, intersector);
   const d1 = p1 && pointDistance2(a2, p1);
   const d2 = p2 && pointDistance2(a2, p2);
-  let p = null;
+  let projection = null;
   if (d1 != null && d2 != null) {
-    p = d1 < d2 ? p1 : p2;
+    projection = d1 < d2 ? p1 : p2;
   } else {
-    p = p1 || p2 || null;
+    projection = p1 || p2 || null;
+  }
+  if (projection && isPointInElement(projection, element, elementsMap)) {
+    return projection;
   }
-  return p && isPointInElement(p, element, elementsMap) ? p : null;
+  return null;
 };
 
 // src/textElement.ts
@@ -6984,8 +7061,9 @@ var bumpVersion = (element, version) => {
 };
 
 // src/binding.ts
-var BASE_BINDING_GAP = 10;
+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 getBindingGap = (bindTarget, opts) => {
   return (opts.elbowed ? BASE_BINDING_GAP_ELBOW : BASE_BINDING_GAP) + bindTarget.strokeWidth / 2;
@@ -7408,7 +7486,8 @@ var getBindingStrategyForDraggingBindingElementEndpoints_simple = (arrow, draggi
       globalPoint,
       hit,
       startDragged ? "start" : "end",
-      elementsMap
+      elementsMap,
+      appState.zoom
     ) || globalPoint
   } : { mode: null };
   const otherEndpoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(
@@ -7416,7 +7495,15 @@ var getBindingStrategyForDraggingBindingElementEndpoints_simple = (arrow, draggi
     startDragged ? -1 : 0,
     elementsMap
   );
-  const other = otherBindableElement && !otherFocusPointIsInElement && appState.selectedLinearElement?.initialState.altFocusPoint ? {
+  const pointIsCloseToOtherElement = otherFocusPoint && otherBindableElement && hitElementItself({
+    point: globalPoint,
+    element: otherBindableElement,
+    elementsMap,
+    threshold: maxBindingDistance_simple(appState.zoom),
+    overrideShouldTestInside: true
+  });
+  const otherNeverOverride = opts?.newArrow ? appState.selectedLinearElement?.initialState.arrowStartIsInside : otherBinding?.mode === "inside";
+  const other = !otherNeverOverride ? otherBindableElement && !otherFocusPointIsInElement && !pointIsCloseToOtherElement && appState.selectedLinearElement?.initialState.altFocusPoint ? {
     mode: "orbit",
     element: otherBindableElement,
     focusPoint: appState.selectedLinearElement.initialState.altFocusPoint
@@ -7428,9 +7515,10 @@ var getBindingStrategyForDraggingBindingElementEndpoints_simple = (arrow, draggi
       otherEndpoint,
       otherBindableElement,
       startDragged ? "end" : "start",
-      elementsMap
+      elementsMap,
+      appState.zoom
     ) || otherEndpoint
-  } : { mode: void 0 };
+  } : { mode: void 0 } : { mode: void 0 };
   return {
     start: startDragged ? current : other,
     end: endDragged ? current : other
@@ -7611,7 +7699,7 @@ var updateBoundElements = (changedElement, scene, options) => {
       elementsMap.set(element.id, element);
     });
   }
-  boundElementsVisitor(elementsMap, changedElement, (element) => {
+  const visitor = (element) => {
     if (!isArrowElement(element) || element.isDeleted) {
       return;
     }
@@ -7657,7 +7745,8 @@ var updateBoundElements = (changedElement, scene, options) => {
     if (boundText && !boundText.isDeleted) {
       handleBindTextResize(element, scene, false);
     }
-  });
+  };
+  boundElementsVisitor(elementsMap, changedElement, visitor);
 };
 var updateArrowBindings = (latestElement, startOrEnd, elementsMap, scene, appState) => {
   invariant7(
@@ -7790,20 +7879,22 @@ var bindPointToSnapToElementOutline = (arrowElement, bindableElement, startOrEnd
       headingForPointFromElement(bindableElement, aabb, point)
     );
     const snapPoint = snapToMid(
-      arrowElement,
       bindableElement,
       elementsMap,
-      edgePoint
+      edgePoint,
+      0.05,
+      arrowElement
     );
+    const resolved = snapPoint || point;
     const otherPoint = pointFrom8(
-      isHorizontal ? bindableCenter[0] : snapPoint[0],
-      !isHorizontal ? bindableCenter[1] : snapPoint[1]
+      isHorizontal ? bindableCenter[0] : resolved[0],
+      !isHorizontal ? bindableCenter[1] : resolved[1]
     );
     const intersector = customIntersector ?? lineSegment4(
       otherPoint,
       pointFromVector6(
         vectorScale7(
-          vectorNormalize4(vectorFromPoint7(snapPoint, otherPoint)),
+          vectorNormalize4(vectorFromPoint7(resolved, otherPoint)),
           Math.max(bindableElement.width, bindableElement.height) * 2
         ),
         otherPoint
@@ -7817,14 +7908,14 @@ var bindPointToSnapToElementOutline = (arrowElement, bindableElement, startOrEnd
     ).sort(pointDistanceSq)[0];
     if (!intersection) {
       const anotherPoint = pointFrom8(
-        !isHorizontal ? bindableCenter[0] : snapPoint[0],
-        isHorizontal ? bindableCenter[1] : snapPoint[1]
+        !isHorizontal ? bindableCenter[0] : resolved[0],
+        isHorizontal ? bindableCenter[1] : resolved[1]
       );
       const anotherIntersector = lineSegment4(
         anotherPoint,
         pointFromVector6(
           vectorScale7(
-            vectorNormalize4(vectorFromPoint7(snapPoint, anotherPoint)),
+            vectorNormalize4(vectorFromPoint7(resolved, anotherPoint)),
             Math.max(bindableElement.width, bindableElement.height) * 2
           ),
           anotherPoint
@@ -7933,15 +8024,15 @@ var avoidRectangularCorner = (arrowElement, bindTarget, elementsMap, p) => {
   }
   return p;
 };
-var snapToMid = (arrowElement, bindTarget, elementsMap, p, tolerance = 0.05) => {
+var snapToMid = (bindTarget, elementsMap, p, tolerance = 0.05, arrowElement) => {
   const { x, y, width, height, angle } = bindTarget;
   const center = elementCenterPoint(bindTarget, elementsMap, -0.1, -0.1);
   const nonRotated = pointRotateRads8(p, center, -angle);
-  const bindingGap = getBindingGap(bindTarget, arrowElement);
+  const bindingGap = arrowElement ? getBindingGap(bindTarget, arrowElement) : 0;
   const verticalThreshold = clamp3(tolerance * height, 5, 80);
   const horizontalThreshold = clamp3(tolerance * width, 5, 80);
   if (pointDistance4(center, nonRotated) < bindingGap) {
-    return p;
+    return void 0;
   }
   if (nonRotated[0] <= x + width / 2 && nonRotated[1] > center[1] - verticalThreshold && nonRotated[1] < center[1] + verticalThreshold) {
     return pointRotateRads8(
@@ -7950,7 +8041,11 @@ var snapToMid = (arrowElement, bindTarget, elementsMap, p, tolerance = 0.05) =>
       angle
     );
   } 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);
+    return pointRotateRads8(
+      pointFrom8(center[0], y - bindingGap),
+      center,
+      angle
+    );
   } 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]),
@@ -7994,10 +8089,36 @@ var snapToMid = (arrowElement, bindTarget, elementsMap, p, tolerance = 0.05) =>
       return pointRotateRads8(bottomRight, center, angle);
     }
   }
-  return p;
+  return void 0;
+};
+var extractBinding = (arrow, startOrEnd, elementsMap) => {
+  const binding = arrow[startOrEnd];
+  if (!binding) {
+    return {
+      element: null,
+      fixedPoint: null,
+      focusPoint: null,
+      binding,
+      mode: null
+    };
+  }
+  const element = elementsMap.get(
+    binding.elementId
+  );
+  return {
+    element,
+    fixedPoint: binding.fixedPoint,
+    focusPoint: getGlobalFixedPointForBindableElement(
+      normalizeFixedPoint(binding.fixedPoint),
+      element,
+      elementsMap
+    ),
+    binding,
+    mode: binding.mode
+  };
 };
-var compareElementArea = (a2, b2) => b2.width ** 2 + b2.height ** 2 - (a2.width ** 2 + a2.height ** 2);
-var updateBoundPoint = (arrow, startOrEnd, binding, bindableElement, elementsMap, opts) => {
+var elementArea = (element) => element.width * element.height;
+var updateBoundPoint = (arrow, startOrEnd, binding, bindableElement, elementsMap, dragging) => {
   if (binding == null || // We only need to update the other end if this is a 2 point line element
   binding.elementId !== bindableElement.id && arrow.points.length > 2 || // Initial arrow created on pointer down needs to not update the points
   pointsEqual5(
@@ -8006,110 +8127,92 @@ var updateBoundPoint = (arrow, startOrEnd, binding, bindableElement, elementsMap
   )) {
     return null;
   }
-  const global2 = getGlobalFixedPointForBindableElement(
+  const focusPoint = getGlobalFixedPointForBindableElement(
     normalizeFixedPoint(binding.fixedPoint),
     bindableElement,
     elementsMap
   );
-  const pointIndex = startOrEnd === "startBinding" ? 0 : arrow.points.length - 1;
-  const elbowed = isElbowArrow(arrow);
-  const otherBinding = startOrEnd === "startBinding" ? arrow.endBinding : arrow.startBinding;
-  const otherBindableElement = otherBinding && elementsMap.get(otherBinding.elementId);
-  const bounds = getElementBounds(bindableElement, elementsMap);
-  const otherBounds = otherBindableElement && getElementBounds(otherBindableElement, elementsMap);
-  const isLargerThanOther = otherBindableElement && compareElementArea(bindableElement, otherBindableElement) < // if both shapes the same size, pretend the other is larger
-  (startOrEnd === "endBinding" ? 1 : 0);
-  const isOverlapping = otherBounds && doBoundsIntersect(bounds, otherBounds);
-  let arrowTooShort = false;
-  if (!isOverlapping && !elbowed && arrow.startBinding && arrow.endBinding && otherBindableElement && arrow.points.length === 2) {
-    const startFocusPoint = getGlobalFixedPointForBindableElement(
-      arrow.startBinding.fixedPoint,
-      startOrEnd === "startBinding" ? bindableElement : otherBindableElement,
-      elementsMap
-    );
-    const endFocusPoint = getGlobalFixedPointForBindableElement(
-      arrow.endBinding.fixedPoint,
-      startOrEnd === "endBinding" ? bindableElement : otherBindableElement,
-      elementsMap
-    );
-    const segment = lineSegment4(startFocusPoint, endFocusPoint);
-    const startIntersection = intersectElementWithLineSegment(
-      startOrEnd === "endBinding" ? bindableElement : otherBindableElement,
+  if (binding.mode === "inside") {
+    return LinearElementEditor.createPointAt(
+      arrow,
       elementsMap,
-      segment,
-      0,
-      true
+      focusPoint[0],
+      focusPoint[1],
+      null
     );
-    const endIntersection = intersectElementWithLineSegment(
-      startOrEnd === "startBinding" ? bindableElement : otherBindableElement,
+  }
+  const { element: otherBindable, focusPoint: otherFocusPoint } = extractBinding(
+    arrow,
+    startOrEnd === "startBinding" ? "endBinding" : "startBinding",
+    elementsMap
+  );
+  const otherArrowPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(
+    arrow,
+    startOrEnd === "startBinding" ? 1 : -2,
+    elementsMap
+  );
+  const otherFocusPointOrArrowPoint = arrow.points.length === 2 ? otherFocusPoint || otherArrowPoint : otherArrowPoint;
+  const intersector = otherFocusPointOrArrowPoint && lineSegment4(focusPoint, otherFocusPointOrArrowPoint);
+  const otherOutlinePoint = otherBindable && intersector && intersectElementWithLineSegment(
+    otherBindable,
+    elementsMap,
+    intersector,
+    getBindingGap(otherBindable, arrow)
+  ).sort(
+    (a2, b2) => pointDistanceSq(a2, focusPoint) - pointDistanceSq(b2, focusPoint)
+  )[0];
+  const outlinePoint = intersector && intersectElementWithLineSegment(
+    bindableElement,
+    elementsMap,
+    intersector,
+    getBindingGap(bindableElement, arrow)
+  ).sort(
+    (a2, b2) => pointDistanceSq(a2, otherFocusPointOrArrowPoint) - pointDistanceSq(b2, otherFocusPointOrArrowPoint)
+  )[0];
+  const startHasArrowhead = arrow.startArrowhead !== null;
+  const endHasArrowhead = arrow.endArrowhead !== null;
+  const resolvedTarget = !startHasArrowhead && !endHasArrowhead || startOrEnd === "startBinding" && startHasArrowhead || startOrEnd === "endBinding" && endHasArrowhead ? focusPoint : outlinePoint || focusPoint;
+  if (otherBindable && outlinePoint && !dragging && // Arbitrary threshold to handle wireframing use cases
+  elementArea(otherBindable) < elementArea(bindableElement) * 2 && hitElementItself({
+    element: otherBindable,
+    point: outlinePoint,
+    elementsMap,
+    threshold: getBindingGap(otherBindable, arrow),
+    overrideShouldTestInside: true
+  })) {
+    return LinearElementEditor.createPointAt(
+      arrow,
       elementsMap,
-      segment,
-      0,
-      true
+      resolvedTarget[0],
+      resolvedTarget[1],
+      null
     );
-    if (startIntersection.length > 0 && endIntersection.length > 0) {
-      const len = pointDistance4(startIntersection[0], endIntersection[0]);
-      arrowTooShort = len < 40;
-    }
   }
-  const isNested = (arrowTooShort || isOverlapping) && isLargerThanOther;
-  let _customIntersector = opts?.customIntersector;
-  if (!elbowed && !_customIntersector) {
-    const [x1, y1, x2, y2] = LinearElementEditor.getElementAbsoluteCoords(
+  const otherTargetPoint = otherBindable ? otherOutlinePoint || otherFocusPoint || otherArrowPoint : otherArrowPoint;
+  const arrowTooShort = pointDistance4(otherTargetPoint, outlinePoint || focusPoint) <= BASE_ARROW_MIN_LENGTH;
+  if (!otherBindable) {
+    return LinearElementEditor.createPointAt(
       arrow,
-      elementsMap
-    );
-    const center = pointFrom8((x1 + x2) / 2, (y1 + y2) / 2);
-    const edgePoint = global2;
-    const adjacentPoint = pointRotateRads8(
-      pointFrom8(
-        arrow.x + arrow.points[pointIndex === 0 ? 1 : arrow.points.length - 2][0],
-        arrow.y + arrow.points[pointIndex === 0 ? 1 : arrow.points.length - 2][1]
-      ),
-      center,
-      arrow.angle
-    );
-    const bindingGap = getBindingGap(bindableElement, arrow);
-    const halfVector = vectorScale7(
-      vectorNormalize4(vectorFromPoint7(edgePoint, adjacentPoint)),
-      pointDistance4(edgePoint, adjacentPoint) + Math.max(bindableElement.width, bindableElement.height) + bindingGap * 2
+      elementsMap,
+      arrowTooShort ? focusPoint[0] : outlinePoint?.[0] ?? focusPoint[0],
+      arrowTooShort ? focusPoint[1] : outlinePoint?.[1] ?? focusPoint[1],
+      null
     );
-    _customIntersector = lineSegment4(
-      pointFromVector6(halfVector, adjacentPoint),
-      pointFromVector6(vectorScale7(halfVector, -1), adjacentPoint)
+  }
+  if (arrowTooShort) {
+    return LinearElementEditor.createPointAt(
+      arrow,
+      elementsMap,
+      resolvedTarget?.[0] || focusPoint[0],
+      resolvedTarget?.[1] || focusPoint[1],
+      null
     );
   }
-  const maybeOutlineGlobal = binding.mode === "orbit" && bindableElement ? isNested ? global2 : bindPointToSnapToElementOutline(
-    {
-      ...arrow,
-      points: [
-        pointIndex === 0 ? LinearElementEditor.createPointAt(
-          arrow,
-          elementsMap,
-          global2[0],
-          global2[1],
-          null
-        ) : arrow.points[0],
-        ...arrow.points.slice(1, -1),
-        pointIndex === arrow.points.length - 1 ? LinearElementEditor.createPointAt(
-          arrow,
-          elementsMap,
-          global2[0],
-          global2[1],
-          null
-        ) : arrow.points[arrow.points.length - 1]
-      ]
-    },
-    bindableElement,
-    pointIndex === 0 ? "start" : "end",
-    elementsMap,
-    _customIntersector
-  ) : global2;
   return LinearElementEditor.createPointAt(
     arrow,
     elementsMap,
-    maybeOutlineGlobal[0],
-    maybeOutlineGlobal[1],
+    outlinePoint?.[0] || focusPoint[0],
+    outlinePoint?.[1] || focusPoint[1],
     null
   );
 };
@@ -8477,10 +8580,17 @@ var getArrowLocalFixedPoints = (arrow, elementsMap) => {
     LinearElementEditor.pointFromAbsoluteCoords(arrow, endPoint, elementsMap)
   ];
 };
+var isFixedPoint = (fixedPoint) => {
+  return Array.isArray(fixedPoint) && fixedPoint.length === 2 && fixedPoint.every((coord) => Number.isFinite(coord));
+};
 var normalizeFixedPoint = (fixedPoint) => {
-  if (fixedPoint && (Math.abs(fixedPoint[0] - 0.5) < 1e-4 || Math.abs(fixedPoint[1] - 0.5) < 1e-4)) {
+  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) < 1e-4 ? 0.5001 : ratio
+      (ratio) => Math.abs(ratio - 0.5) < EPSILON2 ? 0.5001 : ratio
     );
   }
   return fixedPoint;
@@ -9005,7 +9115,8 @@ var LinearElementEditor = class _LinearElementEditor {
       elements,
       app,
       shouldRotateWithDiscreteAngle(event),
-      event.altKey
+      event.altKey,
+      linearElementEditor
     );
     _LinearElementEditor.movePoints(element, app.scene, positions, {
       startBinding: updates?.startBinding,
@@ -9041,12 +9152,13 @@ var LinearElementEditor = class _LinearElementEditor {
       customLineAngle,
       initialState: {
         ...linearElementEditor.initialState,
-        altFocusPoint: !linearElementEditor.initialState.altFocusPoint && startBindingElement && updates?.suggestedBinding?.id !== startBindingElement.id ? projectFixedPointOntoDiagonal2(
+        altFocusPoint: !linearElementEditor.initialState.altFocusPoint && startBindingElement && updates?.suggestedBinding?.element.id !== startBindingElement.id ? projectFixedPointOntoDiagonal2(
           element,
           pointFrom9(element.x, element.y),
           startBindingElement,
           "start",
-          elementsMap
+          elementsMap,
+          app.state.zoom
         ) : linearElementEditor.initialState.altFocusPoint
       }
     };
@@ -9134,7 +9246,8 @@ var LinearElementEditor = class _LinearElementEditor {
       elements,
       app,
       shouldRotateWithDiscreteAngle(event) && singlePointDragged,
-      event.altKey
+      event.altKey,
+      linearElementEditor
     );
     _LinearElementEditor.movePoints(element, app.scene, positions, {
       startBinding: updates?.startBinding,
@@ -9178,8 +9291,8 @@ var LinearElementEditor = class _LinearElementEditor {
       element.endBinding.elementId
     );
     const altFocusPointBindableElement = endIsSelected && // The "other" end (i.e. "end") is dragged
-    startBindingElement && updates?.suggestedBinding?.id !== startBindingElement.id ? startBindingElement : startIsSelected && // The "other" end (i.e. "start") is dragged
-    endBindingElement && updates?.suggestedBinding?.id !== endBindingElement.id ? endBindingElement : null;
+    startBindingElement && updates?.suggestedBinding?.element.id !== startBindingElement.id ? startBindingElement : startIsSelected && // The "other" end (i.e. "start") is dragged
+    endBindingElement && updates?.suggestedBinding?.element.id !== endBindingElement.id ? endBindingElement : null;
     const newLinearElementEditor = {
       ...linearElementEditor,
       selectedPointsIndices: newSelectedPointsIndices,
@@ -9192,7 +9305,8 @@ var LinearElementEditor = class _LinearElementEditor {
           pointFrom9(element.x, element.y),
           altFocusPointBindableElement,
           "start",
-          elementsMap
+          elementsMap,
+          app.state.zoom
         ) : linearElementEditor.initialState.altFocusPoint
       },
       segmentMidPointHoveredCoords: newSelectedMidPointHoveredCoords,
@@ -10206,7 +10320,7 @@ var normalizeSelectedPoints = (points) => {
   nextPoints = nextPoints.sort((a2, b2) => a2 - b2);
   return nextPoints.length ? nextPoints : null;
 };
-var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX, scenePointerY, elementsMap, element, elements, app, angleLocked, altKey) => {
+var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX, scenePointerY, elementsMap, element, elements, app, angleLocked, altKey, linearElementEditor) => {
   const naiveDraggingPoints = new Map(
     selectedPointsIndices.map((pointIndex) => {
       return [
@@ -10245,10 +10359,21 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
     }
   );
   if (isElbowArrow(element)) {
+    const suggestedBindingElement = startIsDragged ? start.element : endIsDragged ? end.element : null;
     return {
       positions: naiveDraggingPoints,
       updates: {
-        suggestedBinding: startIsDragged ? start.element : endIsDragged ? end.element : null
+        suggestedBinding: suggestedBindingElement ? {
+          element: suggestedBindingElement,
+          midPoint: snapToMid(
+            suggestedBindingElement,
+            elementsMap,
+            pointFrom9(
+              scenePointerX - linearElementEditor.pointerOffset.x,
+              scenePointerY - linearElementEditor.pointerOffset.y
+            )
+          )
+        } : null
       }
     };
   }
@@ -10320,7 +10445,18 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
       )
     };
     if (startIsDragged && (updates.startBinding.mode === "orbit" || !getFeatureFlag2("COMPLEX_BINDINGS"))) {
-      updates.suggestedBinding = start.element;
+      updates.suggestedBinding = start.element ? {
+        element: start.element,
+        midPoint: getSnapOutlineMidPoint2(
+          pointFrom9(
+            scenePointerX - linearElementEditor.pointerOffset.x,
+            scenePointerY - linearElementEditor.pointerOffset.y
+          ),
+          start.element,
+          elementsMap,
+          app.state.zoom
+        )
+      } : null;
     }
   } else if (startIsDragged) {
     updates.suggestedBinding = app.state.suggestedBinding;
@@ -10340,7 +10476,18 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
       )
     };
     if (endIsDragged && (updates.endBinding.mode === "orbit" || !getFeatureFlag2("COMPLEX_BINDINGS"))) {
-      updates.suggestedBinding = end.element;
+      updates.suggestedBinding = end.element ? {
+        element: end.element,
+        midPoint: getSnapOutlineMidPoint2(
+          pointFrom9(
+            scenePointerX - linearElementEditor.pointerOffset.x,
+            scenePointerY - linearElementEditor.pointerOffset.y
+          ),
+          end.element,
+          elementsMap,
+          app.state.zoom
+        )
+      } : null;
     }
   } else if (endIsDragged) {
     updates.suggestedBinding = app.state.suggestedBinding;
@@ -10363,8 +10510,6 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
     startBinding: updates.startBinding === void 0 ? element.startBinding : updates.startBinding === null ? null : updates.startBinding,
     endBinding: updates.endBinding === void 0 ? element.endBinding : updates.endBinding === null ? null : updates.endBinding
   };
-  const startCustomIntersector = start.focusPoint && end.focusPoint ? lineSegment5(start.focusPoint, end.focusPoint) : void 0;
-  const endCustomIntersector = start.focusPoint && end.focusPoint ? lineSegment5(end.focusPoint, start.focusPoint) : void 0;
   const startIsDraggingOverEndElement = element.endBinding && nextArrow.startBinding && startIsDragged && nextArrow.startBinding.elementId === element.endBinding.elementId;
   const endIsDraggingOverStartElement = element.startBinding && nextArrow.endBinding && endIsDragged && element.startBinding.elementId === nextArrow.endBinding.elementId;
   const endBindable = nextArrow.endBinding ? end.element ?? elementsMap.get(
@@ -10376,9 +10521,7 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
     nextArrow.endBinding,
     endBindable,
     elementsMap,
-    {
-      customIntersector: endCustomIntersector
-    }
+    endIsDragged
   ) || nextArrow.points[nextArrow.points.length - 1] : nextArrow.points[nextArrow.points.length - 1];
   nextArrow.points[nextArrow.points.length - 1] = endLocalPoint;
   const startBindable = nextArrow.startBinding ? start.element ?? elementsMap.get(
@@ -10390,7 +10533,7 @@ var pointDraggingUpdates = (selectedPointsIndices, deltaX, deltaY, scenePointerX
     nextArrow.startBinding,
     startBindable,
     elementsMap,
-    { customIntersector: startCustomIntersector }
+    startIsDragged
   ) || nextArrow.points[0] : nextArrow.points[0];
   const endChanged = !startIsDraggingOverEndElement && !(endIsDraggingOverStartElement && app.state.bindMode !== "inside" && getFeatureFlag2("COMPLEX_BINDINGS")) && !!endBindable;
   const startChanged = pointDistance5(startLocalPoint, nextArrow.points[0]) !== 0;
@@ -12202,7 +12345,7 @@ 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),
@@ -12214,7 +12357,7 @@ function getFreedrawOutlineAsSegments(element, points, elementsMap) {
       return acc;
     },
     [
-      lineSegment6(
+      lineSegment5(
         pointRotateRads11(
           pointFrom12(
             points[0][0] + element.x,
@@ -13149,7 +13292,7 @@ var getElementLineSegments = (element, elementsMap) => {
         let i = 0;
         while (i < points.length - 1) {
           segments.push(
-            lineSegment7(
+            lineSegment6(
               pointFrom14(points[i][0], points[i][1]),
               pointFrom14(points[i + 1][0], points[i + 1][1])
             )
@@ -13162,7 +13305,7 @@ var getElementLineSegments = (element, elementsMap) => {
       let i = 0;
       while (i < points.length - 1) {
         segments.push(
-          lineSegment7(
+          lineSegment6(
             pointFrom14(points[i][0], points[i][1]),
             pointFrom14(points[i + 1][0], points[i + 1][1])
           )
@@ -13188,10 +13331,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(pointFrom14(x1, y1), pointFrom14(x2, y1)),
+          lineSegment6(pointFrom14(x2, y1), pointFrom14(x2, y2)),
+          lineSegment6(pointFrom14(x2, y2), pointFrom14(x1, y2)),
+          lineSegment6(pointFrom14(x1, y2), pointFrom14(x1, y1))
         ];
         return segments2;
       }
@@ -13199,7 +13342,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") {
@@ -13216,14 +13359,14 @@ var getElementLineSegments = (element, elementsMap) => {
     [x2, cy]
   ].map((point) => pointRotateRads13(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) => {
@@ -13231,7 +13374,7 @@ var _isRectanguloidElement = (element) => {
 };
 var getRotatedSides = (sides, center, angle) => {
   return sides.map((side) => {
-    return lineSegment7(
+    return lineSegment6(
       pointRotateRads13(side[0], center, angle),
       pointRotateRads13(side[1], center, angle)
     );
@@ -13243,7 +13386,7 @@ var getSegmentsOnCurve = (curve4, center, angle) => {
   const segments = [];
   while (i < points.length - 1) {
     segments.push(
-      lineSegment7(
+      lineSegment6(
         pointRotateRads13(
           pointFrom14(points[i][0], points[i][1]),
           center,
@@ -13278,9 +13421,9 @@ var getSegmentsOnEllipse = (ellipse4) => {
     points.push(pointRotateRads13(pointFrom14(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) => {
@@ -17715,7 +17858,7 @@ var RE_GENERIC_EMBED = /^<(?:iframe|blockquote)[\s\S]*?\s(?:src|href)=["']([^"']
 var RE_GIPHY = /giphy.com\/(?:clips|embed|gifs)\/[a-zA-Z0-9]*?-?([a-zA-Z0-9]+)(?:[^a-zA-Z0-9]|$)/;
 var RE_REDDIT = /^(?:http(?:s)?:\/\/)?(?:www\.)?reddit\.com\/r\/([a-zA-Z0-9_]+)\/comments\/([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)\/?(?:\?[^#\s]*)?(?:#[^\s]*)?$/;
 var RE_REDDIT_EMBED = /^<blockquote[\s\S]*?\shref=["'](https?:\/\/(?:www\.)?reddit\.com\/[^"']*)/i;
-var parseYouTubeTimestamp = (url) => {
+var parseYouTubeLikeTimestamp = (url) => {
   let timeParam;
   try {
     const urlObj = new URL(url.startsWith("http") ? url : `https://${url}`);
@@ -17737,11 +17880,42 @@ var parseYouTubeTimestamp = (url) => {
   const [, hours = "0", minutes = "0", seconds = "0"] = timeMatch;
   return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);
 };
+var parseGoogleDriveVideoLink = (url) => {
+  try {
+    const urlObj = new URL(url.startsWith("http") ? url : `https://${url}`);
+    const hostname = urlObj.hostname.replace(/^www\./, "");
+    if (hostname !== "drive.google.com") {
+      return null;
+    }
+    let fileId = null;
+    const pathMatch = urlObj.pathname.match(/^\/file\/d\/([^/]+)(?:\/|$)/);
+    if (pathMatch?.[1]) {
+      fileId = pathMatch[1];
+    } else if (urlObj.pathname === "/open" || urlObj.pathname === "/uc") {
+      fileId = urlObj.searchParams.get("id");
+    }
+    if (!fileId || !/^[a-zA-Z0-9_-]+$/.test(fileId)) {
+      return null;
+    }
+    const resourceKey = urlObj.searchParams.get("resourcekey");
+    const timestamp = parseYouTubeLikeTimestamp(urlObj.toString());
+    return {
+      fileId,
+      resourceKey: resourceKey && /^[a-zA-Z0-9_-]+$/.test(resourceKey) ? resourceKey : void 0,
+      // Drive accepts YouTube-like `t` formats (e.g. `t=90`, `t=1m30s`);
+      // normalize to seconds for a stable preview URL.
+      timestamp: timestamp > 0 ? timestamp : void 0
+    };
+  } catch (error) {
+    return null;
+  }
+};
 var ALLOWED_DOMAINS = /* @__PURE__ */ new Set([
   "youtube.com",
   "youtu.be",
   "vimeo.com",
   "player.vimeo.com",
+  "drive.google.com",
   "figma.com",
   "link.excalidraw.com",
   "gist.github.com",
@@ -17759,6 +17933,7 @@ var ALLOW_SAME_ORIGIN = /* @__PURE__ */ new Set([
   "youtu.be",
   "vimeo.com",
   "player.vimeo.com",
+  "drive.google.com",
   "figma.com",
   "twitter.com",
   "x.com",
@@ -17785,7 +17960,7 @@ var getEmbedLink = (link) => {
   let aspectRatio = { w: 560, h: 840 };
   const ytLink = link.match(RE_YOUTUBE);
   if (ytLink?.[2]) {
-    const startTime = parseYouTubeTimestamp(originalLink);
+    const startTime = parseYouTubeLikeTimestamp(originalLink);
     const time = startTime > 0 ? `&start=${startTime}` : ``;
     const isPortrait = link.includes("shorts");
     type = "video";
@@ -17838,6 +18013,32 @@ var getEmbedLink = (link) => {
       sandbox: { allowSameOrigin }
     };
   }
+  const googleDriveVideo = parseGoogleDriveVideoLink(link);
+  if (googleDriveVideo) {
+    type = "video";
+    const searchParams = new URLSearchParams();
+    if (googleDriveVideo.resourceKey) {
+      searchParams.set("resourcekey", googleDriveVideo.resourceKey);
+    }
+    if (googleDriveVideo.timestamp) {
+      searchParams.set("t", `${googleDriveVideo.timestamp}`);
+    }
+    const search = searchParams.toString();
+    link = `https://drive.google.com/file/d/${googleDriveVideo.fileId}/preview${search ? `?${search}` : ""}`;
+    aspectRatio = { w: 560, h: 315 };
+    embeddedLinkCache.set(originalLink, {
+      link,
+      intrinsicSize: aspectRatio,
+      type,
+      sandbox: { allowSameOrigin }
+    });
+    return {
+      link,
+      intrinsicSize: aspectRatio,
+      type,
+      sandbox: { allowSameOrigin }
+    };
+  }
   const figmaLink = link.match(RE_FIGMA);
   if (figmaLink) {
     type = "generic";
@@ -18900,7 +19101,7 @@ var moveAllRight = (allElements, appState) => {
 };
 
 // src/arrows/focus.ts
-var isFocusPointVisible = (focusPoint, arrow, bindableElement, elementsMap, appState, ignoreOverlap = false) => {
+var isFocusPointVisible = (focusPoint, arrow, bindableElement, elementsMap, appState, startOrEnd, ignoreOverlap = false) => {
   if (isElbowArrow(arrow) || !isBindingEnabled(appState) || arrow.points.length !== 2) {
     return false;
   }
@@ -18915,7 +19116,12 @@ var isFocusPointVisible = (focusPoint, arrow, bindableElement, elementsMap, appS
       return false;
     }
   }
-  return hitElementItself({
+  const arrowPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(
+    arrow,
+    startOrEnd === "end" ? arrow.points.length - 1 : 0,
+    elementsMap
+  );
+  return pointDistance8(focusPoint, arrowPoint) >= FOCUS_POINT_SIZE * 1.5 / appState.zoom.value && hitElementItself({
     element: bindableElement,
     elementsMap,
     point: focusPoint,
@@ -18948,13 +19154,14 @@ var focusPointUpdate = (arrow, bindableElement, isStartBinding, elementsMap, sce
       bindingField,
       currentBinding,
       bindableElement,
-      elementsMap
+      elementsMap,
+      true
     );
     if (newPoint) {
       pointUpdates.set(pointIndex, { point: newPoint });
     }
   }
-  if (adjacentBinding) {
+  if (adjacentBinding && adjacentBinding.mode === "orbit") {
     const adjacentBindableElement = elementsMap.get(
       adjacentBinding.elementId
     );
@@ -19105,7 +19312,8 @@ var handleFocusPointPointerDown = (arrow, pointerDownState, elementsMap, appStat
         arrow,
         bindableElement,
         elementsMap,
-        appState
+        appState,
+        "start"
       ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
         return {
           hitFocusPoint: "start",
@@ -19130,7 +19338,8 @@ var handleFocusPointPointerDown = (arrow, pointerDownState, elementsMap, appStat
         arrow,
         bindableElement,
         elementsMap,
-        appState
+        appState,
+        "end"
       ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
         return {
           hitFocusPoint: "end",
@@ -19203,7 +19412,8 @@ var handleFocusPointHover = (arrow, scenePointerX, scenePointerY, scene, appStat
         arrow,
         bindableElement,
         elementsMap,
-        appState
+        appState,
+        "start"
       ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
         return "start";
       }
@@ -19222,7 +19432,8 @@ var handleFocusPointHover = (arrow, scenePointerX, scenePointerY, scene, appStat
         arrow,
         bindableElement,
         elementsMap,
-        appState
+        appState,
+        "end"
       ) && pointDistance8(pointerPos, focusPoint) <= hitThreshold) {
         return "end";
       }
@@ -21372,6 +21583,7 @@ var getNonDeletedElements2 = (elements) => elements.filter((element) => !element
 var isNonDeletedElement2 = (element) => !element.isDeleted;
 export {
   AppStateDelta,
+  BASE_ARROW_MIN_LENGTH,
   BASE_BINDING_GAP,
   BASE_BINDING_GAP_ELBOW,
   BASE_PADDING,
@@ -21492,6 +21704,7 @@ export {
   getCursorForResizingElement,
   getDefaultFrameName,
   getDefaultRoundnessTypeForElement,
+  getDiamondBaseCorners,
   getDiamondPoints,
   getDragOffsetXY,
   getDraggedElementsBounds,
@@ -21554,6 +21767,7 @@ export {
   getSelectedGroupIdForElement,
   getSelectedGroupIds,
   getSelectionStateForElements,
+  getSnapOutlineMidPoint,
   getTargetElements,
   getTargetFrame,
   getTextElementAngle,
@@ -21614,6 +21828,7 @@ export {
   isElementLink,
   isEmbeddableElement,
   isExcalidrawElement,
+  isFixedPoint,
   isFlowchartNodeElement,
   isFocusPointVisible,
   isFrameElement,
@@ -21708,6 +21923,7 @@ export {
   shouldEnableBindingForPointerEvent,
   shouldTestInside,
   showSelectedShapeActions,
+  snapToMid,
   suppportsHorizontalAlign,
   syncInvalidIndices,
   syncInvalidIndicesImmutable,