debug

Co-authored-by: Mark Tolmacs <mark@lazycat.hu>

.github/workflows/cancel.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: styfle/cancel-workflow-action@0.6.0
+      - uses: styfle/cancel-workflow-action@ce177499ccf9fd2aded3b0426c97e5434c2e8a73 # 0.6.0
         with:
           workflow_id: 400555, 400556, 905313, 1451724, 1710116, 3185001, 3438604
           access_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/locales-coverage.yml

@@ -40,7 +40,7 @@ jobs:
           echo ::set-output name=body::$body
 
       - name: Update description with coverage
-        uses: kt3k/update-pr-description@v1.0.1
+        uses: kt3k/update-pr-description@1b35a6dcd84d81aa0bc1889610efdcde7f37b0c0 # v1.0.1
         with:
           pr_body: ${{ steps.getCommentBody.outputs.body }}
           pr_title: "chore: Update translations from Crowdin"

.github/workflows/publish-docker.yml

@@ -13,16 +13,16 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v3
       - name: Login to DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@465a07811f14bebb1938fbed4728c6a1ff8901fc # v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
       - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
         with:
           context: .
           push: true

.github/workflows/semantic-pr-title.yml

@@ -11,6 +11,6 @@ jobs:
   semantic:
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@v5
+      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/size-limit.yml

@@ -20,7 +20,7 @@ jobs:
         working-directory: packages/excalidraw
         env:
           CI: true
-      - uses: andresz1/size-limit-action@v1
+      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           build_script: build:esm

.github/workflows/test-coverage-pr.yml

@@ -21,6 +21,6 @@ jobs:
         run: yarn test:coverage
       - name: "Report Coverage"
         if: always() # Also generate the report if tests are failing
-        uses: davelosert/vitest-coverage-report-action@v2
+        uses: davelosert/vitest-coverage-report-action@2500dafcee7dd64f85ab689c0b83798a8359770e # v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

.playwright-mcp/page-2026-06-26T08-26-20-195Z.yml

@@ -0,0 +1,124 @@
+- generic [ref=e1]:
+  - banner:
+    - heading "Excalidraw" [level=1] [ref=e2]
+  - generic [active] [ref=e5]:
+    - generic:
+      - generic:
+        - generic:
+          - button [ref=e9] [cursor=pointer]:
+            - img [ref=e10]
+          - region "Shapes":
+            - generic [ref=e16]:
+              - generic:
+                - generic:
+                  - text: To move canvas, hold
+                  - generic: Scroll wheel
+                  - text: or
+                  - generic: Space
+                  - text: while dragging, or use the hand tool
+              - heading "Shapes" [level=2] [ref=e17]
+              - generic [ref=e18]:
+                - generic "Keep selected tool active after drawing — Q" [ref=e19] [cursor=pointer]:
+                  - checkbox "Keep selected tool active after drawing"
+                  - img [ref=e21]
+                - generic "Hand (panning tool) — H or null" [ref=e29] [cursor=pointer]:
+                  - radio "Hand (panning tool)"
+                  - img [ref=e31]
+                - generic "Selection — V or 1" [ref=e38] [cursor=pointer]:
+                  - radio "Selection" [checked]
+                  - generic [ref=e39]:
+                    - img [ref=e40]
+                    - generic [ref=e45]: "1"
+                - generic "Rectangle — R or 2" [ref=e46] [cursor=pointer]:
+                  - radio "Rectangle"
+                  - generic [ref=e47]:
+                    - img [ref=e48]
+                    - generic [ref=e52]: "2"
+                - generic "Diamond — D or 3" [ref=e53] [cursor=pointer]:
+                  - radio "Diamond"
+                  - generic [ref=e54]:
+                    - img [ref=e55]
+                    - generic [ref=e59]: "3"
+                - generic "Ellipse — O or 4" [ref=e60] [cursor=pointer]:
+                  - radio "Ellipse"
+                  - generic [ref=e61]:
+                    - img [ref=e62]
+                    - generic [ref=e66]: "4"
+                - generic "Arrow — A or 5" [ref=e67] [cursor=pointer]:
+                  - radio "Arrow"
+                  - generic [ref=e68]:
+                    - img [ref=e69]
+                    - generic [ref=e74]: "5"
+                - generic "Line — L or 6" [ref=e75] [cursor=pointer]:
+                  - radio "Line"
+                  - generic [ref=e76]:
+                    - img [ref=e77]
+                    - generic [ref=e78]: "6"
+                - generic "Draw — P or 7" [ref=e79] [cursor=pointer]:
+                  - radio "Draw"
+                  - generic [ref=e80]:
+                    - img [ref=e81]
+                    - generic [ref=e85]: "7"
+                - generic "Text — T or 8" [ref=e86] [cursor=pointer]:
+                  - radio "Text"
+                  - generic [ref=e87]:
+                    - img [ref=e88]
+                    - generic [ref=e93]: "8"
+                - generic "Insert image — 9" [ref=e94] [cursor=pointer]:
+                  - radio "Insert image"
+                  - generic [ref=e95]:
+                    - img [ref=e96]
+                    - generic [ref=e101]: "9"
+                - generic "Eraser — E or 0" [ref=e102] [cursor=pointer]:
+                  - radio "Eraser"
+                  - generic [ref=e103]:
+                    - img [ref=e104]
+                    - generic [ref=e109]: "0"
+                - button "More tools" [ref=e112] [cursor=pointer]:
+                  - img [ref=e113]
+          - generic:
+            - generic [ref=e119]:
+              - link "Excalidraw+" [ref=e120] [cursor=pointer]:
+                - /url: https://plus.excalidraw.com/plus?utm_source=excalidraw&utm_medium=app&utm_content=guestBanner#excalidraw-redirect
+              - button "Live collaboration..." [ref=e121] [cursor=pointer]:
+                - img [ref=e122]
+            - generic "Library" [ref=e124]:
+              - checkbox "Library"
+              - img [ref=e127] [cursor=pointer]
+      - contentinfo:
+        - region "Canvas actions" [ref=e132]:
+          - heading "Canvas actions" [level=2] [ref=e133]
+          - generic [ref=e135]:
+            - button "Zoom out" [ref=e136] [cursor=pointer]:
+              - img [ref=e138]
+            - button "Reset zoom" [ref=e140] [cursor=pointer]: 100%
+            - button "Zoom in" [ref=e141] [cursor=pointer]:
+              - img [ref=e143]
+          - generic [ref=e145]:
+            - button "Undo" [disabled] [ref=e148]:
+              - img [ref=e150]
+            - button "Redo" [disabled] [ref=e154]:
+              - img [ref=e156]
+        - generic [ref=e158]:
+          - generic [ref=e159]:
+            - button "lock scroll" [ref=e160] [cursor=pointer]
+            - generic [ref=e161]:
+              - text: overscroll
+              - spinbutton "overscroll" [ref=e162]: "0.2"
+            - generic [ref=e163]:
+              - text: zoom factor
+              - spinbutton "zoom factor" [ref=e164]: "0.2"
+            - generic [ref=e165]:
+              - checkbox "lock zoom" [ref=e166]
+              - text: lock zoom
+            - generic [ref=e167]:
+              - checkbox "animate" [ref=e168]
+              - text: animate
+          - link "Blog post on end-to-end encryption in Excalidraw" [ref=e169] [cursor=pointer]:
+            - /url: https://plus.excalidraw.com/blog/end-to-end-encryption
+            - img [ref=e171]
+        - button "Help" [ref=e174] [cursor=pointer]:
+          - img [ref=e175]
+    - generic:
+      - img
+    - generic [ref=e180]: Drawing canvas

.playwright-mcp/page-2026-06-26T08-26-34-790Z.yml

@@ -0,0 +1,126 @@
+- generic [ref=e1]:
+  - banner:
+    - heading "Excalidraw" [level=1] [ref=e2]
+  - generic [ref=e5]:
+    - generic:
+      - generic:
+        - generic:
+          - generic:
+            - img
+            - img
+        - generic:
+          - text: Your drawings are saved in your browser's storage.
+          - text: Browser storage can be cleared unexpectedly.
+          - text: Save your work to a file regularly to avoid losing it.
+        - generic:
+          - button "Open Ctrl+O" [ref=e181] [cursor=pointer]:
+            - img [ref=e183]
+            - generic [ref=e185]: Open
+            - generic [ref=e186]: Ctrl+O
+          - button "Help ?" [ref=e187] [cursor=pointer]:
+            - img [ref=e189]
+            - generic [ref=e194]: Help
+            - generic [ref=e195]: "?"
+          - button "Live collaboration..." [ref=e196] [cursor=pointer]:
+            - img [ref=e198]
+            - generic [ref=e205]: Live collaboration...
+          - link "Sign up" [ref=e206] [cursor=pointer]:
+            - /url: https://plus.excalidraw.com/plus?utm_source=excalidraw&utm_medium=app&utm_content=welcomeScreenGuest
+            - img [ref=e208]
+            - generic [ref=e214]: Sign up
+      - generic:
+        - generic:
+          - button [ref=e9] [cursor=pointer]:
+            - img [ref=e10]
+          - region "Shapes":
+            - generic [ref=e16]:
+              - generic:
+                - generic:
+                  - text: To move canvas, hold
+                  - generic: Scroll wheel
+                  - text: or
+                  - generic: Space
+                  - text: while dragging, or use the hand tool
+              - heading "Shapes" [level=2] [ref=e17]
+              - generic [ref=e18]:
+                - generic "Keep selected tool active after drawing — Q" [ref=e19] [cursor=pointer]:
+                  - checkbox "Keep selected tool active after drawing"
+                  - img [ref=e21]
+                - generic "Hand (panning tool) — H or null" [ref=e29] [cursor=pointer]:
+                  - radio "Hand (panning tool)"
+                  - img [ref=e31]
+                - generic "Selection" [ref=e215] [cursor=pointer]:
+                  - radio "Selection" [checked]
+                  - img [ref=e217]
+                - generic "Rectangle — R or 2" [ref=e46] [cursor=pointer]:
+                  - radio "Rectangle"
+                  - img [ref=e48]
+                - generic "Diamond — D or 3" [ref=e53] [cursor=pointer]:
+                  - radio "Diamond"
+                  - img [ref=e55]
+                - generic "Ellipse — O or 4" [ref=e60] [cursor=pointer]:
+                  - radio "Ellipse"
+                  - img [ref=e62]
+                - generic "Arrow — A or 5" [ref=e67] [cursor=pointer]:
+                  - radio "Arrow"
+                  - img [ref=e69]
+                - generic "Line — L or 6" [ref=e75] [cursor=pointer]:
+                  - radio "Line"
+                  - img [ref=e77]
+                - generic "Draw — P or 7" [ref=e79] [cursor=pointer]:
+                  - radio "Draw"
+                  - img [ref=e81]
+                - generic "Text — T or 8" [ref=e86] [cursor=pointer]:
+                  - radio "Text"
+                  - img [ref=e88]
+                - generic "Insert image — 9" [ref=e94] [cursor=pointer]:
+                  - radio "Insert image"
+                  - img [ref=e96]
+                - generic "Eraser — E or 0" [ref=e102] [cursor=pointer]:
+                  - radio "Eraser"
+                  - img [ref=e104]
+                - button "More tools" [ref=e112] [cursor=pointer]:
+                  - img [ref=e113]
+          - generic:
+            - button "Live collaboration..." [ref=e121] [cursor=pointer]:
+              - img [ref=e122]
+            - generic "Library" [ref=e124]:
+              - checkbox "Library"
+              - img [ref=e127] [cursor=pointer]
+      - contentinfo:
+        - region "Canvas actions" [ref=e132]:
+          - heading "Canvas actions" [level=2] [ref=e133]
+          - generic [ref=e135]:
+            - button "Zoom out" [ref=e136] [cursor=pointer]:
+              - img [ref=e138]
+            - button "Reset zoom" [disabled] [ref=e140]: 100%
+            - button "Zoom in" [ref=e141] [cursor=pointer]:
+              - img [ref=e143]
+          - generic [ref=e145]:
+            - button "Undo" [disabled] [ref=e148]:
+              - img [ref=e150]
+            - button "Redo" [disabled] [ref=e154]:
+              - img [ref=e156]
+        - generic [ref=e158]:
+          - generic [ref=e159]:
+            - button "disable scroll lock" [active] [ref=e222] [cursor=pointer]
+            - generic [ref=e161]:
+              - text: overscroll
+              - spinbutton "overscroll" [ref=e162]: "0.2"
+            - generic [ref=e163]:
+              - text: zoom factor
+              - spinbutton "zoom factor" [ref=e164]: "0.2"
+            - generic [ref=e165]:
+              - checkbox "lock zoom" [ref=e166]
+              - text: lock zoom
+            - generic [ref=e167]:
+              - checkbox "animate" [ref=e168]
+              - text: animate
+          - link "Blog post on end-to-end encryption in Excalidraw" [ref=e169] [cursor=pointer]:
+            - /url: https://plus.excalidraw.com/blog/end-to-end-encryption
+            - img [ref=e171]
+        - button "Help" [ref=e174] [cursor=pointer]:
+          - img [ref=e175]
+    - generic:
+      - img
+    - generic [ref=e180]: Drawing canvas

README.md

@@ -29,7 +29,7 @@
   <a href="https://docs.excalidraw.com/docs/introduction/contributing">
     <img alt="PRs welcome!" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat"  /></a>
   <a href="https://discord.gg/UexuTaE">
-    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widge=false"/></a>
+    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widget=false"/></a>
   <a href="https://deepwiki.com/excalidraw/excalidraw">
     <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></a>
   <a href="https://twitter.com/excalidraw">

examples/with-nextjs/src/excalidrawWrapper.tsx

@@ -4,8 +4,20 @@ import { Excalidraw } from "@excalidraw/excalidraw";
 
 import "@excalidraw/excalidraw/index.css";
 
+import type { ScrollConstraints } from "@excalidraw/excalidraw/types";
+
 import App from "../../with-script-in-browser/components/ExampleApp";
 
