@excalidraw/excalidraw 0.18.0-432a46e → 0.18.0-6fc8502

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

@@ -1,6 +1,6 @@
 import {
   define_import_meta_env_default
-} from "./chunk-ZG3EI5XS.js";
+} from "./chunk-H7XJ5UVD.js";
 import {
   __publicField
 } from "./chunk-XDFCUUT6.js";
@@ -103,6 +103,7 @@ var BinaryHeap = class {
 
 // ../common/src/colors.ts
 import oc from "open-color";
+var COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
 var pick = (source, keys) => {
   return keys.reduce((acc, key) => {
     if (key in source) {
@@ -479,6 +480,7 @@ var LIBRARY_DISABLED_TYPES = /* @__PURE__ */ new Set([
 ]);
 var TOOL_TYPE = {
   selection: "selection",
+  lasso: "lasso",
   rectangle: "rectangle",
   diamond: "diamond",
   ellipse: "ellipse",
@@ -935,9 +937,9 @@ var distanceToLineSegment = (point, line2) => {
   const dy = y - yy;
   return Math.sqrt(dx * dx + dy * dy);
 };
-function lineSegmentIntersectionPoints(l, s) {
+function lineSegmentIntersectionPoints(l, s, threshold) {
   const candidate = linesIntersectAt(line(l[0], l[1]), line(s[0], s[1]));
-  if (!candidate || !pointOnLineSegment(candidate, s) || !pointOnLineSegment(candidate, l)) {
+  if (!candidate || !pointOnLineSegment(candidate, s, threshold) || !pointOnLineSegment(candidate, l, threshold)) {
     return null;
   }
   return candidate;
@@ -1131,6 +1133,27 @@ var polygonIncludesPoint = (point, polygon2) => {
   }
   return inside;
 };
+var polygonIncludesPointNonZero = (point, polygon2) => {
+  const [x, y] = point;
+  let windingNumber = 0;
+  for (let i = 0; i < polygon2.length; i++) {
+    const j = (i + 1) % polygon2.length;
+    const [xi, yi] = polygon2[i];
+    const [xj, yj] = polygon2[j];
+    if (yi <= y) {
+      if (yj > y) {
+        if ((xj - xi) * (y - yi) - (x - xi) * (yj - yi) > 0) {
+          windingNumber++;
+        }
+      }
+    } else if (yj <= y) {
+      if ((xj - xi) * (y - yi) - (x - xi) * (yj - yi) < 0) {
+        windingNumber--;
+      }
+    }
+  }
+  return windingNumber !== 0;
+};
 var pointOnPolygon = (p, poly, threshold = PRECISION) => {
   let on = false;
   for (let i = 0, l = poly.length - 1; i < l; i++) {
@@ -1469,7 +1492,8 @@ var updateActiveTool = (appState, data) => {
     lastActiveTool: data.lastActiveToolBeforeEraser === void 0 ? appState.activeTool.lastActiveTool : data.lastActiveToolBeforeEraser,
     type: data.type,
     customType: null,
-    locked: data.locked ?? appState.activeTool.locked
+    locked: data.locked ?? appState.activeTool.locked,
+    fromSelection: data.fromSelection ?? false
   };
 };
 var getShortcutKey = (shortcut) => {
@@ -2107,6 +2131,9 @@ var pointInEllipse = (p, ellipse2) => {
   return rotatedPointX / halfWidth * (rotatedPointX / halfWidth) + rotatedPointY / halfHeight * (rotatedPointY / halfHeight) <= 1;
 };
 
+// ../element/src/bounds.ts
+import { pointsOnBezierCurves as pointsOnBezierCurves2 } from "points-on-curve";
+
 // ../element/src/ShapeCache.ts
 import { RoughGenerator } from "roughjs/bin/generator";
 
@@ -2903,19 +2930,6 @@ var HEADING_RIGHT = [1, 0];
 var HEADING_DOWN = [0, 1];
 var HEADING_LEFT = [-1, 0];
 var HEADING_UP = [0, -1];
-var headingForDiamond = (a, b) => {
-  const angle = radiansToDegrees(
-    normalizeRadians(Math.atan2(b[1] - a[1], b[0] - a[0]))
-  );
-  if (angle >= 315 || angle < 45) {
-    return HEADING_UP;
-  } else if (angle >= 45 && angle < 135) {
-    return HEADING_RIGHT;
-  } else if (angle >= 135 && angle < 225) {
-    return HEADING_DOWN;
-  }
-  return HEADING_LEFT;
-};
 var vectorToHeading = (vec) => {
   const [x, y] = vec;
   const absX = Math.abs(x);
@@ -2933,69 +2947,135 @@ var headingForPoint = (p, o) => vectorToHeading(vectorFromPoint(p, o));
 var headingForPointIsHorizontal = (p, o) => headingIsHorizontal(headingForPoint(p, o));
 var compareHeading = (a, b) => a[0] === b[0] && a[1] === b[1];
 var headingIsHorizontal = (a) => compareHeading(a, HEADING_RIGHT) || compareHeading(a, HEADING_LEFT);
-var headingForPointFromElement = (element, aabb, p) => {
-  const SEARCH_CONE_MULTIPLIER = 2;
+var headingForPointFromDiamondElement = (element, aabb, point) => {
   const midPoint = getCenterForBounds(aabb);
-  if (element.type === "diamond") {
-    if (p[0] < element.x) {
-      return HEADING_LEFT;
-    } else if (p[1] < element.y) {
-      return HEADING_UP;
-    } else if (p[0] > element.x + element.width) {
-      return HEADING_RIGHT;
-    } else if (p[1] > element.y + element.height) {
-      return HEADING_DOWN;
-    }
-    const top = pointRotateRads(
-      pointScaleFromOrigin(
-        pointFrom(element.x + element.width / 2, element.y),
-        midPoint,
-        SEARCH_CONE_MULTIPLIER
-      ),
-      midPoint,
-      element.angle
+  if (isDevEnv() || isTestEnv()) {
+    invariant(
+      element.width > 0 && element.height > 0,
+      "Diamond element has no width or height"
     );
-    const right = pointRotateRads(
-      pointScaleFromOrigin(
-        pointFrom(element.x + element.width, element.y + element.height / 2),
-        midPoint,
-        SEARCH_CONE_MULTIPLIER
-      ),
-      midPoint,
-      element.angle
+    invariant(
+      !pointsEqual(midPoint, point),
+      "The point is too close to the element mid point to determine heading"
     );
-    const bottom = pointRotateRads(
-      pointScaleFromOrigin(
-        pointFrom(element.x + element.width / 2, element.y + element.height),
-        midPoint,
-        SEARCH_CONE_MULTIPLIER
+  }
+  const SHRINK = 0.95;
+  const top = pointFromVector(
+    vectorScale(
+      vectorFromPoint(
+        pointRotateRads(
+          pointFrom(element.x + element.width / 2, element.y),
+          midPoint,
+          element.angle
+        ),
+        midPoint
       ),
-      midPoint,
-      element.angle
-    );
-    const left = pointRotateRads(
-      pointScaleFromOrigin(
-        pointFrom(element.x, element.y + element.height / 2),
-        midPoint,
-        SEARCH_CONE_MULTIPLIER
+      SHRINK
+    ),
+    midPoint
+  );
+  const right = pointFromVector(
+    vectorScale(
+      vectorFromPoint(
+        pointRotateRads(
+          pointFrom(
+            element.x + element.width,
+            element.y + element.height / 2
+          ),
+          midPoint,
+          element.angle
+        ),
+        midPoint
       ),
-      midPoint,
-      element.angle
-    );
-    if (triangleIncludesPoint([top, right, midPoint], p)) {
-      return headingForDiamond(top, right);
-    } else if (triangleIncludesPoint(
-      [right, bottom, midPoint],
-      p
-    )) {
-      return headingForDiamond(right, bottom);
-    } else if (triangleIncludesPoint(
-      [bottom, left, midPoint],
-      p
-    )) {
-      return headingForDiamond(bottom, left);
-    }
-    return headingForDiamond(left, top);
+      SHRINK
+    ),
+    midPoint
+  );
+  const bottom = pointFromVector(
+    vectorScale(
+      vectorFromPoint(
+        pointRotateRads(
+          pointFrom(
+            element.x + element.width / 2,
+            element.y + element.height
+          ),
+          midPoint,
+          element.angle
+        ),
+        midPoint
+      ),
+      SHRINK
+    ),
+    midPoint
+  );
+  const left = pointFromVector(
+    vectorScale(
+      vectorFromPoint(
+        pointRotateRads(
+          pointFrom(element.x, element.y + element.height / 2),
+          midPoint,
+          element.angle
+        ),
+        midPoint
+      ),
+      SHRINK
+    ),
+    midPoint
+  );
+  if (vectorCross(vectorFromPoint(point, top), vectorFromPoint(top, right)) <= 0 && vectorCross(vectorFromPoint(point, top), vectorFromPoint(top, left)) > 0) {
+    return headingForPoint(top, midPoint);
+  } else if (vectorCross(
+    vectorFromPoint(point, right),
+    vectorFromPoint(right, bottom)
+  ) <= 0 && vectorCross(vectorFromPoint(point, right), vectorFromPoint(right, top)) > 0) {
+    return headingForPoint(right, midPoint);
+  } else if (vectorCross(
+    vectorFromPoint(point, bottom),
+    vectorFromPoint(bottom, left)
+  ) <= 0 && vectorCross(
+    vectorFromPoint(point, bottom),
+    vectorFromPoint(bottom, right)
+  ) > 0) {
+    return headingForPoint(bottom, midPoint);
+  } else if (vectorCross(vectorFromPoint(point, left), vectorFromPoint(left, top)) <= 0 && vectorCross(vectorFromPoint(point, left), vectorFromPoint(left, bottom)) > 0) {
+    return headingForPoint(left, midPoint);
+  }
+  if (vectorCross(
+    vectorFromPoint(point, midPoint),
+    vectorFromPoint(top, midPoint)
+  ) <= 0 && vectorCross(
+    vectorFromPoint(point, midPoint),
+    vectorFromPoint(right, midPoint)
+  ) > 0) {
+    const p2 = element.width > element.height ? top : right;
+    return headingForPoint(p2, midPoint);
+  } else if (vectorCross(
+    vectorFromPoint(point, midPoint),
+    vectorFromPoint(right, midPoint)
+  ) <= 0 && vectorCross(
+    vectorFromPoint(point, midPoint),
+    vectorFromPoint(bottom, midPoint)
+  ) > 0) {
+    const p2 = element.width > element.height ? bottom : right;
+    return headingForPoint(p2, midPoint);
+  } else if (vectorCross(
+    vectorFromPoint(point, midPoint),
+    vectorFromPoint(bottom, midPoint)
+  ) <= 0 && vectorCross(
+    vectorFromPoint(point, midPoint),
+    vectorFromPoint(left, midPoint)
+  ) > 0) {
+    const p2 = element.width > element.height ? bottom : left;
+    return headingForPoint(p2, midPoint);
+  }
+  const p = element.width > element.height ? top : left;
+  return headingForPoint(p, midPoint);
+};
+var headingForPointFromElement = (element, aabb, p) => {
+  const SEARCH_CONE_MULTIPLIER = 2;
+  const midPoint = getCenterForBounds(aabb);
+  if (element.type === "diamond") {
+    return headingForPointFromDiamondElement(element, aabb, p);
   }
   const topLeft = pointScaleFromOrigin(
     pointFrom(aabb[0], aabb[1]),
@@ -3910,7 +3990,7 @@ var getLinearElementEdgeCoors = (linearElement, startOrEnd, elementsMap) => {
     )
   );
 };
-var fixBindingsAfterDuplication = (newElements, oldIdToDuplicatedId, duplicatedElementsMap) => {
+var fixDuplicatedBindingsAfterDuplication = (newElements, oldIdToDuplicatedId, duplicatedElementsMap) => {
   for (const element of newElements) {
     if ("boundElements" in element && element.boundElements) {
       Object.assign(element, {
@@ -3966,6 +4046,151 @@ var fixBindingsAfterDuplication = (newElements, oldIdToDuplicatedId, duplicatedE
     }
   }
 };
+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) {
@@ -8308,6 +8533,7 @@ var _LinearElementEditor = class _LinearElementEditor {
     this.elementId = element.id;
     if (!pointsEqual(element.points[0], pointFrom(0, 0))) {
       console.error("Linear element is not normalized", Error().stack);
+      _LinearElementEditor.normalizePoints(element);
     }
     this.selectedPointsIndices = null;
     this.lastUncommittedPoint = null;
@@ -11463,40 +11689,62 @@ var getElementAbsoluteCoords = (element, elementsMap, includeBoundText = false)
   ];
 };
 var getElementLineSegments = (element, elementsMap) => {
+  const shape = getElementShape(element, elementsMap);
   const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(
     element,
     elementsMap
   );
   const center = pointFrom(cx, cy);
-  if (isLinearElement(element) || isFreeDrawElement(element)) {
-    const segments = [];
+  if (shape.type === "polycurve") {
+    const curves = shape.data;
+    const points = curves.map((curve2) => pointsOnBezierCurves2(curve2, 10)).flat();
     let i = 0;
-    while (i < element.points.length - 1) {
+    const segments = [];
+    while (i < points.length - 1) {
       segments.push(
         lineSegment(
-          pointRotateRads(
-            pointFrom(
-              element.points[i][0] + element.x,
-              element.points[i][1] + element.y
-            ),
-            center,
-            element.angle
-          ),
-          pointRotateRads(
-            pointFrom(
-              element.points[i + 1][0] + element.x,
-              element.points[i + 1][1] + element.y
-            ),
-            center,
-            element.angle
-          )
+          pointFrom(points[i][0], points[i][1]),
+          pointFrom(points[i + 1][0], points[i + 1][1])
         )
       );
       i++;
     }
     return segments;
+  } else if (shape.type === "polyline") {
+    return shape.data;
+  } else if (_isRectanguloidElement(element)) {
+    const [sides, corners] = deconstructRectanguloidElement(element);
+    const cornerSegments = corners.map((corner) => getSegmentsOnCurve(corner, center, element.angle)).flat();
+    const rotatedSides = getRotatedSides(sides, center, element.angle);
+    return [...rotatedSides, ...cornerSegments];
+  } else if (element.type === "diamond") {
+    const [sides, corners] = deconstructDiamondElement(element);
+    const cornerSegments = corners.map((corner) => getSegmentsOnCurve(corner, center, element.angle)).flat();
+    const rotatedSides = getRotatedSides(sides, center, element.angle);
+    return [...rotatedSides, ...cornerSegments];
+  } else if (shape.type === "polygon") {
+    if (isTextElement(element)) {
+      const container = getContainerElement(element, elementsMap);
+      if (container && isLinearElement(container)) {
+        const segments2 = [
+          lineSegment(pointFrom(x1, y1), pointFrom(x2, y1)),
+          lineSegment(pointFrom(x2, y1), pointFrom(x2, y2)),
+          lineSegment(pointFrom(x2, y2), pointFrom(x1, y2)),
+          lineSegment(pointFrom(x1, y2), pointFrom(x1, y1))
+        ];
+        return segments2;
+      }
+    }
+    const points = shape.data;
+    const segments = [];
+    for (let i = 0; i < points.length - 1; i++) {
+      segments.push(lineSegment(points[i], points[i + 1]));
+    }
+    return segments;
+  } else if (shape.type === "ellipse") {
+    return getSegmentsOnEllipse(element);
   }
-  const [nw, ne, sw, se, n, s, w, e] = [
+  const [nw, ne, sw, se, , , w, e] = [
     [x1, y1],
     [x2, y1],
     [x1, y2],
@@ -11506,26 +11754,6 @@ var getElementLineSegments = (element, elementsMap) => {
     [x1, cy],
     [x2, cy]
   ].map((point) => pointRotateRads(point, center, element.angle));
-  if (element.type === "diamond") {
-    return [
-      lineSegment(n, w),
-      lineSegment(n, e),
-      lineSegment(s, w),
-      lineSegment(s, e)
-    ];
-  }
-  if (element.type === "ellipse") {
-    return [
-      lineSegment(n, w),
-      lineSegment(n, e),
-      lineSegment(s, w),
-      lineSegment(s, e),
-      lineSegment(n, w),
-      lineSegment(n, e),
-      lineSegment(s, w),
-      lineSegment(s, e)
-    ];
-  }
   return [
     lineSegment(nw, ne),
     lineSegment(sw, se),
@@ -11537,6 +11765,63 @@ var getElementLineSegments = (element, elementsMap) => {
     lineSegment(se, w)
   ];
 };
+var _isRectanguloidElement = (element) => {
+  return element != null && (element.type === "rectangle" || element.type === "image" || element.type === "iframe" || element.type === "embeddable" || element.type === "frame" || element.type === "magicframe" || element.type === "text" && !element.containerId);
+};
+var getRotatedSides = (sides, center, angle) => {
+  return sides.map((side) => {
+    return lineSegment(
+      pointRotateRads(side[0], center, angle),
+      pointRotateRads(side[1], center, angle)
+    );
+  });
+};
+var getSegmentsOnCurve = (curve2, center, angle) => {
+  const points = pointsOnBezierCurves2(curve2, 10);
+  let i = 0;
+  const segments = [];
+  while (i < points.length - 1) {
+    segments.push(
+      lineSegment(
+        pointRotateRads(
+          pointFrom(points[i][0], points[i][1]),
+          center,
+          angle
+        ),
+        pointRotateRads(
+          pointFrom(points[i + 1][0], points[i + 1][1]),
+          center,
+          angle
+        )
+      )
+    );
+    i++;
+  }
+  return segments;
+};
+var getSegmentsOnEllipse = (ellipse2) => {
+  const center = pointFrom(
+    ellipse2.x + ellipse2.width / 2,
+    ellipse2.y + ellipse2.height / 2
+  );
+  const a = ellipse2.width / 2;
+  const b = ellipse2.height / 2;
+  const segments = [];
+  const points = [];
+  const n = 90;
+  const deltaT = Math.PI * 2 / n;
+  for (let i = 0; i < n; i++) {
+    const t = i * deltaT;
+    const x = center[0] + a * Math.cos(t);
+    const y = center[1] + b * Math.sin(t);
+    points.push(pointRotateRads(pointFrom(x, y), center, ellipse2.angle));
+  }
+  for (let i = 0; i < points.length - 1; i++) {
+    segments.push(lineSegment(points[i], points[i + 1]));
+  }
+  segments.push(lineSegment(points[points.length - 1], points[0]));
+  return segments;
+};
 var getDiamondPoints = (element) => {
   const topX = Math.floor(element.width / 2) + 1;
   const topY = 0;
@@ -12145,6 +12430,7 @@ var getDefaultAppState = () => {
       type: "selection",
       customType: null,
       locked: DEFAULT_ELEMENT_PROPS.locked,
+      fromSelection: false,
       lastActiveTool: null
     },
     penMode: false,
@@ -17109,6 +17395,7 @@ var getExportSize = (elements, exportPadding, scale) => {
 // data/restore.ts
 var AllowedExcalidrawActiveTools = {
   selection: true,
+  lasso: true,
   text: true,
   rectangle: true,
   diamond: true,
@@ -17187,7 +17474,7 @@ var restoreElementWithProperties = (element, extra) => {
   if ("customData" in element || "customData" in extra) {
     base.customData = "customData" in extra ? extra.customData : element.customData;
   }
-  return {
+  const ret = {
     // spread the original element properties to not lose unknown ones
     // for forward-compatibility
     ...element,
@@ -17196,6 +17483,9 @@ var restoreElementWithProperties = (element, extra) => {
     ...getNormalizedDimensions(base),
     ...extra
   };
+  delete ret.strokeSharpness;
+  delete ret.boundElementIds;
+  return ret;
 };
 var restoreElement = (element) => {
   element = { ...element };
@@ -17593,7 +17883,7 @@ var parseFileContents = async (blob) => {
   let contents;
   if (blob.type === MIME_TYPES.png) {
     try {
-      return await (await import("./data/image-5HAY2PCR.js")).decodePngMetadata(blob);
+      return await (await import("./data/image-NKFINVKH.js")).decodePngMetadata(blob);
     } catch (error) {
       if (error.message === "INVALID") {
         throw new ImageSceneDataError(
@@ -17982,6 +18272,7 @@ var decodePngMetadata = async (blob) => {
 };
 
 export {
+  COLOR_OUTLINE_CONTRAST_THRESHOLD,
   MAX_CUSTOM_COLORS_USED_IN_CANVAS,
   COLORS_PER_ROW,
   DEFAULT_CHART_COLOR_INDEX,
@@ -18105,7 +18396,11 @@ export {
   pointRotateRads,
   pointCenter,
   pointDistance,
+  lineSegment,
   pointOnLineSegment,
+  lineSegmentIntersectionPoints,
+  polygonFromPoints,
+  polygonIncludesPointNonZero,
   rangeInclusive,
   rangesOverlap,
   rangeIntersection,
@@ -18249,7 +18544,8 @@ export {
   updateBoundElements,
   bindPointToSnapToElementOutline,
   calculateFixedPointForElbowArrowBinding,
-  fixBindingsAfterDuplication,
+  fixDuplicatedBindingsAfterDuplication,
+  fixReversedBindings,
   fixBindingsAfterDeletion,
   maxBindingGap,
   bindingProperties,
@@ -18348,6 +18644,7 @@ export {
   getFreeDrawSvgPath,
   ShapeCache,
   getElementAbsoluteCoords,
+  getElementLineSegments,
   getElementBounds,
   getCommonBounds,
   getDraggedElementsBounds,
@@ -18439,4 +18736,4 @@ export {
   createFile,
   normalizeFile
 };
-//# sourceMappingURL=chunk-S7W4OWSF.js.map
+//# sourceMappingURL=chunk-KYBDXI6F.js.map