@excalidraw/excalidraw 0.18.0-6fc8502 → 0.18.0-a5d6939

package/dist/dev/{chunk-KYBDXI6F.js → chunk-GBJ7S76A.js}

@@ -1,6 +1,6 @@
 import {
   define_import_meta_env_default
-} from "./chunk-H7XJ5UVD.js";
+} from "./chunk-GIMGG4AT.js";
 import {
   __publicField
 } from "./chunk-XDFCUUT6.js";
@@ -264,7 +264,8 @@ var YOUTUBE_STATES = {
 };
 var ENV = {
   TEST: "test",
-  DEVELOPMENT: "development"
+  DEVELOPMENT: "development",
+  PRODUCTION: "production"
 };
 var CLASSES = {
   SHAPE_ACTIONS_MENU: "App-menu__left",
@@ -411,6 +412,9 @@ var DEFAULT_EXPORT_PADDING = 10;
 var DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
 var MAX_ALLOWED_FILE_BYTES = 4 * 1024 * 1024;
 var SVG_NS = "http://www.w3.org/2000/svg";
+var SVG_DOCUMENT_PREAMBLE = `<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+`;
 var VERSIONS = {
   excalidraw: 2,
   excalidrawLibrary: 2
@@ -1651,6 +1655,7 @@ var arrayToList = (array) => array.reduce((acc, curr, index) => {
 }, []);
 var isTestEnv = () => define_import_meta_env_default.MODE === ENV.TEST;
 var isDevEnv = () => define_import_meta_env_default.MODE === ENV.DEVELOPMENT;
+var isProdEnv = () => define_import_meta_env_default.MODE === ENV.PRODUCTION;
 var isServerEnv = () => typeof process !== "undefined" && true;
 var wrapEvent = (name, nativeEvent) => {
   return new CustomEvent(name, {
@@ -1862,6 +1867,12 @@ var escapeDoubleQuotes = (str) => {
   return str.replace(/"/g, "&quot;");
 };
 var castArray = (value) => Array.isArray(value) ? value : [value];
+var elementCenterPoint = (element, xOffset = 0, yOffset = 0) => {
+  const { x, y, width, height } = element;
+  const centerXPoint = x + width / 2 + xOffset;
+  const centerYPoint = y + height / 2 + yOffset;
+  return pointFrom(centerXPoint, centerYPoint);
+};
 
 // ../common/src/random.ts
 var random = new Random(Date.now());
@@ -2434,10 +2445,7 @@ function deconstructRectanguloidElement(element, offset = 0) {
     const sides2 = [top2, right2, bottom2, left2];
     return [sides2, []];
   }
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const r = rectangle(
     pointFrom(element.x, element.y),
     pointFrom(element.x + element.width, element.y + element.height)
@@ -2603,10 +2611,7 @@ function deconstructDiamondElement(element, offset = 0) {
     );
     return [[topRight, bottomRight, bottomLeft, topLeft], []];
   }
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const [top, right, bottom, left] = [
     pointFrom(element.x + topX, element.y + topY),
     pointFrom(element.x + rightX, element.y + rightY),
@@ -2787,10 +2792,7 @@ var intersectElementWithLineSegment = (element, line2, offset = 0) => {
   }
 };
 var intersectRectanguloidWithLineSegment = (element, l, offset = 0) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const rotatedA = pointRotateRads(
     l[0],
     center,
@@ -2820,10 +2822,7 @@ var intersectRectanguloidWithLineSegment = (element, l, offset = 0) => {
   );
 };
 var intersectDiamondWithLineSegment = (element, l, offset = 0) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const rotatedA = pointRotateRads(l[0], center, -element.angle);
   const rotatedB = pointRotateRads(l[1], center, -element.angle);
   const [sides, curves] = deconstructDiamondElement(element, offset);
@@ -2841,10 +2840,7 @@ var intersectDiamondWithLineSegment = (element, l, offset = 0) => {
   );
 };
 var intersectEllipseWithLineSegment = (element, l, offset = 0) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const rotatedA = pointRotateRads(l[0], center, -element.angle);
   const rotatedB = pointRotateRads(l[1], center, -element.angle);
   return ellipseLineIntersectionPoints(
@@ -2890,10 +2886,7 @@ var distanceToBindableElement = (element, p) => {
   }
 };
 var distanceToRectanguloidElement = (element, p) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const rotatedPoint = pointRotateRads(p, center, -element.angle);
   const [sides, corners] = deconstructRectanguloidElement(element);
   return Math.min(
@@ -2902,10 +2895,7 @@ var distanceToRectanguloidElement = (element, p) => {
   );
 };
 var distanceToDiamondElement = (element, p) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const rotatedPoint = pointRotateRads(p, center, -element.angle);
   const [sides, curves] = deconstructDiamondElement(element);
   return Math.min(
@@ -2914,10 +2904,7 @@ var distanceToDiamondElement = (element, p) => {
   );
 };
 var distanceToEllipseElement = (element, p) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   return ellipseDistanceFromPoint(
     // Instead of rotating the ellipse, rotate the point to the inverse angle
     pointRotateRads(p, center, -element.angle),
@@ -3619,13 +3606,7 @@ var getHeadingForElbowArrowSnap = (p, otherPoint, bindableElement, aabb, element
   );
   if (!distance2) {
     return vectorToHeading(
-      vectorFromPoint(
-        p,
-        pointFrom(
-          bindableElement.x + bindableElement.width / 2,
-          bindableElement.y + bindableElement.height / 2
-        )
-      )
+      vectorFromPoint(p, elementCenterPoint(bindableElement))
     );
   }
   return headingForPointFromElement(bindableElement, aabb, p);
@@ -3719,10 +3700,7 @@ var bindPointToSnapToElementOutline = (arrow, bindableElement, startOrEnd) => {
   return edgePoint;
 };
 var avoidRectangularCorner = (element, p) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   const nonRotatedPoint = pointRotateRads(p, center, -element.angle);
   if (nonRotatedPoint[0] < element.x && nonRotatedPoint[1] < element.y) {
     if (nonRotatedPoint[1] - element.y > -FIXED_BINDING_DISTANCE) {
@@ -3793,10 +3771,7 @@ var avoidRectangularCorner = (element, p) => {
 };
 var snapToMid = (element, p, tolerance = 0.05) => {
   const { x, y, width, height, angle } = element;
-  const center = pointFrom(
-    x + width / 2 - 0.1,
-    y + height / 2 - 0.1
-  );
+  const center = elementCenterPoint(element, -0.1, -0.1);
   const nonRotated = pointRotateRads(p, center, -angle);
   const verticalThrehsold = clamp(tolerance * height, 5, 80);
   const horizontalThrehsold = clamp(tolerance * width, 5, 80);
@@ -3841,10 +3816,7 @@ var updateBoundPoint = (linearElement, startOrEnd, binding, bindableElement, ele
       startOrEnd === "startBinding" ? "start" : "end",
       elementsMap
     ).fixedPoint;
-    const globalMidPoint = pointFrom(
-      bindableElement.x + bindableElement.width / 2,
-      bindableElement.y + bindableElement.height / 2
-    );
+    const globalMidPoint = elementCenterPoint(bindableElement);
     const global = pointFrom(
       bindableElement.x + fixedPoint[0] * bindableElement.width,
       bindableElement.y + fixedPoint[1] * bindableElement.height
@@ -3880,10 +3852,7 @@ var updateBoundPoint = (linearElement, startOrEnd, binding, bindableElement, ele
       edgePointIndex,
       elementsMap
     );
-    const center = pointFrom(
-      bindableElement.x + bindableElement.width / 2,
-      bindableElement.y + bindableElement.height / 2
-    );
+    const center = elementCenterPoint(bindableElement);
     const interceptorLength = pointDistance(adjacentPoint, edgePointAbsolute) + pointDistance(adjacentPoint, center) + Math.max(bindableElement.width, bindableElement.height) * 2;
     const intersections = [
       ...intersectElementWithLineSegment(
@@ -3990,13 +3959,13 @@ var getLinearElementEdgeCoors = (linearElement, startOrEnd, elementsMap) => {
     )
   );
 };
-var fixDuplicatedBindingsAfterDuplication = (newElements, oldIdToDuplicatedId, duplicatedElementsMap) => {
-  for (const element of newElements) {
-    if ("boundElements" in element && element.boundElements) {
-      Object.assign(element, {
-        boundElements: element.boundElements.reduce(
+var fixDuplicatedBindingsAfterDuplication = (duplicatedElements, origIdToDuplicateId, duplicateElementsMap) => {
+  for (const duplicateElement of duplicatedElements) {
+    if ("boundElements" in duplicateElement && duplicateElement.boundElements) {
+      Object.assign(duplicateElement, {
+        boundElements: duplicateElement.boundElements.reduce(
           (acc, binding) => {
-            const newBindingId = oldIdToDuplicatedId.get(binding.id);
+            const newBindingId = origIdToDuplicateId.get(binding.id);
             if (newBindingId) {
               acc.push({ ...binding, id: newBindingId });
             }
@@ -4006,191 +3975,46 @@ var fixDuplicatedBindingsAfterDuplication = (newElements, oldIdToDuplicatedId, d
         )
       });
     }
-    if ("containerId" in element && element.containerId) {
-      Object.assign(element, {
-        containerId: oldIdToDuplicatedId.get(element.containerId) ?? null
+    if ("containerId" in duplicateElement && duplicateElement.containerId) {
+      Object.assign(duplicateElement, {
+        containerId: origIdToDuplicateId.get(duplicateElement.containerId) ?? null
       });
     }
-    if ("endBinding" in element && element.endBinding) {
-      const newEndBindingId = oldIdToDuplicatedId.get(
-        element.endBinding.elementId
+    if ("endBinding" in duplicateElement && duplicateElement.endBinding) {
+      const newEndBindingId = origIdToDuplicateId.get(
+        duplicateElement.endBinding.elementId
       );
-      Object.assign(element, {
+      Object.assign(duplicateElement, {
         endBinding: newEndBindingId ? {
-          ...element.endBinding,
+          ...duplicateElement.endBinding,
           elementId: newEndBindingId
         } : null
       });
     }
-    if ("startBinding" in element && element.startBinding) {
-      const newEndBindingId = oldIdToDuplicatedId.get(
-        element.startBinding.elementId
+    if ("startBinding" in duplicateElement && duplicateElement.startBinding) {
+      const newEndBindingId = origIdToDuplicateId.get(
+        duplicateElement.startBinding.elementId
       );
-      Object.assign(element, {
+      Object.assign(duplicateElement, {
         startBinding: newEndBindingId ? {
-          ...element.startBinding,
+          ...duplicateElement.startBinding,
           elementId: newEndBindingId
         } : null
       });
     }
-    if (isElbowArrow(element)) {
+    if (isElbowArrow(duplicateElement)) {
       Object.assign(
-        element,
-        updateElbowArrowPoints(element, duplicatedElementsMap, {
+        duplicateElement,
+        updateElbowArrowPoints(duplicateElement, duplicateElementsMap, {
           points: [
-            element.points[0],
-            element.points[element.points.length - 1]
+            duplicateElement.points[0],
+            duplicateElement.points[duplicateElement.points.length - 1]
           ]
         })
       );
     }
   }
 };
-var fixReversedBindingsForBindables = (original, duplicate, originalElements, elementsWithClones, oldIdToDuplicatedId) => {
-  original.boundElements?.forEach((binding, idx) => {
-    if (binding.type !== "arrow") {
-      return;
-    }
-    const oldArrow = elementsWithClones.find((el) => el.id === binding.id);
-    if (!isBindingElement(oldArrow)) {
-      return;
-    }
-    if (originalElements.has(binding.id)) {
-      const newArrowId = oldIdToDuplicatedId.get(binding.id) ?? binding.id;
-      const newArrow = elementsWithClones.find(
-        (el) => el.id === newArrowId
-      );
-      mutateElement(newArrow, {
-        startBinding: oldArrow.startBinding?.elementId === binding.id ? {
-          ...oldArrow.startBinding,
-          elementId: duplicate.id
-        } : newArrow.startBinding,
-        endBinding: oldArrow.endBinding?.elementId === binding.id ? {
-          ...oldArrow.endBinding,
-          elementId: duplicate.id
-        } : newArrow.endBinding
-      });
-      mutateElement(duplicate, {
-        boundElements: [
-          ...(duplicate.boundElements ?? []).filter(
-            (el) => el.id !== binding.id && el.id !== newArrowId
-          ),
-          {
-            type: "arrow",
-            id: newArrowId
-          }
-        ]
-      });
-    } else {
-      mutateElement(oldArrow, {
-        startBinding: oldArrow.startBinding?.elementId === original.id ? {
-          ...oldArrow.startBinding,
-          elementId: duplicate.id
-        } : oldArrow.startBinding,
-        endBinding: oldArrow.endBinding?.elementId === original.id ? {
-          ...oldArrow.endBinding,
-          elementId: duplicate.id
-        } : oldArrow.endBinding
-      });
-      mutateElement(duplicate, {
-        boundElements: [
-          ...duplicate.boundElements ?? [],
-          {
-            type: "arrow",
-            id: oldArrow.id
-          }
-        ]
-      });
-      mutateElement(original, {
-        boundElements: original.boundElements?.filter((_, i) => i !== idx) ?? null
-      });
-    }
-  });
-};
-var fixReversedBindingsForArrows = (original, duplicate, originalElements, bindingProp, oldIdToDuplicatedId, elementsWithClones) => {
-  const oldBindableId = original[bindingProp]?.elementId;
-  if (oldBindableId) {
-    if (originalElements.has(oldBindableId)) {
-      const newBindableId = oldIdToDuplicatedId.get(oldBindableId) ?? oldBindableId;
-      const newBindable = elementsWithClones.find(
-        (el) => el.id === newBindableId
-      );
-      mutateElement(duplicate, {
-        [bindingProp]: {
-          ...original[bindingProp],
-          elementId: newBindableId
-        }
-      });
-      mutateElement(newBindable, {
-        boundElements: [
-          ...(newBindable.boundElements ?? []).filter(
-            (el) => el.id !== original.id && el.id !== duplicate.id
-          ),
-          {
-            id: duplicate.id,
-            type: "arrow"
-          }
-        ]
-      });
-    } else {
-      const originalBindable = elementsWithClones.find(
-        (el) => el.id === oldBindableId
-      );
-      if (originalBindable) {
-        mutateElement(duplicate, {
-          [bindingProp]: original[bindingProp]
-        });
-        mutateElement(original, {
-          [bindingProp]: null
-        });
-        mutateElement(originalBindable, {
-          boundElements: [
-            ...originalBindable.boundElements?.filter(
-              (el) => el.id !== original.id
-            ) ?? [],
-            {
-              id: duplicate.id,
-              type: "arrow"
-            }
-          ]
-        });
-      }
-    }
-  }
-};
-var fixReversedBindings = (originalElements, elementsWithClones, oldIdToDuplicatedId) => {
-  for (const original of originalElements.values()) {
-    const duplicate = elementsWithClones.find(
-      (el) => el.id === oldIdToDuplicatedId.get(original.id)
-    );
-    if (isBindableElement(original) && isBindableElement(duplicate)) {
-      fixReversedBindingsForBindables(
-        original,
-        duplicate,
-        originalElements,
-        elementsWithClones,
-        oldIdToDuplicatedId
-      );
-    } else if (isArrowElement(original) && isArrowElement(duplicate)) {
-      fixReversedBindingsForArrows(
-        original,
-        duplicate,
-        originalElements,
-        "startBinding",
-        oldIdToDuplicatedId,
-        elementsWithClones
-      );
-      fixReversedBindingsForArrows(
-        original,
-        duplicate,
-        originalElements,
-        "endBinding",
-        oldIdToDuplicatedId,
-        elementsWithClones
-      );
-    }
-  }
-};
 var fixBindingsAfterDeletion = (sceneElements, deletedElements) => {
   const elements = arrayToMap(sceneElements);
   for (const element of deletedElements) {
@@ -4230,10 +4054,7 @@ var maxBindingGap = (element, elementWidth, elementHeight, zoom) => {
   );
 };
 var determineFocusDistance = (element, a, b) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   if (pointsEqual(a, b)) {
     return 0;
   }
@@ -4336,10 +4157,7 @@ var determineFocusDistance = (element, a, b) => {
   return signedDistanceRatio;
 };
 var determineFocusPoint = (element, focus, adjacentPoint) => {
-  const center = pointFrom(
-    element.x + element.width / 2,
-    element.y + element.height / 2
-  );
+  const center = elementCenterPoint(element);
   if (focus === 0) {
     return center;
   }
@@ -4617,10 +4435,7 @@ var getGlobalFixedPointForBindableElement = (fixedPointRatio, element) => {
       element.x + element.width * fixedX,
       element.y + element.height * fixedY
     ),
-    pointFrom(
-      element.x + element.width / 2,
-      element.y + element.height / 2
-    ),
+    elementCenterPoint(element),
     element.angle
   );
 };
@@ -6668,13 +6483,19 @@ var satisfiesWordInvariant = (word) => {
 // ../element/src/textElement.ts
 var redrawTextBoundingBox = (textElement, container, elementsMap, informMutation = true) => {
   let maxWidth = void 0;
+  if (!isProdEnv()) {
+    invariant(
+      !container || !isArrowElement(container) || textElement.angle === 0,
+      "text element angle must be 0 if bound to arrow container"
+    );
+  }
   const boundTextUpdates = {
     x: textElement.x,
     y: textElement.y,
     text: textElement.text,
     width: textElement.width,
     height: textElement.height,
-    angle: container?.angle ?? textElement.angle
+    angle: container ? isArrowElement(container) ? 0 : container.angle : textElement.angle
   };
   boundTextUpdates.text = textElement.text;
   if (container || !textElement.autoResize) {
@@ -6892,7 +6713,10 @@ var getContainerCoords = (container) => {
   };
 };
 var getTextElementAngle = (textElement, container) => {
-  if (!container || isArrowElement(container)) {
+  if (isArrowElement(container)) {
+    return 0;
+  }
+  if (!container) {
     return textElement.angle;
   }
   return container.angle;
@@ -7140,23 +6964,21 @@ var elementsOverlappingBBox = ({
 };
 
 // ../element/src/frame.ts
-var bindElementsToFramesAfterDuplication = (nextElements, oldElements, oldIdToDuplicatedId) => {
+var bindElementsToFramesAfterDuplication = (nextElements, origElements, origIdToDuplicateId) => {
   const nextElementMap = arrayToMap(nextElements);
-  for (const element of oldElements) {
+  for (const element of origElements) {
     if (element.frameId) {
-      const nextElementId = oldIdToDuplicatedId.get(element.id);
-      const nextFrameId = oldIdToDuplicatedId.get(element.frameId);
-      if (nextElementId) {
-        const nextElement = nextElementMap.get(nextElementId);
-        if (nextElement) {
-          mutateElement(
-            nextElement,
-            {
-              frameId: nextFrameId ?? element.frameId
-            },
-            false
-          );
-        }
+      const nextElementId = origIdToDuplicateId.get(element.id);
+      const nextFrameId = origIdToDuplicateId.get(element.frameId);
+      const nextElement = nextElementId && nextElementMap.get(nextElementId);
+      if (nextElement) {
+        mutateElement(
+          nextElement,
+          {
+            frameId: nextFrameId ?? null
+          },
+          false
+        );
       }
     }
   }
@@ -7766,6 +7588,41 @@ var makeNextSelectedElementIds = (nextSelectedElementIds, prevState) => {
   }
   return nextSelectedElementIds;
 };
+var _getLinearElementEditor = (targetElements) => {
+  const linears = targetElements.filter(isLinearElement);
+  if (linears.length === 1) {
+    const linear = linears[0];
+    const boundElements = linear.boundElements?.map((def) => def.id) ?? [];
+    const onlySingleLinearSelected = targetElements.every(
+      (el) => el.id === linear.id || boundElements.includes(el.id)
+    );
+    if (onlySingleLinearSelected) {
+      return new LinearElementEditor(linear);
+    }
+  }
+  return null;
+};
+var getSelectionStateForElements = (targetElements, allElements, appState) => {
+  return {
+    selectedLinearElement: _getLinearElementEditor(targetElements),
+    ...selectGroupsForSelectedElements(
+      {
+        editingGroupId: appState.editingGroupId,
+        selectedElementIds: excludeElementsInFramesFromSelection(
+          targetElements
+        ).reduce((acc, element) => {
+          if (!isBoundToContainer(element)) {
+            acc[element.id] = true;
+          }
+          return acc;
+        }, {})
+      },
+      allElements,
+      appState,
+      null
+    )
+  };
+};
 
 // ../element/src/groups.ts
 var selectGroup = (groupId, appState, elements) => {
@@ -9932,7 +9789,7 @@ var aabbForElement = (element, offset) => {
     midX: element.x + element.width / 2,
     midY: element.y + element.height / 2
   };
-  const center = pointFrom(bbox.midX, bbox.midY);
+  const center = elementCenterPoint(element);
   const [topLeftX, topLeftY] = pointRotateRads(
     pointFrom(bbox.minX, bbox.minY),
     center,
@@ -10017,7 +9874,7 @@ var cropElement = (element, transformHandle, naturalWidth, naturalHeight, pointe
   const croppedTop = (element.crop?.y ?? 0) / naturalHeightToUncropped;
   const rotatedPointer = pointRotateRads(
     pointFrom(pointerX, pointerY),
-    pointFrom(element.x + element.width / 2, element.y + element.height / 2),
+    elementCenterPoint(element),
     -element.angle
   );
   pointerX = rotatedPointer[0];
@@ -17638,6 +17495,7 @@ var repairContainerElement = (container, elementsMap) => {
 };
 var repairBoundElement = (boundElement, elementsMap) => {
   const container = boundElement.containerId ? elementsMap.get(boundElement.containerId) : null;
+  boundElement.angle = isArrowElement(container) ? 0 : container?.angle ?? 0;
   if (!container) {
     boundElement.containerId = null;
     return;
@@ -17883,7 +17741,7 @@ var parseFileContents = async (blob) => {
   let contents;
   if (blob.type === MIME_TYPES.png) {
     try {
-      return await (await import("./data/image-NKFINVKH.js")).decodePngMetadata(blob);
+      return await (await import("./data/image-JN3Y4CVN.js")).decodePngMetadata(blob);
     } catch (error) {
       if (error.message === "INVALID") {
         throw new ImageSceneDataError(
@@ -18350,6 +18208,7 @@ export {
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   MAX_ALLOWED_FILE_BYTES,
   SVG_NS,
+  SVG_DOCUMENT_PREAMBLE,
   VERSIONS,
   BOUND_TEXT_PADDING,
   VERTICAL_ALIGN,
@@ -18491,6 +18350,7 @@ export {
   isUsingAdaptiveRadius,
   canApplyRoundnessTypeToElement,
   getDefaultRoundnessTypeForElement,
+  shouldTestInside,
   hitElementItself,
   hitElementBoundingBox,
   hitElementBoundingBoxOnly,
@@ -18545,7 +18405,6 @@ export {
   bindPointToSnapToElementOutline,
   calculateFixedPointForElbowArrowBinding,
   fixDuplicatedBindingsAfterDuplication,
-  fixReversedBindings,
   fixBindingsAfterDeletion,
   maxBindingGap,
   bindingProperties,
@@ -18599,6 +18458,7 @@ export {
   getSelectedElements,
   getTargetElements,
   makeNextSelectedElementIds,
+  getSelectionStateForElements,
   selectGroup,
   selectGroupsForSelectedElements,
   isSelectedViaGroup,
@@ -18736,4 +18596,4 @@ export {
   createFile,
   normalizeFile
 };
-//# sourceMappingURL=chunk-KYBDXI6F.js.map
+//# sourceMappingURL=chunk-GBJ7S76A.js.map