+const scrollConstraints: ScrollConstraints = {
+  x: 0,
+  y: 0,
+  width: 850,
+  height: 400,
+  lockZoom: true,
+  overscrollAllowance: 0,
+  viewportZoomFactor: 1,
+};
+
 const ExcalidrawWrapper: React.FC = () => {
   return (
     <>
@@ -14,7 +26,7 @@ const ExcalidrawWrapper: React.FC = () => {
         useCustom={(api: any, args?: any[]) => {}}
         excalidrawLib={excalidrawLib}
       >
-        <Excalidraw />
+        <Excalidraw scrollConstraints={scrollConstraints} />
       </App>
     </>
   );

examples/with-script-in-browser/components/ExampleApp.tsx

@@ -178,7 +178,8 @@ export default function ExampleApp({
     const newElement = cloneElement(
       Excalidraw,
       {
-        excalidrawAPI: (api: ExcalidrawImperativeAPI) => setExcalidrawAPI(api),
+        onExcalidrawAPI: (api: ExcalidrawImperativeAPI | null) =>
+          setExcalidrawAPI(api),
         initialData: initialStatePromiseRef.current.promise,
         onChange: (
           elements: NonDeletedExcalidrawElement[],
@@ -820,6 +821,48 @@ export default function ExampleApp({
             />
             Export with embed scene
           </label>
+          <button
+            type="button"
+            onClick={() => {
+              if (!excalidrawAPI) {
+                return;
+              }
+
+              const elements = excalidrawAPI.getSceneElements();
+              excalidrawAPI.scrollToContent(elements[0], {
+                animate: true,
+                fitToViewport: true,
+                viewportZoomFactor: 0.9,
+                scrollLock: {
+                  lockZoom: true,
+                  overscrollAllowance: 0,
+                },
+              });
+            }}
+          >
+            Fit and lock first element
+          </button>
+          <button
+            type="button"
+            onClick={() => {
+              if (!excalidrawAPI) {
+                return;
+              }
+
+              const elements = excalidrawAPI.getSceneElements();
+              excalidrawAPI.scrollToContent(elements[1], {
+                animate: true,
+                fitToViewport: true,
+                viewportZoomFactor: 0.9,
+                scrollLock: {
+                  lockZoom: true,
+                  overscrollAllowance: 0,
+                },
+              });
+            }}
+          >
+            Fit and lock second element
+          </button>
           <button
             onClick={async () => {
               if (!excalidrawAPI) {

excalidraw-app/App.tsx

@@ -1015,7 +1015,10 @@ const ExcalidrawWrapper = () => {
             </OverwriteConfirmDialog.Action>
           )}
         </OverwriteConfirmDialog>
-        <AppFooter onChange={() => excalidrawAPI?.refresh()} />
+        <AppFooter
+          excalidrawAPI={excalidrawAPI}
+          onChange={() => excalidrawAPI?.refresh()}
+        />
         {excalidrawAPI && <AIComponents excalidrawAPI={excalidrawAPI} />}
 
         <TTDDialogTrigger />

excalidraw-app/components/AppFooter.tsx

@@ -1,13 +1,178 @@
 import { Footer } from "@excalidraw/excalidraw/index";
-import React from "react";
+import {
+  getCommonBounds,
+  getSelectedElements,
+  getVisibleSceneBounds,
+} from "@excalidraw/element";
+import React, { useCallback, useState } from "react";
+
+import type {
+  ExcalidrawImperativeAPI,
+  ScrollConstraints,
+} from "@excalidraw/excalidraw/types";
 
 import { isExcalidrawPlusSignedUser } from "../app_constants";
 
 import { DebugFooter, isVisualDebuggerEnabled } from "./DebugCanvas";
 import { EncryptedIcon } from "./EncryptedIcon";
 
+type ScrollConstraintOptions = Pick<
+  ScrollConstraints,
+  "lockZoom" | "overscrollAllowance" | "viewportZoomFactor"
+>;
+
+const ScrollConstraintsDebugFooter = ({
+  excalidrawAPI,
+}: {
+  excalidrawAPI: ExcalidrawImperativeAPI | null;
+}) => {
+  const [activeLock, setActiveLock] = useState<ScrollConstraints | null>(null);
+  const [options, setOptions] = useState<ScrollConstraintOptions>({
+    lockZoom: false,
+    overscrollAllowance: 0.2,
+    viewportZoomFactor: 0.2,
+  });
+
+  const setLock = useCallback(
+    (nextLock: ScrollConstraints) => {
+      excalidrawAPI?.setScrollConstraints(nextLock);
+      setActiveLock(nextLock);
+    },
+    [excalidrawAPI],
+  );
+
+  const toggleScrollLock = useCallback(() => {
+    if (!excalidrawAPI) {
+      return;
+    }
+
+    if (activeLock) {
+      excalidrawAPI.setScrollConstraints(null);
+      setActiveLock(null);
+      return;
+    }
+
+    const selectedElements = getSelectedElements(
+      excalidrawAPI.getSceneElements(),
+      excalidrawAPI.getAppState(),
+      {
+        includeBoundTextElement: true,
+        includeElementsInFrames: true,
+      },
+    );
+    const [x1, y1, x2, y2] = selectedElements.length
+      ? getCommonBounds(
+          selectedElements,
+          excalidrawAPI.getSceneElementsMapIncludingDeleted(),
+        )
+      : getVisibleSceneBounds(excalidrawAPI.getAppState());
+
+    setLock({
+      x: x1,
+      y: y1,
+      width: x2 - x1,
+      height: y2 - y1,
+      ...options,
+    });
+  }, [activeLock, excalidrawAPI, options, setLock]);
+
+  const updateOptions = useCallback(
+    (nextOptions: ScrollConstraintOptions) => {
+      setOptions(nextOptions);
+
+      if (activeLock) {
+        setLock({ ...activeLock, ...nextOptions });
+      }
+    },
+    [activeLock, setLock],
+  );
+
+  const updateNumberOption = useCallback(
+    (option: "overscrollAllowance" | "viewportZoomFactor", value: string) => {
+      updateOptions({
+        ...options,
+        [option]: value === "" ? undefined : Number(value),
+      });
+    },
+    [options, updateOptions],
+  );
+
+  const updateBooleanOption = useCallback(
+    (option: "lockZoom", value: boolean) => {
+      updateOptions({
+        ...options,
+        [option]: value,
+      });
+    },
+    [options, updateOptions],
+  );
+
+  return (
+    <div
+      style={{
+        display: "flex",
+        gap: ".45rem",
+        alignItems: "center",
+        padding: "0 .35rem",
+        fontSize: 12,
+      }}
+    >
+      <button
+        className="ToolIcon_type_button"
+        type="button"
+        onClick={toggleScrollLock}
+      >
+        {activeLock ? "disable scroll lock" : "lock scroll"}
+      </button>
+      <label style={{ display: "flex", gap: ".25rem", alignItems: "center" }}>
+        overscroll
+        <input
+          type="number"
+          min={0}
+          max={1}
+          step={0.05}
+          value={options.overscrollAllowance ?? ""}
+          onChange={(event) =>
+            updateNumberOption("overscrollAllowance", event.target.value)
+          }
+          style={{ width: 56 }}
+        />
+      </label>
+      <label style={{ display: "flex", gap: ".25rem", alignItems: "center" }}>
+        zoom factor
+        <input
+          type="number"
+          min={0.1}
+          step={0.1}
+          value={options.viewportZoomFactor ?? ""}
+          onChange={(event) =>
+            updateNumberOption("viewportZoomFactor", event.target.value)
+          }
+          style={{ width: 56 }}
+        />
+      </label>
+      <label style={{ display: "flex", gap: ".2rem", alignItems: "center" }}>
+        <input
+          type="checkbox"
+          checked={!!options.lockZoom}
+          onChange={(event) =>
+            updateBooleanOption("lockZoom", event.target.checked)
+          }
+        />
+        lock zoom
+      </label>
+    </div>
+  );
+};
+
 export const AppFooter = React.memo(
-  ({ onChange }: { onChange: () => void }) => {
+  ({
+    excalidrawAPI,
+    onChange,
+  }: {
+    excalidrawAPI: ExcalidrawImperativeAPI | null;
+    onChange: () => void;
+  }) => {
     return (
       <Footer>
         <div
@@ -17,6 +182,7 @@ export const AppFooter = React.memo(
             alignItems: "center",
           }}
         >
+          <ScrollConstraintsDebugFooter excalidrawAPI={excalidrawAPI} />
           {isVisualDebuggerEnabled() && <DebugFooter onChange={onChange} />}
           {!isExcalidrawPlusSignedUser && <EncryptedIcon />}
         </div>

packages/common/src/bounds.ts

@@ -1,5 +1,3 @@
-import type { Radians } from "@excalidraw/math";
-
 /**
  * x and y position of top left corner, x and y position of bottom right corner
  */
@@ -8,31 +6,7 @@ export type Bounds = readonly [
   minY: number,
   maxX: number,
   maxY: number,
-] & { _brand: "excalidraw__bounds" };
-
-export type RotatedBounds = readonly [
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-  angle: Radians,
-] & {
-  _brand_rotated: "excalidraw__rotated_bounds";
-};
-
-export const bounds = <T extends Radians | undefined = undefined>(
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-  angle: T = undefined as T,
-) => {
-  return (
-    angle
-      ? ([minX, minY, maxX, maxY, angle] as unknown)
-      : ([minX, minY, maxX, maxY] as unknown)
-  ) as T extends Radians ? RotatedBounds : Bounds;
-};
+];
 
 export const isBounds = (box: unknown): box is Bounds =>
   Array.isArray(box) &&
@@ -41,12 +15,3 @@ export const isBounds = (box: unknown): box is Bounds =>
   typeof box[1] === "number" &&
   typeof box[2] === "number" &&
   typeof box[3] === "number";
-
-export const isRotatedBounds = (box: unknown): box is RotatedBounds =>
-  Array.isArray(box) &&
-  box.length === 5 &&
-  typeof box[0] === "number" &&
-  typeof box[1] === "number" &&
-  typeof box[2] === "number" &&
-  typeof box[3] === "number" &&
-  typeof box[4] === "number";

packages/element/src/bounds.ts

@@ -2,11 +2,9 @@ import rough from "roughjs/bin/rough";
 
 import {
   arrayToMap,
-  bounds,
   type Bounds,
   invariant,
   rescalePoints,
-  type RotatedBounds,
   sizeOf,
 } from "@excalidraw/common";
 
@@ -92,7 +90,7 @@ export class ElementBounds {
   private static boundsCache = new WeakMap<
     ExcalidrawElement,
     {
-      bounds: RotatedBounds;
+      bounds: Bounds;
       version: ExcalidrawElement["version"];
     }
   >();
@@ -104,11 +102,11 @@ export class ElementBounds {
     }
   >();
 
-  static getBounds<T extends boolean = false>(
+  static getBounds(
     element: ExcalidrawElement,
     elementsMap: ElementsMap,
-    nonRotated: T = false as T,
-  ): T extends true ? Bounds : RotatedBounds {
+    nonRotated: boolean = false,
+  ) {
     const cachedBounds =
       nonRotated && element.angle !== 0
         ? ElementBounds.nonRotatedBoundsCache.get(element)
@@ -121,41 +119,40 @@ export class ElementBounds {
       // which is causing problems down the line. Fix TBA.
       !isBoundToContainer(element)
     ) {
-      return cachedBounds.bounds as T extends true ? Bounds : RotatedBounds;
+      return cachedBounds.bounds;
     }
 
     if (nonRotated && element.angle !== 0) {
-      const [minX, minY, maxX, maxY] = ElementBounds.calculateBounds(
+      const nonRotatedBounds = ElementBounds.calculateBounds(
         {
           ...element,
           angle: 0 as Radians,
         },
         elementsMap,
       );
-      const nonRotatedBounds = bounds(minX, minY, maxX, maxY);
       ElementBounds.nonRotatedBoundsCache.set(element, {
         version: element.version,
         bounds: nonRotatedBounds,
       });
 
-      return nonRotatedBounds as T extends true ? Bounds : RotatedBounds;
+      return nonRotatedBounds;
     }
 
-    const _bounds = ElementBounds.calculateBounds(element, elementsMap);
+    const bounds = ElementBounds.calculateBounds(element, elementsMap);
 
     ElementBounds.boundsCache.set(element, {
       version: element.version,
-      bounds: _bounds,
+      bounds,
     });
 
-    return _bounds as T extends true ? Bounds : RotatedBounds;
+    return bounds;
   }
 
   private static calculateBounds(
     element: ExcalidrawElement,
     elementsMap: ElementsMap,
-  ): RotatedBounds {
-    let _bounds: RotatedBounds;
+  ): Bounds {
+    let bounds: Bounds;
 
     const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(
       element,
@@ -172,15 +169,14 @@ export class ElementBounds {
         ),
       );
 
-      return bounds(
+      return [
         minX + element.x,
         minY + element.y,
         maxX + element.x,
         maxY + element.y,
-        element.angle,
-      );
+      ];
     } else if (isLinearElement(element)) {
-      _bounds = getLinearElementRotatedBounds(element, cx, cy, elementsMap);
+      bounds = getLinearElementRotatedBounds(element, cx, cy, elementsMap);
     } else if (element.type === "diamond") {
       const [x11, y11] = pointRotateRads(
         pointFrom(cx, y1),
@@ -206,7 +202,7 @@ export class ElementBounds {
       const minY = Math.min(y11, y12, y22, y21);
       const maxX = Math.max(x11, x12, x22, x21);
       const maxY = Math.max(y11, y12, y22, y21);
-      _bounds = bounds(minX, minY, maxX, maxY, element.angle);
+      bounds = [minX, minY, maxX, maxY];
     } else if (element.type === "ellipse") {
       const w = (x2 - x1) / 2;
       const h = (y2 - y1) / 2;
@@ -214,7 +210,7 @@ export class ElementBounds {
       const sin = Math.sin(element.angle);
       const ww = Math.hypot(w * cos, h * sin);
       const hh = Math.hypot(h * cos, w * sin);
-      _bounds = bounds(cx - ww, cy - hh, cx + ww, cy + hh, element.angle);
+      bounds = [cx - ww, cy - hh, cx + ww, cy + hh];
     } else {
       const [x11, y11] = pointRotateRads(
         pointFrom(x1, y1),
@@ -240,10 +236,10 @@ export class ElementBounds {
       const minY = Math.min(y11, y12, y22, y21);
       const maxX = Math.max(x11, x12, x22, x21);
       const maxY = Math.max(y11, y12, y22, y21);
-      _bounds = bounds(minX, minY, maxX, maxY, element.angle);
+      bounds = [minX, minY, maxX, maxY];
     }
 
-    return _bounds;
+    return bounds;
   }
 }
 
@@ -628,7 +624,7 @@ export const getCubicBezierCurveBound = (
     minY = Math.min(minY, ...ys);
     maxY = Math.max(maxY, ...ys);
   }
-  return bounds(minX, minY, maxX, maxY);
+  return [minX, minY, maxX, maxY];
 };
 
 export const getMinMaxXYFromCurvePathOps = (
@@ -681,11 +677,12 @@ export const getMinMaxXYFromCurvePathOps = (
     },
     { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity },
   );
-  return bounds(minX, minY, maxX, maxY);
+  return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = (
-  points: ExcalidrawFreeDrawElement["points"],
+export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
+  points: readonly P[],
+  padding: number = 0,
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -699,7 +696,7 @@ export const getBoundsFromPoints = (
     maxY = Math.max(maxY, y);
   }
 
-  return bounds(minX, minY, maxX, maxY);
+  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -942,7 +939,7 @@ const getLinearElementRotatedBounds = (
   cx: number,
   cy: number,
   elementsMap: ElementsMap,
-): RotatedBounds => {
+): Bounds => {
   const boundTextElement = getBoundTextElement(element, elementsMap);
 
   if (element.points.length < 2) {
@@ -953,21 +950,20 @@ const getLinearElementRotatedBounds = (
       element.angle,
     );
 
-    let coords: RotatedBounds = bounds(x, y, x, y, element.angle);
+    let coords: Bounds = [x, y, x, y];
     if (boundTextElement) {
       const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(
         element,
         elementsMap,
-        bounds(x, y, x, y, element.angle),
+        [x, y, x, y],
         boundTextElement,
       );
-      coords = bounds(
+      coords = [
         coordsWithBoundText[0],
         coordsWithBoundText[1],
         coordsWithBoundText[2],
         coordsWithBoundText[3],
-        element.angle,
-      );
+      ];
     }
     return coords;
   }
@@ -983,13 +979,7 @@ const getLinearElementRotatedBounds = (
       element.angle,
     );
   const res = getMinMaxXYFromCurvePathOps(ops, transformXY);
-  let coords: RotatedBounds = bounds(
-    res[0],
-    res[1],
-    res[2],
-    res[3],
-    element.angle,
-  );
+  let coords: Bounds = [res[0], res[1], res[2], res[3]];
   if (boundTextElement) {
     const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(
       element,
@@ -997,23 +987,22 @@ const getLinearElementRotatedBounds = (
       coords,
       boundTextElement,
     );
-    coords = bounds(
+    coords = [
       coordsWithBoundText[0],
       coordsWithBoundText[1],
       coordsWithBoundText[2],
       coordsWithBoundText[3],
-      element.angle,
-    );
+    ];
   }
   return coords;
 };
 
-export const getElementBounds = <T extends boolean = false>(
+export const getElementBounds = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
-  nonRotated: T = false as T,
-) => {
-  return ElementBounds.getBounds<T>(element, elementsMap, nonRotated);
+  nonRotated: boolean = false,
+): Bounds => {
+  return ElementBounds.getBounds(element, elementsMap, nonRotated);
 };
 
 export const getCommonBounds = (
@@ -1021,7 +1010,7 @@ export const getCommonBounds = (
   elementsMap?: ElementsMap,
 ): Bounds => {
   if (!sizeOf(elements)) {
-    return bounds(0, 0, 0, 0);
+    return [0, 0, 0, 0];
   }
 
   let minX = Infinity;
@@ -1039,7 +1028,7 @@ export const getCommonBounds = (
     maxY = Math.max(maxY, y2);
   });
 
-  return bounds(minX, minY, maxX, maxY);
+  return [minX, minY, maxX, maxY];
 };
 
 export const getDraggedElementsBounds = (
@@ -1062,12 +1051,12 @@ export const getResizedElementAbsoluteCoords = (
   normalizePoints: boolean,
 ): Bounds => {
   if (!(isLinearElement(element) || isFreeDrawElement(element))) {
-    return bounds(
+    return [
       element.x,
       element.y,
       element.x + nextWidth,
       element.y + nextHeight,
-    );
+    ];
   }
 
   const points = rescalePoints(
@@ -1077,11 +1066,11 @@ export const getResizedElementAbsoluteCoords = (
     normalizePoints,
   );
 
-  let _bounds: Bounds;
+  let bounds: Bounds;
 
   if (isFreeDrawElement(element)) {
     // Free Draw
-    _bounds = getBoundsFromPoints(points);
+    bounds = getBoundsFromPoints(points);
   } else {
     // Line
     const gen = rough.generator();
@@ -1093,16 +1082,16 @@ export const getResizedElementAbsoluteCoords = (
       : gen.curve(points as [number, number][], generateRoughOptions(element));
 
     const ops = getCurvePathOps(curve);
-    _bounds = getMinMaxXYFromCurvePathOps(ops);
+    bounds = getMinMaxXYFromCurvePathOps(ops);
   }
 
-  const [minX, minY, maxX, maxY] = _bounds;
-  return bounds(
+  const [minX, minY, maxX, maxY] = bounds;
+  return [
     minX + element.x,
     minY + element.y,
     maxX + element.x,
     maxY + element.y,
-  );
+  ];
 };
 
 export const getElementPointsCoords = (
@@ -1120,20 +1109,20 @@ export const getElementPointsCoords = (
       : gen.curve(points as [number, number][], generateRoughOptions(element));
   const ops = getCurvePathOps(curve);
   const [minX, minY, maxX, maxY] = getMinMaxXYFromCurvePathOps(ops);
-  return bounds(
+  return [
     minX + element.x,
     minY + element.y,
     maxX + element.x,
     maxY + element.y,
-  );
+  ];
 };
 
 export const getClosestElementBounds = (
   elements: readonly ExcalidrawElement[],
   from: { x: number; y: number },
-): RotatedBounds => {
+): Bounds => {
   if (!elements.length) {
-    return bounds(0, 0, 0, 0, 0 as Radians);
+    return [0, 0, 0, 0];
   }
 
   let minDistance = Infinity;
@@ -1202,9 +1191,7 @@ export const getVisibleSceneBounds = ({
   ];
 };
 
-export const getCenterForBounds = (
-  bounds: Bounds | RotatedBounds,
-): GlobalPoint =>
+export const getCenterForBounds = (bounds: Bounds): GlobalPoint =>
   pointFrom(
     bounds[0] + (bounds[2] - bounds[0]) / 2,
     bounds[1] + (bounds[3] - bounds[1]) / 2,
@@ -1249,24 +1236,24 @@ export const aabbForElement = (
     element.angle,
   );
 
-  const _bounds = bounds(
+  const bounds = [
     Math.min(topLeftX, topRightX, bottomRightX, bottomLeftX),
     Math.min(topLeftY, topRightY, bottomRightY, bottomLeftY),
     Math.max(topLeftX, topRightX, bottomRightX, bottomLeftX),
     Math.max(topLeftY, topRightY, bottomRightY, bottomLeftY),
-  );
+  ] as Bounds;
 
   if (offset) {
     const [topOffset, rightOffset, downOffset, leftOffset] = offset;
-    return bounds(
-      _bounds[0] - leftOffset,
-      _bounds[1] - topOffset,
-      _bounds[2] + rightOffset,
-      _bounds[3] + downOffset,
-    );
+    return [
+      bounds[0] - leftOffset,
+      bounds[1] - topOffset,
+      bounds[2] + rightOffset,
+      bounds[3] + downOffset,
+    ] as Bounds;
   }
 
-  return _bounds;
+  return bounds;
 };
 
 export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
@@ -1275,7 +1262,18 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
   p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
 
-export const doNonRotatedBoundsIntersect = (
+// TODO make pointInsideBounds inclusive and remove this function once we
+// test nothing is breaking
+export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
+  p: P,
+  bounds: Bounds,
+): boolean =>
+  p[0] >= bounds[0] &&
+  p[0] <= bounds[2] &&
+  p[1] >= bounds[1] &&
+  p[1] <= bounds[3];
+
+export const doBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
 ): boolean => {
@@ -1289,6 +1287,14 @@ export const doNonRotatedBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
+export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
+  [
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
+  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
+
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,

packages/element/src/collision.ts

@@ -1,9 +1,4 @@
-import {
-  bounds,
-  invariant,
-  isTransparent,
-  type Bounds,
-} from "@excalidraw/common";
+import { invariant, isTransparent, type Bounds } from "@excalidraw/common";
 import {
   curveIntersectLineSegment,
   isPointWithinBounds,
@@ -34,7 +29,7 @@ import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
 
 import { isPathALoop } from "./utils";
 import {
-  doNonRotatedBoundsIntersect,
+  doBoundsIntersect,
   elementCenterPoint,
   getCenterForBounds,
   getCubicBezierCurveBound,
@@ -194,48 +189,6 @@ export const hitElementItself = ({
   return result;
 };
 
-export function getBoundsCorners(
-  bounds: Bounds,
-): readonly [GlobalPoint, GlobalPoint, GlobalPoint, GlobalPoint];
-export function getBoundsCorners(
-  bounds: Bounds,
-  angle: Radians,
-): readonly [GlobalPoint, GlobalPoint, GlobalPoint, GlobalPoint];
-export function getBoundsCorners(
-  bounds: Bounds,
-  angle: Radians = 0 as Radians,
-) {
-  const [x1, y1, x2, y2] = bounds;
-  const center = getCenterForBounds(bounds);
-  const corners = [
-    pointFrom<GlobalPoint>(x1, y1),
-    pointFrom<GlobalPoint>(x2, y1),
-    pointFrom<GlobalPoint>(x2, y2),
-    pointFrom<GlobalPoint>(x1, y2),
-  ] as const;
-
-  if (angle === 0) {
-    return corners;
-  }
-
-  return corners.map((point) => pointRotateRads(point, center, angle)) as [
-    GlobalPoint,
-    GlobalPoint,
-    GlobalPoint,
-    GlobalPoint,
-  ];
-}
-
-export const getBoundsEdges = (
-  corners: readonly [GlobalPoint, GlobalPoint, GlobalPoint, GlobalPoint],
-) =>
-  [
-    lineSegment(corners[0], corners[1]),
-    lineSegment(corners[1], corners[2]),
-    lineSegment(corners[2], corners[3]),
-    lineSegment(corners[3], corners[0]),
-  ] as const;
-
 const isPointInRotatedBounds = (
   point: GlobalPoint,
   bounds: Bounds,
@@ -264,40 +217,6 @@ export const hitElementBoundingBox = (
   return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
 };
 
-export const doBoundsIntersectElementBoundingBox = (
-  intersectorBounds: Bounds,
-  element: ExcalidrawElement,
-  elementsMap: ElementsMap,
-) => {
-  const [x1, y1, x2, y2] = intersectorBounds;
-  const intersectorCorners = [
-    pointFrom<GlobalPoint>(x1, y1),
-    pointFrom<GlobalPoint>(x2, y1),
-    pointFrom<GlobalPoint>(x2, y2),
-    pointFrom<GlobalPoint>(x1, y2),
-  ] as const;
-  const intersectorEdges = getBoundsEdges(intersectorCorners);
-
-  const elementBounds = getElementBounds(element, elementsMap, true);
-  const elementBoundsCorners = getBoundsCorners(elementBounds, element.angle);
-  const elementBoundsEdges = getBoundsEdges(elementBoundsCorners);
-
-  return (
-    elementBoundsCorners.some((point) =>
-      isPointWithinBounds(intersectorCorners[0], point, intersectorCorners[2]),
-    ) ||
-    intersectorCorners.some((point) =>
-      isPointInRotatedBounds(point, elementBounds, element.angle),
-    ) ||
-    intersectorEdges.some((selectionEdge) =>
-      elementBoundsEdges.some(
-        (elementBoundsEdge) =>
-          !!lineSegmentIntersectionPoints(selectionEdge, elementBoundsEdge),
-      ),
-    )
-  );
-};
-
 export const hitElementBoundingBoxOnly = (
   hitArgs: HitTestArgs,
   elementsMap: ElementsMap,
@@ -348,13 +267,9 @@ const bindingBorderTest = (
   // PERF: Run a cheap test to see if the binding element
   // is even close to the element
   const t = Math.max(1, tolerance);
-  const elementBounds = getElementBounds(element, elementsMap, true);
-  if (
-    !doNonRotatedBoundsIntersect(
-      bounds(x - t, y - t, x + t, y + t),
-      elementBounds,
-    )
-  ) {
+  const bounds = [x - t, y - t, x + t, y + t] as Bounds;
+  const elementBounds = getElementBounds(element, elementsMap);
+  if (!doBoundsIntersect(bounds, elementBounds)) {
     return false;
   }
 
@@ -365,7 +280,6 @@ const bindingBorderTest = (
       const enclosingFrameBounds = getElementBounds(
         enclosingFrame,
         elementsMap,
-        true,
       );
       if (!pointInsideBounds(p, enclosingFrameBounds)) {
         return false;
@@ -515,15 +429,15 @@ export const intersectElementWithLineSegment = (
 ): GlobalPoint[] => {
   // First check if the line intersects the element's axis-aligned bounding box
   // as it is much faster than checking intersection against the element's shape
-  const intersectorBounds = bounds(
+  const intersectorBounds = [
     Math.min(line[0][0] - offset, line[1][0] - offset),
     Math.min(line[0][1] - offset, line[1][1] - offset),
     Math.max(line[0][0] + offset, line[1][0] + offset),
     Math.max(line[0][1] + offset, line[1][1] + offset),
-  );
-  const elementBounds = getElementBounds(element, elementsMap, true);
+  ] as Bounds;
+  const elementBounds = getElementBounds(element, elementsMap);
 
-  if (!doNonRotatedBoundsIntersect(intersectorBounds, elementBounds)) {
+  if (!doBoundsIntersect(intersectorBounds, elementBounds)) {
     return [];
   }
 
@@ -582,14 +496,14 @@ const curveIntersections = (
   for (const c of curves) {
     // Optimize by doing a cheap bounding box check first
     const b1 = getCubicBezierCurveBound(c[0], c[1], c[2], c[3]);
-    const b2 = bounds(
+    const b2 = [
       Math.min(segment[0][0], segment[1][0]),
       Math.min(segment[0][1], segment[1][1]),
       Math.max(segment[0][0], segment[1][0]),
       Math.max(segment[0][1], segment[1][1]),
-    );
+    ] as Bounds;
 
-    if (!doNonRotatedBoundsIntersect(b1, b2)) {
+    if (!doBoundsIntersect(b1, b2)) {
       continue;
     }
 
@@ -659,18 +573,20 @@ const intersectLinearOrFreeDrawWithLineSegment = (
   for (const c of curves) {
     // Optimize by doing a cheap bounding box check first
     const b1 = getCubicBezierCurveBound(c[0], c[1], c[2], c[3]);
-    const b2 = bounds(
+    const b2 = [
       Math.min(segment[0][0], segment[1][0]),
       Math.min(segment[0][1], segment[1][1]),
       Math.max(segment[0][0], segment[1][0]),
       Math.max(segment[0][1], segment[1][1]),
-    );
+    ] as Bounds;
 
-    if (!doNonRotatedBoundsIntersect(b1, b2)) {
+    if (!doBoundsIntersect(b1, b2)) {
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment);
+    const hits = curveIntersectLineSegment(c, segment, {
+      iterLimit: 10,
+    });
 
     if (hits.length > 0) {
       intersections.push(...hits);

packages/element/src/frame.ts

@@ -1,7 +1,6 @@
 import { arrayToMap } from "@excalidraw/common";
 import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
 import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
-import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";
 
 import type {
   AppClassProperties,
@@ -18,6 +17,8 @@ import {
   getElementLineSegments,
   getCommonBounds,
   getElementAbsoluteCoords,
+  doBoundsIntersect,
+  getElementBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
@@ -99,7 +100,7 @@ export const isElementContainingFrame = (
   element: ExcalidrawElement,
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
-): boolean => {
+) => {
   return getElementsWithinSelection([frame], element, elementsMap).some(
     (e) => e.id === frame.id,
   );
@@ -140,7 +141,7 @@ export const elementOverlapsWithFrame = (
   element: ExcalidrawElement,
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
-): boolean => {
+) => {
   return (
     elementsAreInFrameBounds([element], frame, elementsMap) ||
     isElementIntersectingFrame(element, frame, elementsMap) ||
@@ -920,16 +921,17 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  elementsMap: ElementsMap,
 ) => {
-  return (
-    elementsOverlappingBBox({
-      elements,
-      bounds: frame,
-      type: "overlap",
-    })
-      // removes elements who are overlapping, but are in a different frame,
+  return elements.filter(
+    (el) =>
+      // exclude elements which are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      .filter((el) => !el.frameId || el.frameId === frame.id)
+      (!el.frameId || el.frameId === frame.id) &&
+      doBoundsIntersect(
+        getElementBounds(el, elementsMap),
+        getElementBounds(frame, elementsMap),
+      ),
   );
 };
 

packages/element/src/linearElementEditor.ts

@@ -21,7 +21,6 @@ import {
   invariant,
   isShallowEqual,
   getFeatureFlag,
-  bounds,
 } from "@excalidraw/common";
 
 import {
@@ -43,7 +42,7 @@ import type {
   NullableGridSize,
   Zoom,
 } from "@excalidraw/excalidraw/types";
-import type { RotatedBounds } from "@excalidraw/common";
+import type { Bounds } from "@excalidraw/common";
 
 import {
   calculateFixedPointForNonElbowArrowBinding,
@@ -1880,7 +1879,7 @@ export class LinearElementEditor {
   static getMinMaxXYWithBoundText = (
     element: ExcalidrawLinearElement,
     elementsMap: ElementsMap,
-    elementBounds: RotatedBounds,
+    elementBounds: Bounds,
     boundTextElement: ExcalidrawTextElementWithContainer,
   ): [number, number, number, number, number, number] => {
     let [x1, y1, x2, y2] = elementBounds;
@@ -2005,7 +2004,7 @@ export class LinearElementEditor {
       return LinearElementEditor.getMinMaxXYWithBoundText(
         element,
         elementsMap,
-        bounds(x1, y1, x2, y2, element.angle),
+        [x1, y1, x2, y2],
         boundTextElement,
       );
     }

packages/element/src/selection.ts

@@ -2,8 +2,8 @@ import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
 import {
   lineSegment,
   pointFrom,
+  pointRotateRads,
   type GlobalPoint,
-  type LineSegment,
 } from "@excalidraw/math";
 
 import type {
@@ -13,20 +13,17 @@ import type {
 } from "@excalidraw/excalidraw/types";
 
 import {
+  boundsContainBounds,
+  doBoundsIntersect,
+  elementCenterPoint,
   getElementAbsoluteCoords,
   getElementBounds,
-  getElementLineSegments,
+  pointInsideBounds,
 } from "./bounds";
-import {
-  doBoundsIntersectElementBoundingBox,
-  getBoundsCorners,
-  getBoundsEdges,
-  intersectElementWithLineSegment,
-  isPointInElement,
-  shouldTestInside,
-} from "./collision";
+import { intersectElementWithLineSegment } from "./collision";
 import { isElementInViewport } from "./sizeHelpers";
 import {
+  isArrowElement,
   isBoundToContainer,
   isFrameLikeElement,
   isFreeDrawElement,
@@ -37,218 +34,38 @@ import {
   elementOverlapsWithFrame,
   getContainingFrame,
   getFrameChildren,
+  isElementIntersectingFrame,
 } from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
+import { getBoundTextElement } from "./textElement";
 
 import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
+  ExcalidrawFrameLikeElement,
   NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
-// Broad-phase only for overlap mode. Rotated closed shapes should not select
-// from the empty corners of their axis-aligned bounds. Linear elements and
-// freedraw already rely on the outline-specific path below, so exclude them.
-const shouldUseRotatedOverlapBroadPhase = (
+const shouldIgnoreElementFromSelection = (
   element: NonDeletedExcalidrawElement,
-) =>
-  element.angle !== 0 &&
-  !isLinearElement(element) &&
-  !isFreeDrawElement(element);
+) => element.locked || isBoundToContainer(element);
 
-const clipLineSegmentToBounds = (
-  segment: LineSegment<GlobalPoint>,
-  bounds: Bounds,
-): LineSegment<GlobalPoint> | null => {
-  const [minX, minY, maxX, maxY] = bounds;
-  const [[x1, y1], [x2, y2]] = segment;
-  const deltaX = x2 - x1;
-  const deltaY = y2 - y1;
-  let tMin = 0;
-  let tMax = 1;
-
-  const clip = (p: number, q: number) => {
-    if (p === 0) {
-      return q >= 0;
-    }
-
-    const ratio = q / p;
-
-    if (p < 0) {
-      if (ratio > tMax) {
-        return false;
-      }
-      tMin = Math.max(tMin, ratio);
-      return true;
-    }
-
-    if (ratio < tMin) {
+const excludeElementsFromFrames = <T extends ExcalidrawElement>(
+  selectedElements: readonly T[],
+  framesInSelection: Set<ExcalidrawFrameLikeElement["id"]>,
+) => {
+  return selectedElements.filter((element) => {
+    if (element.frameId && framesInSelection.has(element.frameId)) {
       return false;
     }
-    tMax = Math.min(tMax, ratio);
-    return true;
-  };
-
-  if (
-    !clip(-deltaX, x1 - minX) ||
-    !clip(deltaX, maxX - x1) ||
-    !clip(-deltaY, y1 - minY) ||
-    !clip(deltaY, maxY - y1)
-  ) {
-    return null;
-  }
-
-  return lineSegment(
-    pointFrom<GlobalPoint>(x1 + tMin * deltaX, y1 + tMin * deltaY),
-    pointFrom<GlobalPoint>(x1 + tMax * deltaX, y1 + tMax * deltaY),
-  );
-};
-
-const isPointWithinAabb = (point: GlobalPoint, bounds: Bounds) =>
-  point[0] >= bounds[0] &&
-  point[0] <= bounds[2] &&
-  point[1] >= bounds[1] &&
-  point[1] <= bounds[3];
-
-const shouldUsePreciseFilledOverlap = (element: NonDeletedExcalidrawElement) =>
-  element.type === "ellipse" ||
-  element.type === "diamond" ||
-  (element.type === "rectangle" && !!element.roundness);
-
-const shouldSkipElementFromSelection = (element: NonDeletedExcalidrawElement) =>
-  element.locked || element.type === "selection" || isBoundToContainer(element);
-
-const getFrameBoundsForSelection = (
-  element: NonDeletedExcalidrawElement,
-  elementsMap: ElementsMap,
-): Bounds | null => {
-  if (!element.frameId) {
-    return null;
-  }
-
-  const containingFrame = getContainingFrame(element, elementsMap);
-  return containingFrame
-    ? (getElementBounds(containingFrame, elementsMap) as Bounds)
-    : null;
-};
-
-const finalizeElementsInSelection = (
-  elementsInSelection: NonDeletedExcalidrawElement[],
-  excludeElementsInFrames: boolean,
-  elementsMap: ElementsMap,
-): NonDeletedExcalidrawElement[] => {
-  elementsInSelection = excludeElementsInFrames
-    ? excludeElementsInFramesFromSelection(elementsInSelection)
-    : elementsInSelection;
-
-  return elementsInSelection.filter((element) => {
-    const containingFrame = getContainingFrame(element, elementsMap);
-
-    if (containingFrame) {
-      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
-    }
-
     return true;
   });
 };
 
-const getVisibleElementOutlineSegments = (
-  element: NonDeletedExcalidrawElement,
-  frameBounds: Bounds | null,
-  elementsMap: ElementsMap,
-) =>
-  frameBounds
-    ? getElementLineSegments(element, elementsMap).flatMap((segment) => {
-        const clippedSegment = clipLineSegmentToBounds(segment, frameBounds);
-        return clippedSegment ? [clippedSegment] : [];
-      })
-    : getElementLineSegments(element, elementsMap);
-
-const doesSelectionIntersectElementOutline = (
-  element: NonDeletedExcalidrawElement,
-  frameBounds: Bounds | null,
-  selectionEdges: readonly LineSegment<GlobalPoint>[],
-  elementsMap: ElementsMap,
-) =>
-  selectionEdges.some((selectionEdge) =>
-    intersectElementWithLineSegment(
-      element,
-      elementsMap,
-      selectionEdge,
-      0,
-      true,
-    ).some((point) => !frameBounds || isPointWithinAabb(point, frameBounds)),
-  );
-
-const doesSelectionContainElementOutline = (
-  outlineSegments: readonly LineSegment<GlobalPoint>[],
-  selectionBounds: Bounds,
-) =>
-  outlineSegments.length > 0 &&
-  outlineSegments.every(
-    (outlineSegment) =>
-      isPointWithinAabb(outlineSegment[0], selectionBounds) &&
-      isPointWithinAabb(outlineSegment[1], selectionBounds),
-  );
-
-const doesSelectionContainElementInterior = (
-  element: NonDeletedExcalidrawElement,
-  frameBounds: Bounds | null,
-  selectionCorners: readonly GlobalPoint[],
-  elementsMap: ElementsMap,
-) =>
-  selectionCorners.some(
-    (selectionCorner) =>
-      (!frameBounds || isPointWithinAabb(selectionCorner, frameBounds)) &&
-      isPointInElement(selectionCorner, element, elementsMap),
-  );
-
-const doesSelectionOverlapFilledElement = (
-  element: NonDeletedExcalidrawElement,
-  frameBounds: Bounds | null,
-  selectionBounds: Bounds,
-  selectionCorners: readonly GlobalPoint[],
-  selectionEdges: readonly LineSegment<GlobalPoint>[],
-  elementsMap: ElementsMap,
-) => {
-  if (
-    doesSelectionContainElementInterior(
-      element,
-      frameBounds,
-      selectionCorners,
-      elementsMap,
-    )
-  ) {
-    return true;
-  }
-
-  if (
-    doesSelectionIntersectElementOutline(
-      element,
-      frameBounds,
-      selectionEdges,
-      elementsMap,
-    )
-  ) {
-    return true;
-  }
-
-  const outlineSegments = getVisibleElementOutlineSegments(
-    element,
-    frameBounds,
-    elementsMap,
-  );
-
-  return (
-    outlineSegments.length > 0 &&
-    doesSelectionContainElementOutline(outlineSegments, selectionBounds)
-  );
-};
-
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -268,18 +85,14 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return selectedElements.filter((element) => {
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
+  return excludeElementsFromFrames(selectedElements, framesInSelection);
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
+  // TODO remove (this flag is effectively unused AFAIK)
   excludeElementsInFrames: boolean = true,
   boxSelectionMode: BoxSelectionMode = "contain",
 ): NonDeletedExcalidrawElement[] => {
@@ -295,152 +108,233 @@ export const getElementsWithinSelection = (
     selectionX2,
     selectionY2,
   ] as Bounds;
+  const selectionEdges = [
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY1),
+      pointFrom(selectionX2, selectionY1),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY1),
+      pointFrom(selectionX2, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY2),
+      pointFrom(selectionX1, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY2),
+      pointFrom(selectionX1, selectionY1),
+    ),
+  ];
 
-  if (boxSelectionMode !== "overlap") {
-    const elementsInSelection: NonDeletedExcalidrawElement[] = [];
-
-    for (const element of elements) {
-      if (shouldSkipElementFromSelection(element)) {
-        continue;
-      }
-
-      const elementBounds = getElementBounds(element, elementsMap) as Bounds;
-      const frameBounds = getFrameBoundsForSelection(element, elementsMap);
-      let elementX1 = elementBounds[0];
-      let elementY1 = elementBounds[1];
-      let elementX2 = elementBounds[2];
-      let elementY2 = elementBounds[3];
-
-      if (frameBounds) {
-        elementX1 = Math.max(frameBounds[0], elementX1);
-        elementY1 = Math.max(frameBounds[1], elementY1);
-        elementX2 = Math.min(frameBounds[2], elementX2);
-        elementY2 = Math.min(frameBounds[3], elementY2);
-      }
-
-      if (
-        selectionX1 <= elementX1 &&
-        selectionY1 <= elementY1 &&
-        selectionX2 >= elementX2 &&
-        selectionY2 >= elementY2
-      ) {
-        elementsInSelection.push(element);
-      }
-    }
-
-    return finalizeElementsInSelection(
-      elementsInSelection,
-      excludeElementsInFrames,
-      elementsMap,
-    );
-  }
-
-  const selectionCorners = getBoundsCorners(selectionBounds);
-  const selectionEdges = getBoundsEdges(selectionCorners);
-  const elementsInSelection: NonDeletedExcalidrawElement[] = [];
+  const framesInSelection = excludeElementsInFrames
+    ? new Set<NonDeletedExcalidrawElement["id"]>()
+    : null;
+  let elementsInSelection: NonDeletedExcalidrawElement[] = [];
 
   for (const element of elements) {
-    if (shouldSkipElementFromSelection(element)) {
+    if (shouldIgnoreElementFromSelection(element)) {
       continue;
     }
 
-    const elementBounds = getElementBounds(element, elementsMap) as Bounds;
-    const frameBounds = getFrameBoundsForSelection(element, elementsMap);
-    let elementX1 = elementBounds[0];
-    let elementY1 = elementBounds[1];
-    let elementX2 = elementBounds[2];
-    let elementY2 = elementBounds[3];
+    const strokeWidth = element.strokeWidth;
+    let labelAABB: Bounds | null = null;
+    let elementAABB = getElementBounds(element, elementsMap);
 
-    if (frameBounds) {
-      elementX1 = Math.max(frameBounds[0], elementX1);
-      elementY1 = Math.max(frameBounds[1], elementY1);
-      elementX2 = Math.min(frameBounds[2], elementX2);
-      elementY2 = Math.min(frameBounds[3], elementY2);
+    elementAABB = [
+      elementAABB[0] - strokeWidth / 2,
+      elementAABB[1] - strokeWidth / 2,
+      elementAABB[2] + strokeWidth / 2,
+      elementAABB[3] + strokeWidth / 2,
+    ] as Bounds;
+
+    // Whether the element bounds should include the bound text element bounds
+    const boundTextElement =
+      isArrowElement(element) && getBoundTextElement(element, elementsMap);
+    if (boundTextElement) {
+      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
+        element,
+        boundTextElement,
+        elementsMap,
+      );
+      labelAABB = [
+        x,
+        y,
+        x + boundTextElement.width,
+        y + boundTextElement.height,
+      ] as Bounds;
     }
 
-    const isSelectionContainingElement =
-      selectionX1 <= elementX1 &&
-      selectionY1 <= elementY1 &&
-      selectionX2 >= elementX2 &&
-      selectionY2 >= elementY2;
+    // Clip element bounds by its containing frame (if any), since only the
+    // visible (frame-clipped) portion of the element is relevant for selection.
+    const associatedFrame = getContainingFrame(element, elementsMap);
+    if (
+      associatedFrame &&
+      isElementIntersectingFrame(element, associatedFrame, elementsMap)
+    ) {
+      const frameAABB = getElementBounds(associatedFrame, elementsMap);
+      elementAABB = [
+        Math.max(elementAABB[0], frameAABB[0]),
+        Math.max(elementAABB[1], frameAABB[1]),
+        Math.min(elementAABB[2], frameAABB[2]),
+        Math.min(elementAABB[3], frameAABB[3]),
+      ] as Bounds;
 
-    const isSelectionOverlappingElementAabb =
-      selectionX1 <= elementX2 &&
-      selectionY1 <= elementY2 &&
-      selectionX2 >= elementX1 &&
-      selectionY2 >= elementY1;
-    const isSelectionOverlappingElement = shouldUseRotatedOverlapBroadPhase(
-      element,
-    )
-      ? isSelectionOverlappingElementAabb &&
-        doBoundsIntersectElementBoundingBox(
-          selectionBounds,
+      labelAABB = labelAABB
+        ? ([
+            Math.max(labelAABB[0], frameAABB[0]),
+            Math.max(labelAABB[1], frameAABB[1]),
+            Math.min(labelAABB[2], frameAABB[2]),
+            Math.min(labelAABB[3], frameAABB[3]),
+          ] as Bounds)
+        : null;
+    }
+
+    const commonAABB = labelAABB
+      ? ([
+          Math.min(labelAABB[0], elementAABB[0]),
+          Math.min(labelAABB[1], elementAABB[1]),
+          Math.max(labelAABB[2], elementAABB[2]),
+          Math.max(labelAABB[3], elementAABB[3]),
+        ] as Bounds)
+      : elementAABB;
+
+    // ============== Evaluation ==============
+
+    // 1. If the selection box WRAPs the element's AABB, then add it to the
+    //    selection and move on, regardless of the selection mode.
+    //
+    //    PERF: This trick only works with axis-aligned box selection and the
+    //          current convex element shapes!
+    if (boundsContainBounds(selectionBounds, commonAABB)) {
+      if (framesInSelection && isFrameLikeElement(element)) {
+        framesInSelection.add(element.id);
+      } else {
+        elementsInSelection.push(element);
+        continue;
+      }
+    }
+
+    // 2. Handle the case where the label is overlapped by the selection box
+    if (
+      boxSelectionMode === "overlap" &&
+      labelAABB &&
+      doBoundsIntersect(selectionBounds, labelAABB)
+    ) {
+      elementsInSelection.push(element);
+      continue;
+    }
+
+    // 3. Handle the case where the selection is not wrapping the element, but
+    //    it does intersect the element's outline (non-AABB).
+    if (
+      boxSelectionMode === "overlap" &&
+      doBoundsIntersect(selectionBounds, elementAABB)
+    ) {
+      let hasIntersection = false;
+
+      // Preliminary check potential intersection imprecision
+      if (isLinearElement(element) || isFreeDrawElement(element)) {
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = element.points.some((point) => {
+          const rotatedPoint = pointRotateRads(
+            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
+            center,
+            element.angle,
+          );
+
+          return pointInsideBounds(rotatedPoint, selectionBounds);
+        });
+      } else {
+        const nonRotatedElementBounds = getElementBounds(
           element,
           elementsMap,
-        )
-      : isSelectionOverlappingElementAabb;
-
-    const shouldSelectFromInside = shouldTestInside(element);
-
-    if (shouldSelectFromInside) {
-      if (
-        isSelectionOverlappingElement &&
-        (!shouldUsePreciseFilledOverlap(element) ||
-          isSelectionContainingElement ||
-          doesSelectionOverlapFilledElement(
-            element,
-            frameBounds,
+          true,
+        );
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = [
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[1],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[2],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[3],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[0],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+        ].some((point) => {
+          return pointInsideBounds(
+            pointRotateRads(point, center, element.angle),
             selectionBounds,
-            selectionCorners,
-            selectionEdges,
-            elementsMap,
-          ))
-      ) {
-        elementsInSelection.push(element);
+          );
+        });
+      }
+
+      if (!hasIntersection) {
+        hasIntersection = selectionEdges.some(
+          (selectionEdge) =>
+            intersectElementWithLineSegment(
+              element,
+              elementsMap,
+              selectionEdge,
+              strokeWidth / 2,
+              true, // Stop at first hit for better performance
+            ).length > 0,
+        );
+      }
+
+      if (hasIntersection) {
+        if (framesInSelection && isFrameLikeElement(element)) {
+          framesInSelection.add(element.id);
+        }
+
+        elementsInSelection.push(element);
+        continue;
       }
-      continue;
     }
 
-    if (!isSelectionOverlappingElement) {
-      continue;
-    }
-
-    if (isSelectionContainingElement) {
-      elementsInSelection.push(element);
-      continue;
-    }
-
-    if (
-      doesSelectionIntersectElementOutline(
-        element,
-        frameBounds,
-        selectionEdges,
-        elementsMap,
-      )
-    ) {
-      elementsInSelection.push(element);
-      continue;
-    }
-
-    const outlineSegments = getVisibleElementOutlineSegments(
-      element,
-      frameBounds,
-      elementsMap,
-    );
-
-    if (
-      outlineSegments.length > 0 &&
-      doesSelectionContainElementOutline(outlineSegments, selectionBounds)
-    ) {
-      elementsInSelection.push(element);
-    }
+    // 4. We don't need to handle when the selection is inside the element
+    //    as it is separately handled in App.
   }
 
-  return finalizeElementsInSelection(
-    elementsInSelection,
-    excludeElementsInFrames,
-    elementsMap,
-  );
+  elementsInSelection = framesInSelection
+    ? excludeElementsFromFrames(elementsInSelection, framesInSelection)
+    : elementsInSelection;
+
+  elementsInSelection = elementsInSelection.filter((element) => {
+    const containingFrame = getContainingFrame(element, elementsMap);
+
+    if (containingFrame) {
+      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
+    }
+
+    return true;
+  });
+
+  return elementsInSelection;
 };
 
 export const getVisibleAndNonSelectedElements = (

packages/element/tests/collision.test.tsx

@@ -1,4 +1,4 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMap, reseed } from "@excalidraw/common";
 import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";
 import { Excalidraw } from "@excalidraw/excalidraw";
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
@@ -12,6 +12,7 @@ import { hitElementItself } from "../src/collision";
 describe("check rotated elements can be hit:", () => {
   beforeEach(async () => {
     localStorage.clear();
+    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 
@@ -29,7 +30,7 @@ describe("check rotated elements can be hit:", () => {
       ] as LocalPoint[],
     });
     const hit = hitElementItself({
-      point: pointFrom<GlobalPoint>(87, -67),
+      point: pointFrom<GlobalPoint>(88, -68),
       element: window.h.elements[0],
       threshold: 10,
       elementsMap: window.h.scene.getNonDeletedElementsMap(),
@@ -56,6 +57,7 @@ describe("hitElementItself cache", () => {
     });
 
     localStorage.clear();
+    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 

packages/excalidraw/actions/actionCanvas.tsx

@@ -40,6 +40,7 @@ import {
   ZoomResetIcon,
 } from "../components/icons";
 import { setCursor } from "../cursor";
+import { constrainScrollState } from "../scene/scrollConstraints";
 
 import { t } from "../i18n";
 import { getNormalizedZoom } from "../scene";
@@ -51,6 +52,8 @@ import { register } from "./register";
 
 import type { AppState, Offsets } from "../types";
 
+const canUseZoomActions = (appState: AppState) => !appState.scrollConstraints;
+
 export const actionChangeViewBackgroundColor = register<Partial<AppState>>({
   name: "changeViewBackgroundColor",
   label: "labels.canvasBackground",
@@ -139,7 +142,7 @@ export const actionZoomIn = register({
   trackEvent: { category: "canvas" },
   perform: (_elements, appState, _, app) => {
     return {
-      appState: {
+      appState: constrainScrollState({
         ...appState,
         ...getStateForZoom(
           {
@@ -150,7 +153,7 @@ export const actionZoomIn = register({
           appState,
         ),
         userToFollow: null,
-      },
+      }),
       captureUpdate: CaptureUpdateAction.EVENTUALLY,
     };
   },
@@ -180,7 +183,7 @@ export const actionZoomOut = register({
   trackEvent: { category: "canvas" },
   perform: (_elements, appState, _, app) => {
     return {
-      appState: {
+      appState: constrainScrollState({
         ...appState,
         ...getStateForZoom(
           {
@@ -191,7 +194,7 @@ export const actionZoomOut = register({
           appState,
         ),
         userToFollow: null,
-      },
+      }),
       captureUpdate: CaptureUpdateAction.EVENTUALLY,
     };
   },
@@ -243,6 +246,7 @@ export const actionResetZoom = register({
         className="reset-zoom-button zoom-button"
         title={t("buttons.resetZoom")}
         aria-label={t("buttons.resetZoom")}
+        disabled={!canUseZoomActions(appState)}
         onClick={() => {
           updateData(null);
         }}
@@ -251,6 +255,7 @@ export const actionResetZoom = register({
       </ToolButton>
     </Tooltip>
   ),
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   keyTest: (event) =>
     (event.code === CODES.ZERO || event.code === CODES.NUM_ZERO) &&
     (event[KEYS.CTRL_OR_CMD] || event.shiftKey),
@@ -274,7 +279,7 @@ const zoomValueToFitBoundsOnViewport = (
   return Math.min(adjustedZoomValue, 1);
 };
 
-export const zoomToFitBounds = ({
+export function resolveViewportForBounds({
   bounds,
   appState,
   canvasOffsets,
@@ -292,7 +297,7 @@ export const zoomToFitBounds = ({
   viewportZoomFactor?: number;
   minZoom?: number;
   maxZoom?: number;
-}) => {
+}) {
   viewportZoomFactor = clamp(viewportZoomFactor, MIN_ZOOM, MAX_ZOOM);
 
   const [x1, y1, x2, y2] = bounds;
@@ -345,12 +350,58 @@ export const zoomToFitBounds = ({
     zoom: { value: newZoomValue },
   });
 
+  return {
+    bounds,
+    scrollX: centerScroll.scrollX,
+    scrollY: centerScroll.scrollY,
+    zoom: { value: newZoomValue },
+    viewportZoomFactor,
+    viewportDimensions: {
+      width: appState.width,
+      height: appState.height,
+    },
+    effectiveViewportDimensions: {
+      width: effectiveCanvasWidth,
+      height: effectiveCanvasHeight,
+    },
+  };
+}
+
+export const zoomToFitBounds = ({
+  bounds,
+  appState,
+  canvasOffsets,
+  fitToViewport = false,
+  viewportZoomFactor = 1,
+  minZoom = -Infinity,
+  maxZoom = Infinity,
+}: {
+  bounds: SceneBounds;
+  canvasOffsets?: Offsets;
+  appState: Readonly<AppState>;
+  /** whether to fit content to viewport (beyond >100%) */
+  fitToViewport: boolean;
+  /** zoom content to cover X of the viewport, when fitToViewport=true */
+  viewportZoomFactor?: number;
+  minZoom?: number;
+  maxZoom?: number;
+}) => {
+  const resolvedViewport = resolveViewportForBounds({
+    bounds,
+    appState,
+    canvasOffsets,
+    fitToViewport,
+    viewportZoomFactor,
+    minZoom,
+    maxZoom,
+  });
+
   return {
     appState: {
       ...appState,
-      scrollX: centerScroll.scrollX,
-      scrollY: centerScroll.scrollY,
-      zoom: { value: newZoomValue },
+      scrollX: resolvedViewport.scrollX,
+      scrollY: resolvedViewport.scrollY,
+      zoom: resolvedViewport.zoom,
     },
     captureUpdate: CaptureUpdateAction.EVENTUALLY,
   };
@@ -408,6 +459,7 @@ export const actionZoomToFitSelectionInViewport = register({
       canvasOffsets: app.getEditorUIOffsets(),
     });
   },
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   // NOTE shift-2 should have been assigned actionZoomToFitSelection.
   // TBD on how proceed
   keyTest: (event) =>
@@ -434,6 +486,7 @@ export const actionZoomToFitSelection = register({
       canvasOffsets: app.getEditorUIOffsets(),
     });
   },
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   // NOTE this action should use shift-2 per figma, alas
   keyTest: (event) =>
     event.code === CODES.THREE &&
@@ -458,6 +511,7 @@ export const actionZoomToFit = register({
       fitToViewport: false,
       canvasOffsets: app.getEditorUIOffsets(),
     }),
+  predicate: (_elements, appState) => canUseZoomActions(appState),
   keyTest: (event) =>
     event.code === CODES.ONE &&
     event.shiftKey &&

packages/excalidraw/actions/actionGroup.tsx

@@ -49,9 +49,18 @@ import { register } from "./register";
 
 import type { AppClassProperties, AppState } from "../types";
 
-const allElementsInSameGroup = (elements: readonly ExcalidrawElement[]) => {
+const allElementsInSameGroup = (
+  elements: readonly ExcalidrawElement[],
+  editingGroupId: AppState["editingGroupId"],
+) => {
   if (elements.length >= 2) {
-    const groupIds = elements[0].groupIds;
+    const editingGroupIndex = editingGroupId
+      ? elements[0].groupIds.indexOf(editingGroupId)
+      : -1;
+    const groupIds =
+      editingGroupIndex > -1
+        ? elements[0].groupIds.slice(0, editingGroupIndex)
+        : elements[0].groupIds;
     for (const groupId of groupIds) {
       if (
         elements.reduce(
@@ -78,7 +87,7 @@ const enableActionGroup = (
 
   return (
     selectedElements.length >= 2 &&
-    !allElementsInSameGroup(selectedElements) &&
+    !allElementsInSameGroup(selectedElements, appState.editingGroupId) &&
     !frameAndChildrenSelectedTogether(selectedElements)
   );
 };

packages/excalidraw/actions/actionToggleSearchMenu.ts

@@ -53,8 +53,5 @@ export const actionToggleSearchMenu = register({
     };
   },
   checked: (appState: AppState) => appState.gridModeEnabled,
-  predicate: (element, appState, props) => {
-    return props.gridModeEnabled === undefined;
-  },
   keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.key === KEYS.F,
 });

packages/excalidraw/actions/manager.tsx

@@ -95,6 +95,13 @@ export class ActionManager {
           (action.name in canvasActions
             ? canvasActions[action.name as keyof typeof canvasActions]
             : true) &&
+          (!action.predicate ||
+            action.predicate(
+              this.getElementsIncludingDeleted(),
+              this.getAppState(),
+              this.app.props,
+              this.app,
+            )) &&
           action.keyTest &&
           action.keyTest(
             event,

packages/excalidraw/appState.ts

@@ -122,12 +122,14 @@ export const getDefaultAppState = (): Omit<
     objectsSnapModeEnabled: false,
     userToFollow: null,
     followedBy: new Set(),
+    scrollConstraints: null,
     isCropping: false,
     croppingElementId: null,
     searchMatches: null,
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
+    boxSelectionMode: "contain",
   };
 };
 
@@ -249,6 +251,7 @@ const APP_STATE_STORAGE_CONF = (<
   objectsSnapModeEnabled: { browser: true, export: false, server: false },
   userToFollow: { browser: false, export: false, server: false },
   followedBy: { browser: false, export: false, server: false },
+  scrollConstraints: { browser: true, 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 },

packages/excalidraw/components/App.tsx

@@ -246,7 +246,7 @@ import {
   bindOrUnbindBindingElement,
   mutateElement,
   getElementBounds,
-  doNonRotatedBoundsIntersect,
+  doBoundsIntersect,
   isPointInElement,
   maxBindingDistance_simple,
   convertToExcalidrawElements,
@@ -326,7 +326,10 @@ import {
   actionToggleCropEditor,
 } from "../actions";
 import { actionWrapTextInContainer } from "../actions/actionBoundText";
-import { actionToggleHandTool, zoomToFit } from "../actions/actionCanvas";
+import {
+  actionToggleHandTool,
+  resolveViewportForBounds,
+} from "../actions/actionCanvas";
 import { actionPaste } from "../actions/actionClipboard";
 import { actionCopyElementLink } from "../actions/actionElementLink";
 import { actionUnlockAllElements } from "../actions/actionElementLock";
@@ -370,7 +373,7 @@ import {
   hasBackground,
   isSomeElementSelected,
 } from "../scene";
-import { getStateForZoom } from "../scene/zoom";
+import { getConstrainedZoomAnchor, getStateForZoom } from "../scene/zoom";
 import {
   dataURLToString,
   generateIdFromFile,
@@ -426,6 +429,12 @@ import { isMaybeMermaidDefinition } from "../mermaid";
 
 import { LassoTrail } from "../lasso";
 
+import {
+  constrainScrollState,
+  calculateConstrainedScrollCenter,
+  areCanvasTranslatesClose,
+  getScrollConstraintsForBounds,
+} from "../scene/scrollConstraints";
 import { EraserTrail } from "../eraser";
 
 import { getShortcutKey } from "../shortcut";
@@ -488,6 +497,9 @@ import type {
   CollaboratorPointer,
   ToolType,
   OnUserFollowedPayload,
+  ScrollConstraints,
+  AnimateTranslateCanvasValues,
+  ScrollToContentOptions,
   UnsubscribeCallback,
   EmbedsValidationStatus,
   ElementsPendingErasure,
@@ -540,6 +552,7 @@ const ExcalidrawAppStateContext = React.createContext<AppState>({
   height: 0,
   offsetLeft: 0,
   offsetTop: 0,
+  scrollConstraints: null,
 });
 ExcalidrawAppStateContext.displayName = "ExcalidrawAppStateContext";
 
@@ -594,6 +607,20 @@ let isDraggingScrollBar: boolean = false;
 let currentScrollBars: ScrollBars = { horizontal: null, vertical: null };
 let touchTimeout = 0;
 let invalidateContextMenu = false;
+let scrollConstraintsAnimationTimeout: ReturnType<typeof setTimeout> | null =
+  null;
+
+const areScrollConstraintsEqual = (
+  left: ScrollConstraints | null | undefined,
+  right: ScrollConstraints | null | undefined,
+) => {
+  return left === right || (!!left && !!right && isShallowEqual(left, right));
+};
+
+const SET_SCROLL_CONSTRAINTS_CONTROLLED_WARNING =
+  "Excalidraw: `setScrollConstraints()` is ignored when the `scrollConstraints` prop is controlled.";
+const SCROLL_TO_CONTENT_SCROLL_LOCK_CONTROLLED_WARNING =
+  "Excalidraw: `scrollToContent()` with `scrollLock` is ignored when the `scrollConstraints` prop is controlled.";
 
 /**
  * Map of youtube embed video states
@@ -781,6 +808,8 @@ class App extends React.Component<AppProps, AppState> {
       onUserFollow: (cb) => this.onUserFollowEmitter.on(cb),
       onStateChange: this.onStateChange,
       onEvent: this.onEvent,
+      app: this,
+      setScrollConstraints: this.setScrollConstraints,
     };
     return api;
   }
@@ -795,6 +824,7 @@ class App extends React.Component<AppProps, AppState> {
       objectsSnapModeEnabled = false,
       theme = defaultAppState.theme,
       name = `${t("labels.untitled")}-${getDateTime()}`,
+      scrollConstraints,
     } = props;
 
     this.state = {
@@ -810,6 +840,7 @@ class App extends React.Component<AppProps, AppState> {
       name,
       width: window.innerWidth,
       height: window.innerHeight,
+      scrollConstraints: scrollConstraints ?? null,
     };
 
     this.refreshEditorInterface();
@@ -1154,7 +1185,7 @@ class App extends React.Component<AppProps, AppState> {
         startBounds &&
         endBounds &&
         startElement.id !== endElement.id &&
-        doNonRotatedBoundsIntersect(startBounds, endBounds)
+        doBoundsIntersect(startBounds, endBounds)
       );
     }
 
@@ -2525,6 +2556,7 @@ class App extends React.Component<AppProps, AppState> {
     const magicFrameChildren = getElementsOverlappingFrame(
       this.scene.getNonDeletedElements(),
       magicFrame,
+      this.scene.getNonDeletedElementsMap(),
     ).filter((el) => !isMagicFrameElement(el));
 
     if (!magicFrameChildren.length) {
@@ -2944,7 +2976,13 @@ class App extends React.Component<AppProps, AppState> {
       toast: this.state.toast,
     };
 
-    if (initialData?.scrollToContent) {
+    if (this.props.scrollConstraints) {
+      restoredAppState = {
+        ...restoredAppState,
+        scrollConstraints: this.props.scrollConstraints,
+        ...calculateConstrainedScrollCenter(this.state, restoredAppState),
+      };
+    } else if (initialData?.scrollToContent) {
       restoredAppState = {
         ...restoredAppState,
         ...calculateScrollCenter(restoredElements, {
@@ -2953,10 +2991,18 @@ class App extends React.Component<AppProps, AppState> {
           height: this.state.height,
           offsetTop: this.state.offsetTop,
           offsetLeft: this.state.offsetLeft,
+          scrollConstraints: this.state.scrollConstraints,
         }),
       };
     }
 
+    if (initialData?.scrollX != null) {
+      restoredAppState.scrollX = initialData.scrollX;
+    }
+    if (initialData?.scrollY != null) {
+      restoredAppState.scrollY = initialData.scrollY;
+    }
+
     this.resetStore();
     this.resetHistory();
     this.syncActionResult({
@@ -3207,7 +3253,11 @@ class App extends React.Component<AppProps, AppState> {
       .forEach((element) => ShapeCache.delete(element));
     this.refreshEditorInterface();
     this.updateDOMRect();
-    this.setState({});
+    if (this.state.scrollConstraints) {
+      this.setState((state) => constrainScrollState(state));
+    } else {
+      this.setState({});
+    }
   });
 
   /** generally invoked only if fullscreen was invoked programmatically */
@@ -3457,6 +3507,15 @@ class App extends React.Component<AppProps, AppState> {
       this.setState({ viewModeEnabled: !!this.props.viewModeEnabled });
     }
 
+    if (
+      !areScrollConstraintsEqual(
+        prevProps.scrollConstraints,
+        this.props.scrollConstraints,
+      )
+    ) {
+      this.syncScrollConstraints(this.props.scrollConstraints ?? null);
+    }
+
     if (prevState.viewModeEnabled !== this.state.viewModeEnabled) {
       this.addEventListeners();
       this.deselectElements();
@@ -3517,6 +3576,33 @@ class App extends React.Component<AppProps, AppState> {
       this.props.onChange?.(elements, this.state, this.files);
       this.onChangeEmitter.trigger(elements, this.state, this.files);
     }
+
+    if (this.state.scrollConstraints?.animateOnNextUpdate) {
+      const newState = constrainScrollState(this.state, "rigid");
+      const fromValues = {
+        scrollX: this.state.scrollX,
+        scrollY: this.state.scrollY,
+        zoom: this.state.zoom.value,
+      };
+      const toValues = {
+        scrollX: newState.scrollX,
+        scrollY: newState.scrollY,
+        zoom: newState.zoom.value,
+      };
+
+      if (areCanvasTranslatesClose(fromValues, toValues)) {
+        return;
+      }
+
+      if (scrollConstraintsAnimationTimeout) {
+        clearTimeout(scrollConstraintsAnimationTimeout);
+      }
+
+      scrollConstraintsAnimationTimeout = setTimeout(() => {
+        this.cancelInProgressAnimation?.();
+        this.animateToConstrainedArea(fromValues, toValues);
+      }, 200);
+    }
   }
 
   private renderInteractiveSceneCallback = ({
@@ -4284,8 +4370,8 @@ class App extends React.Component<AppProps, AppState> {
      */
     value: number,
   ) => {
-    this.setState({
-      ...getStateForZoom(
+    this.setState(
+      getStateForZoom(
         {
           viewportX: this.state.width / 2 + this.state.offsetLeft,
           viewportY: this.state.height / 2 + this.state.offsetTop,
@@ -4293,11 +4379,13 @@ class App extends React.Component<AppProps, AppState> {
         },
         this.state,
       ),
-    });
+    );
   };
 
   private cancelInProgressAnimation: (() => void) | null = null;
 
+  private scrollToContentRequestId = 0;
+
   scrollToContent = (
     /**
      * target to scroll to
@@ -4309,30 +4397,13 @@ class App extends React.Component<AppProps, AppState> {
       | string
       | ExcalidrawElement
       | readonly ExcalidrawElement[] = this.scene.getNonDeletedElements(),
-    opts?: (
-      | {
-          fitToContent?: boolean;
-          fitToViewport?: never;
-          viewportZoomFactor?: number;
-          animate?: boolean;
-          duration?: number;
-        }
-      | {
-          fitToContent?: never;
-          fitToViewport?: boolean;
-          /** when fitToViewport=true, how much screen should the content cover,
-           * between 0.1 (10%) and 1 (100%)
-           */
-          viewportZoomFactor?: number;
-          animate?: boolean;
-          duration?: number;
-        }
-    ) & {
-      minZoom?: number;
-      maxZoom?: number;
-      canvasOffsets?: Offsets;
-    },
+    opts?: ScrollToContentOptions,
   ) => {
+    if (opts?.scrollLock && this.props.scrollConstraints !== undefined) {
+      console.warn(SCROLL_TO_CONTENT_SCROLL_LOCK_CONTROLLED_WARNING);
+      opts = { ...opts, scrollLock: undefined };
+    }
+
     if (typeof target === "string") {
       let id: string | null;
       if (isElementLink(target)) {
@@ -4344,10 +4415,29 @@ class App extends React.Component<AppProps, AppState> {
         const elements = this.scene.getElementsFromId(id);
 
         if (elements?.length) {
-          this.scrollToContent(elements, {
-            fitToContent: opts?.fitToContent ?? true,
-            animate: opts?.animate ?? true,
-          });
+          if (opts?.fitToViewport) {
+            this.scrollToContent(elements, {
+              fitToViewport: true,
+              viewportZoomFactor: opts.viewportZoomFactor,
+              animate: opts.animate ?? true,
+              duration: opts.duration,
+              scrollLock: opts.scrollLock,
+              minZoom: opts.minZoom,
+              maxZoom: opts.maxZoom,
+              canvasOffsets: opts.canvasOffsets,
+            });
+          } else {
+            this.scrollToContent(elements, {
+              fitToContent: opts?.fitToContent ?? true,
+              viewportZoomFactor: opts?.viewportZoomFactor,
+              animate: opts?.animate ?? true,
+              duration: opts?.duration,
+              scrollLock: opts?.scrollLock,
+              minZoom: opts?.minZoom,
+              maxZoom: opts?.maxZoom,
+              canvasOffsets: opts?.canvasOffsets,
+            });
+          }
         } else if (isElementLink(target)) {
           this.setState({
             toast: {
@@ -4362,27 +4452,45 @@ class App extends React.Component<AppProps, AppState> {
     }
 
     this.cancelInProgressAnimation?.();
+    this.scrollToContentRequestId += 1;
+    this.debounceConstrainScrollState.cancel();
+
+    if (scrollConstraintsAnimationTimeout) {
+      clearTimeout(scrollConstraintsAnimationTimeout);
+      scrollConstraintsAnimationTimeout = null;
+    }
+
+    if (opts?.scrollLock != null && this.state.scrollConstraints) {
+      // Clear the previous lock before starting the next locked transition so
+      // stale constraint enforcement cannot snap us back mid-flight.
+      this.setState({ scrollConstraints: null });
+    }
 
     // convert provided target into ExcalidrawElement[] if necessary
     const targetElements = Array.isArray(target) ? target : [target];
 
+    if (!targetElements.length) {
+      return;
+    }
+
     let zoom = this.state.zoom;
     let scrollX = this.state.scrollX;
     let scrollY = this.state.scrollY;
+    const targetBounds = getCommonBounds(targetElements);
 
     if (opts?.fitToContent || opts?.fitToViewport) {
-      const { appState } = zoomToFit({
+      const resolvedViewport = resolveViewportForBounds({
+        bounds: targetBounds,
         canvasOffsets: opts.canvasOffsets,
-        targetElements,
         appState: this.state,
         fitToViewport: !!opts?.fitToViewport,
         viewportZoomFactor: opts?.viewportZoomFactor,
         minZoom: opts?.minZoom,
         maxZoom: opts?.maxZoom,
       });
-      zoom = appState.zoom;
-      scrollX = appState.scrollX;
-      scrollY = appState.scrollY;
+      zoom = resolvedViewport.zoom;
+      scrollX = resolvedViewport.scrollX;
+      scrollY = resolvedViewport.scrollY;
     } else {
       // compute only the viewport location, without any zoom adjustment
       const scroll = calculateScrollCenter(targetElements, this.state);
@@ -4390,51 +4498,72 @@ class App extends React.Component<AppProps, AppState> {
       scrollY = scroll.scrollY;
     }
 
+    const scrollConstraints = opts?.scrollLock
+      ? getScrollConstraintsForBounds({
+          bounds: targetBounds,
+          zoom,
+          viewportDimensions: {
+            width: this.state.width,
+            height: this.state.height,
+          },
+          scrollLock: opts.scrollLock,
+        })
+      : null;
+    const requestId = this.scrollToContentRequestId;
+
+    const installScrollConstraints = () => {
+      if (!scrollConstraints || requestId !== this.scrollToContentRequestId) {
+        return;
+      }
+
+      this.setState({
+        scrollConstraints,
+      });
+    };
+
     // when animating, we use RequestAnimationFrame to prevent the animation
     // from slowing down other processes
     if (opts?.animate) {
-      const origScrollX = this.state.scrollX;
-      const origScrollY = this.state.scrollY;
-      const origZoom = this.state.zoom.value;
+      const fromValues = {
+        scrollX: this.state.scrollX,
+        scrollY: this.state.scrollY,
+        zoom: 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) => {
-          // for zoom, use different easing
-          if (key === "zoom") {
-            return from * Math.pow(to / from, easeOut(progress));
-          }
-          // handle using default
-          return undefined;
-        },
-        onStep: ({ scrollX, scrollY, zoom }) => {
-          this.setState({
-            scrollX,
-            scrollY,
-            zoom: { value: zoom },
-          });
-        },
+      const toValues = { scrollX, scrollY, zoom: zoom.value };
+
+      this.animateTranslateCanvas({
+        fromValues,
+        toValues,
+        duration: opts?.duration ?? 500,
         onStart: () => {
           this.setState({ shouldCacheIgnoreZoom: true });
         },
         onEnd: () => {
-          this.setState({ shouldCacheIgnoreZoom: false });
+          if (requestId !== this.scrollToContentRequestId) {
+            return;
+          }
+
+          this.setState(
+            { shouldCacheIgnoreZoom: false },
+            installScrollConstraints,
+          );
         },
         onCancel: () => {
+          if (requestId !== this.scrollToContentRequestId) {
+            return;
+          }
+
           this.setState({ shouldCacheIgnoreZoom: false });
         },
-        duration: opts?.duration ?? 500,
       });
-
-      this.cancelInProgressAnimation = () => {
-        cancel();
-        this.cancelInProgressAnimation = null;
-      };
+    } else if (scrollConstraints) {
+      this.setState({
+        scrollX,
+        scrollY,
+        zoom,
+        scrollConstraints,
+      });
     } else {
       this.setState({ scrollX, scrollY, zoom });
     }
@@ -4448,11 +4577,165 @@ class App extends React.Component<AppProps, AppState> {
 
   /** use when changing scrollX/scrollY/zoom based on user interaction */
   private translateCanvas: React.Component<any, AppState>["setState"] = (
-    state,
+    stateUpdate,
   ) => {
     this.cancelInProgressAnimation?.();
     this.maybeUnfollowRemoteUser();
-    this.setState(state);
+
+    if (scrollConstraintsAnimationTimeout) {
+      clearTimeout(scrollConstraintsAnimationTimeout);
+    }
+
+    const partialNewState =
+      typeof stateUpdate === "function"
+        ? (
+            stateUpdate as (
+              prevState: Readonly<AppState>,
+              props: Readonly<AppProps>,
+            ) => AppState
+          )(this.state, this.props)
+        : stateUpdate;
+
+    const newState: AppState = {
+      ...this.state,
+      ...partialNewState,
+      ...(this.state.scrollConstraints && {
+        // manually reset if setState in onCancel wasn't committed yet
+        shouldCacheIgnoreZoom: false,
+      }),
+    };
+
+    // RULE: cannot go below the minimum zoom level if zoom lock is enabled
+    const constrainedState =
+      newState.scrollConstraints && newState.scrollConstraints.lockZoom
+        ? constrainScrollState(newState, "elastic")
+        : newState;
+    if (constrainedState.zoom.value > newState.zoom.value) {
+      newState.zoom = constrainedState.zoom;
+      newState.scrollX = constrainedState.scrollX;
+      newState.scrollY = constrainedState.scrollY;
+
+      this.debounceConstrainScrollState(newState);
+      return;
+    }
+
+    this.setState(newState);
+    if (this.state.scrollConstraints) {
+      if (newState.zoom.value < this.state.zoom.value) {
+        // zoom-out: debounce to allow centering on user's cursor position before constraining
+        this.debounceConstrainScrollState(newState);
+      } else {
+        // zoom-in or pan: valid range only expands on zoom-in, constrain immediately
+        this.setState(constrainScrollState(newState));
+      }
+    }
+  };
+
+  private debounceConstrainScrollState = debounce((state: AppState) => {
+    const newState = constrainScrollState(state, "rigid");
+
+    const fromValues = {
+      scrollX: this.state.scrollX,
+      scrollY: this.state.scrollY,
+      zoom: this.state.zoom.value,
+    };
+    const toValues = {
+      scrollX: newState.scrollX,
+      scrollY: newState.scrollY,
+      zoom: newState.zoom.value,
+    };
+
+    if (areCanvasTranslatesClose(fromValues, toValues)) {
+      return;
+    }
+
+    this.cancelInProgressAnimation?.();
+    this.animateToConstrainedArea(fromValues, toValues);
+  }, 200);
+
+  private animateToConstrainedArea = (
+    fromValues: AnimateTranslateCanvasValues,
+    toValues: AnimateTranslateCanvasValues,
+  ) => {
+    const cleanUp = () => {
+      this.setState((state) => ({
+        shouldCacheIgnoreZoom: false,
+        scrollConstraints: {
+          ...state.scrollConstraints!,
+          animateOnNextUpdate: false,
+        },
+      }));
+    };
+
+    this.animateTranslateCanvas({
+      fromValues,
+      toValues,
+      duration: 200,
+      onStart: () => {
+        this.setState((state) => {
+          return {
+            shouldCacheIgnoreZoom: true,
+            scrollConstraints: {
+              ...state.scrollConstraints!,
+              animateOnNextUpdate: false,
+            },
+          };
+        });
+      },
+      onEnd: cleanUp,
+      onCancel: cleanUp,
+    });
+  };
+
+  private animateTranslateCanvas = ({
+    fromValues,
+    toValues,
+    duration,
+    onStart,
+    onEnd,
+    onCancel,
+  }: {
+    fromValues: AnimateTranslateCanvasValues;
+    toValues: AnimateTranslateCanvasValues;
+    duration: number;
+    onStart: () => void;
+    onEnd: () => void;
+    onCancel: () => void;
+  }) => {
+    const cancel = easeToValuesRAF({
+      fromValues,
+      toValues,
+      interpolateValue: (from, to, progress, key) => {
+        // for zoom, use different easing
+        if (key === "zoom") {
+          return from * Math.pow(to / from, easeOut(progress));
+        }
+        // handle using default
+        return undefined;
+      },
+      onStep: ({ scrollX, scrollY, zoom }) => {
+        this.setState({
+          scrollX,
+          scrollY,
+          zoom: { value: zoom },
+        });
+      },
+      onStart,
+      onEnd: () => {
+        this.cancelInProgressAnimation = null;
+        onEnd();
+      },
+      onCancel: () => {
+        this.cancelInProgressAnimation = null;
+        onCancel();
+      },
+      duration,
+    });
+
+    this.cancelInProgressAnimation = () => {
+      cancel();
+      this.cancelInProgressAnimation = null;
+    };
   };
 
   setToast = (toast: AppState["toast"]) => {
@@ -5633,16 +5916,22 @@ class App extends React.Component<AppProps, AppState> {
 
     const initialScale = gesture.initialScale;
     if (initialScale) {
-      this.setState((state) => ({
-        ...getStateForZoom(
+      this.setState((state) =>
+        constrainScrollState(
           {
-            viewportX: this.lastViewportPosition.x,
-            viewportY: this.lastViewportPosition.y,
-            nextZoom: getNormalizedZoom(initialScale * event.scale),
+            ...state,
+            ...getStateForZoom(
+              {
+                viewportX: this.lastViewportPosition.x,
+                viewportY: this.lastViewportPosition.y,
+                nextZoom: getNormalizedZoom(initialScale * event.scale),
+              },
+              state,
+            ),
           },
-          state,
+          "loose",
         ),
-      }));
+      );
     }
   });
 
@@ -12619,17 +12908,21 @@ class App extends React.Component<AppProps, AppState> {
           // reduced amplification for small deltas (small movements on a trackpad)
           Math.min(1, absDelta / 20);
 
-        this.translateCanvas((state) => ({
-          ...getStateForZoom(
+        this.translateCanvas((state) => {
+          const nextZoom = getNormalizedZoom(newZoom);
+          const anchor = getConstrainedZoomAnchor(
             {
               viewportX: this.lastViewportPosition.x,
               viewportY: this.lastViewportPosition.y,
-              nextZoom: getNormalizedZoom(newZoom),
+              nextZoom,
             },
             state,
-          ),
-          shouldCacheIgnoreZoom: true,
-        }));
+          );
+          return {
+            ...getStateForZoom({ ...anchor, nextZoom }, state),
+            shouldCacheIgnoreZoom: true,
+          };
+        });
         this.resetShouldCacheIgnoreZoomDebounced();
         return;
       }
@@ -12787,6 +13080,71 @@ class App extends React.Component<AppProps, AppState> {
     await setLanguage(currentLang);
     this.setAppState({});
   }
+
+  /**
+   * Sets the scroll constraints of the application state.
+   *
+   * @param scrollConstraints - The new scroll constraints.
+   */
+  public setScrollConstraints = (
+    scrollConstraints: ScrollConstraints | null,
+  ) => {
+    if (this.props.scrollConstraints !== undefined) {
+      console.warn(SET_SCROLL_CONSTRAINTS_CONTROLLED_WARNING);
+      return;
+    }
+
+    this.syncScrollConstraints(scrollConstraints);
+  };
+
+  private syncScrollConstraints = (
+    scrollConstraints: ScrollConstraints | null,
+  ) => {
+    this.debounceConstrainScrollState.cancel();
+
+    if (scrollConstraintsAnimationTimeout) {
+      clearTimeout(scrollConstraintsAnimationTimeout);
+      scrollConstraintsAnimationTimeout = null;
+    }
+
+    this.cancelInProgressAnimation?.();
+
+    if (scrollConstraints) {
+      this.setState(
+        {
+          scrollConstraints,
+          shouldCacheIgnoreZoom: false,
+        },
+        () => {
+          const newState = constrainScrollState(
+            {
+              ...this.state,
+              scrollConstraints,
+            },
+            "rigid",
+          );
+
+          this.animateToConstrainedArea(
+            {
+              scrollX: this.state.scrollX,
+              scrollY: this.state.scrollY,
+              zoom: this.state.zoom.value,
+            },
+            {
+              scrollX: newState.scrollX,
+              scrollY: newState.scrollY,
+              zoom: newState.zoom.value,
+            },
+          );
+        },
+      );
+    } else {
+      this.setState({
+        scrollConstraints: null,
+        shouldCacheIgnoreZoom: false,
+      });
+    }
+  };
 }
 
 // -----------------------------------------------------------------------------

packages/excalidraw/components/Stats/stats.test.tsx

@@ -750,7 +750,7 @@ describe("frame resizing behavior", () => {
       x: 0,
       y: 0,
       width: 100,
-      height: 100,
+      height: 103,
     });
 
     // Create a rectangle outside the frame

packages/excalidraw/components/main-menu/DefaultItems.tsx

@@ -437,16 +437,15 @@ const PreferencesBoxSelectionModeItem = () => {
   const { t } = useI18n();
   const appState = useUIAppState();
   const setAppState = useExcalidrawSetAppState();
-  const boxSelectionMode = appState.boxSelectionMode ?? "contain";
 
   return (
     <DropdownMenuItemContentRadio<"contain" | "overlap">
       name="boxSelectionMode"
       icon={emptyIcon}
-      value={boxSelectionMode}
+      value={appState.boxSelectionMode}
       onChange={(value) => {
         setAppState({
-          boxSelectionMode: value === "contain" ? undefined : value,
+          boxSelectionMode: value,
         });
       }}
       choices={[

packages/excalidraw/data/index.ts

@@ -6,6 +6,7 @@ import {
   MIME_TYPES,
   cloneJSON,
   SVG_DOCUMENT_PREAMBLE,
+  arrayToMap,
 } from "@excalidraw/common";
 
 import { getNonDeletedElements } from "@excalidraw/element";
@@ -49,6 +50,7 @@ export const prepareElementsForExport = (
   exportSelectionOnly: boolean,
 ) => {
   elements = getNonDeletedElements(elements);
+  const elementsMap = arrayToMap(elements);
 
   const isExportingSelection =
     exportSelectionOnly &&
@@ -71,7 +73,11 @@ export const prepareElementsForExport = (
       isFrameLikeElement(exportedElements[0])
     ) {
       exportingFrame = exportedElements[0];
-      exportedElements = getElementsOverlappingFrame(elements, exportingFrame);
+      exportedElements = getElementsOverlappingFrame(
+        elements,
+        exportingFrame,
+        elementsMap,
+      );
     } else if (exportedElements.length > 1) {
       exportedElements = getSelectedElements(
         elements,

packages/excalidraw/eraser/index.ts

@@ -2,7 +2,7 @@ import { arrayToMap, easeOut, THEME } from "@excalidraw/common";
 
 import {
   computeBoundTextPosition,
-  doNonRotatedBoundsIntersect,
+  doBoundsIntersect,
   getBoundTextElement,
   getElementBounds,
   getElementLineSegments,
@@ -219,7 +219,7 @@ const eraserTest = (
     origElementBounds[3] + threshold,
   ];
 
-  if (!doNonRotatedBoundsIntersect(segmentBounds, elementBounds)) {
+  if (!doBoundsIntersect(segmentBounds, elementBounds)) {
     return false;
   }
 

packages/excalidraw/index.tsx

@@ -98,6 +98,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
     aiEnabled,
     showDeprecatedFonts,
     renderScrollbars,
+    scrollConstraints,
   } = props;
 
   const canvasActions = props.UIOptions?.canvasActions;
@@ -208,6 +209,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
           aiEnabled={aiEnabled !== false}
           showDeprecatedFonts={showDeprecatedFonts}
           renderScrollbars={renderScrollbars}
+          scrollConstraints={scrollConstraints}
         >
           {children}
         </App>

packages/excalidraw/lasso/utils.ts

@@ -10,7 +10,7 @@ import { type Bounds } from "@excalidraw/common";
 
 import {
   computeBoundTextPosition,
-  doNonRotatedBoundsIntersect,
+  doBoundsIntersect,
   getBoundTextElement,
   getElementBounds,
   intersectElementWithLineSegment,
@@ -66,7 +66,7 @@ export const getLassoSelectedElementIds = (input: {
     const elementBounds = getElementBounds(element, elementsMap);
 
     if (
-      doNonRotatedBoundsIntersect(lassoBounds, elementBounds) &&
+      doBoundsIntersect(lassoBounds, elementBounds) &&
       !intersectedElements.has(element.id) &&
       !enclosedElements.has(element.id)
     ) {

packages/excalidraw/scene/export.ts

@@ -157,7 +157,11 @@ const prepareElementsForRender = ({
   let nextElements: readonly ExcalidrawElement[];
 
   if (exportingFrame) {
-    nextElements = getElementsOverlappingFrame(elements, exportingFrame);
+    nextElements = getElementsOverlappingFrame(
+      elements,
+      exportingFrame,
+      arrayToMap(elements),
+    );
   } else if (frameRendering.enabled && frameRendering.name) {
     nextElements = addFrameLabelsAsTextElements(elements, {
       exportWithDarkMode,

packages/excalidraw/scene/scrollConstraints.ts

@@ -0,0 +1,590 @@
+import { MAX_ZOOM } from "@excalidraw/common";
+
+import { isShallowEqual } from "@excalidraw/common";
+
+import { clamp } from "@excalidraw/math";
+
+import { getNormalizedZoom } from "./normalize";
+
+import type {
+  AnimateTranslateCanvasValues,
+  AppState,
+  ScrollConstraints,
+  ScrollToContentLockOptions,
+} from "../types";
+
+// Constants for viewport zoom factor and overscroll allowance
+const MIN_VIEWPORT_ZOOM_FACTOR = 0.1;
+const MAX_VIEWPORT_ZOOM_FACTOR = MAX_ZOOM;
+const DEFAULT_VIEWPORT_ZOOM_FACTOR = 0.2;
+const DEFAULT_OVERSCROLL_ALLOWANCE = 0.2;
+
+// Memoization variable to cache constraints for performance optimization
+let memoizedValues: {
+  previousState: Pick<
+    AppState,
+    "zoom" | "width" | "height" | "scrollConstraints"
+  >;
+  constraints: ReturnType<typeof calculateConstraints>;
+  allowOverscroll: boolean;
+} | null = null;
+
+type CanvasTranslate = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+
+export const getScrollConstraintsForBounds = ({
+  bounds,
+  zoom,
+  viewportDimensions,
+  scrollLock,
+}: {
+  bounds: readonly [number, number, number, number];
+  zoom: AppState["zoom"];
+  viewportDimensions: Pick<AppState, "width" | "height">;
+  scrollLock?: boolean | ScrollToContentLockOptions;
+}): ScrollConstraints => {
+  const [x1, y1, x2, y2] = bounds;
+  const width = x2 - x1;
+  const height = y2 - y1;
+  const baseZoom = Math.min(
+    viewportDimensions.width / width,
+    viewportDimensions.height / height,
+  );
+  const lockOptions =
+    scrollLock && typeof scrollLock === "object" ? scrollLock : undefined;
+  const viewportZoomFactor =
+    lockOptions?.viewportZoomFactor ?? zoom.value / baseZoom;
+
+  return {
+    x: x1,
+    y: y1,
+    width,
+    height,
+    animateOnNextUpdate: false,
+    lockZoom: !!lockOptions?.lockZoom,
+    overscrollAllowance: lockOptions?.overscrollAllowance,
+    viewportZoomFactor,
+  };
+};
+
+/**
+ * Calculates the zoom levels necessary to fit the constrained scrollable area within the viewport on the X and Y axes.
+ *
+ * The function considers the dimensions of the scrollable area, the dimensions of the viewport, the viewport zoom factor,
+ * and whether the zoom should be locked. It then calculates the necessary zoom levels for the X and Y axes separately.
+ * If the zoom should be locked, it calculates the maximum zoom level that fits the scrollable area within the viewport,
+ * factoring in the viewport zoom factor. If the zoom should not be locked, the maximum zoom level is set to null.
+ *
+ * @param scrollConstraints - The constraints of the scrollable area including width, height, and position.
+ * @param width - The width of the viewport.
+ * @param height - The height of the viewport.
+ * @returns An object containing the calculated zoom levels for the X and Y axes, and the initial zoom level.
+ */
+const calculateZoomLevel = (
+  scrollConstraints: ScrollConstraints,
+  width: AppState["width"],
+  height: AppState["height"],
+) => {
+  const viewportZoomFactor = scrollConstraints.viewportZoomFactor
+    ? clamp(
+        scrollConstraints.viewportZoomFactor,
+        MIN_VIEWPORT_ZOOM_FACTOR,
+        MAX_VIEWPORT_ZOOM_FACTOR,
+      )
+    : DEFAULT_VIEWPORT_ZOOM_FACTOR;
+
+  const scrollableWidth = scrollConstraints.width;
+  const scrollableHeight = scrollConstraints.height;
+  const zoomLevelX = width / scrollableWidth;
+  const zoomLevelY = height / scrollableHeight;
+  const initialZoomLevel = getNormalizedZoom(
+    Math.min(zoomLevelX, zoomLevelY) * viewportZoomFactor,
+  );
+  return { zoomLevelX, zoomLevelY, initialZoomLevel };
+};
+
+/**
+ * Calculates the effective zoom level based on the scroll constraints and current zoom.
+ *
+ * @param params - Object containing scrollConstraints, width, height, and zoom.
+ * @returns An object with the effective zoom level, initial zoom level, and zoom levels for X and Y axes.
+ */
+const calculateZoom = ({
+  scrollConstraints,
+  width,
+  height,
+  zoom,
+}: {
+  scrollConstraints: ScrollConstraints;
+  width: AppState["width"];
+  height: AppState["height"];
+  zoom: AppState["zoom"];
+}) => {
+  const { zoomLevelX, zoomLevelY, initialZoomLevel } = calculateZoomLevel(
+    scrollConstraints,
+    width,
+    height,
+  );
+  const effectiveZoom = scrollConstraints.lockZoom
+    ? Math.max(initialZoomLevel, zoom.value)
+    : zoom.value;
+  return {
+    effectiveZoom: getNormalizedZoom(effectiveZoom),
+    initialZoomLevel,
+    zoomLevelX,
+    zoomLevelY,
+  };
+};
+
+/**
+ * Calculates the scroll bounds (min and max scroll values) based on the scroll constraints and zoom level.
+ *
+ * @param params - Object containing scrollConstraints, width, height, effectiveZoom, zoomLevelX, zoomLevelY, and allowOverscroll.
+ * @returns An object with min and max scroll values for X and Y axes.
+ */
+const calculateScrollBounds = ({
+  scrollConstraints,
+  width,
+  height,
+  effectiveZoom,
+  zoomLevelX,
+  zoomLevelY,
+  allowOverscroll,
+}: {
+  scrollConstraints: ScrollConstraints;
+  width: AppState["width"];
+  height: AppState["height"];
+  effectiveZoom: number;
+  zoomLevelX: number;
+  zoomLevelY: number;
+  allowOverscroll: boolean;
+}) => {
+  const overscrollAllowance =
+    scrollConstraints.overscrollAllowance ?? DEFAULT_OVERSCROLL_ALLOWANCE;
+  const validatedOverscroll = clamp(overscrollAllowance, 0, 1);
+
+  const calculateCenter = (zoom: number) => {
+    const centerX =
+      scrollConstraints.x + (scrollConstraints.width - width / zoom) / -2;
+    const centerY =
+      scrollConstraints.y + (scrollConstraints.height - height / zoom) / -2;
+    return { centerX, centerY };
+  };
+
+  const { centerX, centerY } = calculateCenter(effectiveZoom);
+
+  const overscrollValue = Math.min(
+    validatedOverscroll * scrollConstraints.width,
+    validatedOverscroll * scrollConstraints.height,
+  );
+
+  const fitsX = effectiveZoom <= zoomLevelX;
+  const fitsY = effectiveZoom <= zoomLevelY;
+
+  const getScrollRange = (
+    axis: "x" | "y",
+    fits: boolean,
+    constraint: ScrollConstraints,
+    viewportSize: number,
+    zoom: number,
+    overscroll: number,
+  ) => {
+    const { pos, size } =
+      axis === "x"
+        ? { pos: constraint.x, size: constraint.width }
+        : { pos: constraint.y, size: constraint.height };
+    const center = axis === "x" ? centerX : centerY;
+    if (allowOverscroll) {
+      return fits
+        ? { min: center - overscroll, max: center + overscroll }
+        : {
+            min: pos - size + viewportSize / zoom - overscroll,
+            max: pos + overscroll,
+          };
+    }
+    return fits
+      ? { min: center, max: center }
+      : { min: pos - size + viewportSize / zoom, max: pos };
+  };
+
+  const xRange = getScrollRange(
+    "x",
+    fitsX,
+    scrollConstraints,
+    width,
+    effectiveZoom,
+    overscrollValue,
+  );
+  const yRange = getScrollRange(
+    "y",
+    fitsY,
+    scrollConstraints,
+    height,
+    effectiveZoom,
+    overscrollValue,
+  );
+
+  return {
+    minScrollX: xRange.min,
+    maxScrollX: xRange.max,
+    minScrollY: yRange.min,
+    maxScrollY: yRange.max,
+  };
+};
+
+/**
+ * Calculates the scroll constraints including min and max scroll values and the effective zoom level.
+ *
+ * @param params - Object containing scrollConstraints, width, height, zoom, and allowOverscroll.
+ * @returns An object with min and max scroll values, effective zoom, and initial zoom level.
+ */
+const calculateConstraints = ({
+  scrollConstraints,
+  width,
+  height,
+  zoom,
+  allowOverscroll,
+}: {
+  scrollConstraints: ScrollConstraints;
+  width: AppState["width"];
+  height: AppState["height"];
+  zoom: AppState["zoom"];
+  allowOverscroll: boolean;
+}) => {
+  const { effectiveZoom, initialZoomLevel, zoomLevelX, zoomLevelY } =
+    calculateZoom({ scrollConstraints, width, height, zoom });
+  const scrollBounds = calculateScrollBounds({
+    scrollConstraints,
+    width,
+    height,
+    effectiveZoom,
+    zoomLevelX,
+    zoomLevelY,
+    allowOverscroll,
+  });
+
+  return {
+    ...scrollBounds,
+    effectiveZoom: { value: effectiveZoom },
+    initialZoomLevel,
+  };
+};
+
+/**
+ * Constrains the scroll values within the provided min and max bounds.
+ *
+ * @param params - Object containing scrollX, scrollY, minScrollX, maxScrollX, minScrollY, maxScrollY, and constrainedZoom.
+ * @returns An object with constrained scrollX, scrollY, and zoom.
+ */
+const constrainScrollValues = ({
+  scrollX,
+  scrollY,
+  minScrollX,
+  maxScrollX,
+  minScrollY,
+  maxScrollY,
+  constrainedZoom,
+}: {
+  scrollX: number;
+  scrollY: number;
+  minScrollX: number;
+  maxScrollX: number;
+  minScrollY: number;
+  maxScrollY: number;
+  constrainedZoom: AppState["zoom"];
+}): CanvasTranslate => {
+  const constrainedScrollX = clamp(scrollX, minScrollX, maxScrollX);
+  const constrainedScrollY = clamp(scrollY, minScrollY, maxScrollY);
+  return {
+    scrollX: constrainedScrollX,
+    scrollY: constrainedScrollY,
+    zoom: constrainedZoom,
+  };
+};
+
+/**
+ * Inverts the scroll constraints to align with the state scrollX and scrollY values, which are inverted.
+ * This is a temporary fix and should be removed once issue #5965 is resolved.
+ *
+ * @param originalScrollConstraints - The original scroll constraints.
+ * @returns The aligned scroll constraints with inverted x and y coordinates.
+ */
+const alignScrollConstraints = (
+  originalScrollConstraints: ScrollConstraints,
+): ScrollConstraints => {
+  return {
+    ...originalScrollConstraints,
+    x: originalScrollConstraints.x * -1,
+    y: originalScrollConstraints.y * -1,
+  };
+};
+
+/**
+ * Determines whether the current viewport is outside the constrained area.
+ *
+ * @param state - The application state.
+ * @returns True if the viewport is outside the constrained area, false otherwise.
+ */
+const isViewportOutsideOfConstrainedArea = (state: AppState): boolean => {
+  if (!state.scrollConstraints) {
+    return false;
+  }
+
+  const {
+    scrollX,
+    scrollY,
+    width,
+    height,
+    scrollConstraints: inverseScrollConstraints,
+    zoom,
+  } = state;
+
+  const scrollConstraints = alignScrollConstraints(inverseScrollConstraints);
+
+  const adjustedWidth = width / zoom.value;
+  const adjustedHeight = height / zoom.value;
+
+  return (
+    scrollX > scrollConstraints.x ||
+    scrollX - adjustedWidth < scrollConstraints.x - scrollConstraints.width ||
+    scrollY > scrollConstraints.y ||
+    scrollY - adjustedHeight < scrollConstraints.y - scrollConstraints.height
+  );
+};
+
+/**
+ * Calculates the scroll center coordinates and the optimal zoom level to fit the constrained scrollable area within the viewport.
+ *
+ * @param state - The application state.
+ * @param scroll - Object containing current scrollX and scrollY.
+ * @returns An object with the calculated scrollX, scrollY, and zoom.
+ */
+export const calculateConstrainedScrollCenter = (
+  state: AppState,
+  { scrollX, scrollY }: Pick<AppState, "scrollX" | "scrollY">,
+): CanvasTranslate => {
+  const { width, height, scrollConstraints } = state;
+  if (!scrollConstraints) {
+    return { scrollX, scrollY, zoom: state.zoom };
+  }
+
+  const adjustedConstraints = alignScrollConstraints(scrollConstraints);
+  const zoomLevels = calculateZoomLevel(adjustedConstraints, width, height);
+  const initialZoom = { value: zoomLevels.initialZoomLevel };
+  const constraints = calculateConstraints({
+    scrollConstraints: adjustedConstraints,
+    width,
+    height,
+    zoom: initialZoom,
+    allowOverscroll: false,
+  });
+
+  return {
+    scrollX: constraints.minScrollX,
+    scrollY: constraints.minScrollY,
+    zoom: constraints.effectiveZoom,
+  };
+};
+
+/**
+ * Encodes scroll constraints into a compact string.
+ *
+ * @param constraints - The scroll constraints to encode.
+ * @returns A compact encoded string representing the scroll constraints.
+ */
+export const encodeConstraints = (constraints: ScrollConstraints): string => {
+  const payload = {
+    x: constraints.x,
+    y: constraints.y,
+    w: constraints.width,
+    h: constraints.height,
+    a: !!constraints.animateOnNextUpdate,
+    l: !!constraints.lockZoom,
+    v: constraints.viewportZoomFactor ?? 1,
+    oa: constraints.overscrollAllowance ?? DEFAULT_OVERSCROLL_ALLOWANCE,
+  };
+  const serialized = JSON.stringify(payload);
+  return encodeURIComponent(window.btoa(serialized).replace(/=+/, ""));
+};
+
+/**
+ * Decodes a compact string back into scroll constraints.
+ *
+ * @param encoded - The encoded string representing the scroll constraints.
+ * @returns The decoded scroll constraints object.
+ */
+export const decodeConstraints = (encoded: string): ScrollConstraints => {
+  try {
+    const decodedStr = window.atob(decodeURIComponent(encoded));
+    const parsed = JSON.parse(decodedStr) as {
+      x: number;
+      y: number;
+      w: number;
+      h: number;
+      a: boolean;
+      l: boolean;
+      v: number;
+      oa: number;
+    };
+    return {
+      x: parsed.x || 0,
+      y: parsed.y || 0,
+      width: parsed.w || 0,
+      height: parsed.h || 0,
+      lockZoom: parsed.l || false,
+      viewportZoomFactor: parsed.v || 1,
+      animateOnNextUpdate: parsed.a || false,
+      overscrollAllowance: parsed.oa || DEFAULT_OVERSCROLL_ALLOWANCE,
+    };
+  } catch (error) {
+    return {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      animateOnNextUpdate: false,
+      lockZoom: false,
+      viewportZoomFactor: 1,
+      overscrollAllowance: DEFAULT_OVERSCROLL_ALLOWANCE,
+    };
+  }
+};
+
+type Options = { allowOverscroll: boolean; disableAnimation: boolean };
+const DEFAULT_OPTION: Options = {
+  allowOverscroll: true,
+  disableAnimation: false,
+};
+
+/**
+ * Constrains the AppState scroll values within the defined scroll constraints.
+ *
+ * constraintMode can be "elastic", "rigid", or "loose":
+ * - "elastic": snaps to constraints but allows overscroll
+ * - "rigid": snaps to constraints without overscroll
+ * - "loose": allows overscroll and disables animation/snapping to constraints
+ *
+ * @param state - The original AppState.
+ * @param options - Options for allowing overscroll and disabling animation.
+ * @returns A new AppState object with constrained scroll values.
+ */
+export const constrainScrollState = (
+  state: AppState,
+  constraintMode: "elastic" | "rigid" | "loose" = "elastic",
+): AppState => {
+  if (!state.scrollConstraints) {
+    return state;
+  }
+  const {
+    scrollX,
+    scrollY,
+    width,
+    height,
+    scrollConstraints: inverseScrollConstraints,
+    zoom,
+  } = state;
+
+  let allowOverscroll: boolean;
+  let disableAnimation: boolean;
+
+  switch (constraintMode) {
+    case "elastic":
+      ({ allowOverscroll, disableAnimation } = DEFAULT_OPTION);
+      break;
+    case "rigid":
+      allowOverscroll = false;
+      disableAnimation = false;
+      break;
+    case "loose":
+      allowOverscroll = true;
+      disableAnimation = true;
+      break;
+    default:
+      ({ allowOverscroll, disableAnimation } = DEFAULT_OPTION);
+      break;
+  }
+
+  const scrollConstraints = alignScrollConstraints(inverseScrollConstraints);
+
+  const canUseMemoizedValues =
+    memoizedValues &&
+    memoizedValues.previousState.scrollConstraints &&
+    memoizedValues.allowOverscroll === allowOverscroll &&
+    isShallowEqual(
+      state.scrollConstraints,
+      memoizedValues.previousState.scrollConstraints,
+    ) &&
+    isShallowEqual(
+      { zoom: zoom.value, width, height },
+      {
+        zoom: memoizedValues.previousState.zoom.value,
+        width: memoizedValues.previousState.width,
+        height: memoizedValues.previousState.height,
+      },
+    );
+
+  const constraints = canUseMemoizedValues
+    ? memoizedValues!.constraints
+    : calculateConstraints({
+        scrollConstraints,
+        width,
+        height,
+        zoom,
+        allowOverscroll,
+      });
+
+  if (!canUseMemoizedValues) {
+    memoizedValues = {
+      previousState: {
+        zoom: state.zoom,
+        width: state.width,
+        height: state.height,
+        scrollConstraints: state.scrollConstraints,
+      },
+      constraints,
+      allowOverscroll,
+    };
+  }
+
+  const constrainedValues =
+    zoom.value >= constraints.effectiveZoom.value
+      ? constrainScrollValues({
+          scrollX,
+          scrollY,
+          minScrollX: constraints.minScrollX,
+          maxScrollX: constraints.maxScrollX,
+          minScrollY: constraints.minScrollY,
+          maxScrollY: constraints.maxScrollY,
+          constrainedZoom: constraints.effectiveZoom,
+        })
+      : calculateConstrainedScrollCenter(state, { scrollX, scrollY });
+
+  return {
+    ...state,
+    scrollConstraints: {
+      ...state.scrollConstraints,
+      animateOnNextUpdate: disableAnimation
+        ? false
+        : isViewportOutsideOfConstrainedArea(state),
+    },
+    ...constrainedValues,
+  };
+};
+
+/**
+ * Checks if two canvas translate values are close within a threshold.
+ *
+ * @param from - First set of canvas translate values.
+ * @param to - Second set of canvas translate values.
+ * @returns True if the values are close, false otherwise.
+ */
+export const areCanvasTranslatesClose = (
+  from: AnimateTranslateCanvasValues,
+  to: AnimateTranslateCanvasValues,
+): boolean => {
+  const threshold = 0.1;
+  return (
+    Math.abs(from.scrollX - to.scrollX) < threshold &&
+    Math.abs(from.scrollY - to.scrollY) < threshold &&
+    Math.abs(from.zoom - to.zoom) < threshold
+  );
+};

packages/excalidraw/scene/zoom.ts

@@ -1,5 +1,67 @@
+import { constrainScrollState } from "./scrollConstraints";
+
 import type { AppState, NormalizedZoomValue } from "../types";
 
+/**
+ * When zooming out with scroll constraints active, the cursor-anchored zoom may
+ * produce a scroll position outside the valid bounds, causing a snap-back.
+ *
+ * This function adjusts the effective zoom anchor point so the resulting scroll
+ * stays within bounds — silently, without any snap. When no adjustment is needed
+ * (zoom-in, no constraints, or already within bounds) it returns the original
+ * viewport position unchanged.
+ */
+export const getConstrainedZoomAnchor = (
+  {
+    viewportX,
+    viewportY,
+    nextZoom,
+  }: { viewportX: number; viewportY: number; nextZoom: NormalizedZoomValue },
+  state: AppState,
+): { viewportX: number; viewportY: number } => {
+  if (!state.scrollConstraints || nextZoom >= state.zoom.value) {
+    return { viewportX, viewportY };
+  }
+
+  const appLayerX = viewportX - state.offsetLeft;
+  const appLayerY = viewportY - state.offsetTop;
+  const factor = 1 / nextZoom - 1 / state.zoom.value;
+
+  const newScrollX = state.scrollX + appLayerX * factor;
+  const newScrollY = state.scrollY + appLayerY * factor;
+
+  const constrained = constrainScrollState(
+    {
+      ...state,
+      scrollX: newScrollX,
+      scrollY: newScrollY,
+      zoom: { value: nextZoom },
+    },
+    "rigid",
+  );
+
+  if (
+    constrained.scrollX === newScrollX &&
+    constrained.scrollY === newScrollY
+  ) {
+    return { viewportX, viewportY };
+  }
+
+  const adjustedAppLayerX =
+    constrained.scrollX !== newScrollX
+      ? (constrained.scrollX - state.scrollX) / factor
+      : appLayerX;
+  const adjustedAppLayerY =
+    constrained.scrollY !== newScrollY
+      ? (constrained.scrollY - state.scrollY) / factor
+      : appLayerY;
+
+  return {
+    viewportX: adjustedAppLayerX + state.offsetLeft,
+    viewportY: adjustedAppLayerY + state.offsetTop,
+  };
+};
+
 export const getStateForZoom = (
   {
     viewportX,

packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap

@@ -13,6 +13,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -960,6 +961,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1086,6 +1088,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1156,6 +1159,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": true,
@@ -1300,6 +1304,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1370,6 +1375,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1631,6 +1637,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1701,6 +1708,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1962,6 +1970,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2032,6 +2041,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": true,
@@ -2176,6 +2186,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2246,6 +2257,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2417,6 +2429,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2487,6 +2500,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2715,6 +2729,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2787,6 +2802,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3087,6 +3103,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3157,6 +3174,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3580,6 +3598,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3650,6 +3669,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3903,6 +3923,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3973,6 +3994,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4226,6 +4248,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4298,6 +4321,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4637,6 +4661,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -5583,6 +5608,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5854,6 +5880,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -6800,6 +6827,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7122,6 +7150,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -7758,6 +7787,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7811,6 +7841,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -8755,6 +8786,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": true,
@@ -8802,6 +8834,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -9749,6 +9782,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,

packages/excalidraw/tests/__snapshots__/history.test.tsx.snap

@@ -13,6 +13,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -84,6 +85,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
     "id4": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -646,6 +648,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -717,6 +720,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
     "id4": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -1207,6 +1211,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1279,6 +1284,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -1567,6 +1573,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1639,6 +1646,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -1929,6 +1937,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2001,6 +2010,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -2192,6 +2202,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2261,6 +2272,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -2645,6 +2657,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2717,6 +2730,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -2948,6 +2962,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3020,6 +3035,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -3267,6 +3283,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3339,6 +3356,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -3561,6 +3579,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3633,6 +3652,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -3847,6 +3867,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3919,6 +3940,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -4082,6 +4104,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4154,6 +4177,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -4339,6 +4363,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4411,6 +4436,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -4610,6 +4636,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4682,6 +4709,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -4839,6 +4867,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4911,6 +4940,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -5068,6 +5098,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5140,6 +5171,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -5315,6 +5347,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5387,6 +5420,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -5571,6 +5605,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5643,6 +5678,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -5829,6 +5865,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5900,6 +5937,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
     "id1": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -6158,6 +6196,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6229,6 +6268,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
     "id8": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -6585,6 +6625,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6656,6 +6697,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
     "id1": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -6959,6 +7001,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7031,6 +7074,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -7271,6 +7315,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7340,6 +7385,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -7563,6 +7609,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7632,6 +7679,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -7793,6 +7841,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7862,6 +7911,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -8145,6 +8195,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8214,6 +8265,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -8497,6 +8549,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8569,6 +8622,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -8903,6 +8957,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8972,6 +9027,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -9182,6 +9238,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9251,6 +9308,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -9446,6 +9504,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9515,6 +9574,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -9711,6 +9771,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9780,6 +9841,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -9943,6 +10005,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10015,6 +10078,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -10240,6 +10304,7 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10309,6 +10374,7 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -10557,6 +10623,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10626,6 +10693,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -10793,6 +10861,7 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10865,6 +10934,7 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -11718,6 +11788,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11787,6 +11858,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -11978,6 +12050,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12047,6 +12120,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -12213,6 +12287,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12282,6 +12357,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -12450,6 +12526,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12519,6 +12596,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -12841,6 +12919,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12913,6 +12992,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -13051,6 +13131,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13120,6 +13201,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -13258,6 +13340,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13330,6 +13413,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -13559,6 +13643,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13628,6 +13713,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -13857,6 +13943,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13929,6 +14016,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": -50,
   "scrollY": -50,
   "searchMatches": null,
@@ -14102,6 +14190,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14171,6 +14260,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -14339,6 +14429,7 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14408,6 +14499,7 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -14576,6 +14668,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14647,6 +14740,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -14823,6 +14917,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14892,6 +14987,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -15154,6 +15250,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15226,6 +15323,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -15324,6 +15422,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15393,6 +15492,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -15608,6 +15708,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15680,6 +15781,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -15871,6 +15973,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15943,6 +16046,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -16024,6 +16128,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16095,6 +16200,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -16306,6 +16412,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16378,6 +16485,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -16468,6 +16576,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16539,6 +16648,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -17216,6 +17326,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -17287,6 +17398,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -17862,6 +17974,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -17933,6 +18046,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -18508,6 +18622,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -18577,6 +18692,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -19257,6 +19373,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -19328,6 +19445,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -20025,6 +20143,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20096,6 +20215,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -20505,6 +20625,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20576,6 +20697,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
     "id1": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -21016,6 +21138,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -21087,6 +21210,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,
@@ -21475,6 +21599,7 @@ exports[`history > singleplayer undo/redo > should support linear element creati
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -21546,6 +21671,7 @@ exports[`history > singleplayer undo/redo > should support linear element creati
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "searchMatches": null,

packages/excalidraw/tests/__snapshots__/regressionTests.test.tsx.snap

@@ -13,6 +13,7 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -87,6 +88,7 @@ exports[`given element A and group of elements B and given both are selected whe
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -439,6 +441,7 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -513,6 +516,7 @@ exports[`given element A and group of elements B and given both are selected whe
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -855,6 +859,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -925,6 +930,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1421,6 +1427,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1491,6 +1498,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -1628,6 +1636,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1700,6 +1709,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2012,6 +2022,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2084,6 +2095,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2257,6 +2269,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2327,6 +2340,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2437,6 +2451,7 @@ exports[`regression tests > can drag element that covers another element, while
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2509,6 +2524,7 @@ exports[`regression tests > can drag element that covers another element, while
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -2762,6 +2778,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2832,6 +2849,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3017,6 +3035,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3089,6 +3108,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3258,6 +3278,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3330,6 +3351,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3494,6 +3516,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3566,6 +3589,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -3752,6 +3776,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3824,6 +3849,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4066,6 +4092,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4136,6 +4163,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4502,6 +4530,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4575,6 +4604,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -4785,6 +4815,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4858,6 +4889,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5061,6 +5093,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5133,6 +5166,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5269,6 +5303,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5341,6 +5376,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5469,6 +5505,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5539,6 +5576,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -5862,6 +5900,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5935,6 +5974,7 @@ exports[`regression tests > drags selected elements from point inside common bou
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -6159,6 +6199,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6229,6 +6270,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -6947,6 +6989,7 @@ exports[`regression tests > given a group of selected elements with an element t
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7020,6 +7063,7 @@ exports[`regression tests > given a group of selected elements with an element t
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7281,6 +7325,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7353,6 +7398,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7560,6 +7606,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7632,6 +7679,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -7795,6 +7843,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7867,6 +7916,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8035,6 +8085,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8105,6 +8156,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8215,6 +8267,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8285,6 +8338,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8395,6 +8449,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8465,6 +8520,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8575,6 +8631,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8645,6 +8702,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -8807,6 +8865,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8877,6 +8936,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9037,6 +9097,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9107,6 +9168,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9229,6 +9291,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9299,6 +9362,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9461,6 +9525,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9531,6 +9596,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9641,6 +9707,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9711,6 +9778,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -9871,6 +9939,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9941,6 +10010,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10051,6 +10121,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10121,6 +10192,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10243,6 +10315,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10313,6 +10386,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10423,6 +10497,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10497,6 +10572,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -10954,6 +11030,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11026,6 +11103,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11234,6 +11312,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11304,6 +11383,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": "-6.25000",
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11357,6 +11437,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11429,6 +11510,7 @@ exports[`regression tests > shift click on selected element should deselect it o
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11557,6 +11639,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11630,6 +11713,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -11876,6 +11960,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11950,6 +12035,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -12305,6 +12391,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12380,6 +12467,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -12945,6 +13033,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13018,6 +13107,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 60,
   "scrollY": 60,
   "scrolledOutside": false,
@@ -13071,6 +13161,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13143,6 +13234,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
     "id0": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -13702,6 +13794,7 @@ exports[`regression tests > switches from group of selected elements to another
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13775,6 +13868,7 @@ exports[`regression tests > switches from group of selected elements to another
     "id6": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14041,6 +14135,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14113,6 +14208,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
     "id3": true,
   },
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14305,6 +14401,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14375,6 +14472,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 20,
   "scrollY": "-18.53553",
   "scrolledOutside": false,
@@ -14428,6 +14526,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14498,6 +14597,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14792,6 +14892,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14862,6 +14963,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,
@@ -14915,6 +15017,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14988,6 +15091,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,

packages/excalidraw/tests/history.test.tsx

@@ -314,7 +314,7 @@ describe("history", () => {
         expect.objectContaining({ id: rect2.id, isDeleted: true }),
       ]);
 
-      mouse.downAt(0, 0);
+      mouse.downAt(-10, -10);
       mouse.moveTo(25, 25);
       mouse.moveTo(50, 50);
       mouse.upAt(50, 50);

packages/excalidraw/tests/regressionTests.test.tsx

@@ -468,7 +468,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(...end);
+    mouse.restorePosition(end[0] + 3, end[1] + 3);
     mouse.up();
 
     expect(h.elements.length).toBe(3);
@@ -519,7 +519,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(...end);
+    mouse.restorePosition(end[0] + 3, end[1] + 3);
     mouse.up();
 
     for (const element of h.elements) {
@@ -537,7 +537,7 @@ describe("regression tests", () => {
     mouse.moveTo(-10, -10); // the NW resizing handle is at [0, 0], so moving further
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(...end);
+    mouse.restorePosition(end[0] + 3, end[1] + 3);
     mouse.up();
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {

packages/excalidraw/tests/scrollConstraints.test.tsx

@@ -0,0 +1,135 @@
+import React from "react";
+import { vi } from "vitest";
+
+import { resolvablePromise } from "@excalidraw/common";
+
+import { Excalidraw } from "../index";
+
+import { API } from "./helpers/api";
+import { act, render, waitFor } from "./test-utils";
+
+import type { ExcalidrawImperativeAPI, ScrollConstraints } from "../types";
+
+const FIRST_SCROLL_CONSTRAINTS: ScrollConstraints = {
+  x: 0,
+  y: 0,
+  width: 400,
+  height: 300,
+  lockZoom: true,
+  overscrollAllowance: 0,
+  viewportZoomFactor: 1,
+  animateOnNextUpdate: false,
+};
+
+const SECOND_SCROLL_CONSTRAINTS: ScrollConstraints = {
+  x: 100,
+  y: 200,
+  width: 500,
+  height: 350,
+  lockZoom: false,
+  overscrollAllowance: 0.2,
+  viewportZoomFactor: 0.8,
+  animateOnNextUpdate: false,
+};
+
+describe("scrollConstraints", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("syncs prop updates after mount", async () => {
+    const { rerender } = await render(<Excalidraw />);
+
+    expect(window.h.state.scrollConstraints).toBe(null);
+
+    rerender(<Excalidraw scrollConstraints={FIRST_SCROLL_CONSTRAINTS} />);
+
+    await waitFor(() => {
+      expect(window.h.state.scrollConstraints).toEqual(
+        FIRST_SCROLL_CONSTRAINTS,
+      );
+    });
+
+    rerender(<Excalidraw scrollConstraints={SECOND_SCROLL_CONSTRAINTS} />);
+
+    await waitFor(() => {
+      expect(window.h.state.scrollConstraints).toEqual(
+        SECOND_SCROLL_CONSTRAINTS,
+      );
+    });
+
+    rerender(<Excalidraw />);
+
+    await waitFor(() => {
+      expect(window.h.state.scrollConstraints).toBe(null);
+    });
+  });
+
+  it("ignores setScrollConstraints() when the prop is controlled", async () => {
+    const excalidrawAPIPromise = resolvablePromise<ExcalidrawImperativeAPI>();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await render(
+      <Excalidraw
+        scrollConstraints={FIRST_SCROLL_CONSTRAINTS}
+        onExcalidrawAPI={(api) => {
+          if (api) {
+            excalidrawAPIPromise.resolve(api);
+          }
+        }}
+      />,
+    );
+
+    const excalidrawAPI = await excalidrawAPIPromise;
+
+    act(() => {
+      excalidrawAPI.setScrollConstraints(SECOND_SCROLL_CONSTRAINTS);
+    });
+
+    expect(warn).toHaveBeenCalledWith(
+      "Excalidraw: `setScrollConstraints()` is ignored when the `scrollConstraints` prop is controlled. Update the prop value instead.",
+    );
+    expect(window.h.state.scrollConstraints).toEqual(FIRST_SCROLL_CONSTRAINTS);
+  });
+
+  it("ignores scrollToContent() scrollLock when the prop is controlled", async () => {
+    const excalidrawAPIPromise = resolvablePromise<ExcalidrawImperativeAPI>();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await render(
+      <Excalidraw
+        scrollConstraints={FIRST_SCROLL_CONSTRAINTS}
+        onExcalidrawAPI={(api) => {
+          if (api) {
+            excalidrawAPIPromise.resolve(api);
+          }
+        }}
+      />,
+    );
+
+    const excalidrawAPI = await excalidrawAPIPromise;
+    const rectangle = API.createElement({
+      x: 1000,
+      y: 1000,
+      width: 100,
+      height: 100,
+    });
+    API.setElements([rectangle]);
+
+    act(() => {
+      excalidrawAPI.scrollToContent(rectangle, {
+        animate: false,
+        fitToViewport: true,
+        scrollLock: {
+          lockZoom: true,
+          overscrollAllowance: 0,
+        },
+      });
+    });
+
+    expect(warn).toHaveBeenCalledWith(
+      "Excalidraw: `scrollToContent()` with `scrollLock` is ignored when the `scrollConstraints` prop is controlled. Update the prop value instead.",
+    );
+    expect(window.h.state.scrollConstraints).toEqual(FIRST_SCROLL_CONSTRAINTS);
+  });
+});

packages/excalidraw/tests/selection.test.tsx

@@ -348,10 +348,10 @@ describe("box-selection overlap mode", () => {
     );
     const [outlineX1, outlineY1, outlineX2, outlineY2] = getOutlineBounds(rect);
 
-    expect(outlineX1).toBeGreaterThan(boundsX1);
-    expect(outlineY1).toBeGreaterThan(boundsY1);
-    expect(outlineX2).toBeLessThan(boundsX2);
-    expect(outlineY2).toBeLessThan(boundsY2);
+    expect(outlineX1).toBeGreaterThan(boundsX1 - 1);
+    expect(outlineY1).toBeGreaterThan(boundsY1 - 1);
+    expect(outlineX2).toBeLessThan(boundsX2 + 1);
+    expect(outlineY2).toBeLessThan(boundsY2 + 1);
 
     boxSelect(
       outlineX1 - (outlineX1 - boundsX1) / 2,

packages/excalidraw/types.ts

@@ -310,7 +310,7 @@ export interface AppState {
    */
   isBindingEnabled: boolean;
   /** user box selection preference; defaults to "contain" when unset */
-  boxSelectionMode?: BoxSelectionMode;
+  boxSelectionMode: BoxSelectionMode;
   /** user arrow binding preference */
   bindingPreference: "enabled" | "disabled";
   /** user preference whether arrow snap to midpoints while binding */
@@ -454,6 +454,7 @@ export interface AppState {
   userToFollow: UserToFollow | null;
   /** the socket ids of the users following the current user */
   followedBy: Set<SocketId>;
+  scrollConstraints: ScrollConstraints | null;
 
   /** image cropping */
   isCropping: boolean;
@@ -546,6 +547,8 @@ export type ExcalidrawInitialDataState = Merge<
   ImportedDataState,
   {
     libraryItems?: MaybePromise<Required<ImportedDataState>["libraryItems"]>;
+    scrollX?: number;
+    scrollY?: number;
   }
 >;
 
@@ -662,6 +665,7 @@ export interface ExcalidrawProps {
   onScrollChange?: (scrollX: number, scrollY: number, zoom: Zoom) => void;
   onUserFollow?: (payload: OnUserFollowedPayload) => void;
   children?: React.ReactNode;
+  scrollConstraints?: AppState["scrollConstraints"];
   validateEmbeddable?:
     | boolean
     | string[]
@@ -988,6 +992,8 @@ export interface ExcalidrawImperativeAPI {
   ) => UnsubscribeCallback;
   onStateChange: InstanceType<typeof App>["onStateChange"];
   onEvent: InstanceType<typeof App>["onEvent"];
+  app: InstanceType<typeof App>;
+  setScrollConstraints: InstanceType<typeof App>["setScrollConstraints"];
 }
 
 export type FrameNameBounds = {
@@ -1054,3 +1060,69 @@ export type Offsets = Partial<{
   bottom: number;
   left: number;
 }>;
+
+export type ScrollConstraints = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  animateOnNextUpdate?: boolean;
+  /**
+   * A factor that determines the minimum zoom level that should fit the
+   * constrained area into the viewport.
+   */
+  viewportZoomFactor?: number;
+  /**
+   * If true, the user will not be able to zoom out beyond the scroll
+   * constraints (taking into account the viewportZoomFactor).
+   */
+  lockZoom?: boolean;
+  /**
+   * <0-1> - how much can you scroll beyond the constrained area within the
+   * timeout window. Note you will still be snapped back to the constrained area
+   * after the timeout.
+   */
+  overscrollAllowance?: number;
+};
+
+/**
+ * Optional scroll constraint settings derived from the final viewport computed
+ * by `scrollToContent()`.
+ */
+export type ScrollToContentLockOptions = {
+  lockZoom?: boolean;
+  overscrollAllowance?: number;
+  viewportZoomFactor?: number;
+};
+
+export type ScrollToContentOptions =
+  | ({
+      fitToContent?: boolean;
+      fitToViewport?: never;
+      viewportZoomFactor?: number;
+      animate?: boolean;
+      duration?: number;
+      scrollLock?: boolean | ScrollToContentLockOptions;
+    } & {
+      minZoom?: number;
+      maxZoom?: number;
+      canvasOffsets?: Offsets;
+    })
+  | ({
+      fitToContent?: never;
+      fitToViewport?: boolean;
+      viewportZoomFactor?: number;
+      animate?: boolean;
+      duration?: number;
+      scrollLock?: boolean | ScrollToContentLockOptions;
+    } & {
+      minZoom?: number;
+      maxZoom?: number;
+      canvasOffsets?: Offsets;
+    });
+
+export type AnimateTranslateCanvasValues = {
+  scrollX: AppState["scrollX"];
+  scrollY: AppState["scrollY"];
+  zoom: AppState["zoom"]["value"];
+};

packages/math/src/curve.ts

@@ -137,8 +137,17 @@ const calculate = <Point extends GlobalPoint | LocalPoint>(
   [t0, s0]: [number, number],
   l: LineSegment<Point>,
   c: Curve<Point>,
+  tolerance: number = 1e-2,
+  iterLimit: number = 4,
 ) => {
-  const solution = solveWithAnalyticalJacobian(c, l, t0, s0, 1e-2, 4);
+  const solution = solveWithAnalyticalJacobian(
+    c,
+    l,
+    t0,
+    s0,
+    tolerance,
+    iterLimit,
+  );
 
   if (!solution) {
     return null;
@@ -158,18 +167,43 @@ const calculate = <Point extends GlobalPoint | LocalPoint>(
  */
 export function curveIntersectLineSegment<
   Point extends GlobalPoint | LocalPoint,
->(c: Curve<Point>, l: LineSegment<Point>): Point[] {
-  let solution = calculate(initial_guesses[0], l, c);
+>(
+  c: Curve<Point>,
+  l: LineSegment<Point>,
+  opts?: {
+    tolerance?: number;
+    iterLimit?: number;
+  },
+): Point[] {
+  let solution = calculate(
+    initial_guesses[0],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit,
+  );
   if (solution) {
     return [solution];
   }
 
-  solution = calculate(initial_guesses[1], l, c);
+  solution = calculate(
+    initial_guesses[1],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit,
+  );
   if (solution) {
     return [solution];
   }
 
-  solution = calculate(initial_guesses[2], l, c);
+  solution = calculate(
+    initial_guesses[2],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit,
+  );
   if (solution) {
     return [solution];
   }

packages/math/src/types.ts

@@ -1,14 +1,3 @@
-//
-// Generic markers
-//
-
-/**
- * Can be used for any type of point-likes to mark them as rotated to enlist
- * the type checker to weed out subtle bugs due to rotated and non-rotated
- * versions of the same data point.
- */
-export type Rotated<T> = T & { _brand_rotated: "excalimath_rotated" };
-
 //
 // Measurements
 //

packages/utils/src/withinBounds.ts

@@ -1,9 +1,4 @@
-import {
-  arrayToMap,
-  bounds,
-  type RotatedBounds,
-  type Bounds,
-} from "@excalidraw/common";
+import { arrayToMap, type Bounds } from "@excalidraw/common";
 import { getElementBounds } from "@excalidraw/element";
 import {
   isArrowElement,
@@ -95,7 +90,7 @@ const getMinMaxPoints = (points: Points) => {
   return ret;
 };
 
-const getRotatedBBox = (element: Element): RotatedBounds => {
+const getRotatedBBox = (element: Element): Bounds => {
   const points = getElementRelativePoints(element);
 
   const { cx, cy } = getMinMaxPoints(points);
@@ -106,13 +101,12 @@ const getRotatedBBox = (element: Element): RotatedBounds => {
   );
   const { minX, minY, maxX, maxY } = getMinMaxPoints(rotatedPoints);
 
-  return bounds(
+  return [
     minX + element.x,
     minY + element.y,
     maxX + element.x,
     maxY + element.y,
-    element.angle,
-  );
+  ];
 };
 
 export const isElementInsideBBox = (
@@ -166,12 +160,12 @@ export const elementPartiallyOverlapsWithOrContainsBBox = (
 
 export const elementsOverlappingBBox = ({
   elements,
-  bounds: _bounds,
+  bounds,
   type,
   errorMargin = 0,
 }: {
   elements: Elements;
-  bounds: RotatedBounds | ExcalidrawElement;
+  bounds: Bounds | ExcalidrawElement;
   /** safety offset. Defaults to 0. */
   errorMargin?: number;
   /**
@@ -181,16 +175,15 @@ export const elementsOverlappingBBox = ({
    **/
   type: "overlap" | "contain" | "inside";
 }) => {
-  if (isExcalidrawElement(_bounds)) {
-    _bounds = getElementBounds(_bounds, arrayToMap(elements));
+  if (isExcalidrawElement(bounds)) {
+    bounds = getElementBounds(bounds, arrayToMap(elements));
   }
-  const adjustedBBox = bounds(
-    _bounds[0] - errorMargin,
-    _bounds[1] - errorMargin,
-    _bounds[2] + errorMargin,
-    _bounds[3] + errorMargin,
-    _bounds[4],
-  );
+  const adjustedBBox: Bounds = [
+    bounds[0] - errorMargin,
+    bounds[1] - errorMargin,
+    bounds[2] + errorMargin,
+    bounds[3] + errorMargin,
+  ];
 
   const includedElementSet = new Set<string>();
 

packages/utils/tests/__snapshots__/export.test.ts.snap

@@ -13,6 +13,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -84,6 +85,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "previousSelectedElementIds": {},
   "resizingElement": null,
+  "scrollConstraints": null,
   "scrollX": 0,
   "scrollY": 0,
   "scrolledOutside": false,

scripts/woff2/woff2-vite-plugins.js

@@ -90,6 +90,13 @@ module.exports.woff2BrowserPlugin = () => {
         type="font/woff2"
         crossorigin="anonymous"
       />
+      <link
+        rel="preload"
+        href="${OSS_FONTS_CDN}fonts/Assistant/Assistant-SemiBold.woff2"
+        as="font"
+        type="font/woff2"
+        crossorigin="anonymous"
+      />
       <link
         rel="preload"
         href="${OSS_FONTS_CDN}fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2"

vercel.json

@@ -1,5 +1,4 @@
 {
-  "public": true,
   "headers": [
     {
       "source": "/(.*)",