@myoc/excalidraw 0.19.503 → 0.19.505

package/dist/dev/index.js

@@ -64,10 +64,10 @@ import {
   serializeAsJSON,
   serializeLibraryAsJSON,
   strokeRectWithRotation_simple
-} from "./chunk-YVUPBWS6.js";
+} from "./chunk-D5OSJVKD.js";
 import {
   define_import_meta_env_default
-} from "./chunk-OF725VHI.js";
+} from "./chunk-KCN2IL3S.js";
 import {
   en_default
 } from "./chunk-KLM3KPI7.js";
@@ -177,7 +177,7 @@ import {
   normalizeEOL as normalizeEOL2,
   getDateTime,
   isShallowEqual as isShallowEqual9,
-  arrayToMap as arrayToMap28,
+  arrayToMap as arrayToMap30,
   applyDarkModeFilter as applyDarkModeFilter4,
   AppEventBus,
   randomInteger as randomInteger4,
@@ -208,7 +208,6 @@ import {
   getHoveredElementForBinding as getHoveredElementForBinding2,
   isBindingEnabled as isBindingEnabled2,
   updateBoundElements as updateBoundElements4,
-  LinearElementEditor as LinearElementEditor11,
   newElementWith as newElementWith10,
   newFrameElement as newFrameElement2,
   newFreeDrawElement,
@@ -248,7 +247,7 @@ import {
   isElementInViewport as isElementInViewport3,
   isInvisiblySmallElement as isInvisiblySmallElement3,
   getCornerRadius as getCornerRadius2,
-  isPathALoop as isPathALoop4,
+  isPathALoop as isPathALoop3,
   createSrcDoc,
   embeddableURLValidator as embeddableURLValidator2,
   maybeParseEmbedSrc,
@@ -304,7 +303,7 @@ import {
   isSelectedViaGroup as isSelectedViaGroup2,
   selectGroupsForSelectedElements as selectGroupsForSelectedElements6,
   syncInvalidIndices,
-  syncMovedIndices as syncMovedIndices4,
+  syncMovedIndices as syncMovedIndices5,
   excludeElementsInFramesFromSelection,
   getSelectionStateForElements as getSelectionStateForElements2,
   makeNextSelectedElementIds as makeNextSelectedElementIds2,
@@ -343,6 +342,8 @@ import {
   getUncroppedWidthAndHeight as getUncroppedWidthAndHeight4,
   getActiveTextElement as getActiveTextElement2
 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor11 } from "@excalidraw/element/linearElementEditor";
+import { findShapeByKey } from "@excalidraw/element/shapes";
 
 // actions/actionDeleteSelected.tsx
 import {
@@ -352,7 +353,7 @@ import {
 } from "@excalidraw/common";
 import { getNonDeletedElements } from "@excalidraw/element";
 import { fixBindingsAfterDeletion } from "@excalidraw/element";
-import { LinearElementEditor } from "@excalidraw/element";
+import { LinearElementEditor } from "@excalidraw/element/linearElementEditor";
 import { newElementWith } from "@excalidraw/element";
 import { getContainerElement } from "@excalidraw/element";
 import {
@@ -3535,7 +3536,7 @@ var actionBringToFront = register({
 
 // actions/actionSelectAll.ts
 import { getNonDeletedElements as getNonDeletedElements2 } from "@excalidraw/element";
-import { LinearElementEditor as LinearElementEditor2 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor2 } from "@excalidraw/element/linearElementEditor";
 import { isLinearElement, isTextElement } from "@excalidraw/element";
 import { arrayToMap, KEYS as KEYS3 } from "@excalidraw/common";
 import { selectGroupsForSelectedElements as selectGroupsForSelectedElements2 } from "@excalidraw/element";
@@ -3587,7 +3588,7 @@ import {
   arrayToMap as arrayToMap2
 } from "@excalidraw/common";
 import { getNonDeletedElements as getNonDeletedElements3 } from "@excalidraw/element";
-import { LinearElementEditor as LinearElementEditor3 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor3 } from "@excalidraw/element/linearElementEditor";
 import {
   getSelectedElements as getSelectedElements2,
   getSelectionStateForElements
@@ -3718,7 +3719,7 @@ import {
   calculateFixedPointForElbowArrowBinding,
   updateBoundElements
 } from "@excalidraw/element";
-import { LinearElementEditor as LinearElementEditor4 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor4 } from "@excalidraw/element/linearElementEditor";
 import { newElementWith as newElementWith2 } from "@excalidraw/element";
 import { getArrowheadForPicker } from "@excalidraw/element";
 import {
@@ -8543,11 +8544,8 @@ var actionSetEmbeddableAsActiveTool = register({
 // actions/actionFinalize.tsx
 import { pointFrom as pointFrom2 } from "@excalidraw/math";
 import { bindOrUnbindBindingElement } from "@excalidraw/element/binding";
-import {
-  isValidPolygon,
-  LinearElementEditor as LinearElementEditor5,
-  newElementWith as newElementWith3
-} from "@excalidraw/element";
+import { isValidPolygon, newElementWith as newElementWith3 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor5 } from "@excalidraw/element/linearElementEditor";
 import {
   isBindingElement,
   isFreeDrawElement,
@@ -9504,7 +9502,7 @@ var exportCanvas = async (type, elements, appState, files, {
     let blob = canvasToBlob(tempCanvas);
     if (appState.exportEmbedScene) {
       blob = blob.then(
-        (blob2) => import("./data/image-I24D3FB6.js").then(
+        (blob2) => import("./data/image-KFKBCMAI.js").then(
           ({ encodePngMetadata: encodePngMetadata2 }) => encodePngMetadata2({
             blob: blob2,
             metadata: serializeAsJSON(elements, appState, files, "local")
@@ -11094,16 +11092,46 @@ import { arrayToMap as arrayToMap9, KEYS as KEYS21, matchKey } from "@excalidraw
 import { CaptureUpdateAction as CaptureUpdateAction17 } from "@excalidraw/element";
 import { updateFrameMembershipOfSelectedElements as updateFrameMembershipOfSelectedElements3 } from "@excalidraw/element/frame";
 import { arrangeElements } from "@excalidraw/element/arrange";
+
+// editorPreferences.ts
+var DEFAULT_SMART_ZOOM_PREFERENCES = {
+  fitToViewport: true,
+  animate: true,
+  duration: 200,
+  viewportZoomFactor: 0.8
+};
+var getEffectiveEditorPreferences = (appState, editorPreferences) => {
+  return {
+    smartZoom: {
+      ...DEFAULT_SMART_ZOOM_PREFERENCES,
+      ...editorPreferences?.smartZoom
+    },
+    arrange: {
+      ...appState.arrangeConfiguration,
+      ...editorPreferences?.arrange
+    },
+    normalise: {
+      ...appState.normaliseConfiguration,
+      ...editorPreferences?.normalise
+    }
+  };
+};
+
+// actions/actionArrange.tsx
 import { jsx as jsx48 } from "react/jsx-runtime";
 var arrangeSelectedElements = (elements, appState, app) => {
   const selectedElements = app.scene.getSelectedElements(appState);
   const elementsMap = arrayToMap9(elements);
+  const { arrange } = getEffectiveEditorPreferences(
+    appState,
+    app.props.editorPreferences
+  );
   const updatedElements = arrangeElements(
     app.scene,
     selectedElements,
     elementsMap,
-    appState.arrangeConfiguration.algorithm,
-    appState.arrangeConfiguration.gap
+    arrange.algorithm,
+    arrange.gap
   );
   const updatedElementsMap = arrayToMap9(updatedElements);
   return updateFrameMembershipOfSelectedElements3(
@@ -11150,12 +11178,16 @@ import { jsx as jsx49 } from "react/jsx-runtime";
 var normaliseSelectedElements = (elements, appState, app) => {
   const selectedElements = app.scene.getSelectedElements(appState);
   const elementsMap = arrayToMap10(elements);
+  const { normalise } = getEffectiveEditorPreferences(
+    appState,
+    app.props.editorPreferences
+  );
   const updatedElements = normaliseElements(
     app.scene,
     selectedElements,
     elementsMap,
-    appState.normaliseConfiguration.mode,
-    appState.normaliseConfiguration.metric
+    normalise.mode,
+    normalise.metric
   );
   const updatedElementsMap = arrayToMap10(updatedElements);
   return updateFrameMembershipOfSelectedElements4(
@@ -12545,7 +12577,7 @@ import {
   isLinearElement as isLinearElement8,
   isLineElement as isLineElement4
 } from "@excalidraw/element";
-import { arrayToMap as arrayToMap22, invariant as invariant14 } from "@excalidraw/common";
+import { arrayToMap as arrayToMap24, invariant as invariant14 } from "@excalidraw/common";
 import {
   toggleLinePolygonState as toggleLinePolygonState3,
   CaptureUpdateAction as CaptureUpdateAction33
@@ -12607,7 +12639,7 @@ import {
   updateActiveTool as updateActiveTool5
 } from "@excalidraw/common";
 import { measureText as measureText2 } from "@excalidraw/element";
-import { LinearElementEditor as LinearElementEditor6 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor6 } from "@excalidraw/element/linearElementEditor";
 import {
   newArrowElement,
   newElement as newElement2,
@@ -17602,10 +17634,7 @@ var ShapesSwitcher = ({
       title: capitalizeString2(t("toolBar.lasso"))
     }
   ];
-  const frameToolSelected = activeTool.type === "frame";
-  const laserToolSelected = activeTool.type === "laser";
   const lassoToolSelected = isFullStylesPanel && activeTool.type === "lasso" && app.state.preferredSelectionTool.type !== "lasso";
-  const embeddableToolSelected = activeTool.type === "embeddable";
   const simplifiedShapeTools = SHAPES.filter(
     (s) => s.myocSimplifiedMode === false
   );
@@ -18686,7 +18715,7 @@ import {
 // ../element/src/bounds.ts
 import rough from "roughjs/bin/rough";
 import {
-  arrayToMap as arrayToMap18,
+  arrayToMap as arrayToMap23,
   invariant as invariant12,
   rescalePoints,
   sizeOf
@@ -18695,20 +18724,20 @@ import {
   degreesToRadians,
   lineSegment as lineSegment5,
   pointDistance as pointDistance6,
-  pointFrom as pointFrom13,
+  pointFrom as pointFrom15,
   pointFromArray as pointFromArray3,
-  pointRotateRads as pointRotateRads10
+  pointRotateRads as pointRotateRads11
 } from "@excalidraw/math";
 import { pointsOnBezierCurves as pointsOnBezierCurves2 } from "points-on-curve";
 
 // ../element/src/linearElementEditor.ts
 import {
   pointCenter,
-  pointFrom as pointFrom12,
-  pointRotateRads as pointRotateRads9,
+  pointFrom as pointFrom14,
+  pointRotateRads as pointRotateRads10,
   pointsEqual as pointsEqual7,
   pointDistance as pointDistance5,
-  vectorFromPoint as vectorFromPoint7,
+  vectorFromPoint as vectorFromPoint8,
   curveLength,
   curvePointAtLength
 } from "@excalidraw/math";
@@ -18718,16 +18747,9 @@ import {
   shouldRotateWithDiscreteAngle as shouldRotateWithDiscreteAngle2,
   getGridPoint,
   invariant as invariant11,
-  isShallowEqual as isShallowEqual2,
+  isShallowEqual as isShallowEqual3,
   getFeatureFlag as getFeatureFlag2
 } from "@excalidraw/common";
-import {
-  deconstructLinearOrFreeDrawElement as deconstructLinearOrFreeDrawElement2,
-  getSnapOutlineMidPoint,
-  isPathALoop as isPathALoop3,
-  moveArrowAboveBindable,
-  projectFixedPointOntoDiagonal as projectFixedPointOntoDiagonal2
-} from "@excalidraw/element";
 
 // ../element/src/binding.ts
 import {
@@ -18968,172 +18990,24 @@ import {
 } from "@excalidraw/math";
 import { pointsEqual as pointsEqual6 } from "@excalidraw/math";
 
-// ../element/src/bounds.ts
-var getDiamondPoints = (element) => {
-  const topX = Math.floor(element.width / 2) + 1;
-  const topY = 0;
-  const rightX = element.width;
-  const rightY = Math.floor(element.height / 2) + 1;
-  const bottomX = topX;
-  const bottomY = element.height;
-  const leftX = 0;
-  const leftY = rightY;
-  return [topX, topY, rightX, rightY, bottomX, bottomY, leftX, leftY];
-};
-var CARDINALITY_MARKER_SIZE = 20;
-var CROWFOOT_ARROWHEAD_SIZE = 15;
-var getArrowheadSize = (arrowhead) => {
-  switch (arrowhead) {
-    case "arrow":
-      return 25;
-    case "diamond":
-    case "diamond_outline":
-      return 12;
-    case "cardinality_many":
-    case "cardinality_one_or_many":
-    case "cardinality_zero_or_many":
-      return CROWFOOT_ARROWHEAD_SIZE;
-    case "cardinality_one":
-    case "cardinality_exactly_one":
-    case "cardinality_zero_or_one":
-      return CARDINALITY_MARKER_SIZE;
-    default:
-      return 15;
-  }
-};
-var getArrowheadAngle = (arrowhead) => {
-  switch (arrowhead) {
-    case "bar":
-      return 90;
-    case "arrow":
-      return 20;
-    default:
-      return 25;
-  }
-};
-var getArrowheadPoints = (element, shape, position, arrowhead, offsetMultiplier = 0) => {
-  if (arrowhead === null) {
-    return null;
-  }
-  if (shape.length < 1) {
-    return null;
-  }
-  const ops = getCurvePathOps(shape[0]);
-  if (ops.length < 1) {
-    return null;
-  }
-  const index = position === "start" ? 1 : ops.length - 1;
-  const data = ops[index].data;
-  invariant12(data.length === 6, "Op data length is not 6");
-  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 = pointFrom13(0, 0);
-  if (prevOp.op === "move") {
-    const p = pointFromArray3(prevOp.data);
-    invariant12(p != null, "Op data is not a point");
-    p0 = p;
-  } else if (prevOp.op === "bcurveTo") {
-    p0 = pointFrom13(prevOp.data[4], prevOp.data[5]);
-  }
-  const equation = (t2, idx) => Math.pow(1 - t2, 3) * p3[idx] + 3 * t2 * Math.pow(1 - t2, 2) * p2[idx] + 3 * Math.pow(t2, 2) * (1 - t2) * p1[idx] + p0[idx] * Math.pow(t2, 3);
-  const [x2, y2] = position === "start" ? p0 : p3;
-  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
-  const distance3 = Math.hypot(x2 - x1, y2 - y1);
-  const nx = (x2 - x1) / distance3;
-  const ny = (y2 - y1) / distance3;
-  const size = getArrowheadSize(arrowhead);
-  let length = 0;
-  {
-    const [cx, cy] = position === "end" ? element.points[element.points.length - 1] : element.points[0];
-    const [px, py] = element.points.length > 1 ? position === "end" ? element.points[element.points.length - 2] : element.points[1] : [0, 0];
-    length = Math.hypot(cx - px, cy - py);
-  }
-  const lengthMultiplier = arrowhead === "diamond" || arrowhead === "diamond_outline" ? 0.25 : 0.5;
-  const minSize = Math.min(size, length * lengthMultiplier);
-  const tx = x2 - nx * minSize * offsetMultiplier;
-  const ty = y2 - ny * minSize * offsetMultiplier;
-  const xs = tx - nx * minSize;
-  const ys = ty - ny * minSize;
-  if (arrowhead === "circle" || arrowhead === "circle_outline") {
-    const diameter = Math.hypot(ys - ty, xs - tx) + element.strokeWidth - 2;
-    return [tx, ty, diameter];
-  }
-  const angle = getArrowheadAngle(arrowhead);
-  if (arrowhead === "cardinality_many" || arrowhead === "cardinality_one_or_many") {
-    const [x32, y32] = pointRotateRads10(
-      pointFrom13(tx, ty),
-      pointFrom13(xs, ys),
-      degreesToRadians(-angle)
-    );
-    const [x42, y42] = pointRotateRads10(
-      pointFrom13(tx, ty),
-      pointFrom13(xs, ys),
-      degreesToRadians(angle)
-    );
-    return [xs, ys, x32, y32, x42, y42];
-  }
-  const [x3, y3] = pointRotateRads10(
-    pointFrom13(xs, ys),
-    pointFrom13(tx, ty),
-    -angle * Math.PI / 180
-  );
-  const [x4, y4] = pointRotateRads10(
-    pointFrom13(xs, ys),
-    pointFrom13(tx, ty),
-    degreesToRadians(angle)
-  );
-  if (arrowhead === "diamond" || arrowhead === "diamond_outline") {
-    let ox;
-    let oy;
-    if (position === "start") {
-      const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];
-      [ox, oy] = pointRotateRads10(
-        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] = pointRotateRads10(
-        pointFrom13(tx - minSize * 2, ty),
-        pointFrom13(tx, ty),
-        Math.atan2(ty - py, tx - px)
-      );
-    }
-    return [tx, ty, x3, y3, ox, oy, x4, y4];
-  }
-  return [tx, ty, x3, y3, x4, y4];
-};
+// ../element/src/zindex.ts
+import { arrayToMap as arrayToMap22, findIndex, findLastIndex } from "@excalidraw/common";
 
-// ../element/src/cropElement.ts
-import {
-  pointFrom as pointFrom14,
-  pointCenter as pointCenter2,
-  pointRotateRads as pointRotateRads11,
-  vectorFromPoint as vectorFromPoint8,
-  vectorNormalize as vectorNormalize4,
-  vectorSubtract,
-  vectorAdd as vectorAdd2,
-  vectorScale as vectorScale7,
-  pointFromVector as pointFromVector6,
-  clamp as clamp4,
-  isCloseTo
-} from "@excalidraw/math";
+// ../element/src/selection.ts
+import { arrayToMap as arrayToMap20, isShallowEqual as isShallowEqual2 } from "@excalidraw/common";
 
 // ../element/src/frame.ts
-import { arrayToMap as arrayToMap21 } from "@excalidraw/common";
-import { isPointWithinBounds as isPointWithinBounds2, pointFrom as pointFrom16 } from "@excalidraw/math";
+import { arrayToMap as arrayToMap19 } from "@excalidraw/common";
+import { isPointWithinBounds as isPointWithinBounds2, pointFrom as pointFrom13 } from "@excalidraw/math";
 
 // ../utils/src/bbox.ts
 import {
   vectorCross as vectorCross3,
-  vectorFromPoint as vectorFromPoint9
+  vectorFromPoint as vectorFromPoint7
 } from "@excalidraw/math";
 
 // ../utils/src/withinBounds.ts
-import { arrayToMap as arrayToMap19 } from "@excalidraw/common";
+import { arrayToMap as arrayToMap18 } from "@excalidraw/common";
 import { getElementBounds as getElementBounds2 } from "@excalidraw/element";
 import {
   isArrowElement as isArrowElement8,
@@ -19144,24 +19018,24 @@ import {
 } from "@excalidraw/element";
 import {
   rangeIncludesValue,
-  pointFrom as pointFrom15,
-  pointRotateRads as pointRotateRads12,
+  pointFrom as pointFrom12,
+  pointRotateRads as pointRotateRads9,
   rangeInclusive
 } from "@excalidraw/math";
 var getNonLinearElementRelativePoints = (element) => {
   if (element.type === "diamond") {
     return [
-      pointFrom15(element.width / 2, 0),
-      pointFrom15(element.width, element.height / 2),
-      pointFrom15(element.width / 2, element.height),
-      pointFrom15(0, element.height / 2)
+      pointFrom12(element.width / 2, 0),
+      pointFrom12(element.width, element.height / 2),
+      pointFrom12(element.width / 2, element.height),
+      pointFrom12(0, element.height / 2)
     ];
   }
   return [
-    pointFrom15(0, 0),
-    pointFrom15(0 + element.width, 0),
-    pointFrom15(0 + element.width, element.height),
-    pointFrom15(0, element.height)
+    pointFrom12(0, 0),
+    pointFrom12(0 + element.width, 0),
+    pointFrom12(0 + element.width, element.height),
+    pointFrom12(0, element.height)
   ];
 };
 var getElementRelativePoints = (element) => {
@@ -19195,9 +19069,9 @@ var getMinMaxPoints = (points) => {
 var getRotatedBBox = (element) => {
   const points = getElementRelativePoints(element);
   const { cx, cy } = getMinMaxPoints(points);
-  const centerPoint = pointFrom15(cx, cy);
+  const centerPoint = pointFrom12(cx, cy);
   const rotatedPoints = points.map(
-    (p) => pointRotateRads12(p, centerPoint, element.angle)
+    (p) => pointRotateRads9(p, centerPoint, element.angle)
   );
   const { minX, minY, maxX, maxY } = getMinMaxPoints(rotatedPoints);
   return [
@@ -19235,7 +19109,7 @@ var elementsOverlappingBBox = ({
   errorMargin = 0
 }) => {
   if (isExcalidrawElement2(bounds)) {
-    bounds = getElementBounds2(bounds, arrayToMap19(elements));
+    bounds = getElementBounds2(bounds, arrayToMap18(elements));
   }
   const adjustedBBox = [
     bounds[0] - errorMargin,
@@ -19272,8 +19146,75 @@ var elementsOverlappingBBox = ({
   return elements.filter((element) => includedElementSet.has(element.id));
 };
 
+// ../element/src/frame.ts
+var getFrameChildren2 = (allElements, frameId) => {
+  const frameChildren = [];
+  for (const element of allElements.values()) {
+    if (element.frameId === frameId) {
+      frameChildren.push(element);
+    }
+  }
+  return frameChildren;
+};
+
 // ../element/src/selection.ts
-import { arrayToMap as arrayToMap20, isShallowEqual as isShallowEqual3 } from "@excalidraw/common";
+var isSomeElementSelected2 = function() {
+  let lastElements = null;
+  let lastSelectedElementIds = null;
+  let isSelected = null;
+  const ret = (elements, appState) => {
+    if (isSelected != null && elements === lastElements && appState.selectedElementIds === lastSelectedElementIds) {
+      return isSelected;
+    }
+    isSelected = elements.some(
+      (element) => appState.selectedElementIds[element.id]
+    );
+    lastElements = elements;
+    lastSelectedElementIds = appState.selectedElementIds;
+    return isSelected;
+  };
+  ret.clearCache = () => {
+    lastElements = null;
+    lastSelectedElementIds = null;
+    isSelected = null;
+  };
+  return ret;
+}();
+var getSelectedElements3 = (elements, appState, opts) => {
+  const addedElements = /* @__PURE__ */ new Set();
+  const selectedElements = [];
+  for (const element of elements.values()) {
+    if (appState.selectedElementIds[element.id]) {
+      selectedElements.push(element);
+      addedElements.add(element.id);
+      continue;
+    }
+    if (opts?.includeBoundTextElement && isBoundToContainer5(element) && appState.selectedElementIds[element?.containerId]) {
+      selectedElements.push(element);
+      addedElements.add(element.id);
+      continue;
+    }
+  }
+  if (opts?.includeElementsInFrames) {
+    const elementsToInclude = [];
+    selectedElements.forEach((element) => {
+      if (isFrameLikeElement7(element)) {
+        getFrameChildren2(elements, element.id).forEach(
+          (e) => !addedElements.has(e.id) && elementsToInclude.push(e)
+        );
+      }
+      elementsToInclude.push(element);
+    });
+    return elementsToInclude;
+  }
+  return selectedElements;
+};
+var makeNextSelectedElementIds = (nextSelectedElementIds, prevState) => {
+  if (isShallowEqual2(prevState.selectedElementIds, nextSelectedElementIds)) {
+    return prevState.selectedElementIds;
+  }
+  return nextSelectedElementIds;
+};
 
 // ../element/src/groups.ts
 var selectGroupsForSelectedElements4 = function() {
@@ -19365,76 +19306,164 @@ var selectGroupsForSelectedElements4 = function() {
   return selectGroupsForSelectedElements7;
 }();
 
-// ../element/src/selection.ts
-var isSomeElementSelected2 = function() {
-  let lastElements = null;
-  let lastSelectedElementIds = null;
-  let isSelected = null;
-  const ret = (elements, appState) => {
-    if (isSelected != null && elements === lastElements && appState.selectedElementIds === lastSelectedElementIds) {
-      return isSelected;
-    }
-    isSelected = elements.some(
-      (element) => appState.selectedElementIds[element.id]
-    );
-    lastElements = elements;
-    lastSelectedElementIds = appState.selectedElementIds;
-    return isSelected;
-  };
-  ret.clearCache = () => {
-    lastElements = null;
-    lastSelectedElementIds = null;
-    isSelected = null;
-  };
-  return ret;
-}();
-var getSelectedElements3 = (elements, appState, opts) => {
-  const addedElements = /* @__PURE__ */ new Set();
-  const selectedElements = [];
-  for (const element of elements.values()) {
-    if (appState.selectedElementIds[element.id]) {
-      selectedElements.push(element);
-      addedElements.add(element.id);
-      continue;
-    }
-    if (opts?.includeBoundTextElement && isBoundToContainer5(element) && appState.selectedElementIds[element?.containerId]) {
-      selectedElements.push(element);
-      addedElements.add(element.id);
-      continue;
-    }
-  }
-  if (opts?.includeElementsInFrames) {
-    const elementsToInclude = [];
-    selectedElements.forEach((element) => {
-      if (isFrameLikeElement7(element)) {
-        getFrameChildren2(elements, element.id).forEach(
-          (e) => !addedElements.has(e.id) && elementsToInclude.push(e)
-        );
-      }
-      elementsToInclude.push(element);
-    });
-    return elementsToInclude;
+// ../element/src/fractionalIndex.ts
+import { generateNKeysBetween } from "fractional-indexing";
+import { arrayToMap as arrayToMap21 } from "@excalidraw/common";
+
+// ../element/src/bounds.ts
+var getDiamondPoints = (element) => {
+  const topX = Math.floor(element.width / 2) + 1;
+  const topY = 0;
+  const rightX = element.width;
+  const rightY = Math.floor(element.height / 2) + 1;
+  const bottomX = topX;
+  const bottomY = element.height;
+  const leftX = 0;
+  const leftY = rightY;
+  return [topX, topY, rightX, rightY, bottomX, bottomY, leftX, leftY];
+};
+var CARDINALITY_MARKER_SIZE = 20;
+var CROWFOOT_ARROWHEAD_SIZE = 15;
+var getArrowheadSize = (arrowhead) => {
+  switch (arrowhead) {
+    case "arrow":
+      return 25;
+    case "diamond":
+    case "diamond_outline":
+      return 12;
+    case "cardinality_many":
+    case "cardinality_one_or_many":
+    case "cardinality_zero_or_many":
+      return CROWFOOT_ARROWHEAD_SIZE;
+    case "cardinality_one":
+    case "cardinality_exactly_one":
+    case "cardinality_zero_or_one":
+      return CARDINALITY_MARKER_SIZE;
+    default:
+      return 15;
   }
-  return selectedElements;
 };
-var makeNextSelectedElementIds = (nextSelectedElementIds, prevState) => {
-  if (isShallowEqual3(prevState.selectedElementIds, nextSelectedElementIds)) {
-    return prevState.selectedElementIds;
+var getArrowheadAngle = (arrowhead) => {
+  switch (arrowhead) {
+    case "bar":
+      return 90;
+    case "arrow":
+      return 20;
+    default:
+      return 25;
   }
-  return nextSelectedElementIds;
 };
-
-// ../element/src/frame.ts
-var getFrameChildren2 = (allElements, frameId) => {
-  const frameChildren = [];
-  for (const element of allElements.values()) {
-    if (element.frameId === frameId) {
-      frameChildren.push(element);
+var getArrowheadPoints = (element, shape, position, arrowhead, offsetMultiplier = 0) => {
+  if (arrowhead === null) {
+    return null;
+  }
+  if (shape.length < 1) {
+    return null;
+  }
+  const ops = getCurvePathOps(shape[0]);
+  if (ops.length < 1) {
+    return null;
+  }
+  const index = position === "start" ? 1 : ops.length - 1;
+  const data = ops[index].data;
+  invariant12(data.length === 6, "Op data length is not 6");
+  const p3 = pointFrom15(data[4], data[5]);
+  const p2 = pointFrom15(data[2], data[3]);
+  const p1 = pointFrom15(data[0], data[1]);
+  const prevOp = ops[index - 1];
+  let p0 = pointFrom15(0, 0);
+  if (prevOp.op === "move") {
+    const p = pointFromArray3(prevOp.data);
+    invariant12(p != null, "Op data is not a point");
+    p0 = p;
+  } else if (prevOp.op === "bcurveTo") {
+    p0 = pointFrom15(prevOp.data[4], prevOp.data[5]);
+  }
+  const equation = (t2, idx) => Math.pow(1 - t2, 3) * p3[idx] + 3 * t2 * Math.pow(1 - t2, 2) * p2[idx] + 3 * Math.pow(t2, 2) * (1 - t2) * p1[idx] + p0[idx] * Math.pow(t2, 3);
+  const [x2, y2] = position === "start" ? p0 : p3;
+  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
+  const distance3 = Math.hypot(x2 - x1, y2 - y1);
+  const nx = (x2 - x1) / distance3;
+  const ny = (y2 - y1) / distance3;
+  const size = getArrowheadSize(arrowhead);
+  let length = 0;
+  {
+    const [cx, cy] = position === "end" ? element.points[element.points.length - 1] : element.points[0];
+    const [px, py] = element.points.length > 1 ? position === "end" ? element.points[element.points.length - 2] : element.points[1] : [0, 0];
+    length = Math.hypot(cx - px, cy - py);
+  }
+  const lengthMultiplier = arrowhead === "diamond" || arrowhead === "diamond_outline" ? 0.25 : 0.5;
+  const minSize = Math.min(size, length * lengthMultiplier);
+  const tx = x2 - nx * minSize * offsetMultiplier;
+  const ty = y2 - ny * minSize * offsetMultiplier;
+  const xs = tx - nx * minSize;
+  const ys = ty - ny * minSize;
+  if (arrowhead === "circle" || arrowhead === "circle_outline") {
+    const diameter = Math.hypot(ys - ty, xs - tx) + element.strokeWidth - 2;
+    return [tx, ty, diameter];
+  }
+  const angle = getArrowheadAngle(arrowhead);
+  if (arrowhead === "cardinality_many" || arrowhead === "cardinality_one_or_many") {
+    const [x32, y32] = pointRotateRads11(
+      pointFrom15(tx, ty),
+      pointFrom15(xs, ys),
+      degreesToRadians(-angle)
+    );
+    const [x42, y42] = pointRotateRads11(
+      pointFrom15(tx, ty),
+      pointFrom15(xs, ys),
+      degreesToRadians(angle)
+    );
+    return [xs, ys, x32, y32, x42, y42];
+  }
+  const [x3, y3] = pointRotateRads11(
+    pointFrom15(xs, ys),
+    pointFrom15(tx, ty),
+    -angle * Math.PI / 180
+  );
+  const [x4, y4] = pointRotateRads11(
+    pointFrom15(xs, ys),
+    pointFrom15(tx, ty),
+    degreesToRadians(angle)
+  );
+  if (arrowhead === "diamond" || arrowhead === "diamond_outline") {
+    let ox;
+    let oy;
+    if (position === "start") {
+      const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];
+      [ox, oy] = pointRotateRads11(
+        pointFrom15(tx + minSize * 2, ty),
+        pointFrom15(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] = pointRotateRads11(
+        pointFrom15(tx - minSize * 2, ty),
+        pointFrom15(tx, ty),
+        Math.atan2(ty - py, tx - px)
+      );
     }
+    return [tx, ty, x3, y3, ox, oy, x4, y4];
   }
-  return frameChildren;
+  return [tx, ty, x3, y3, x4, y4];
 };
 
+// ../element/src/cropElement.ts
+import {
+  pointFrom as pointFrom16,
+  pointCenter as pointCenter2,
+  pointRotateRads as pointRotateRads12,
+  vectorFromPoint as vectorFromPoint9,
+  vectorNormalize as vectorNormalize4,
+  vectorSubtract,
+  vectorAdd as vectorAdd2,
+  vectorScale as vectorScale7,
+  pointFromVector as pointFromVector6,
+  clamp as clamp4,
+  isCloseTo
+} from "@excalidraw/math";
+
 // ../element/src/renderElement.ts
 var IMAGE_PLACEHOLDER_IMG = typeof document !== "undefined" ? document.createElement("img") : { src: "" };
 IMAGE_PLACEHOLDER_IMG.src = `data:${MIME_TYPES7.svg},${encodeURIComponent(
@@ -20207,7 +20236,7 @@ var actionTogglePolygon = register({
     }
     const targetElements = selectedElements;
     const nextPolygonState = targetElements.some((element) => !element.polygon);
-    const targetElementsMap = arrayToMap22(targetElements);
+    const targetElementsMap = arrayToMap24(targetElements);
     return {
       elements: elements.map((element) => {
         if (!targetElementsMap.has(element.id) || !isLineElement4(element)) {
@@ -20523,7 +20552,7 @@ import {
   isWindows,
   KEYS as KEYS40,
   matchKey as matchKey2,
-  arrayToMap as arrayToMap23,
+  arrayToMap as arrayToMap25,
   MOBILE_ACTION_BUTTON_BG as MOBILE_ACTION_BUTTON_BG4
 } from "@excalidraw/common";
 import { CaptureUpdateAction as CaptureUpdateAction38 } from "@excalidraw/element";
@@ -20750,7 +20779,7 @@ var createUndoAction = (history) => ({
   perform: (elements, appState, value, app) => executeHistoryAction(
     app,
     appState,
-    () => history.undo(arrayToMap23(elements), appState)
+    () => history.undo(arrayToMap25(elements), appState)
   ),
   keyTest: (event) => event[KEYS40.CTRL_OR_CMD] && matchKey2(event, KEYS40.Z) && !event.shiftKey,
   PanelComponent: ({ appState, updateData, data, app }) => {
@@ -20788,7 +20817,7 @@ var createRedoAction = (history) => ({
   perform: (elements, appState, __, app) => executeHistoryAction(
     app,
     appState,
-    () => history.redo(arrayToMap23(elements), appState)
+    () => history.redo(arrayToMap25(elements), appState)
   ),
   keyTest: (event) => event[KEYS40.CTRL_OR_CMD] && event.shiftKey && matchKey2(event, KEYS40.Z) || isWindows && event.ctrlKey && !event.shiftKey && matchKey2(event, KEYS40.Y),
   PanelComponent: ({ appState, updateData, data, app }) => {
@@ -22513,7 +22542,7 @@ import {
   updateBoundElements as updateBoundElements2,
   updateOriginalContainerCache as updateOriginalContainerCache3
 } from "@excalidraw/element";
-import { LinearElementEditor as LinearElementEditor8 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor8 } from "@excalidraw/element/linearElementEditor";
 import { bumpVersion as bumpVersion2 } from "@excalidraw/element";
 import {
   getBoundTextElementId,
@@ -23283,7 +23312,7 @@ import {
   pointFrom as pointFrom22
 } from "@excalidraw/math";
 import { getElementLineSegments as getElementLineSegments2 } from "@excalidraw/element";
-import { LinearElementEditor as LinearElementEditor9 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor9 } from "@excalidraw/element/linearElementEditor";
 import {
   isFrameLikeElement as isFrameLikeElement9,
   isLinearElement as isLinearElement9,
@@ -23292,7 +23321,7 @@ import {
 import { getFrameChildren as getFrameChildren4 } from "@excalidraw/element";
 import { selectGroupsForSelectedElements as selectGroupsForSelectedElements5 } from "@excalidraw/element";
 import { getContainerElement as getContainerElement4 } from "@excalidraw/element";
-import { arrayToMap as arrayToMap24, easeOut as easeOut2, isShallowEqual as isShallowEqual4 } from "@excalidraw/common";
+import { arrayToMap as arrayToMap26, easeOut as easeOut2, isShallowEqual as isShallowEqual4 } from "@excalidraw/common";
 
 // lasso/utils.ts
 import { simplify as simplify2 } from "points-on-curve";
@@ -23488,7 +23517,7 @@ var LassoTrail = class extends AnimatedTrail {
       if (!this.elementsSegments || !isShallowEqual4(currentCanvasTranslate, this.canvasTranslate ?? {})) {
         this.canvasTranslate = currentCanvasTranslate;
         this.elementsSegments = /* @__PURE__ */ new Map();
-        const visibleElementsMap = arrayToMap24(this.app.visibleElements);
+        const visibleElementsMap = arrayToMap26(this.app.visibleElements);
         for (const element of this.app.visibleElements) {
           const segments = getElementLineSegments2(element, visibleElementsMap);
           this.elementsSegments.set(element.id, segments);
@@ -23533,6 +23562,7 @@ var LassoTrail = class extends AnimatedTrail {
 
 // actions/actionSmartZoom.tsx
 import { KEYS as KEYS43 } from "@excalidraw/common";
+import { CaptureUpdateAction as CaptureUpdateAction40 } from "@excalidraw/element/store";
 import { jsx as jsx86 } from "react/jsx-runtime";
 var actionSmartZoom = register({
   name: "smartZoom",
@@ -23541,12 +23571,10 @@ var actionSmartZoom = register({
   icon: arrowsToEyeIcon,
   viewMode: true,
   perform: (elements, appState, _, app) => {
-    const settings = {
-      fitToViewport: true,
-      animate: true,
-      duration: 200,
-      viewportZoomFactor: 0.8
-    };
+    const settings = getEffectiveEditorPreferences(
+      appState,
+      app.props.editorPreferences
+    ).smartZoom;
     const selectedElements = getSelectedElements(elements, appState);
     if (selectedElements.length < 1) {
       app.scrollToContent(elements, settings);
@@ -23573,7 +23601,7 @@ var actionSmartZoom = register({
 });
 
 // eraser/index.ts
-import { arrayToMap as arrayToMap25, easeOut as easeOut3, THEME as THEME12 } from "@excalidraw/common";
+import { arrayToMap as arrayToMap27, easeOut as easeOut3, THEME as THEME12 } from "@excalidraw/common";
 import {
   computeBoundTextPosition as computeBoundTextPosition4,
   doBoundsIntersect as doBoundsIntersect3,
@@ -23642,7 +23670,7 @@ var EraserTrail = class extends AnimatedTrail {
     const candidateElements = this.app.visibleElements.filter(
       (el) => !el.locked
     );
-    const candidateElementsMap = arrayToMap25(candidateElements);
+    const candidateElementsMap = arrayToMap27(candidateElements);
     for (const element of candidateElements) {
       if (restoreToErase && this.elementsToErase.has(element.id)) {
         const intersects = eraserTest(
@@ -25116,7 +25144,7 @@ import {
   CLASSES as CLASSES10,
   DEFAULT_SIDEBAR as DEFAULT_SIDEBAR6,
   TOOL_TYPE as TOOL_TYPE2,
-  arrayToMap as arrayToMap26,
+  arrayToMap as arrayToMap28,
   capitalizeString as capitalizeString5,
   isShallowEqual as isShallowEqual6
 } from "@excalidraw/common";
@@ -32200,7 +32228,7 @@ var LayerUI = ({
           }
           if (selectedElements.length) {
             for (const element of selectedElements) {
-              mutateElement5(element, arrayToMap26(elements), {
+              mutateElement5(element, arrayToMap28(elements), {
                 [altKey && eyeDropperState.swapPreviewOnAlt ? colorPickerType === "elementBackground" ? "strokeColor" : "backgroundColor" : colorPickerType === "elementBackground" ? "backgroundColor" : "strokeColor"]: color
               });
               ShapeCache3.delete(element);
@@ -32421,7 +32449,7 @@ import {
   pointDistance as pointDistance8
 } from "@excalidraw/math";
 import {
-  arrayToMap as arrayToMap27,
+  arrayToMap as arrayToMap29,
   BIND_MODE_TIMEOUT,
   DEFAULT_TRANSFORM_HANDLE_SPACING as DEFAULT_TRANSFORM_HANDLE_SPACING2,
   FRAME_STYLE as FRAME_STYLE3,
@@ -32449,9 +32477,9 @@ import {
   isLineElement as isLineElement7,
   maxBindingDistance_simple as maxBindingDistance_simple2,
   isTextElement as isTextElement18,
-  LinearElementEditor as LinearElementEditor10,
   getActiveTextElement
 } from "@excalidraw/element";
+import { LinearElementEditor as LinearElementEditor10 } from "@excalidraw/element/linearElementEditor";
 import { renderSelectionElement } from "@excalidraw/element";
 import {
   getElementsInGroup as getElementsInGroup7,
@@ -33800,7 +33828,7 @@ var _renderInteractiveScene = ({
     }
     const selectionColor = renderConfig.selectionColor || "#000";
     if (showBoundingBox) {
-      const locallySelectedIds = arrayToMap27(selectedElements);
+      const locallySelectedIds = arrayToMap29(selectedElements);
       const selections = [];
       for (const element of elementsMap.values()) {
         const selectionColors = [];
@@ -34582,9 +34610,6 @@ var AppStateObserver = class {
   }
 };
 
-// components/App.tsx
-import { findShapeByKey } from "@excalidraw/element/shapes";
-
 // components/UnlockPopup.tsx
 import {
   getCommonBounds as getCommonBounds10,
@@ -34710,35 +34735,6 @@ var YOUTUBE_VIDEO_STATES = /* @__PURE__ */ new Map();
 var IS_PLAIN_PASTE = false;
 var IS_PLAIN_PASTE_TIMER = 0;
 var PLAIN_PASTE_TOAST_SHOWN = false;
-var MERMAID_TO_EXCALIDRAW_MODULE = "@excalidraw/mermaid-to-excalidraw";
-var MERMAID_DEFINITION_PREFIXES = [
-  "flowchart",
-  "graph",
-  "sequenceDiagram",
-  "classDiagram",
-  "stateDiagram",
-  "erDiagram",
-  "journey",
-  "gantt",
-  "pie",
-  "mindmap",
-  "timeline",
-  "gitGraph",
-  "quadrantChart",
-  "xychart-beta",
-  "C4Context",
-  "C4Container",
-  "C4Component",
-  "C4Dynamic",
-  "C4Deployment",
-  "requirementDiagram"
-];
-var isMaybeMermaidDefinition = (text) => {
-  const trimmedText = text.trimStart();
-  return MERMAID_DEFINITION_PREFIXES.some(
-    (prefix) => trimmedText.startsWith(prefix)
-  );
-};
 var lastPointerUp = null;
 var gesture = {
   pointers: /* @__PURE__ */ new Map(),
@@ -35671,7 +35667,7 @@ var App = class _App extends React44.Component {
         prevElements
       );
       nextElements = mappedNewSceneElements || nextElements;
-      syncMovedIndices4(nextElements, arrayToMap28(duplicatedElements));
+      syncMovedIndices5(nextElements, arrayToMap30(duplicatedElements));
       const topLayerFrame = this.getTopLayerFrameAtSceneCoords({ x, y });
       if (topLayerFrame) {
         const eligibleElements = filterElementsEligibleAsFrameChildren(
@@ -35816,6 +35812,63 @@ var App = class _App extends React44.Component {
       });
     });
     __publicField(this, "cancelInProgressAnimation", null);
+    __publicField(this, "scrollToViewport", (target, opts) => {
+      this.cancelInProgressAnimation?.();
+      const zoom = { value: getNormalizedZoom(target.zoom) };
+      const animateDuration = opts?.duration ?? 500;
+      if (opts?.animate && animateDuration > 0) {
+        const origScrollX = this.state.scrollX;
+        const origScrollY = this.state.scrollY;
+        const origZoom = this.state.zoom.value;
+        const cancel = easeToValuesRAF({
+          fromValues: {
+            scrollX: origScrollX,
+            scrollY: origScrollY,
+            zoom: origZoom
+          },
+          toValues: {
+            scrollX: target.scrollX,
+            scrollY: target.scrollY,
+            zoom: zoom.value
+          },
+          interpolateValue: (from, to, progress, key) => {
+            if (key === "zoom") {
+              return from * Math.pow(to / from, easeOut4(progress));
+            }
+            return void 0;
+          },
+          onStep: ({ scrollX, scrollY, zoom: zoom2 }) => {
+            this.setState({
+              scrollX,
+              scrollY,
+              zoom: { value: zoom2 }
+            });
+          },
+          onStart: () => {
+            this.setState({ shouldCacheIgnoreZoom: true });
+          },
+          onEnd: () => {
+            this.cancelInProgressAnimation = null;
+            this.setState({ shouldCacheIgnoreZoom: false });
+          },
+          onCancel: () => {
+            this.cancelInProgressAnimation = null;
+            this.setState({ shouldCacheIgnoreZoom: false });
+          },
+          duration: animateDuration
+        });
+        this.cancelInProgressAnimation = () => {
+          cancel();
+          this.cancelInProgressAnimation = null;
+        };
+      } else {
+        this.setState({
+          scrollX: target.scrollX,
+          scrollY: target.scrollY,
+          zoom
+        });
+      }
+    });
     __publicField(this, "scrollToContent", (target = this.scene.getNonDeletedElements(), opts) => {
       if (typeof target === "string") {
         let id;
@@ -35843,7 +35896,6 @@ var App = class _App extends React44.Component {
         }
         return;
       }
-      this.cancelInProgressAnimation?.();
       const targetElements = Array.isArray(target) ? target : [target];
       let zoom = this.state.zoom;
       let scrollX = this.state.scrollX;
@@ -35866,48 +35918,17 @@ var App = class _App extends React44.Component {
         scrollX = scroll.scrollX;
         scrollY = scroll.scrollY;
       }
-      if (opts?.animate) {
-        const origScrollX = this.state.scrollX;
-        const origScrollY = this.state.scrollY;
-        const origZoom = this.state.zoom.value;
-        const cancel = easeToValuesRAF({
-          fromValues: {
-            scrollX: origScrollX,
-            scrollY: origScrollY,
-            zoom: origZoom
-          },
-          toValues: { scrollX, scrollY, zoom: zoom.value },
-          interpolateValue: (from, to, progress, key) => {
-            if (key === "zoom") {
-              return from * Math.pow(to / from, easeOut4(progress));
-            }
-            return void 0;
-          },
-          onStep: ({ scrollX: scrollX2, scrollY: scrollY2, zoom: zoom2 }) => {
-            this.setState({
-              scrollX: scrollX2,
-              scrollY: scrollY2,
-              zoom: { value: zoom2 }
-            });
-          },
-          onStart: () => {
-            this.setState({ shouldCacheIgnoreZoom: true });
-          },
-          onEnd: () => {
-            this.setState({ shouldCacheIgnoreZoom: false });
-          },
-          onCancel: () => {
-            this.setState({ shouldCacheIgnoreZoom: false });
-          },
-          duration: opts?.duration ?? 500
-        });
-        this.cancelInProgressAnimation = () => {
-          cancel();
-          this.cancelInProgressAnimation = null;
-        };
-      } else {
-        this.setState({ scrollX, scrollY, zoom });
-      }
+      this.scrollToViewport(
+        {
+          scrollX,
+          scrollY,
+          zoom: zoom.value
+        },
+        {
+          animate: opts?.animate,
+          duration: opts?.duration
+        }
+      );
     });
     __publicField(this, "maybeUnfollowRemoteUser", () => {
       if (this.state.userToFollow) {
@@ -37446,7 +37467,7 @@ var App = class _App extends React44.Component {
             }
           });
         } else {
-          if (isPathALoop4(points, this.state.zoom.value)) {
+          if (isPathALoop3(points, this.state.zoom.value)) {
             setCursor(this.interactiveCanvas, CURSOR_TYPE4.POINTER);
           }
           const elementsMap = this.scene.getNonDeletedElementsMap();
@@ -38629,7 +38650,7 @@ var App = class _App extends React44.Component {
           selectedLinearElement,
           "selectedLinearElement is expected to be set"
         );
-        if (multiElement.type === "line" && isPathALoop4(multiElement.points, this.state.zoom.value)) {
+        if (multiElement.type === "line" && isPathALoop3(multiElement.points, this.state.zoom.value)) {
           flushSync3(() => {
             this.setState({
               selectedLinearElement: {
@@ -39220,14 +39241,14 @@ var App = class _App extends React44.Component {
           }
         })
       );
-      const initializedMap = arrayToMap28(initialized);
+      const initializedMap = arrayToMap30(initialized);
       const positioned = positionElementsOnGrid(
         initialized.filter((el) => !el.isDeleted),
         sceneX,
         sceneY,
         gridPadding
       );
-      const positionedMap = arrayToMap28(positioned);
+      const positionedMap = arrayToMap30(positioned);
       const nextElements = this.scene.getElementsIncludingDeleted().map((el) => positionedMap.get(el.id) ?? initializedMap.get(el.id) ?? el);
       this.updateScene({
         appState: {
@@ -39964,6 +39985,7 @@ var App = class _App extends React44.Component {
       history: {
         clear: this.resetHistory
       },
+      scrollToViewport: this.scrollToViewport,
       scrollToContent: this.scrollToContent,
       getSceneElements: this.getSceneElements,
       getAppState: () => this.state,
@@ -40715,25 +40737,6 @@ var App = class _App extends React44.Component {
                               },
                               firstSelectedElement.id
                             ),
-                            !!this.plugins.diagramToCode && selectedElements.length === 1 && isMagicFrameElement2(firstSelectedElement) && /* @__PURE__ */ jsx147(
-                              ElementCanvasButtons,
-                              {
-                                element: firstSelectedElement,
-                                elementsMap,
-                                children: /* @__PURE__ */ jsx147(
-                                  ElementCanvasButton,
-                                  {
-                                    title: t("labels.convertToCode"),
-                                    icon: MagicIcon,
-                                    checked: false,
-                                    onChange: () => this.onMagicFrameGenerate(
-                                      firstSelectedElement,
-                                      "button"
-                                    )
-                                  }
-                                )
-                              }
-                            ),
                             selectedElements.length === 1 && isIframeElement2(firstSelectedElement) && firstSelectedElement.customData?.generationData?.status === "done" && /* @__PURE__ */ jsxs77(
                               ElementCanvasButtons,
                               {
@@ -41414,25 +41417,6 @@ var App = class _App extends React44.Component {
     if (!data.text) {
       return;
     }
-    if (!isPlainPaste && isMaybeMermaidDefinition(data.text)) {
-      try {
-        const api = await import(MERMAID_TO_EXCALIDRAW_MODULE);
-        const { elements: skeletonElements, files } = await api.parseMermaidToExcalidraw(data.text);
-        const elements = convertToExcalidrawElements([...skeletonElements], {
-          regenerateIds: true
-        });
-        this.addElementsFromPasteOrLibrary({
-          elements,
-          files,
-          position: this.editorInterface.formFactor === "desktop" ? "cursor" : "center"
-        });
-        return;
-      } catch (err) {
-        console.warn(
-          `parsing pasted text as mermaid definition failed: ${err.message}`
-        );
-      }
-    }
     const nonEmptyLines = normalizeEOL2(data.text).split(/\n+/).map((s) => s.trim()).filter(Boolean);
     const embbeddableUrls = nonEmptyLines.map((str) => maybeParseEmbedSrc(str)).filter(
       (string) => embeddableURLValidator2(string, this.props.validateEmbeddable) && (/^(http|https):\/\/[^\s/$.?#].[^\s]*$/.test(string) || getEmbedLink2(string)?.type === "video")
@@ -42539,9 +42523,9 @@ var App = class _App extends React44.Component {
               mappedClonedElements,
               elements
             );
-            const elementsWithIndices = syncMovedIndices4(
+            const elementsWithIndices = syncMovedIndices5(
               mappedNewSceneElements || mappedClonedElements,
-              arrayToMap28(duplicatedElements)
+              arrayToMap30(duplicatedElements)
             );
             flushSync3(() => {
               if (pointerDownState.hit.element) {
@@ -44007,7 +43991,7 @@ import { isInvisiblySmallElement as isInvisiblySmallElement4 } from "@excalidraw
 
 // data/reconcile.ts
 import throttle4 from "lodash.throttle";
-import { arrayToMap as arrayToMap29, isDevEnv as isDevEnv10, isTestEnv as isTestEnv6 } from "@excalidraw/common";
+import { arrayToMap as arrayToMap31, isDevEnv as isDevEnv10, isTestEnv as isTestEnv6 } from "@excalidraw/common";
 import {
   orderByFractionalIndex as orderByFractionalIndex2,
   syncInvalidIndices as syncInvalidIndices2,
@@ -44044,7 +44028,7 @@ var validateIndicesThrottled = throttle4(
   { leading: true, trailing: false }
 );
 var reconcileElements = (localElements, remoteElements, localAppState) => {
-  const localElementsMap = arrayToMap29(localElements);
+  const localElementsMap = arrayToMap31(localElements);
   const reconciledElements = [];
   const added = /* @__PURE__ */ new Set();
   for (const remoteElement of remoteElements) {
@@ -44096,7 +44080,7 @@ import {
   newElementWith as newElementWith11,
   bumpVersion as bumpVersion3
 } from "@excalidraw/element";
-import { CaptureUpdateAction as CaptureUpdateAction40 } from "@excalidraw/element";
+import { CaptureUpdateAction as CaptureUpdateAction43 } from "@excalidraw/element";
 import {
   getCommonBounds as getCommonBounds12,
   getVisibleSceneBounds as getVisibleSceneBounds2,
@@ -44148,6 +44132,8 @@ var ExcalidrawBase = (props) => {
     theme,
     name,
     renderCustomStats,
+    editorPreferences,
+    onEditorPreferencesChange,
     onPaste,
     detectScroll = true,
     handleKeyboardGlobally = false,
@@ -44236,6 +44222,8 @@ var ExcalidrawBase = (props) => {
       theme,
       name,
       renderCustomStats,
+      editorPreferences,
+      onEditorPreferencesChange,
       UIOptions,
       onPaste,
       detectScroll,
@@ -44305,7 +44293,7 @@ function useExcalidrawStateValue(selector) {
 }
 export {
   Button,
-  CaptureUpdateAction40 as CaptureUpdateAction,
+  CaptureUpdateAction43 as CaptureUpdateAction,
   CommandPalette,
   DEFAULT_LASER_COLOR2 as DEFAULT_LASER_COLOR,
   DefaultSidebar,