feat: Console log overlay preference

Signed-off-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 }}

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">

excalidraw-app/App.tsx

@@ -136,6 +136,7 @@ import { useHandleAppTheme } from "./useHandleAppTheme";
 import { getPreferredLanguage } from "./app-language/language-detector";
 import { useAppLangCode } from "./app-language/language-state";
 import DebugCanvas, {
+  ConsoleLogger,
   debugRenderer,
   isVisualDebuggerEnabled,
   loadSavedDebugState,
@@ -1261,6 +1262,7 @@ const ExcalidrawWrapper = () => {
             ref={debugCanvasRef}
           />
         )}
+        {isVisualDebuggerEnabled() && <ConsoleLogger />}
       </Excalidraw>
     </div>
   );

excalidraw-app/app_constants.ts

@@ -42,6 +42,7 @@ export const STORAGE_KEYS = {
   LOCAL_STORAGE_COLLAB: "excalidraw-collab",
   LOCAL_STORAGE_THEME: "excalidraw-theme",
   LOCAL_STORAGE_DEBUG: "excalidraw-debug",
+  LOCAL_STORAGE_DEBUG_CONSOLE: "excalidraw-debug-console",
   VERSION_DATA_STATE: "version-dataState",
   VERSION_FILES: "version-files",
 

excalidraw-app/components/AppMainMenu.tsx

@@ -4,7 +4,8 @@ import {
   eyeIcon,
 } from "@excalidraw/excalidraw/components/icons";
 import { MainMenu } from "@excalidraw/excalidraw/index";
-import React from "react";
+import DropdownMenuItemCheckbox from "@excalidraw/excalidraw/components/dropdownMenu/DropdownMenuItemCheckbox";
+import React, { useState } from "react";
 
 import { isDevEnv } from "@excalidraw/common";
 
@@ -13,7 +14,29 @@ import type { Theme } from "@excalidraw/element/types";
 import { LanguageList } from "../app-language/LanguageList";
 import { isExcalidrawPlusSignedUser } from "../app_constants";
 
-import { saveDebugState } from "./DebugCanvas";
+import {
+  isVisualDebuggerEnabled,
+  loadConsoleLoggerState,
+  saveDebugState,
+  setConsoleLoggerEnabled,
+} from "./DebugCanvas";
+
+const ConsoleLoggerToggle = () => {
+  const [checked, setChecked] = useState(() => loadConsoleLoggerState());
+  return (
+    <DropdownMenuItemCheckbox
+      checked={checked}
+      onSelect={(event) => {
+        const next = !checked;
+        setChecked(next);
+        setConsoleLoggerEnabled(next);
+        event.preventDefault();
+      }}
+    >
+      Show console log overlay
+    </DropdownMenuItemCheckbox>
+  );
+};
 
 export const AppMainMenu: React.FC<{
   onCollabDialogOpen: () => any;
@@ -77,7 +100,13 @@ export const AppMainMenu: React.FC<{
         </MainMenu.Item>
       )}
       <MainMenu.Separator />
-      <MainMenu.DefaultItems.Preferences />
+      <MainMenu.DefaultItems.Preferences
+        additionalItems={
+          isDevEnv() && isVisualDebuggerEnabled() ? (
+            <ConsoleLoggerToggle />
+          ) : null
+        }
+      />
       <MainMenu.DefaultItems.ToggleTheme
         allowSystemTheme
         theme={props.theme}

excalidraw-app/components/DebugCanvas.tsx

@@ -9,7 +9,7 @@ import {
 } from "@excalidraw/excalidraw/renderer/helpers";
 import { type AppState } from "@excalidraw/excalidraw/types";
 import { arrayToMap, throttleRAF } from "@excalidraw/common";
-import { useCallback } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
   getGlobalFixedPointForBindableElement,
@@ -435,6 +435,34 @@ export const loadSavedDebugState = () => {
 export const isVisualDebuggerEnabled = () =>
   Array.isArray(window.visualDebug?.data);
 
+export const loadConsoleLoggerState = (): boolean => {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_DEBUG_CONSOLE);
+    if (raw !== null) {
+      return JSON.parse(raw) === true;
+    }
+  } catch {}
+  return false;
+};
+
+export const saveConsoleLoggerState = (enabled: boolean) => {
+  try {
+    localStorage.setItem(
+      STORAGE_KEYS.LOCAL_STORAGE_DEBUG_CONSOLE,
+      JSON.stringify(enabled),
+    );
+  } catch {}
+};
+
+const CONSOLE_LOGGER_TOGGLE_EVENT = "excalidraw-debug-console-toggle";
+
+export const setConsoleLoggerEnabled = (enabled: boolean) => {
+  saveConsoleLoggerState(enabled);
+  window.dispatchEvent(
+    new CustomEvent<boolean>(CONSOLE_LOGGER_TOGGLE_EVENT, { detail: enabled }),
+  );
+};
+
 export const DebugFooter = ({ onChange }: { onChange: () => void }) => {
   const moveForward = useCallback(() => {
     if (
@@ -459,6 +487,7 @@ export const DebugFooter = ({ onChange }: { onChange: () => void }) => {
   }, [onChange]);
   const reset = useCallback(() => {
     window.visualDebug!.currentFrame = undefined;
+    _clearLogsCallback?.();
     onChange();
   }, [onChange]);
   const trashFrames = useCallback(() => {
@@ -466,6 +495,7 @@ export const DebugFooter = ({ onChange }: { onChange: () => void }) => {
       window.visualDebug.currentFrame = undefined;
       window.visualDebug.data = [];
     }
+    _clearLogsCallback?.();
     onChange();
   }, [onChange]);
 
@@ -563,4 +593,181 @@ const DebugCanvas = React.forwardRef<HTMLCanvasElement, DebugCanvasProps>(
   },
 );
 
+type LogLevel = "log" | "info" | "warn" | "error";
+
+interface LogEntry {
+  id: number;
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+}
+
+const LOG_COLORS: Record<LogLevel, string> = {
+  log: "rgba(220,220,220,0.9)",
+  info: "rgba(100,180,255,0.9)",
+  warn: "rgba(255,200,60,0.9)",
+  error: "rgba(255,90,90,0.9)",
+};
+
+const MAX_LOGS = 500;
+let logIdCounter = 0;
+let _clearLogsCallback: (() => void) | null = null;
+
+export const ConsoleLogger = () => {
+  const [enabled, setEnabled] = useState(() => loadConsoleLoggerState());
+  const [logs, setLogs] = useState<LogEntry[]>([]);
+  const logsRef = useRef<LogEntry[]>([]);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const dragState = useRef<{ startY: number; startScrollTop: number } | null>(
+    null,
+  );
+  const isDragging = useRef(false);
+
+  useEffect(() => {
+    const handler = (e: Event) => {
+      setEnabled((e as CustomEvent<boolean>).detail);
+    };
+    window.addEventListener(CONSOLE_LOGGER_TOGGLE_EVENT, handler);
+    return () => {
+      window.removeEventListener(CONSOLE_LOGGER_TOGGLE_EVENT, handler);
+    };
+  }, []);
+
+  useEffect(() => {
+    _clearLogsCallback = () => {
+      logsRef.current = [];
+      setLogs([]);
+    };
+    return () => {
+      _clearLogsCallback = null;
+    };
+  }, []);
+
+  useEffect(() => {
+    const originals: Record<LogLevel, (...args: unknown[]) => void> = {
+      // eslint-disable-next-line no-console
+      log: console.log.bind(console),
+      info: console.info.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+    };
+
+    const patch = (level: LogLevel) => {
+      // eslint-disable-next-line no-console
+      console[level] = (...args: unknown[]) => {
+        originals[level](...args);
+        const message = args
+          .map((a) =>
+            typeof a === "object" ? JSON.stringify(a, null, 0) : String(a),
+          )
+          .join(" ");
+        const entry: LogEntry = {
+          id: ++logIdCounter,
+          level,
+          message,
+          timestamp: Date.now(),
+        };
+        logsRef.current = [...logsRef.current, entry].slice(-MAX_LOGS);
+        setLogs([...logsRef.current]);
+        if (!isDragging.current && scrollRef.current) {
+          scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+        }
+      };
+    };
+
+    (["log", "info", "warn", "error"] as LogLevel[]).forEach(patch);
+
+    return () => {
+      (["log", "info", "warn", "error"] as LogLevel[]).forEach((level) => {
+        // eslint-disable-next-line no-console
+        console[level] = originals[level];
+      });
+    };
+  }, []);
+
+  const onPointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (!scrollRef.current) {
+      return;
+    }
+    dragState.current = {
+      startY: e.clientY,
+      startScrollTop: scrollRef.current.scrollTop,
+    };
+    scrollRef.current.setPointerCapture(e.pointerId);
+    isDragging.current = true;
+    e.preventDefault();
+  }, []);
+
+  const onPointerMove = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (!dragState.current || !scrollRef.current) {
+      return;
+    }
+    const delta = dragState.current.startY - e.clientY;
+    scrollRef.current.scrollTop = dragState.current.startScrollTop + delta;
+    e.preventDefault();
+  }, []);
+
+  const onPointerUp = useCallback(() => {
+    dragState.current = null;
+    isDragging.current = false;
+  }, []);
+
+  if (!enabled || logs.length === 0) {
+    return null;
+  }
+
+  return (
+    <div
+      ref={scrollRef}
+      onPointerDown={onPointerDown}
+      onPointerMove={onPointerMove}
+      onPointerUp={onPointerUp}
+      onPointerCancel={onPointerUp}
+      style={{
+        position: "fixed",
+        top: 8,
+        right: 8,
+        zIndex: 9999,
+        maxWidth: 420,
+        maxHeight: "60vh",
+        overflowY: "auto",
+        display: "flex",
+        flexDirection: "column",
+        gap: 2,
+        pointerEvents: "all",
+        cursor: "grab",
+        userSelect: "none",
+        scrollbarWidth: "none",
+      }}
+    >
+      {logs.map((entry) => (
+        <div
+          key={entry.id}
+          style={{
+            background: "rgba(18,18,20,0.55)",
+            backdropFilter: "blur(8px) saturate(1.4)",
+            WebkitBackdropFilter: "blur(8px) saturate(1.4)",
+            borderLeft: `3px solid ${LOG_COLORS[entry.level]}`,
+            borderRadius: 4,
+            padding: "2px 8px",
+            fontFamily: "monospace",
+            fontSize: 11,
+            lineHeight: 1.5,
+            color: LOG_COLORS[entry.level],
+            wordBreak: "break-all",
+            whiteSpace: "pre-wrap",
+            opacity: 0.95,
+            boxShadow: "0 1px 4px rgba(0,0,0,0.35)",
+          }}
+        >
+          <span style={{ opacity: 0.5, marginRight: 6 }}>
+            {entry.level.toUpperCase()}
+          </span>
+          {entry.message}
+        </div>
+      ))}
+    </div>
+  );
+};
+
 export default DebugCanvas;

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/appState.ts

