@myoc/excalidraw 0.19.521 → 0.19.522

package/dist/dev/{chunk-MN6E45MP.js → chunk-BCNQXIBK.js}

@@ -1,6 +1,6 @@
 import {
   define_import_meta_env_default
-} from "./chunk-P7I4FGOG.js";
+} from "./chunk-6T5HZJCI.js";
 import {
   __publicField
 } from "./chunk-XDFCUUT6.js";
@@ -116,6 +116,7 @@ var getDefaultAppState = () => {
     scrolledOutside: false,
     scrollX: 0,
     scrollY: 0,
+    scrollConstraints: null,
     selectedElementIds: {},
     hoveredElementIds: {},
     selectedGroupIds: {},
@@ -127,6 +128,7 @@ var getDefaultAppState = () => {
       panels: STATS_PANELS.generalStats | STATS_PANELS.elementProperties
     },
     suggestedBinding: null,
+    hoveredArrowTextAnchor: null,
     frameRendering: { enabled: true, clip: true, name: true, outline: true },
     frameToHighlight: null,
     editingFrame: null,
@@ -147,15 +149,18 @@ var getDefaultAppState = () => {
       y: 0
     },
     objectsSnapModeEnabled: false,
-    userToFollow: null,
-    followedBy: /* @__PURE__ */ new Set(),
     isCropping: false,
     croppingElementId: null,
     searchMatches: null,
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
-    boxSelectionMode: "contain"
+    boxSelectionMode: "contain",
+    colorTopPicks: {
+      elementStroke: null,
+      elementBackground: null,
+      bucketFill: null
+    }
   };
 };
 var APP_STATE_STORAGE_CONF = /* @__PURE__ */ ((config) => config)({
@@ -242,6 +247,7 @@ var APP_STATE_STORAGE_CONF = /* @__PURE__ */ ((config) => config)({
   scrolledOutside: { browser: true, export: false, server: false },
   scrollX: { browser: true, export: false, server: false },
   scrollY: { browser: true, export: false, server: false },
+  scrollConstraints: { browser: false, export: false, server: false },
   selectedElementIds: { browser: true, export: false, server: false },
   hoveredElementIds: { browser: false, export: false, server: false },
   selectedGroupIds: { browser: true, export: false, server: false },
@@ -254,6 +260,7 @@ var APP_STATE_STORAGE_CONF = /* @__PURE__ */ ((config) => config)({
   shouldCacheIgnoreZoom: { browser: true, export: false, server: false },
   stats: { browser: true, export: false, server: false },
   suggestedBinding: { browser: false, export: false, server: false },
+  hoveredArrowTextAnchor: { browser: false, export: false, server: false },
   frameRendering: { browser: false, export: false, server: false },
   frameToHighlight: { browser: false, export: false, server: false },
   editingFrame: { browser: false, export: false, server: false },
@@ -270,14 +277,13 @@ var APP_STATE_STORAGE_CONF = /* @__PURE__ */ ((config) => config)({
   snapLines: { browser: false, export: false, server: false },
   originSnapOffset: { browser: false, export: false, server: false },
   objectsSnapModeEnabled: { browser: true, export: false, server: false },
-  userToFollow: { browser: false, export: false, server: false },
-  followedBy: { browser: false, export: false, server: false },
   isCropping: { browser: false, export: false, server: false },
   croppingElementId: { browser: false, export: false, server: false },
   searchMatches: { browser: false, export: false, server: false },
   lockedMultiSelections: { browser: true, export: true, server: true },
   activeLockedId: { browser: false, export: false, server: false },
-  bindMode: { browser: true, export: false, server: false }
+  bindMode: { browser: true, export: false, server: false },
+  colorTopPicks: { browser: true, export: false, server: false }
 });
 var _clearAppStateForStorage = (appState, exportType) => {
   const stateForExport = {};
@@ -357,25 +363,202 @@ import {
   getTargetElements
 } from "@excalidraw/element";
 
-// scene/scroll.ts
-import { getVisibleElements } from "@excalidraw/element";
+// viewport.ts
 import {
-  sceneCoordsToViewportCoords,
-  viewportCoordsToSceneCoords
+  arrayToMap,
+  MAX_ZOOM,
+  MIN_ZOOM,
+  viewportCoordsToSceneCoords,
+  ZOOM_STEP
 } from "@excalidraw/common";
-import { getClosestElementBounds } from "@excalidraw/element";
-import { getCommonBounds } from "@excalidraw/element";
-var isOutsideViewPort = (appState, cords) => {
-  const [x1, y1, x2, y2] = cords;
-  const { x: viewportX1, y: viewportY1 } = sceneCoordsToViewportCoords(
-    { sceneX: x1, sceneY: y1 },
-    appState
+import { clamp, pointDistance, pointFrom, roundToStep } from "@excalidraw/math";
+import {
+  CaptureUpdateAction,
+  getCommonBounds,
+  getElementBounds,
+  getVisibleElements
+} from "@excalidraw/element";
+var DEFAULT_OVERSCROLL = 150;
+var constrainScrollAxis = (scroll, boxStart, boxSize, visibleSize, offsetStart, offsetEnd, overscroll) => {
+  const max = -boxStart + offsetStart;
+  const min = visibleSize - (boxStart + boxSize) - offsetEnd;
+  if (min > max) {
+    const center = (min + max) / 2;
+    return clamp(scroll, center - overscroll, center + overscroll);
+  }
+  return clamp(scroll, min - overscroll, max + overscroll);
+};
+var constrainScrollState = (state, overscroll = 0) => {
+  const { scrollConstraints, width, height } = state;
+  if (!scrollConstraints) {
+    return { scrollX: state.scrollX, scrollY: state.scrollY, zoom: state.zoom };
+  }
+  const minZoom = scrollConstraints.lockZoom ? scrollConstraints.zoom : MIN_ZOOM;
+  const zoomValue = getNormalizedZoom(
+    clamp(state.zoom.value, minZoom, MAX_ZOOM)
   );
-  const { x: viewportX2, y: viewportY2 } = sceneCoordsToViewportCoords(
-    { sceneX: x2, sceneY: y2 },
-    appState
+  if (!scrollConstraints.lockScroll) {
+    return {
+      scrollX: state.scrollX,
+      scrollY: state.scrollY,
+      zoom: { value: zoomValue }
+    };
+  }
+  const give = Math.max(overscroll, 0) / zoomValue;
+  const offsets = scrollConstraints.offsets;
+  const offsetTop = (offsets?.top ?? 0) / zoomValue;
+  const offsetRight = (offsets?.right ?? 0) / zoomValue;
+  const offsetBottom = (offsets?.bottom ?? 0) / zoomValue;
+  const offsetLeft = (offsets?.left ?? 0) / zoomValue;
+  return {
+    scrollX: constrainScrollAxis(
+      state.scrollX,
+      scrollConstraints.x,
+      scrollConstraints.width,
+      width / zoomValue,
+      offsetLeft,
+      offsetRight,
+      give
+    ),
+    scrollY: constrainScrollAxis(
+      state.scrollY,
+      scrollConstraints.y,
+      scrollConstraints.height,
+      height / zoomValue,
+      offsetTop,
+      offsetBottom,
+      give
+    ),
+    zoom: { value: zoomValue }
+  };
+};
+var getViewportForZoom = ({ viewportX, viewportY, nextZoom }, appState) => {
+  const appLayerX = viewportX - appState.offsetLeft;
+  const appLayerY = viewportY - appState.offsetTop;
+  const currentZoom = appState.zoom.value;
+  const baseScrollX = appState.scrollX + (appLayerX - appLayerX / currentZoom);
+  const baseScrollY = appState.scrollY + (appLayerY - appLayerY / currentZoom);
+  const zoomOffsetScrollX = -(appLayerX - appLayerX / nextZoom);
+  const zoomOffsetScrollY = -(appLayerY - appLayerY / nextZoom);
+  return {
+    scrollX: baseScrollX + zoomOffsetScrollX,
+    scrollY: baseScrollY + zoomOffsetScrollY,
+    zoom: {
+      value: nextZoom
+    }
+  };
+};
+var getViewportForZoomWithScrollConstraints = (opts, state) => {
+  const restingViewport = constrainScrollState(state);
+  const overscrollX = (state.scrollX - restingViewport.scrollX) * state.zoom.value;
+  const overscrollY = (state.scrollY - restingViewport.scrollY) * state.zoom.value;
+  const zoomedViewport = constrainScrollState({
+    ...state,
+    ...getViewportForZoom(opts, state)
+  });
+  if (!state.scrollConstraints?.lockScroll || !overscrollX && !overscrollY) {
+    return zoomedViewport;
+  }
+  const zoom = zoomedViewport.zoom.value;
+  return constrainScrollState(
+    {
+      ...state,
+      ...zoomedViewport,
+      scrollX: zoomedViewport.scrollX + overscrollX / zoom,
+      scrollY: zoomedViewport.scrollY + overscrollY / zoom
+    },
+    state.scrollConstraints.overscroll
   );
-  return viewportX2 - viewportX1 > appState.width || viewportY2 - viewportY1 > appState.height;
+};
+var zoomValueToFitBoundsOnViewport = (bounds, viewportDimensions) => {
+  const [x1, y1, x2, y2] = bounds;
+  const commonBoundsWidth = x2 - x1;
+  const zoomValueForWidth = viewportDimensions.width / commonBoundsWidth;
+  const commonBoundsHeight = y2 - y1;
+  const zoomValueForHeight = viewportDimensions.height / commonBoundsHeight;
+  const smallestZoomValue = Math.min(zoomValueForWidth, zoomValueForHeight);
+  return Math.min(smallestZoomValue, 1);
+};
+var zoomToFitBounds = ({
+  bounds,
+  appState,
+  canvasOffsets,
+  fit = "scale-down",
+  minZoom = -Infinity,
+  maxZoom = Infinity,
+  steppedZoom = false
+}) => {
+  const [x1, y1, x2, y2] = bounds;
+  const centerX = (x1 + x2) / 2;
+  const centerY = (y1 + y2) / 2;
+  const canvasOffsetLeft = canvasOffsets?.left ?? 0;
+  const canvasOffsetTop = canvasOffsets?.top ?? 0;
+  const canvasOffsetRight = canvasOffsets?.right ?? 0;
+  const canvasOffsetBottom = canvasOffsets?.bottom ?? 0;
+  const effectiveCanvasWidth = appState.width - canvasOffsetLeft - canvasOffsetRight;
+  const effectiveCanvasHeight = appState.height - canvasOffsetTop - canvasOffsetBottom;
+  let adjustedZoomValue;
+  if (fit === "none") {
+    adjustedZoomValue = appState.zoom.value;
+  } else if (fit === "contain") {
+    const commonBoundsWidth = x2 - x1;
+    const commonBoundsHeight = y2 - y1;
+    adjustedZoomValue = Math.min(
+      effectiveCanvasWidth / commonBoundsWidth,
+      effectiveCanvasHeight / commonBoundsHeight
+    );
+  } else {
+    adjustedZoomValue = zoomValueToFitBoundsOnViewport(bounds, {
+      width: effectiveCanvasWidth,
+      height: effectiveCanvasHeight
+    });
+  }
+  const targetZoomValue = steppedZoom && fit !== "none" ? roundToStep(adjustedZoomValue, ZOOM_STEP, "floor") : adjustedZoomValue;
+  const newZoomValue = getNormalizedZoom(
+    clamp(targetZoomValue, minZoom, maxZoom)
+  );
+  const centerScroll = centerScrollOn({
+    scenePoint: { x: centerX, y: centerY },
+    viewportDimensions: {
+      width: appState.width,
+      height: appState.height
+    },
+    offsets: canvasOffsets,
+    zoom: { value: newZoomValue }
+  });
+  return {
+    appState: {
+      ...appState,
+      scrollX: centerScroll.scrollX,
+      scrollY: centerScroll.scrollY,
+      zoom: { value: newZoomValue }
+    },
+    captureUpdate: CaptureUpdateAction.EVENTUALLY
+  };
+};
+var doBoundsExceedViewport = (appState, bounds) => {
+  const [x1, y1, x2, y2] = bounds;
+  return (x2 - x1) * appState.zoom.value > appState.width || (y2 - y1) * appState.zoom.value > appState.height;
+};
+var getClosestElementBounds = (elements, from) => {
+  if (!elements.length) {
+    return [0, 0, 0, 0];
+  }
+  let minDistance = Infinity;
+  let closestElement = elements[0];
+  const elementsMap = arrayToMap(elements);
+  elements.forEach((element) => {
+    const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
+    const distance2 = pointDistance(
+      pointFrom((x1 + x2) / 2, (y1 + y2) / 2),
+      pointFrom(from.x, from.y)
+    );
+    if (distance2 < minDistance) {
+      minDistance = distance2;
+      closestElement = element;
+    }
+  });
+  return getElementBounds(closestElement, elementsMap);
 };
 var centerScrollOn = ({
   scenePoint,
@@ -392,7 +575,7 @@ var centerScrollOn = ({
     scrollY
   };
 };
-var calculateScrollCenter = (elements, appState) => {
+var getScrollToContentState = (elements, appState) => {
   elements = getVisibleElements(elements);
   if (!elements.length) {
     return {
@@ -401,11 +584,14 @@ var calculateScrollCenter = (elements, appState) => {
     };
   }
   let [x1, y1, x2, y2] = getCommonBounds(elements);
-  if (isOutsideViewPort(appState, [x1, y1, x2, y2])) {
+  if (doBoundsExceedViewport(appState, [x1, y1, x2, y2])) {
     [x1, y1, x2, y2] = getClosestElementBounds(
       elements,
       viewportCoordsToSceneCoords(
-        { clientX: appState.scrollX, clientY: appState.scrollY },
+        {
+          clientX: appState.offsetLeft + appState.width / 2,
+          clientY: appState.offsetTop + appState.height / 2
+        },
         appState
       )
     );
@@ -430,16 +616,16 @@ import {
 } from "@excalidraw/element";
 
 // scene/normalize.ts
-import { MAX_ZOOM, MIN_ZOOM } from "@excalidraw/common";
-import { clamp, round } from "@excalidraw/math";
+import { MAX_ZOOM as MAX_ZOOM2, MIN_ZOOM as MIN_ZOOM2 } from "@excalidraw/common";
+import { clamp as clamp2, round } from "@excalidraw/math";
 var getNormalizedZoom = (zoom) => {
-  return clamp(round(zoom, 6), MIN_ZOOM, MAX_ZOOM);
+  return clamp2(round(zoom, 6), MIN_ZOOM2, MAX_ZOOM2);
 };
 var getNormalizedGridSize = (gridStep) => {
-  return clamp(Math.round(gridStep), 1, 100);
+  return clamp2(Math.round(gridStep), 1, 100);
 };
 var getNormalizedGridStep = (gridStep) => {
-  return clamp(Math.round(gridStep), 1, 100);
+  return clamp2(Math.round(gridStep), 1, 100);
 };
 
 // scene/export.ts
@@ -452,7 +638,7 @@ import {
   THEME as THEME5,
   MIME_TYPES as MIME_TYPES5,
   EXPORT_DATA_TYPES as EXPORT_DATA_TYPES2,
-  arrayToMap,
+  arrayToMap as arrayToMap2,
   distance,
   getFontString as getFontString2,
   toBrandedType,
@@ -3046,6 +3232,7 @@ var Fonts = _Fonts;
 // renderer/staticScene.ts
 import {
   applyDarkModeFilter as applyDarkModeFilter2,
+  COLOR_WHITE as COLOR_WHITE2,
   FRAME_STYLE,
   THEME as THEME3,
   throttleRAF
@@ -3067,7 +3254,7 @@ import { renderElement } from "@excalidraw/element";
 import { getElementAbsoluteCoords as getElementAbsoluteCoords2 } from "@excalidraw/element";
 
 // components/hyperlink/helpers.ts
-import { pointFrom, pointRotateRads } from "@excalidraw/math";
+import { pointFrom as pointFrom2, pointRotateRads } from "@excalidraw/math";
 import { MIME_TYPES as MIME_TYPES3 } from "@excalidraw/common";
 import { getElementAbsoluteCoords } from "@excalidraw/element";
 import { hitElementBoundingBox } from "@excalidraw/element";
@@ -3093,8 +3280,8 @@ var getLinkHandleFromCoords = ([x1, y1, x2, y2], angle, appState) => {
   const x = x2 + dashedLineMargin - centeringOffset;
   const y = y1 - dashedLineMargin - linkMarginY + centeringOffset;
   const [rotatedX, rotatedY] = pointRotateRads(
-    pointFrom(x + linkWidth / 2, y + linkHeight / 2),
-    pointFrom(centerX, centerY),
+    pointFrom2(x + linkWidth / 2, y + linkHeight / 2),
+    pointFrom2(centerX, centerY),
     angle
   );
   return [
@@ -3119,19 +3306,19 @@ var isPointHittingLink = (element, elementsMap, appState, [x, y], isMobile) => {
   if (!element.link || appState.selectedElementIds[element.id]) {
     return false;
   }
-  if (!isMobile && appState.viewModeEnabled && hitElementBoundingBox(pointFrom(x, y), element, elementsMap)) {
+  if (!isMobile && appState.viewModeEnabled && hitElementBoundingBox(pointFrom2(x, y), element, elementsMap)) {
     return true;
   }
   return isPointHittingLinkIcon(
     element,
     elementsMap,
     appState,
-    pointFrom(x, y)
+    pointFrom2(x, y)
   );
 };
 
 // renderer/helpers.ts
-import { THEME as THEME2, applyDarkModeFilter } from "@excalidraw/common";
+import { COLOR_WHITE, THEME as THEME2, applyDarkModeFilter } from "@excalidraw/common";
 var fillCircle = (context, cx, cy, radius, stroke, fill = true) => {
   context.beginPath();
   context.arc(cx, cy, radius, 0, Math.PI * 2);
@@ -3158,19 +3345,20 @@ var bootstrapCanvas = ({
   context.setTransform(1, 0, 0, 1, 0, 0);
   context.scale(scale, scale);
   if (typeof viewBackgroundColor === "string") {
-    const hasTransparence = viewBackgroundColor === "transparent" || viewBackgroundColor.length === 5 || // #RGBA
-    viewBackgroundColor.length === 9 || // #RRGGBBA
-    /(hsla|rgba)\(/.test(viewBackgroundColor);
-    if (hasTransparence) {
+    const isOpaque = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(viewBackgroundColor);
+    if (!isOpaque) {
       context.clearRect(0, 0, normalizedWidth, normalizedHeight);
     }
-    context.save();
-    context.fillStyle = applyDarkModeFilter(
-      viewBackgroundColor,
-      theme === THEME2.DARK
-    );
-    context.fillRect(0, 0, normalizedWidth, normalizedHeight);
-    context.restore();
+    if (viewBackgroundColor !== "transparent") {
+      context.save();
+      context.fillStyle = COLOR_WHITE;
+      context.fillStyle = applyDarkModeFilter(
+        viewBackgroundColor,
+        theme === THEME2.DARK
+      );
+      context.fillRect(0, 0, normalizedWidth, normalizedHeight);
+      context.restore();
+    }
   } else {
     context.clearRect(0, 0, normalizedWidth, normalizedHeight);
   }
@@ -3297,7 +3485,8 @@ var renderLinkIcon = (element, context, appState, elementsMap) => {
         window.devicePixelRatio * appState.zoom.value,
         window.devicePixelRatio * appState.zoom.value
       );
-      linkCanvasCacheContext.fillStyle = appState.viewBackgroundColor || "#fff";
+      linkCanvasCacheContext.fillStyle = COLOR_WHITE2;
+      linkCanvasCacheContext.fillStyle = appState.viewBackgroundColor || COLOR_WHITE2;
       linkCanvasCacheContext.fillRect(0, 0, width, height);
       if (canvasKey === "elementLink") {
         linkCanvasCacheContext.drawImage(ELEMENT_LINK_IMG, 0, 0, width, height);
@@ -3423,7 +3612,7 @@ var _renderStaticScene = ({
         );
       }
       context.restore();
-      if (!isExporting) {
+      if (!isExporting && renderConfig.renderLinks !== false) {
         renderLinkIcon(element, context, appState, elementsMap);
       }
     } catch (error) {
@@ -3461,7 +3650,7 @@ var _renderStaticScene = ({
             appState
           );
         }
-        if (!isExporting) {
+        if (!isExporting && renderConfig.renderLinks !== false) {
           renderLinkIcon(element, context, appState, elementsMap);
         }
       };
@@ -4084,7 +4273,7 @@ var renderSceneToSvg = (elements, elementsMap, rsvg, svgRoot, files, renderConfi
           renderConfig
         );
         const boundTextElement = getBoundTextElement2(element, elementsMap);
-        if (boundTextElement) {
+        if (boundTextElement?.isDeleted === false) {
           renderElementToSvg(
             boundTextElement,
             elementsMap,
@@ -4095,6 +4284,10 @@ var renderSceneToSvg = (elements, elementsMap, rsvg, svgRoot, files, renderConfi
             boundTextElement.y + renderConfig.offsetY,
             renderConfig
           );
+        } else if (boundTextElement) {
+          console.error(
+            "[NONDELETED][INVARIANT] Skipped rendering deleted bound text element"
+          );
         }
       } catch (error) {
         console.error(error);
@@ -4186,7 +4379,7 @@ var prepareElementsForRender = ({
     nextElements = getElementsOverlappingFrame(
       elements,
       exportingFrame,
-      arrayToMap(elements)
+      arrayToMap2(elements)
     );
   } else if (frameRendering.enabled && frameRendering.name) {
     nextElements = addFrameLabelsAsTextElements(elements, {
@@ -4244,10 +4437,10 @@ var exportToCanvas = async (elements, appState, files, {
     canvas,
     rc: rough.canvas(canvas),
     elementsMap: toBrandedType(
-      arrayToMap(elementsForRender)
+      arrayToMap2(elementsForRender)
     ),
     allElementsMap: toBrandedType(
-      arrayToMap(syncInvalidIndices(elements))
+      arrayToMap2(syncInvalidIndices(elements))
     ),
     visibleElements: elementsForRender,
     scale,
@@ -4336,7 +4529,7 @@ var exportToSvg = async (elements, appState, files, opts) => {
   }
   const frameElements = getFrameLikeElements(elements);
   if (frameElements.length) {
-    const elementsMap = arrayToMap(elements);
+    const elementsMap = arrayToMap2(elements);
     for (const frame of frameElements) {
       const clipPath = svgRoot.ownerDocument.createElementNS(
         SVG_NS2,
@@ -4385,7 +4578,7 @@ var exportToSvg = async (elements, appState, files, opts) => {
   const renderEmbeddables = opts?.renderEmbeddables ?? false;
   renderSceneToSvg(
     elementsForRender,
-    toBrandedType(arrayToMap(elementsForRender)),
+    toBrandedType(arrayToMap2(elementsForRender)),
     rsvg,
     svgRoot,
     files || {},
@@ -4456,15 +4649,9 @@ var getCanvasSize = (elements, exportPadding) => {
   const height = distance(minY, maxY) + exportPadding * 2;
   return [minX, minY, width, height];
 };
-var getExportSize = (elements, exportPadding, scale) => {
-  const [, , width, height] = getCanvasSize(elements, exportPadding).map(
-    (dimension) => Math.trunc(dimension * scale)
-  );
-  return [width, height];
-};
 
 // data/restore.ts
-import { isFiniteNumber, isValidPoint, pointFrom as pointFrom2 } from "@excalidraw/math";
+import { isFiniteNumber, isValidPoint, pointFrom as pointFrom3 } from "@excalidraw/math";
 import {
   DEFAULT_FONT_FAMILY as DEFAULT_FONT_FAMILY2,
   DEFAULT_STROKE_STREAMLINE,
@@ -4479,7 +4666,7 @@ import {
   randomId,
   getUpdatedTimestamp,
   updateActiveTool,
-  arrayToMap as arrayToMap2,
+  arrayToMap as arrayToMap3,
   getSizeFromPoints,
   normalizeLink as normalizeLink2,
   getLineHeight,
@@ -4530,20 +4717,20 @@ var handleOversizedLinearElements = (element) => {
     y: 0,
     width: 100,
     height: 100,
-    points: [pointFrom2(0, 0), pointFrom2(100, 100)],
+    points: [pointFrom3(0, 0), pointFrom3(100, 100)],
     isDeleted: true
   };
 };
 var restoreLinearElementPoints = (points, width, height) => {
   const restoredPoints = Array.isArray(points) ? points.reduce((acc, point) => {
     if (isValidPoint(point)) {
-      acc.push(pointFrom2(point[0], point[1]));
+      acc.push(pointFrom3(point[0], point[1]));
     }
     return acc;
   }, []) : [];
   return restoredPoints.length < 2 ? [
-    pointFrom2(0, 0),
-    pointFrom2(
+    pointFrom3(0, 0),
+    pointFrom3(
       isFiniteNumber(width) ? width : 0,
       isFiniteNumber(height) ? height : 0
     )
@@ -4561,7 +4748,7 @@ var restoreFreedrawPoints = (points, pressures) => {
   const restoredPressures = [];
   points.forEach((point, index) => {
     if (isValidPoint(point)) {
-      restoredPoints.push(pointFrom2(point[0], point[1]));
+      restoredPoints.push(pointFrom3(point[0], point[1]));
       if (index in pressureValues) {
         const pressure = pressureValues[index];
         restoredPressures.push(isFiniteNumber(pressure) ? pressure : 0.5);
@@ -4590,7 +4777,9 @@ var AllowedExcalidrawActiveTools = {
   embeddable: true,
   hand: true,
   laser: false,
-  magicframe: false
+  magicframe: false,
+  autoshape: false,
+  bucketfill: false
 };
 var ALLOWED_STROKE_VARIABILITIES = /* @__PURE__ */ new Set([
   "constant",
@@ -4953,8 +5142,8 @@ var repairFrameMembership = (element, elementsMap) => {
 };
 var restoreElements = (targetElements, existingElements, opts) => {
   const existingIds = /* @__PURE__ */ new Set();
-  const targetElementsMap = arrayToMap2(targetElements || []);
-  const existingElementsMap = existingElements ? arrayToMap2(existingElements) : null;
+  const targetElementsMap = arrayToMap3(targetElements || []);
+  const existingElementsMap = existingElements ? arrayToMap3(existingElements) : null;
   const restoredElements = syncInvalidIndices2(
     (targetElements || []).reduce((elements, element) => {
       if (element.type === "selection") {
@@ -4995,7 +5184,7 @@ var restoreElements = (targetElements, existingElements, opts) => {
   if (!opts?.repairBindings) {
     return restoredElements;
   }
-  const restoredElementsMap = arrayToMap2(restoredElements);
+  const restoredElementsMap = arrayToMap3(restoredElements);
   for (const element of restoredElements) {
     if (element.frameId) {
       repairFrameMembership(element, restoredElementsMap);
@@ -5033,7 +5222,7 @@ var restoreElements = (targetElements, existingElements, opts) => {
           restoredElementsMap,
           {
             points: [
-              pointFrom2(0, 0),
+              pointFrom3(0, 0),
               element.points[element.points.length - 1]
             ]
           }
@@ -5062,10 +5251,10 @@ var restoreElements = (targetElements, existingElements, opts) => {
         width: boundElement.width,
         height: boundElement.height,
         points: [
-          pointFrom2(0, 0),
-          pointFrom2(0, -10),
-          pointFrom2(boundElement.width / 2 + 5, -10),
-          pointFrom2(
+          pointFrom3(0, 0),
+          pointFrom3(0, -10),
+          pointFrom3(boundElement.width / 2 + 5, -10),
+          pointFrom3(
             boundElement.width / 2 + 5,
             boundElement.height / 2 + 5
           )
@@ -5156,7 +5345,7 @@ var parseFileContents = async (blob) => {
   let contents;
   if (blob.type === MIME_TYPES6.png) {
     try {
-      return await (await import("./data/image-ZYGVHYLC.js")).decodePngMetadata(blob);
+      return await (await import("./data/image-NFLICJEW.js")).decodePngMetadata(blob);
     } catch (error) {
       if (error.message === "INVALID") {
         throw new ImageSceneDataError(
@@ -5246,7 +5435,7 @@ var loadFromBlob = async (blob, localAppState, localElements, fileHandle) => {
             theme: localAppState?.theme,
             fileHandle: fileHandle || blob.handle || null,
             ...cleanAppStateForExport(data.appState || {}),
-            ...localAppState ? calculateScrollCenter(data.elements || [], localAppState) : {}
+            ...localAppState ? getScrollToContentState(data.elements || [], localAppState) : {}
           },
           localAppState
         ),
@@ -5312,6 +5501,77 @@ var getDataURL_sync = (data, mimeType) => {
 var dataURLToString = (dataURL) => {
   return base64ToString(dataURL.slice(dataURL.indexOf(",") + 1));
 };
+var getImageFileDimensions = async (file) => {
+  const browserURL = typeof window !== "undefined" ? window.URL : void 0;
+  let objectURL = null;
+  let imageSource;
+  try {
+    imageSource = browserURL?.createObjectURL ? objectURL = browserURL.createObjectURL(file) : await getDataURL(file);
+  } catch {
+    objectURL = null;
+    imageSource = await getDataURL(file);
+  }
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    const cleanup = () => {
+      image.onload = null;
+      image.onerror = null;
+      if (objectURL && browserURL?.revokeObjectURL) {
+        browserURL.revokeObjectURL(objectURL);
+      }
+    };
+    image.onload = () => {
+      cleanup();
+      resolve({
+        width: image.naturalWidth || image.width,
+        height: image.naturalHeight || image.height
+      });
+    };
+    image.onerror = (error) => {
+      cleanup();
+      reject(error);
+    };
+    image.src = imageSource;
+  });
+};
+var resizeImageFile = async (file, opts) => {
+  if (file.type === MIME_TYPES6.svg) {
+    return file;
+  }
+  if (!isSupportedImageFile(file)) {
+    throw new Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
+  }
+  if (!opts.outputType || opts.outputType === file.type) {
+    const dimensions = await getImageFileDimensions(file);
+    if (Math.max(dimensions.width, dimensions.height) <= opts.maxWidthOrHeight) {
+      return file;
+    }
+  }
+  const [pica, imageBlobReduce] = await Promise.all([
+    import("pica").then((res) => res.default),
+    // a wrapper for pica for better API
+    import("image-blob-reduce").then((res) => res.default)
+  ]);
+  const reduce = imageBlobReduce({
+    pica: pica({ features: ["js", "wasm"] })
+  });
+  if (opts.outputType) {
+    const { outputType } = opts;
+    reduce._create_blob = function(env) {
+      return this.pica.toBlob(env.out_canvas, outputType, 0.8).then((blob) => {
+        env.out_blob = blob;
+        return env;
+      });
+    };
+  }
+  return new File(
+    [await reduce.toBlob(file, { max: opts.maxWidthOrHeight, alpha: true })],
+    file.name,
+    {
+      type: opts.outputType || file.type
+    }
+  );
+};
 var SVGStringToFile = (SVGString, filename = "") => {
   return new File([new TextEncoder().encode(SVGString)], filename, {
     type: MIME_TYPES6.svg
@@ -5456,8 +5716,11 @@ var decodePngMetadata = async (blob) => {
 };
 
 export {
-  centerScrollOn,
-  calculateScrollCenter,
+  DEFAULT_OVERSCROLL,
+  constrainScrollState,
+  getViewportForZoomWithScrollConstraints,
+  zoomToFitBounds,
+  getScrollToContentState,
   getNormalizedZoom,
   getNormalizedGridStep,
   isSomeElementSelected,
@@ -5494,7 +5757,6 @@ export {
   renderStaticScene,
   exportToCanvas,
   exportToSvg,
-  getExportSize,
   restoreElement,
   restoreElements,
   restoreAppState,
@@ -5512,10 +5774,11 @@ export {
   getDataURL,
   getDataURL_sync,
   dataURLToString,
+  resizeImageFile,
   SVGStringToFile,
   ImageURLToFile,
   getFileHandle,
   createFile,
   normalizeFile
 };
-//# sourceMappingURL=chunk-MN6E45MP.js.map
+//# sourceMappingURL=chunk-BCNQXIBK.js.map