@@ -128,6 +128,7 @@ export const getDefaultAppState = (): Omit<
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
+    boxSelectionMode: "contain",
   };
 };
 

packages/excalidraw/components/App.tsx

@@ -246,7 +246,7 @@ import {
   bindOrUnbindBindingElement,
   mutateElement,
   getElementBounds,
-  doNonRotatedBoundsIntersect,
+  doBoundsIntersect,
   isPointInElement,
   maxBindingDistance_simple,
   convertToExcalidrawElements,
@@ -1154,7 +1154,7 @@ class App extends React.Component<AppProps, AppState> {
         startBounds &&
         endBounds &&
         startElement.id !== endElement.id &&
-        doNonRotatedBoundsIntersect(startBounds, endBounds)
+        doBoundsIntersect(startBounds, endBounds)
       );
     }
 
@@ -2525,6 +2525,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) {

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/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/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": [
@@ -1086,6 +1087,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,
@@ -1300,6 +1302,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1631,6 +1634,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1962,6 +1966,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2176,6 +2181,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2417,6 +2423,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2715,6 +2722,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3087,6 +3095,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3580,6 +3589,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3903,6 +3913,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,
@@ -4226,6 +4237,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4637,6 +4649,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -5854,6 +5867,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -7122,6 +7136,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -7811,6 +7826,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -8802,6 +8818,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [

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,
@@ -646,6 +647,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1207,6 +1209,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1567,6 +1570,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1929,6 +1933,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2192,6 +2197,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2645,6 +2651,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2948,6 +2955,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3267,6 +3275,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3561,6 +3570,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3847,6 +3857,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4082,6 +4093,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4339,6 +4351,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4610,6 +4623,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4839,6 +4853,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5068,6 +5083,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5315,6 +5331,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5571,6 +5588,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5829,6 +5847,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6158,6 +6177,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6585,6 +6605,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6959,6 +6980,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7271,6 +7293,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7563,6 +7586,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7793,6 +7817,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8145,6 +8170,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8497,6 +8523,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,
@@ -8903,6 +8930,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,
@@ -9182,6 +9210,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,
@@ -9446,6 +9475,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9711,6 +9741,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9943,6 +9974,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10240,6 +10272,7 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10557,6 +10590,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10793,6 +10827,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,
@@ -11718,6 +11753,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11978,6 +12014,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12213,6 +12250,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,
@@ -12450,6 +12488,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12841,6 +12880,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,
@@ -13051,6 +13091,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,
@@ -13258,6 +13299,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,
@@ -13559,6 +13601,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,
@@ -13857,6 +13900,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,
@@ -14102,6 +14146,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14339,6 +14384,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,
@@ -14576,6 +14622,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14823,6 +14870,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,
@@ -15154,6 +15202,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15324,6 +15373,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,
@@ -15608,6 +15658,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,
@@ -15871,6 +15922,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16024,6 +16076,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16306,6 +16359,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16468,6 +16522,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -17216,6 +17271,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -17862,6 +17918,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -18508,6 +18565,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -19257,6 +19315,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20025,6 +20084,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20505,6 +20565,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -21016,6 +21077,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -21475,6 +21537,7 @@ exports[`history > singleplayer undo/redo > should support linear element creati
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": 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,
@@ -439,6 +440,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,
@@ -855,6 +857,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1421,6 +1424,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1628,6 +1632,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,
@@ -2012,6 +2017,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,
@@ -2257,6 +2263,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2437,6 +2444,7 @@ exports[`regression tests > can drag element that covers another element, while
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2762,6 +2770,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,
@@ -3017,6 +3026,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,
@@ -3258,6 +3268,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,
@@ -3494,6 +3505,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,
@@ -3752,6 +3764,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,
@@ -4066,6 +4079,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,
@@ -4502,6 +4516,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4785,6 +4800,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,
@@ -5061,6 +5077,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5269,6 +5286,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5469,6 +5487,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,
@@ -5862,6 +5881,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6159,6 +6179,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,
@@ -6947,6 +6968,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,
@@ -7281,6 +7303,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,
@@ -7560,6 +7583,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,
@@ -7795,6 +7819,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,
@@ -8035,6 +8060,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,
@@ -8215,6 +8241,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,
@@ -8395,6 +8422,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,
@@ -8575,6 +8603,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,
@@ -8807,6 +8836,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,
@@ -9037,6 +9067,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,
@@ -9229,6 +9260,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,
@@ -9461,6 +9493,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,
@@ -9641,6 +9674,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,
@@ -9871,6 +9905,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,
@@ -10051,6 +10086,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,
@@ -10243,6 +10279,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,
@@ -10423,6 +10460,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,
@@ -10954,6 +10992,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11234,6 +11273,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,
@@ -11357,6 +11397,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,
@@ -11557,6 +11598,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,
@@ -11876,6 +11918,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,
@@ -12305,6 +12348,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,
@@ -12945,6 +12989,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,
@@ -13071,6 +13116,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13702,6 +13748,7 @@ exports[`regression tests > switches from group of selected elements to another
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14041,6 +14088,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14305,6 +14353,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,
@@ -14428,6 +14477,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,
@@ -14792,6 +14842,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14915,6 +14966,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,

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/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 */

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,

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"