chore: Introducing RotatedBounds

Signed-off-by: Mark Tolmacs <mark@lazycat.hu>

packages/common/src/bounds.ts

@@ -1,3 +1,5 @@
+import type { Radians } from "@excalidraw/math";
+
 /**
  * x and y position of top left corner, x and y position of bottom right corner
  */
@@ -6,7 +8,31 @@ 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) &&
@@ -15,3 +41,12 @@ 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,9 +2,11 @@ import rough from "roughjs/bin/rough";
 
 import {
   arrayToMap,
+  bounds,
   type Bounds,
   invariant,
   rescalePoints,
+  type RotatedBounds,
   sizeOf,
 } from "@excalidraw/common";
 
@@ -90,7 +92,7 @@ export class ElementBounds {
   private static boundsCache = new WeakMap<
     ExcalidrawElement,
     {
-      bounds: Bounds;
+      bounds: RotatedBounds;
       version: ExcalidrawElement["version"];
     }
   >();
@@ -102,11 +104,11 @@ export class ElementBounds {
     }
   >();
 
-  static getBounds(
+  static getBounds<T extends boolean = false>(
     element: ExcalidrawElement,
     elementsMap: ElementsMap,
-    nonRotated: boolean = false,
+    nonRotated: T = false as T,
-  ) {
+  ): T extends true ? Bounds : RotatedBounds {
     const cachedBounds =
       nonRotated && element.angle !== 0
         ? ElementBounds.nonRotatedBoundsCache.get(element)
@@ -119,40 +121,41 @@ export class ElementBounds {
       // which is causing problems down the line. Fix TBA.
       !isBoundToContainer(element)
     ) {
-      return cachedBounds.bounds;
+      return cachedBounds.bounds as T extends true ? Bounds : RotatedBounds;
     }
 
     if (nonRotated && element.angle !== 0) {
-      const nonRotatedBounds = ElementBounds.calculateBounds(
+      const [minX, minY, maxX, maxY] = 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;
+      return nonRotatedBounds as T extends true ? Bounds : RotatedBounds;
     }
 
-    const bounds = ElementBounds.calculateBounds(element, elementsMap);
+    const _bounds = ElementBounds.calculateBounds(element, elementsMap);
 
     ElementBounds.boundsCache.set(element, {
       version: element.version,
-      bounds,
+      bounds: _bounds,
     });
 
-    return bounds;
+    return _bounds as T extends true ? Bounds : RotatedBounds;
   }
 
   private static calculateBounds(
     element: ExcalidrawElement,
     elementsMap: ElementsMap,
-  ): Bounds {
+  ): RotatedBounds {
-    let bounds: Bounds;
+    let _bounds: RotatedBounds;
 
     const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(
       element,
@@ -169,14 +172,15 @@ export class ElementBounds {
         ),
       );
 
-      return [
+      return bounds(
         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),
@@ -202,7 +206,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 = [minX, minY, maxX, maxY];
+      _bounds = bounds(minX, minY, maxX, maxY, element.angle);
     } else if (element.type === "ellipse") {
       const w = (x2 - x1) / 2;
       const h = (y2 - y1) / 2;
@@ -210,7 +214,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 = [cx - ww, cy - hh, cx + ww, cy + hh];
+      _bounds = bounds(cx - ww, cy - hh, cx + ww, cy + hh, element.angle);
     } else {
       const [x11, y11] = pointRotateRads(
         pointFrom(x1, y1),
@@ -236,10 +240,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 = [minX, minY, maxX, maxY];
+      _bounds = bounds(minX, minY, maxX, maxY, element.angle);
     }
 
-    return bounds;
+    return _bounds;
   }
 }
 
@@ -624,7 +628,7 @@ export const getCubicBezierCurveBound = (
     minY = Math.min(minY, ...ys);
     maxY = Math.max(maxY, ...ys);
   }
-  return [minX, minY, maxX, maxY];
+  return bounds(minX, minY, maxX, maxY);
 };
 
 export const getMinMaxXYFromCurvePathOps = (
@@ -677,7 +681,7 @@ export const getMinMaxXYFromCurvePathOps = (
     },
     { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity },
   );
-  return [minX, minY, maxX, maxY];
+  return bounds(minX, minY, maxX, maxY);
 };
 
 export const getBoundsFromPoints = (
@@ -695,7 +699,7 @@ export const getBoundsFromPoints = (
     maxY = Math.max(maxY, y);
   }
 
-  return [minX, minY, maxX, maxY];
+  return bounds(minX, minY, maxX, maxY);
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -938,7 +942,7 @@ const getLinearElementRotatedBounds = (
   cx: number,
   cy: number,
   elementsMap: ElementsMap,
-): Bounds => {
+): RotatedBounds => {
   const boundTextElement = getBoundTextElement(element, elementsMap);
 
   if (element.points.length < 2) {
@@ -949,20 +953,21 @@ const getLinearElementRotatedBounds = (
       element.angle,
     );
 
-    let coords: Bounds = [x, y, x, y];
+    let coords: RotatedBounds = bounds(x, y, x, y, element.angle);
     if (boundTextElement) {
       const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(
         element,
         elementsMap,
-        [x, y, x, y],
+        bounds(x, y, x, y, element.angle),
         boundTextElement,
       );
-      coords = [
+      coords = bounds(
         coordsWithBoundText[0],
         coordsWithBoundText[1],
         coordsWithBoundText[2],
         coordsWithBoundText[3],
-      ];
+        element.angle,
+      );
     }
     return coords;
   }
@@ -978,7 +983,13 @@ const getLinearElementRotatedBounds = (
       element.angle,
     );
   const res = getMinMaxXYFromCurvePathOps(ops, transformXY);
-  let coords: Bounds = [res[0], res[1], res[2], res[3]];
+  let coords: RotatedBounds = bounds(
+    res[0],
+    res[1],
+    res[2],
+    res[3],
+    element.angle,
+  );
   if (boundTextElement) {
     const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(
       element,
@@ -986,22 +997,23 @@ const getLinearElementRotatedBounds = (
       coords,
       boundTextElement,
     );
-    coords = [
+    coords = bounds(
       coordsWithBoundText[0],
       coordsWithBoundText[1],
       coordsWithBoundText[2],
       coordsWithBoundText[3],
-    ];
+      element.angle,
+    );
   }
   return coords;
 };
 
-export const getElementBounds = (
+export const getElementBounds = <T extends boolean = false>(
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
-  nonRotated: boolean = false,
+  nonRotated: T = false as T,
-): Bounds => {
+) => {
-  return ElementBounds.getBounds(element, elementsMap, nonRotated);
+  return ElementBounds.getBounds<T>(element, elementsMap, nonRotated);
 };
 
 export const getCommonBounds = (
@@ -1009,7 +1021,7 @@ export const getCommonBounds = (
   elementsMap?: ElementsMap,
 ): Bounds => {
   if (!sizeOf(elements)) {
-    return [0, 0, 0, 0];
+    return bounds(0, 0, 0, 0);
   }
 
   let minX = Infinity;
@@ -1027,7 +1039,7 @@ export const getCommonBounds = (
     maxY = Math.max(maxY, y2);
   });
 
-  return [minX, minY, maxX, maxY];
+  return bounds(minX, minY, maxX, maxY);
 };
 
 export const getDraggedElementsBounds = (
@@ -1050,12 +1062,12 @@ export const getResizedElementAbsoluteCoords = (
   normalizePoints: boolean,
 ): Bounds => {
   if (!(isLinearElement(element) || isFreeDrawElement(element))) {
-    return [
+    return bounds(
       element.x,
       element.y,
       element.x + nextWidth,
       element.y + nextHeight,
-    ];
+    );
   }
 
   const points = rescalePoints(
@@ -1065,11 +1077,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();
@@ -1081,16 +1093,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;
+  const [minX, minY, maxX, maxY] = _bounds;
-  return [
+  return bounds(
     minX + element.x,
     minY + element.y,
     maxX + element.x,
     maxY + element.y,
-  ];
+  );
 };
 
 export const getElementPointsCoords = (
@@ -1108,20 +1120,20 @@ export const getElementPointsCoords = (
       : gen.curve(points as [number, number][], generateRoughOptions(element));
   const ops = getCurvePathOps(curve);
   const [minX, minY, maxX, maxY] = getMinMaxXYFromCurvePathOps(ops);
-  return [
+  return bounds(
     minX + element.x,
     minY + element.y,
     maxX + element.x,
     maxY + element.y,
-  ];
+  );
 };
 
 export const getClosestElementBounds = (
   elements: readonly ExcalidrawElement[],
   from: { x: number; y: number },
-): Bounds => {
+): RotatedBounds => {
   if (!elements.length) {
-    return [0, 0, 0, 0];
+    return bounds(0, 0, 0, 0, 0 as Radians);
   }
 
   let minDistance = Infinity;
@@ -1190,7 +1202,9 @@ export const getVisibleSceneBounds = ({
   ];
 };
 
-export const getCenterForBounds = (bounds: Bounds): GlobalPoint =>
+export const getCenterForBounds = (
+  bounds: Bounds | RotatedBounds,
+): GlobalPoint =>
   pointFrom(
     bounds[0] + (bounds[2] - bounds[0]) / 2,
     bounds[1] + (bounds[3] - bounds[1]) / 2,
@@ -1235,24 +1249,24 @@ export const aabbForElement = (
     element.angle,
   );
 
-  const bounds = [
+  const _bounds = 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 [
+    return bounds(
-      bounds[0] - leftOffset,
+      _bounds[0] - leftOffset,
-      bounds[1] - topOffset,
+      _bounds[1] - topOffset,
-      bounds[2] + rightOffset,
+      _bounds[2] + rightOffset,
-      bounds[3] + downOffset,
+      _bounds[3] + downOffset,
-    ] as Bounds;
+    );
   }
 
-  return bounds;
+  return _bounds;
 };
 
 export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
@@ -1261,7 +1275,7 @@ 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 doBoundsIntersect = (
+export const doNonRotatedBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
 ): boolean => {
@@ -1281,7 +1295,7 @@ export const elementCenterPoint = (
   xOffset: number = 0,
   yOffset: number = 0,
 ) => {
-  if (isLinearElement(element)) {
+  if (isLinearElement(element) || isFreeDrawElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
 

packages/element/src/collision.ts

@@ -1,4 +1,9 @@
-import { invariant, isTransparent, type Bounds } from "@excalidraw/common";
+import {
+  bounds,
+  invariant,
+  isTransparent,
+  type Bounds,
+} from "@excalidraw/common";
 import {
   curveIntersectLineSegment,
   isPointWithinBounds,
@@ -29,7 +34,7 @@ import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
 
 import { isPathALoop } from "./utils";
 import {
-  doBoundsIntersect,
+  doNonRotatedBoundsIntersect,
   elementCenterPoint,
   getCenterForBounds,
   getCubicBezierCurveBound,
@@ -154,14 +159,11 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointWithinBounds(
+  const hitBounds = isPointInRotatedBounds(
-    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
+    point,
-    pointRotateRads(
+    bounds,
-      point,
+    element.angle,
-      getCenterForBounds(bounds),
+    threshold,
-      -element.angle as Radians,
-    ),
-    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -192,18 +194,108 @@ 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,
+  angle: Radians,
+  tolerance = 0,
+) => {
+  const adjustedPoint =
+    angle === 0
+      ? point
+      : pointRotateRads(point, getCenterForBounds(bounds), -angle as Radians);
+
+  return isPointWithinBounds(
+    pointFrom(bounds[0] - tolerance, bounds[1] - tolerance),
+    adjustedPoint,
+    pointFrom(bounds[2] + tolerance, bounds[3] + tolerance),
+  );
+};
+
 export const hitElementBoundingBox = (
   point: GlobalPoint,
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   tolerance = 0,
 ) => {
-  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
+  const bounds = getElementBounds(element, elementsMap, true);
-  x1 -= tolerance;
+  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
-  y1 -= tolerance;
+};
-  x2 += tolerance;
+
-  y2 += tolerance;
+export const doBoundsIntersectElementBoundingBox = (
-  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
+  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 = (
@@ -256,9 +348,13 @@ 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 bounds = [x - t, y - t, x + t, y + t] as Bounds;
+  const elementBounds = getElementBounds(element, elementsMap, true);
-  const elementBounds = getElementBounds(element, elementsMap);
+  if (
-  if (!doBoundsIntersect(bounds, elementBounds)) {
+    !doNonRotatedBoundsIntersect(
+      bounds(x - t, y - t, x + t, y + t),
+      elementBounds,
+    )
+  ) {
     return false;
   }
 
@@ -269,6 +365,7 @@ const bindingBorderTest = (
       const enclosingFrameBounds = getElementBounds(
         enclosingFrame,
         elementsMap,
+        true,
       );
       if (!pointInsideBounds(p, enclosingFrameBounds)) {
         return false;
@@ -418,15 +515,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 = [
+  const intersectorBounds = bounds(
     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),
-  ] as Bounds;
+  );
-  const elementBounds = getElementBounds(element, elementsMap);
+  const elementBounds = getElementBounds(element, elementsMap, true);
 
-  if (!doBoundsIntersect(intersectorBounds, elementBounds)) {
+  if (!doNonRotatedBoundsIntersect(intersectorBounds, elementBounds)) {
     return [];
   }
 
@@ -485,14 +582,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 = [
+    const b2 = bounds(
       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 (!doBoundsIntersect(b1, b2)) {
+    if (!doNonRotatedBoundsIntersect(b1, b2)) {
       continue;
     }
 
@@ -562,14 +659,14 @@ 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 = [
+    const b2 = bounds(
       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 (!doBoundsIntersect(b1, b2)) {
+    if (!doNonRotatedBoundsIntersect(b1, b2)) {
       continue;
     }
 

packages/element/src/frame.ts

@@ -99,7 +99,7 @@ export const isElementContainingFrame = (
   element: ExcalidrawElement,
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
-) => {
+): boolean => {
   return getElementsWithinSelection([frame], element, elementsMap).some(
     (e) => e.id === frame.id,
   );
@@ -140,7 +140,7 @@ export const elementOverlapsWithFrame = (
   element: ExcalidrawElement,
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
-) => {
+): boolean => {
   return (
     elementsAreInFrameBounds([element], frame, elementsMap) ||
     isElementIntersectingFrame(element, frame, elementsMap) ||

packages/element/src/linearElementEditor.ts

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

packages/element/src/selection.ts

@@ -1,15 +1,35 @@
-import { arrayToMap, isShallowEqual } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import {
+  lineSegment,
+  pointFrom,
+  type GlobalPoint,
+  type LineSegment,
+} from "@excalidraw/math";
 
 import type {
   AppState,
+  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
+import {
+  getElementAbsoluteCoords,
+  getElementBounds,
+  getElementLineSegments,
+} from "./bounds";
+import {
+  doBoundsIntersectElementBoundingBox,
+  getBoundsCorners,
+  getBoundsEdges,
+  intersectElementWithLineSegment,
+  isPointInElement,
+  shouldTestInside,
+} from "./collision";
 import { isElementInViewport } from "./sizeHelpers";
 import {
   isBoundToContainer,
   isFrameLikeElement,
+  isFreeDrawElement,
   isLinearElement,
   isTextElement,
 } from "./typeChecks";
@@ -30,6 +50,205 @@ import type {
   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 = (
+  element: NonDeletedExcalidrawElement,
+) =>
+  element.angle !== 0 &&
+  !isLinearElement(element) &&
+  !isFreeDrawElement(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) {
+      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
@@ -62,55 +281,166 @@ export const getElementsWithinSelection = (
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
   excludeElementsInFrames: boolean = true,
-) => {
+  boxSelectionMode: BoxSelectionMode = "contain",
-  const [selectionX1, selectionY1, selectionX2, selectionY2] =
+): NonDeletedExcalidrawElement[] => {
+  const [selectionStartX, selectionStartY, selectionEndX, selectionEndY] =
     getElementAbsoluteCoords(selection, elementsMap);
+  const selectionX1 = Math.min(selectionStartX, selectionEndX);
+  const selectionY1 = Math.min(selectionStartY, selectionEndY);
+  const selectionX2 = Math.max(selectionStartX, selectionEndX);
+  const selectionY2 = Math.max(selectionStartY, selectionEndY);
+  const selectionBounds = [
+    selectionX1,
+    selectionY1,
+    selectionX2,
+    selectionY2,
+  ] as Bounds;
 
-  let elementsInSelection = elements.filter((element) => {
+  if (boxSelectionMode !== "overlap") {
-    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+    const elementsInSelection: NonDeletedExcalidrawElement[] = [];
-      element,
-      elementsMap,
-    );
 
-    const containingFrame = getContainingFrame(element, elementsMap);
+    for (const element of elements) {
-    if (containingFrame) {
+      if (shouldSkipElementFromSelection(element)) {
-      const [fx1, fy1, fx2, fy2] = getElementBounds(
+        continue;
-        containingFrame,
+      }
-        elementsMap,
-      );
 
-      elementX1 = Math.max(fx1, elementX1);
+      const elementBounds = getElementBounds(element, elementsMap) as Bounds;
-      elementY1 = Math.max(fy1, elementY1);
+      const frameBounds = getFrameBoundsForSelection(element, elementsMap);
-      elementX2 = Math.min(fx2, elementX2);
+      let elementX1 = elementBounds[0];
-      elementY2 = Math.min(fy2, elementY2);
+      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 (
+    return finalizeElementsInSelection(
-      element.locked === false &&
+      elementsInSelection,
-      element.type !== "selection" &&
+      excludeElementsInFrames,
-      !isBoundToContainer(element) &&
+      elementsMap,
+    );
+  }
+
+  const selectionCorners = getBoundsCorners(selectionBounds);
+  const selectionEdges = getBoundsEdges(selectionCorners);
+  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);
+    }
+
+    const isSelectionContainingElement =
       selectionX1 <= elementX1 &&
       selectionY1 <= elementY1 &&
       selectionX2 >= elementX2 &&
-      selectionY2 >= elementY2
+      selectionY2 >= elementY2;
-    );
-  });
 
-  elementsInSelection = excludeElementsInFrames
+    const isSelectionOverlappingElementAabb =
-    ? excludeElementsInFramesFromSelection(elementsInSelection)
+      selectionX1 <= elementX2 &&
-    : elementsInSelection;
+      selectionY1 <= elementY2 &&
+      selectionX2 >= elementX1 &&
+      selectionY2 >= elementY1;
+    const isSelectionOverlappingElement = shouldUseRotatedOverlapBroadPhase(
+      element,
+    )
+      ? isSelectionOverlappingElementAabb &&
+        doBoundsIntersectElementBoundingBox(
+          selectionBounds,
+          element,
+          elementsMap,
+        )
+      : isSelectionOverlappingElementAabb;
 
-  elementsInSelection = elementsInSelection.filter((element) => {
+    const shouldSelectFromInside = shouldTestInside(element);
-    const containingFrame = getContainingFrame(element, elementsMap);
 
-    if (containingFrame) {
+    if (shouldSelectFromInside) {
-      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
+      if (
+        isSelectionOverlappingElement &&
+        (!shouldUsePreciseFilledOverlap(element) ||
+          isSelectionContainingElement ||
+          doesSelectionOverlapFilledElement(
+            element,
+            frameBounds,
+            selectionBounds,
+            selectionCorners,
+            selectionEdges,
+            elementsMap,
+          ))
+      ) {
+        elementsInSelection.push(element);
+      }
+      continue;
     }
 
-    return true;
+    if (!isSelectionOverlappingElement) {
-  });
+      continue;
+    }
 
-  return elementsInSelection;
+    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);
+    }
+  }
+
+  return finalizeElementsInSelection(
+    elementsInSelection,
+    excludeElementsInFrames,
+    elementsMap,
+  );
 };
 
 export const getVisibleAndNonSelectedElements = (

packages/element/tests/collision.test.tsx

@@ -29,7 +29,7 @@ describe("check rotated elements can be hit:", () => {
       ] as LocalPoint[],
     });
     const hit = hitElementItself({
-      point: pointFrom<GlobalPoint>(88, -68),
+      point: pointFrom<GlobalPoint>(87, -67),
       element: window.h.elements[0],
       threshold: 10,
       elementsMap: window.h.scene.getNonDeletedElementsMap(),

packages/excalidraw/actions/actionDeselect.ts

@@ -0,0 +1,145 @@
+import {
+  getElementsInGroup,
+  isSomeElementSelected,
+  makeNextSelectedElementIds,
+  selectGroupsForSelectedElements,
+} from "@excalidraw/element";
+import { CaptureUpdateAction } from "@excalidraw/element";
+import { KEYS, isWritableElement, updateActiveTool } from "@excalidraw/common";
+
+import type { GroupId } from "@excalidraw/element/types";
+
+import { register } from "./register";
+
+import type { AppClassProperties, AppState } from "../types";
+
+const getNextActiveTool = (
+  appState: Readonly<AppState>,
+  app: AppClassProperties,
+) => {
+  if (appState.activeTool.type === "eraser") {
+    return updateActiveTool(appState, {
+      ...(appState.activeTool.lastActiveTool || {
+        type: app.state.preferredSelectionTool.type,
+      }),
+      lastActiveToolBeforeEraser: null,
+    });
+  }
+
+  return updateActiveTool(appState, {
+    type: app.state.preferredSelectionTool.type,
+  });
+};
+
+const getParentEditingGroupId = (
+  appState: Readonly<AppState>,
+  app: AppClassProperties,
+  selectedElementIds: AppState["selectedElementIds"],
+): GroupId | null => {
+  if (!appState.editingGroupId) {
+    return null;
+  }
+
+  const nonDeletedElements = app.scene.getNonDeletedElements();
+  const selectedElements = app.scene.getSelectedElements({
+    selectedElementIds,
+    elements: nonDeletedElements,
+  });
+  const candidateElements = selectedElements.length
+    ? selectedElements
+    : getElementsInGroup(nonDeletedElements, appState.editingGroupId);
+
+  for (const element of candidateElements) {
+    const editingGroupIndex = element.groupIds.indexOf(appState.editingGroupId);
+    if (editingGroupIndex !== -1 && element.groupIds[editingGroupIndex + 1]) {
+      return element.groupIds[editingGroupIndex + 1] as GroupId;
+    }
+  }
+
+  return null;
+};
+
+export const actionDeselect = register({
+  name: "deselect",
+  label: "",
+  trackEvent: false,
+  perform: (_elements, appState, _, app) => {
+    const activeTool = getNextActiveTool(appState, app);
+
+    if (appState.editingGroupId) {
+      const nonDeletedElements = app.scene.getNonDeletedElements();
+      const selectedElementIds =
+        Object.keys(appState.selectedElementIds).length > 0
+          ? appState.selectedElementIds
+          : getElementsInGroup(
+              nonDeletedElements,
+              appState.editingGroupId,
+            ).reduce((acc, element) => {
+              acc[element.id] = true;
+              return acc;
+            }, {} as Record<string, true>);
+
+      return {
+        appState: {
+          ...appState,
+          ...selectGroupsForSelectedElements(
+            {
+              editingGroupId: getParentEditingGroupId(
+                appState,
+                app,
+                selectedElementIds,
+              ),
+              selectedElementIds,
+            },
+            nonDeletedElements,
+            appState,
+            app,
+          ),
+          activeEmbeddable: null,
+          activeTool,
+          selectedLinearElement: null,
+          selectionElement: null,
+          showHyperlinkPopup: false,
+          suggestedBinding: null,
+        },
+        captureUpdate: CaptureUpdateAction.IMMEDIATELY,
+      };
+    }
+
+    return {
+      appState: {
+        ...appState,
+        activeEmbeddable: null,
+        activeTool,
+        editingGroupId: null,
+        selectedElementIds: makeNextSelectedElementIds({}, appState),
+        selectedGroupIds: {},
+        selectedLinearElement: null,
+        selectionElement: null,
+        showHyperlinkPopup: false,
+        suggestedBinding: null,
+      },
+      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
+    };
+  },
+  keyTest: (event, appState, _, app) => {
+    if (event.key !== KEYS.ESCAPE) {
+      return false;
+    }
+
+    if (isWritableElement(event.target)) {
+      return false;
+    }
+
+    return (
+      !appState.newElement &&
+      appState.multiElement === null &&
+      !appState.selectedLinearElement?.isEditing &&
+      (appState.activeEmbeddable !== null ||
+        appState.activeTool.type !== app.state.preferredSelectionTool.type ||
+        !!appState.editingGroupId ||
+        !!appState.selectedLinearElement ||
+        isSomeElementSelected(app.scene.getNonDeletedElements(), appState))
+    );
+  },
+});

packages/excalidraw/actions/actionFinalize.tsx

@@ -348,9 +348,7 @@ export const actionFinalize = register<FormData>({
     };
   },
   keyTest: (event, appState) =>
-    (event.key === KEYS.ESCAPE &&
+    (event.key === KEYS.ESCAPE && appState.selectedLinearElement?.isEditing) ||
-      (appState.selectedLinearElement?.isEditing ||
-        (!appState.newElement && appState.multiElement === null))) ||
     ((event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) &&
       appState.multiElement !== null),
   PanelComponent: ({ appState, updateData, data }) => (

packages/excalidraw/actions/index.ts

@@ -34,6 +34,7 @@ export {
 export { actionSetEmbeddableAsActiveTool } from "./actionEmbeddable";
 
 export { actionFinalize } from "./actionFinalize";
+export { actionDeselect } from "./actionDeselect";
 
 export {
   actionChangeProjectName,

packages/excalidraw/actions/types.ts

@@ -114,6 +114,7 @@ export type ActionName =
   | "distributeVertically"
   | "flipHorizontal"
   | "flipVertical"
+  | "deselect"
   | "viewMode"
   | "exportWithDarkMode"
   | "toggleTheme"

packages/excalidraw/appState.ts

@@ -193,6 +193,7 @@ const APP_STATE_STORAGE_CONF = (<
   gridModeEnabled: { browser: true, export: true, server: true },
   height: { browser: false, export: false, server: false },
   isBindingEnabled: { browser: true, export: false, server: false },
+  boxSelectionMode: { browser: true, export: false, server: false },
   bindingPreference: { browser: true, export: false, server: false },
   isMidpointSnappingEnabled: { browser: true, export: false, server: false },
   defaultSidebarDockedPreference: {

packages/excalidraw/components/App.tsx

@@ -27,6 +27,7 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
+  DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -245,7 +246,7 @@ import {
   bindOrUnbindBindingElement,
   mutateElement,
   getElementBounds,
-  doBoundsIntersect,
+  doNonRotatedBoundsIntersect,
   isPointInElement,
   maxBindingDistance_simple,
   convertToExcalidrawElements,
@@ -1153,7 +1154,7 @@ class App extends React.Component<AppProps, AppState> {
         startBounds &&
         endBounds &&
         startElement.id !== endElement.id &&
-        doBoundsIntersect(startBounds, endBounds)
+        doNonRotatedBoundsIntersect(startBounds, endBounds)
       );
     }
 
@@ -5725,13 +5726,13 @@ class App extends React.Component<AppProps, AppState> {
         const isDeleted = !nextOriginalText.trim();
         updateElement(nextOriginalText, isDeleted);
 
-        // select the created text element only if submitting via keyboard
+        // keyboard-submit keeps focus on the edited object. For bound text, keep
-        // (when submitting via click it should act as signal to deselect)
+        // the container selected even if the text becomes empty and is deleted.
-        if (!isDeleted && viaKeyboard) {
+        const elementIdToSelect = viaKeyboard
-          const elementIdToSelect = element.containerId
+          ? element.containerId || (!isDeleted ? element.id : null)
-            ? element.containerId
+          : null;
-            : element.id;
 
+        if (elementIdToSelect) {
           // needed to ensure state is updated before "finalize" action
           // that's invoked on keyboard-submit as well
           // TODO either move this into finalize as well, or handle all state
@@ -7239,6 +7240,14 @@ class App extends React.Component<AppProps, AppState> {
           this.interactiveCanvas,
           isTextElement(hitElement) ? CURSOR_TYPE.TEXT : CURSOR_TYPE.CROSSHAIR,
         );
+      } else if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        this.isHittingCommonBoundingBoxOfSelectedElements(
+          scenePointer,
+          selectedElements,
+        )
+      ) {
+        setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);
       } else if (this.state.viewModeEnabled) {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.GRAB);
       } else if (this.state.openDialog?.name === "elementLinkSelector") {
@@ -7730,17 +7739,24 @@ class App extends React.Component<AppProps, AppState> {
       const hitSelectedElement =
         pointerDownState.hit.element &&
         this.isASelectedElement(pointerDownState.hit.element);
+      const shouldForceLassoReselect =
+        event.altKey &&
+        event[KEYS.CTRL_OR_CMD] &&
+        !pointerDownState.resize.handleType;
+      const shouldStartLassoSelection =
+        shouldForceLassoReselect ||
+        (!pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+          !pointerDownState.resize.handleType &&
+          !hitSelectedElement);
 
-      if (
+      if (shouldStartLassoSelection) {
-        !pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+        if (!this.lassoTrail.hasCurrentTrail) {
-        !pointerDownState.resize.handleType &&
+          this.lassoTrail.startPath(
-        !hitSelectedElement
+            pointerDownState.origin.x,
-      ) {
+            pointerDownState.origin.y,
-        this.lassoTrail.startPath(
+            event.shiftKey,
-          pointerDownState.origin.x,
+          );
-          pointerDownState.origin.y,
+        }
-          event.shiftKey,
-        );
 
         // block dragging after lasso selection on PCs until the next pointer down
         // (on mobile or tablet, we want to allow user to drag immediately)
@@ -8729,12 +8745,14 @@ class App extends React.Component<AppProps, AppState> {
       DEFAULT_COLLISION_THRESHOLD / this.state.zoom.value,
       1,
     );
+    const boundsPadding =
+      (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / this.state.zoom.value;
     const [x1, y1, x2, y2] = getCommonBounds(selectedElements);
     return (
-      point.x > x1 - threshold &&
+      point.x > x1 - boundsPadding - threshold &&
-      point.x < x2 + threshold &&
+      point.x < x2 + boundsPadding + threshold &&
-      point.y > y1 - threshold &&
+      point.y > y1 - boundsPadding - threshold &&
-      point.y < y2 + threshold
+      point.y < y2 + boundsPadding + threshold
     );
   }
 
@@ -10267,6 +10285,7 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
+                this.state.boxSelectionMode,
               )
             : [];
 

packages/excalidraw/components/FontPicker/FontPickerList.tsx

@@ -46,6 +46,7 @@ import {
 import { fontPickerKeyHandler } from "./keyboardNavHandlers";
 
 import type { JSX } from "react";
+import type { ExcalidrawFontFace } from "../../fonts/ExcalidrawFontFace";
 
 export interface FontDescriptor {
   value: number;
@@ -86,6 +87,15 @@ const getFontFamilyIcon = (fontFamily: FontFamilyValues): JSX.Element => {
   }
 };
 
+const getFontFamilyLabel = (
+  fontFamily: FontFamilyValues,
+  fontFaces: ExcalidrawFontFace[],
+) =>
+  // prefer our config as the browser resolved names may be wrapped in quotes and such
+  Object.entries(FONT_FAMILY).find(([, id]) => id === fontFamily)?.[0] ??
+  fontFaces[0]?.fontFace?.family ??
+  "Unknown";
+
 export const FontPickerList = React.memo(
   ({
     selectedFontFamily,
@@ -114,7 +124,7 @@ export const FontPickerList = React.memo(
             const fontDescriptor = {
               value: familyId,
               icon: getFontFamilyIcon(familyId),
-              text: fontFaces[0]?.fontFace?.family ?? "Unknown",
+              text: getFontFamilyLabel(familyId, fontFaces),
             };
 
             if (metadata.deprecated) {

packages/excalidraw/components/RadioGroup.scss

@@ -26,13 +26,16 @@
     background: var(--RadioGroup-background);
     border: 1px solid var(--RadioGroup-border);
 
+    gap: 2px;
+
     &__choice {
       position: relative;
       display: flex;
       align-items: center;
       justify-content: center;
-      width: 32px;
+      min-width: 20px;
       height: 24px;
+      padding: 0 0.375rem;
 
       color: var(--RadioGroup-choice-color-off);
       background: var(--RadioGroup-choice-background-off);

packages/excalidraw/components/TTDDialog/Chat/Chat.scss

@@ -3,25 +3,7 @@
 $verticalBreakpoint: 861px;
 
 .excalidraw {
-  --ttd-mermaid-token-keyword: #0000ff;
-  --ttd-mermaid-token-string: #a31515;
-  --ttd-mermaid-token-comment: #008000;
-  --ttd-mermaid-token-number: #098658;
-  --ttd-mermaid-token-operator: #1e1e1e;
-  --ttd-mermaid-token-punctuation: #1e1e1e;
-  --ttd-mermaid-token-variable-name: #001080;
-  --ttd-mermaid-token-bracket: #af00db;
-
   &.theme--dark {
-    --ttd-mermaid-token-keyword: #569cd6;
-    --ttd-mermaid-token-string: #ce9178;
-    --ttd-mermaid-token-comment: #6a9955;
-    --ttd-mermaid-token-number: #b5cea8;
-    --ttd-mermaid-token-operator: #d4d4d4;
-    --ttd-mermaid-token-punctuation: #d4d4d4;
-    --ttd-mermaid-token-variable-name: #9cdcfe;
-    --ttd-mermaid-token-bracket: #ffd700;
-
     .chat-message {
       &--assistant {
         .chat-message__content {
@@ -212,7 +194,7 @@ $verticalBreakpoint: 861px;
       align-items: flex-start;
 
       .chat-message__content {
-        background: #f7f7f7;
+        background: var(--color-surface-low);
         color: var(--color-on-surface);
         border-radius: var(--border-radius-md);
         min-width: 6rem;
@@ -310,51 +292,6 @@ $verticalBreakpoint: 861px;
       word-wrap: break-word;
     }
 
-    &__text--error {
-      color: inherit;
-    }
-
-    &__text--mermaid {
-      overflow-x: auto;
-      font-weight: 400;
-    }
-
-    &__token {
-      white-space: inherit;
-    }
-
-    &__token--keyword {
-      color: var(--ttd-mermaid-token-keyword);
-    }
-
-    &__token--string {
-      color: var(--ttd-mermaid-token-string);
-    }
-
-    &__token--comment {
-      color: var(--ttd-mermaid-token-comment);
-    }
-
-    &__token--number {
-      color: var(--ttd-mermaid-token-number);
-    }
-
-    &__token--operator {
-      color: var(--ttd-mermaid-token-operator);
-    }
-
-    &__token--punctuation {
-      color: var(--ttd-mermaid-token-punctuation);
-    }
-
-    &__token--variableName {
-      color: var(--ttd-mermaid-token-variable-name);
-    }
-
-    &__token--bracket {
-      color: var(--ttd-mermaid-token-bracket);
-    }
-
     &__cursor {
       display: inline-block;
       margin-left: 2px;
@@ -395,13 +332,11 @@ $verticalBreakpoint: 861px;
     &__error {
       color: var(--color-danger);
       font-weight: 500;
+      white-space: pre-wrap;
+      word-wrap: break-word;
       display: flex;
       flex-direction: column;
       gap: 0.5rem;
-
-      .chat-message__text--mermaid {
-        color: var(--color-on-surface);
-      }
     }
 
     &__error_message {

packages/excalidraw/components/TTDDialog/Chat/ChatMessage.tsx

@@ -5,49 +5,8 @@ import { t } from "../../../i18n";
 import { FilledButton } from "../../FilledButton";
 import { TrashIcon, codeIcon, stackPushIcon, RetryIcon } from "../../icons";
 
-import { tokenizeMermaid } from "../mermaid-highlighting";
-
 import type { TChat, TTTDDialog } from "../types";
 
-const isMermaidMessage = (message: TChat.ChatMessage) =>
-  message.contentFormat === "mermaid";
-
-const renderMessageContent = (
-  message: TChat.ChatMessage,
-  className: string,
-) => {
-  const content = message.content ?? "";
-
-  console.log("@", message);
-
-  if (!isMermaidMessage(message)) {
-    return (
-      <div className={className}>
-        {content}
-        {message.isGenerating && (
-          <span className="chat-message__cursor">▋</span>
-        )}
-      </div>
-    );
-  }
-
-  return (
-    <div className={clsx(className, "chat-message__text--mermaid")}>
-      {tokenizeMermaid(content).map((token, index) => (
-        <span
-          key={`${index}-${token.type ?? "text"}-${token.value}`}
-          className={clsx("chat-message__token", {
-            [`chat-message__token--${token.type}`]: token.type,
-          })}
-        >
-          {token.value}
-        </span>
-      ))}
-      {message.isGenerating && <span className="chat-message__cursor">▋</span>}
-    </div>
-  );
-};
-
 export const ChatMessage: React.FC<{
   message: TChat.ChatMessage;
   onMermaidTabClick?: (message: TChat.ChatMessage) => void;
@@ -163,14 +122,7 @@ export const ChatMessage: React.FC<{
         <div className="chat-message__body">
           {message.error ? (
             <>
-              <div className="chat-message__error">
+              <div className="chat-message__error">{message.content}</div>
-                {renderMessageContent(
-                  message,
-                  clsx("chat-message__text", {
-                    "chat-message__text--error": !isMermaidMessage(message),
-                  }),
-                )}
-              </div>
               {message.errorType !== "parse" && (
                 <div className="chat-message__error_message">
                   Error: {message.error || t("chat.errors.generationFailed")}
@@ -180,7 +132,7 @@ export const ChatMessage: React.FC<{
                 <div className="chat-message__error_message">
                   <p>{t("chat.errors.invalidDiagram")}</p>
                   <div className="chat-message__error-actions">
-                    {onMermaidTabClick && isMermaidMessage(message) && (
+                    {onMermaidTabClick && (
                       <button
                         className="chat-message__error-link"
                         onClick={() => onMermaidTabClick(message)}
@@ -204,13 +156,18 @@ export const ChatMessage: React.FC<{
               )}
             </>
           ) : (
-            renderMessageContent(message, "chat-message__text")
+            <div className="chat-message__text">
+              {message.content}
+              {message.isGenerating && (
+                <span className="chat-message__cursor">▋</span>
+              )}
+            </div>
           )}
         </div>
       </div>
       {message.type === "assistant" && !message.isGenerating && (
         <div className="chat-message__actions">
-          {!message.error && onInsertMessage && isMermaidMessage(message) && (
+          {!message.error && onInsertMessage && (
             <button
               className="chat-message__action"
               onClick={() => onInsertMessage(message)}
@@ -221,7 +178,7 @@ export const ChatMessage: React.FC<{
               {stackPushIcon}
             </button>
           )}
-          {onMermaidTabClick && isMermaidMessage(message) && message.content && (
+          {onMermaidTabClick && message.content && (
             <button
               className="chat-message__action"
               onClick={() => onMermaidTabClick(message)}

packages/excalidraw/components/TTDDialog/Chat/TTDChatPanel.tsx

@@ -25,7 +25,6 @@ export const TTDChatPanel = ({
   onGenerate,
   isGenerating,
   generatedResponse,
-  generatedResponseFormat,
   isMenuOpen,
   onMenuToggle,
   onMenuClose,
@@ -51,7 +50,6 @@ export const TTDChatPanel = ({
   onGenerate: TTTDDialog.OnGenerate;
   isGenerating: boolean;
   generatedResponse: string | null | undefined;
-  generatedResponseFormat?: TChat.ChatMessage["contentFormat"];
 
   isMenuOpen: boolean;
   onMenuToggle: () => void;
@@ -91,7 +89,7 @@ export const TTDChatPanel = ({
       });
     }
 
-    if (generatedResponse && generatedResponseFormat === "mermaid") {
+    if (generatedResponse) {
       actions.push({
         action: onViewAsMermaid,
         label: t("chat.viewAsMermaid"),

packages/excalidraw/components/TTDDialog/Chat/useChatAgent.ts

@@ -25,7 +25,6 @@ export const useChatAgent = () => {
         {
           type: "assistant",
           content: "",
-          contentFormat: "mermaid",
           isGenerating: true,
         },
       ]),

packages/excalidraw/components/TTDDialog/CodeMirrorEditor.tsx

@@ -1,21 +1,13 @@
 import { useEffect, useRef } from "react";
 import {
   Decoration,
-  type DecorationSet,
   EditorView,
-  ViewPlugin,
-  type ViewUpdate,
   keymap,
   lineNumbers,
   placeholder as cmPlaceholder,
   drawSelection,
 } from "@codemirror/view";
-import {
+import { Compartment, EditorState, type Extension } from "@codemirror/state";
-  Compartment,
-  EditorState,
-  type Extension,
-  type Range,
-} from "@codemirror/state";
 import {
   defaultKeymap,
   history,
@@ -48,13 +40,6 @@ const darkTheme = EditorView.theme(
     },
     ".cm-content": { caretColor: "#fff" },
     ".cm-cursor": { borderLeftColor: "#fff" },
-    ".cm-selectionBackground": {
-      backgroundColor: "rgba(86, 156, 214, 0.3)",
-    },
-    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground":
-      {
-        backgroundColor: "rgba(86, 156, 214, 0.42)",
-      },
     ".cm-gutters": {
       backgroundColor: "#1e1e1e",
       color: "#858585",
@@ -63,10 +48,6 @@ const darkTheme = EditorView.theme(
     ".cm-activeLineGutter": { backgroundColor: "#2a2a2a" },
     ".cm-activeLine": { backgroundColor: "#2a2a2a" },
     ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.15)" },
-    ".cm-selectedWordMatch": {
-      backgroundColor: "rgba(255, 209, 102, 0.22)",
-      borderRadius: "2px",
-    },
   },
   { dark: true },
 );
@@ -99,10 +80,6 @@ const lightTheme = EditorView.theme({
   ".cm-activeLineGutter": { backgroundColor: "#e8e8e8" },
   ".cm-activeLine": { backgroundColor: "#e8e8e8" },
   ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.1)" },
-  ".cm-selectedWordMatch": {
-    backgroundColor: "rgba(255, 209, 102, 0.35)",
-    borderRadius: "2px",
-  },
 });
 
 const lightHighlight = HighlightStyle.define([
@@ -119,79 +96,6 @@ const lightHighlight = HighlightStyle.define([
 // ---- Error line decoration ----
 
 const errorLineDeco = Decoration.line({ class: "cm-errorLine" });
-const selectedWordMatchDeco = Decoration.mark({
-  class: "cm-selectedWordMatch",
-});
-
-const getSelectedWordMatchText = (state: EditorState) => {
-  const mainSelection = state.selection.main;
-  if (state.selection.ranges.length !== 1 || mainSelection.empty) {
-    return null;
-  }
-
-  const selectedWord = state.wordAt(mainSelection.from);
-  if (
-    !selectedWord ||
-    selectedWord.from !== mainSelection.from ||
-    selectedWord.to !== mainSelection.to
-  ) {
-    return null;
-  }
-
-  return state.sliceDoc(mainSelection.from, mainSelection.to);
-};
-
-const getSelectedWordMatchDecorations = (view: EditorView): DecorationSet => {
-  const selectedWord = getSelectedWordMatchText(view.state);
-  if (!selectedWord) {
-    return Decoration.none;
-  }
-
-  const selection = view.state.selection.main;
-  const ranges: Range<Decoration>[] = [];
-  const doc = view.state.doc.toString();
-  let searchFrom = 0;
-
-  while (searchFrom <= doc.length - selectedWord.length) {
-    const matchFrom = doc.indexOf(selectedWord, searchFrom);
-    if (matchFrom === -1) {
-      break;
-    }
-
-    const matchTo = matchFrom + selectedWord.length;
-    const matchWord = view.state.wordAt(matchFrom);
-    if (
-      matchWord?.from === matchFrom &&
-      matchWord.to === matchTo &&
-      (matchFrom !== selection.from || matchTo !== selection.to)
-    ) {
-      ranges.push(selectedWordMatchDeco.range(matchFrom, matchTo));
-    }
-
-    searchFrom = matchTo;
-  }
-
-  return ranges.length ? Decoration.set(ranges) : Decoration.none;
-};
-
-const selectedWordMatchExtension = ViewPlugin.fromClass(
-  class {
-    decorations: DecorationSet;
-
-    constructor(view: EditorView) {
-      this.decorations = getSelectedWordMatchDecorations(view);
-    }
-
-    update(update: ViewUpdate) {
-      if (update.docChanged || update.selectionSet) {
-        this.decorations = getSelectedWordMatchDecorations(update.view);
-      }
-    }
-  },
-  {
-    decorations: (value) => value.decorations,
-  },
-);
 
 const getErrorLineExtension = (
   errorLine: number | null | undefined,
@@ -268,7 +172,6 @@ const CodeMirrorEditor = ({
           errorLineCompartmentRef.current.of([]),
           mermaidLite(),
           drawSelection({ drawRangeCursor: true }),
-          selectedWordMatchExtension,
           ...(placeholder ? [cmPlaceholder(placeholder)] : []),
         ],
       }),

packages/excalidraw/components/TTDDialog/TextToDiagram.tsx

@@ -80,10 +80,7 @@ const TextToDiagramContent = ({
   } = useChatManagement({ persistenceAdapter });
 
   const onViewAsMermaid = () => {
-    if (
+    if (typeof lastAssistantMessage?.content === "string") {
-      lastAssistantMessage?.contentFormat === "mermaid" &&
-      typeof lastAssistantMessage.content === "string"
-    ) {
       saveMermaidDataToStorage(lastAssistantMessage.content);
       setAppState({
         openDialog: { name: "ttd", tab: "mermaid" },
@@ -209,7 +206,6 @@ const TextToDiagramContent = ({
         onGenerate={onGenerate}
         isGenerating={lastAssistantMessage?.isGenerating ?? false}
         generatedResponse={lastAssistantMessage?.content}
-        generatedResponseFormat={lastAssistantMessage?.contentFormat}
         isMenuOpen={isMenuOpen}
         onMenuToggle={handleMenuToggle}
         onMenuClose={handleMenuClose}

packages/excalidraw/components/TTDDialog/hooks/useTextGeneration.ts

@@ -88,7 +88,6 @@ export const useTextGeneration = ({
         updateAssistantContent(prev, {
           isGenerating: true,
           content: "",
-          contentFormat: "mermaid",
           error: undefined,
           errorType: undefined,
           errorDetails: undefined,

packages/excalidraw/components/TTDDialog/mermaid-highlighting.test.ts

@@ -1,40 +0,0 @@
-import {
-  getMermaidHighlightToken,
-  tokenizeMermaid,
-} from "./mermaid-highlighting";
-
-describe("mermaid highlighting", () => {
-  it("tokenizes mermaid syntax with shared token types", () => {
-    const tokens = tokenizeMermaid('flowchart LR\nA["Hello"] --> B');
-
-    expect(tokens).toEqual([
-      { type: "keyword", value: "flowchart" },
-      { type: null, value: " " },
-      { type: "keyword", value: "LR" },
-      { type: null, value: "\n" },
-      { type: "variableName", value: "A" },
-      { type: "bracket", value: "[" },
-      { type: "string", value: '"Hello"' },
-      { type: "bracket", value: "]" },
-      { type: null, value: " " },
-      { type: "operator", value: "-->" },
-      { type: null, value: " " },
-      { type: "variableName", value: "B" },
-    ]);
-  });
-
-  it("limits comment tokens to a single line", () => {
-    const tokens = tokenizeMermaid("%% comment\nflowchart TD");
-
-    expect(tokens[0]).toEqual({ type: "comment", value: "%% comment" });
-    expect(tokens[1]).toEqual({ type: null, value: "\n" });
-    expect(tokens[2]).toEqual({ type: "keyword", value: "flowchart" });
-  });
-
-  it("falls back to plain text for unsupported characters", () => {
-    expect(getMermaidHighlightToken("@node")).toEqual({
-      type: null,
-      value: "@",
-    });
-  });
-});

packages/excalidraw/components/TTDDialog/mermaid-highlighting.ts

@@ -1,79 +0,0 @@
-export type MermaidHighlightTokenType =
-  | "bracket"
-  | "comment"
-  | "keyword"
-  | "number"
-  | "operator"
-  | "punctuation"
-  | "string"
-  | "variableName";
-
-export type MermaidHighlightToken = {
-  type: MermaidHighlightTokenType | null;
-  value: string;
-};
-
-const DIAGRAM_TYPE_PATTERN =
-  /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i;
-const DIRECTION_PATTERN = /^(TB|TD|BT|RL|LR)\b/;
-const KEYWORD_PATTERN =
-  /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i;
-
-const MERMAID_TOKEN_RULES: ReadonlyArray<{
-  pattern: RegExp;
-  type: MermaidHighlightTokenType | null;
-}> = [
-  { pattern: /^%%[^\n]*/, type: "comment" },
-  { pattern: /^"(?:[^"\\]|\\.)*"/, type: "string" },
-  { pattern: DIAGRAM_TYPE_PATTERN, type: "keyword" },
-  { pattern: DIRECTION_PATTERN, type: "keyword" },
-  { pattern: KEYWORD_PATTERN, type: "keyword" },
-  { pattern: /^[-.=<>|ox]+>/, type: "operator" },
-  { pattern: /^<[-.=<>|ox]+/, type: "operator" },
-  { pattern: /^(--+|\.\.+|==+)/, type: "operator" },
-  { pattern: /^[[\](){}|<>]/, type: "bracket" },
-  { pattern: /^[A-Za-z_][A-Za-z0-9_]*/, type: "variableName" },
-  { pattern: /^\d+(\.\d+)?/, type: "number" },
-  { pattern: /^[,:;]/, type: "punctuation" },
-  { pattern: /^\s+/, type: null },
-];
-
-export const getMermaidHighlightToken = (
-  input: string,
-): MermaidHighlightToken | null => {
-  if (!input) {
-    return null;
-  }
-
-  for (const rule of MERMAID_TOKEN_RULES) {
-    const match = input.match(rule.pattern);
-    if (match) {
-      return {
-        type: rule.type,
-        value: match[0],
-      };
-    }
-  }
-
-  return {
-    type: null,
-    value: input[0],
-  };
-};
-
-export const tokenizeMermaid = (input: string): MermaidHighlightToken[] => {
-  const tokens: MermaidHighlightToken[] = [];
-  let remaining = input;
-
-  while (remaining) {
-    const token = getMermaidHighlightToken(remaining);
-    if (!token) {
-      break;
-    }
-
-    tokens.push(token);
-    remaining = remaining.slice(token.value.length);
-  }
-
-  return tokens;
-};

packages/excalidraw/components/TTDDialog/mermaid-lang-lite.ts

@@ -1,17 +1,79 @@
 import { StreamLanguage } from "@codemirror/language";
 
-import { getMermaidHighlightToken } from "./mermaid-highlighting";
-
 const mermaidStreamParser = StreamLanguage.define({
   token(stream) {
-    const token = getMermaidHighlightToken(stream.string.slice(stream.pos));
+    // Comments: %%...
-    if (!token) {
+    if (stream.match(/^%%.*$/)) {
-      stream.skipToEnd();
+      return "comment";
+    }
+
+    // Strings
+    if (stream.match(/^"(?:[^"\\]|\\.)*"/)) {
+      return "string";
+    }
+
+    // Diagram type keywords (at start of line or after whitespace)
+    if (
+      stream.match(
+        /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i,
+      )
+    ) {
+      return "keyword";
+    }
+
+    // Direction keywords
+    if (stream.match(/^(TB|TD|BT|RL|LR)\b/)) {
+      return "keyword";
+    }
+
+    // Keywords
+    if (
+      stream.match(
+        /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i,
+      )
+    ) {
+      return "keyword";
+    }
+
+    // Arrows: -->, ---, -.->, ===>, etc.
+    if (stream.match(/^[-.=<>|ox]+>/)) {
+      return "operator";
+    }
+    if (stream.match(/^<[-.=<>|ox]+/)) {
+      return "operator";
+    }
+    if (stream.match(/^--+|\.\.+|==+/)) {
+      return "operator";
+    }
+
+    // Labels in brackets/parens: [text], (text), {text}, ((text)), etc.
+    if (stream.match(/^[[\](){}|<>]/)) {
+      return "bracket";
+    }
+
+    // Node IDs (alphanumeric)
+    if (stream.match(/^[A-Za-z_][A-Za-z0-9_]*/)) {
+      return "variableName";
+    }
+
+    // Numbers
+    if (stream.match(/^\d+(\.\d+)?/)) {
+      return "number";
+    }
+
+    // Punctuation
+    if (stream.match(/^[,:;]/)) {
+      return "punctuation";
+    }
+
+    // Skip whitespace
+    if (stream.eatSpace()) {
       return null;
     }
 
-    stream.pos += token.value.length;
+    // Skip any other character
-    return token.type;
+    stream.next();
+    return null;
   },
 });
 

packages/excalidraw/components/TTDDialog/types.ts

@@ -18,8 +18,6 @@ export type MermaidData = {
   files: BinaryFiles | null;
 };
 
-export type ChatMessageContentFormat = "text" | "mermaid";
-
 export interface RateLimits {
   rateLimit: number;
   rateLimitRemaining: number;
@@ -35,7 +33,6 @@ export namespace TChat {
     errorType?: "parse" | "network" | "other";
     lastAttemptAt?: number;
     type: "user" | "assistant" | "warning";
-    contentFormat?: ChatMessageContentFormat;
     warningType?: /* daily rate limit */
     "messageLimitExceeded" | /* general 429 */ "rateLimitExceeded";
     content?: string;

packages/excalidraw/components/TTDDialog/useTTDChatStorage.ts

@@ -7,17 +7,6 @@ import { chatHistoryAtom } from "./TTDContext";
 
 import type { SavedChat, SavedChats, TTDPersistenceAdapter } from "./types";
 
-const normalizePersistedChat = (chat: SavedChat): SavedChat => ({
-  ...chat,
-  messages: chat.messages.map((message) => ({
-    ...message,
-    // Legacy TTD chats predate explicit content format metadata.
-    contentFormat:
-      message.contentFormat ??
-      (message.type === "assistant" ? "mermaid" : undefined),
-  })),
-});
-
 interface UseTTDChatStorageProps {
   persistenceAdapter: TTDPersistenceAdapter;
 }
@@ -67,7 +56,7 @@ export const useTTDChatStorage = ({
     setIsLoading(true);
     try {
       const chats = await persistenceAdapter.loadChats();
-      setSavedChats(chats.map(normalizePersistedChat));
+      setSavedChats(chats);
       setChatsLoaded(true);
     } catch (error) {
       console.warn("Failed to load chats:", error);

packages/excalidraw/components/TTDDialog/utils/chat.test.ts

@@ -117,28 +117,6 @@ describe("chat utils", () => {
       expect(result.messages[0].errorType).toBe("network");
     });
 
-    it("should update content format when provided", () => {
-      const chatHistory: TChat.ChatHistory = {
-        id: "chat-1",
-        currentPrompt: "",
-        messages: [
-          {
-            id: "1",
-            type: "assistant",
-            content: "graph TD",
-            timestamp: new Date("2024-01-01"),
-            contentFormat: "text",
-          },
-        ],
-      };
-
-      const result = updateAssistantContent(chatHistory, {
-        contentFormat: "mermaid",
-      });
-
-      expect(result.messages[0].contentFormat).toBe("mermaid");
-    });
-
     it("should return unchanged chatHistory if no assistant message exists", () => {
       const chatHistory: TChat.ChatHistory = {
         id: "chat-1",
@@ -379,7 +357,6 @@ describe("chat utils", () => {
         {
           type: "assistant",
           content: "Message",
-          contentFormat: "mermaid",
           isGenerating: true,
           error: "Error text",
           errorType: "parse",
@@ -387,7 +364,6 @@ describe("chat utils", () => {
       ]);
 
       expect(result.messages[0].isGenerating).toBe(true);
-      expect(result.messages[0].contentFormat).toBe("mermaid");
       expect(result.messages[0].error).toBe("Error text");
       expect(result.messages[0].errorType).toBe("parse");
     });

packages/excalidraw/components/dropdownMenu/DropdownMenu.scss

@@ -2,7 +2,7 @@
 
 .excalidraw {
   .dropdown-menu {
-    max-width: 16rem;
+    max-width: 20rem;
     z-index: 1;
 
     &--placement-top {

packages/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.tsx

@@ -1,4 +1,5 @@
 import { useEditorInterface } from "../App";
+import { Ellipsify } from "../Ellipsify";
 import { RadioGroup } from "../RadioGroup";
 
 type Props<T> = {
@@ -12,6 +13,7 @@ type Props<T> = {
   onChange: (value: T) => void;
   children: React.ReactNode;
   name: string;
+  icon?: React.ReactNode;
 };
 
 const DropdownMenuItemContentRadio = <T,>({
@@ -21,13 +23,17 @@ const DropdownMenuItemContentRadio = <T,>({
   choices,
   children,
   name,
+  icon,
 }: Props<T>) => {
   const editorInterface = useEditorInterface();
 
   return (
     <>
       <div className="dropdown-menu-item-base dropdown-menu-item-bare">
-        <label className="dropdown-menu-item__text">{children}</label>
+        {icon && <div className="dropdown-menu-item__icon">{icon}</div>}
+        <label className="dropdown-menu-item__text">
+          <Ellipsify>{children}</Ellipsify>
+        </label>
         <RadioGroup
           name={name}
           value={value}

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

@@ -39,7 +39,13 @@ import DropdownMenuItemCheckbox from "../dropdownMenu/DropdownMenuItemCheckbox";
 import DropdownMenuItemContentRadio from "../dropdownMenu/DropdownMenuItemContentRadio";
 import DropdownMenuItemLink from "../dropdownMenu/DropdownMenuItemLink";
 import DropdownMenuSub from "../dropdownMenu/DropdownMenuSub";
-import { GithubIcon, DiscordIcon, XBrandIcon, settingsIcon } from "../icons";
+import {
+  GithubIcon,
+  DiscordIcon,
+  XBrandIcon,
+  settingsIcon,
+  emptyIcon,
+} from "../icons";
 import {
   boltIcon,
   DeviceDesktopIcon,
@@ -427,6 +433,40 @@ const PreferencesToggleToolLockItem = () => {
   );
 };
 
+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}
+      onChange={(value) => {
+        setAppState({
+          boxSelectionMode: value === "contain" ? undefined : value,
+        });
+      }}
+      choices={[
+        {
+          value: "contain",
+          label: t("labels.boxSelectionContain"),
+          ariaLabel: t("labels.boxSelectionContain"),
+        },
+        {
+          value: "overlap",
+          label: t("labels.boxSelectionOverlap"),
+          ariaLabel: t("labels.boxSelectionOverlap"),
+        },
+      ]}
+    >
+      {t("labels.boxSelectionMode")}
+    </DropdownMenuItemContentRadio>
+  );
+};
+
 const PreferencesToggleSnapModeItem = () => {
   const { t } = useI18n();
   const actionManager = useExcalidrawActionManager();
@@ -568,6 +608,7 @@ export const Preferences = ({
       <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
         {children || (
           <>
+            <PreferencesBoxSelectionModeItem />
             <PreferencesToggleToolLockItem />
             <PreferencesToggleSnapModeItem />
             <PreferencesToggleGridModeItem />
@@ -585,6 +626,7 @@ export const Preferences = ({
 };
 
 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
+Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;

packages/excalidraw/data/restore.ts

@@ -936,6 +936,12 @@ export const restoreAppState = (
         : defaultValue;
   }
 
+  const boxSelectionMode =
+    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
+  if (boxSelectionMode !== undefined) {
+    nextAppState.boxSelectionMode = boxSelectionMode;
+  }
+
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/eraser/index.ts

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

packages/excalidraw/lasso/utils.ts

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

packages/excalidraw/locales/en.json

@@ -185,6 +185,9 @@
     "shapeSwitch": "Switch shape",
     "preferences": "Preferences",
     "preferences_toolLock": "Tool lock",
+    "boxSelectionMode": "Select on",
+    "boxSelectionContain": "Wrap",
+    "boxSelectionOverlap": "Overlap",
     "arrowBinding": "Arrow binding",
     "midpointSnapping": "Snap to midpoints"
   },
@@ -661,7 +664,7 @@
     "placeholder": {
       "title": "Let's design your diagram",
       "description": "Describe the diagram you want to create, and we'll generate it for you.",
-      "hint": "At the moment we know Flowchart, Sequence, Class, and Entity Relationship diagrams."
+      "hint": "At the moment we know Flowchart, Sequence, Class, State, and Entity Relationship diagrams."
     },
     "preview": "Preview",
     "insert": "Insert",

packages/excalidraw/package.json

@@ -88,7 +88,7 @@
     "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
     "@excalidraw/math": "0.18.0",
-    "@excalidraw/mermaid-to-excalidraw": "2.1.1",
+    "@excalidraw/mermaid-to-excalidraw": "2.2.2",
     "@excalidraw/random-username": "1.1.0",
     "browser-fs-access": "0.38.0",
     "canvas-roundrect-polyfill": "0.0.1",

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

@@ -4358,7 +4358,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 760410951,
+  "versionNonce": 1006504105,
   "width": 20,
   "x": -10,
   "y": 0,
@@ -4383,14 +4383,14 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 238820263,
+  "seed": 400692809,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 1006504105,
+  "versionNonce": 289600103,
   "width": 20,
   "x": 20,
   "y": 30,
@@ -6864,7 +6864,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 747212839,
+  "versionNonce": 1723083209,
   "width": 10,
   "x": -10,
   "y": 0,
@@ -6891,14 +6891,14 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 238820263,
+  "seed": 400692809,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 1723083209,
+  "versionNonce": 760410951,
   "width": 10,
   "x": 12,
   "y": 0,

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

@@ -11222,6 +11222,489 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
 
 exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end of test] undo stack 1`] = `[]`;
 
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] appState 1`] = `
+{
+  "activeEmbeddable": null,
+  "activeLockedId": null,
+  "activeTool": {
+    "customType": null,
+    "fromSelection": false,
+    "lastActiveTool": null,
+    "locked": false,
+    "type": "selection",
+  },
+  "bindMode": "orbit",
+  "bindingPreference": "enabled",
+  "collaborators": Map {},
+  "contextMenu": null,
+  "croppingElementId": null,
+  "currentHoveredFontFamily": null,
+  "currentItemArrowType": "round",
+  "currentItemBackgroundColor": "transparent",
+  "currentItemEndArrowhead": "arrow",
+  "currentItemFillStyle": "solid",
+  "currentItemFontFamily": 5,
+  "currentItemFontSize": 20,
+  "currentItemOpacity": 100,
+  "currentItemRoughness": 1,
+  "currentItemRoundness": "sharp",
+  "currentItemStartArrowhead": null,
+  "currentItemStrokeColor": "#1e1e1e",
+  "currentItemStrokeStyle": "solid",
+  "currentItemStrokeWidth": 2,
+  "currentItemTextAlign": "left",
+  "cursorButton": "up",
+  "defaultSidebarDockedPreference": false,
+  "editingFrame": null,
+  "editingGroupId": null,
+  "editingTextElement": null,
+  "elementsToHighlight": null,
+  "errorMessage": null,
+  "exportBackground": true,
+  "exportEmbedScene": false,
+  "exportScale": 1,
+  "exportWithDarkMode": false,
+  "fileHandle": null,
+  "followedBy": Set {},
+  "frameRendering": {
+    "clip": true,
+    "enabled": true,
+    "name": true,
+    "outline": true,
+  },
+  "frameToHighlight": null,
+  "gridModeEnabled": false,
+  "gridSize": 20,
+  "gridStep": 5,
+  "height": 0,
+  "hoveredElementIds": {},
+  "isBindingEnabled": true,
+  "isCropping": false,
+  "isLoading": false,
+  "isMidpointSnappingEnabled": true,
+  "isResizing": false,
+  "isRotating": false,
+  "lastPointerDownWith": "mouse",
+  "lockedMultiSelections": {},
+  "multiElement": null,
+  "newElement": null,
+  "objectsSnapModeEnabled": false,
+  "offsetLeft": 0,
+  "offsetTop": 0,
+  "openDialog": null,
+  "openMenu": null,
+  "openPopup": null,
+  "openSidebar": null,
+  "originSnapOffset": null,
+  "penDetected": false,
+  "penMode": false,
+  "preferredSelectionTool": {
+    "initialized": true,
+    "type": "selection",
+  },
+  "previousSelectedElementIds": {},
+  "resizingElement": null,
+  "scrollX": 0,
+  "scrollY": 0,
+  "searchMatches": null,
+  "selectedElementIds": {},
+  "selectedElementsAreBeingDragged": false,
+  "selectedGroupIds": {},
+  "selectionElement": null,
+  "shouldCacheIgnoreZoom": false,
+  "showHyperlinkPopup": false,
+  "showWelcomeScreen": true,
+  "snapLines": [],
+  "startBoundElement": null,
+  "stats": {
+    "open": false,
+    "panels": 3,
+  },
+  "suggestedBinding": null,
+  "theme": "light",
+  "toast": null,
+  "userToFollow": null,
+  "viewBackgroundColor": "#ffffff",
+  "viewModeEnabled": false,
+  "width": 0,
+  "zenModeEnabled": false,
+  "zoom": {
+    "value": 1,
+  },
+}
+`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] element 0 1`] = `
+{
+  "angle": 0,
+  "backgroundColor": "transparent",
+  "boundElements": null,
+  "customData": undefined,
+  "fillStyle": "solid",
+  "frameId": null,
+  "groupIds": [
+    "inner",
+    "outer",
+  ],
+  "height": 100,
+  "id": "id0",
+  "index": "a0",
+  "isDeleted": false,
+  "link": null,
+  "locked": false,
+  "opacity": 100,
+  "roughness": 1,
+  "roundness": null,
+  "strokeColor": "#1e1e1e",
+  "strokeStyle": "solid",
+  "strokeWidth": 2,
+  "type": "rectangle",
+  "updated": 1,
+  "version": 2,
+  "width": 100,
+  "x": 0,
+  "y": 0,
+}
+`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] element 1 1`] = `
+{
+  "angle": 0,
+  "backgroundColor": "transparent",
+  "boundElements": null,
+  "customData": undefined,
+  "fillStyle": "solid",
+  "frameId": null,
+  "groupIds": [
+    "outer",
+  ],
+  "height": 100,
+  "id": "id1",
+  "index": "a1",
+  "isDeleted": false,
+  "link": null,
+  "locked": false,
+  "opacity": 100,
+  "roughness": 1,
+  "roundness": null,
+  "strokeColor": "#1e1e1e",
+  "strokeStyle": "solid",
+  "strokeWidth": 2,
+  "type": "rectangle",
+  "updated": 1,
+  "version": 2,
+  "width": 100,
+  "x": 100,
+  "y": 100,
+}
+`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] element 2 1`] = `
+{
+  "angle": 0,
+  "backgroundColor": "transparent",
+  "boundElements": null,
+  "customData": undefined,
+  "fillStyle": "solid",
+  "frameId": null,
+  "groupIds": [
+    "inner",
+    "outer",
+  ],
+  "height": 100,
+  "id": "id2",
+  "index": "a2",
+  "isDeleted": false,
+  "link": null,
+  "locked": false,
+  "opacity": 100,
+  "roughness": 1,
+  "roundness": null,
+  "strokeColor": "#1e1e1e",
+  "strokeStyle": "solid",
+  "strokeWidth": 2,
+  "type": "rectangle",
+  "updated": 1,
+  "version": 2,
+  "width": 100,
+  "x": 200,
+  "y": 200,
+}
+`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] number of elements 1`] = `3`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] number of renders 1`] = `16`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] redo stack 1`] = `[]`;
+
+exports[`history > multiplayer undo/redo > should support undo and redo when escape unwinds nested group editing > [end of test] undo stack 1`] = `
+[
+  {
+    "appState": AppStateDelta {
+      "delta": Delta {
+        "deleted": {
+          "selectedElementIds": {
+            "id0": true,
+            "id1": true,
+            "id2": true,
+          },
+          "selectedGroupIds": {
+            "outer": true,
+          },
+        },
+        "inserted": {
+          "selectedElementIds": {},
+          "selectedGroupIds": {},
+        },
+      },
+    },
+    "elements": {
+      "added": {},
+      "removed": {
+        "id0": {
+          "deleted": {
+            "angle": 0,
+            "backgroundColor": "transparent",
+            "boundElements": null,
+            "customData": undefined,
+            "fillStyle": "solid",
+            "frameId": null,
+            "groupIds": [
+              "inner",
+              "outer",
+            ],
+            "height": 100,
+            "index": "a0",
+            "isDeleted": false,
+            "link": null,
+            "locked": false,
+            "opacity": 100,
+            "roughness": 1,
+            "roundness": null,
+            "strokeColor": "#1e1e1e",
+            "strokeStyle": "solid",
+            "strokeWidth": 2,
+            "type": "rectangle",
+            "version": 2,
+            "width": 100,
+            "x": 0,
+            "y": 0,
+          },
+          "inserted": {
+            "isDeleted": true,
+            "version": 1,
+          },
+        },
+        "id1": {
+          "deleted": {
+            "angle": 0,
+            "backgroundColor": "transparent",
+            "boundElements": null,
+            "customData": undefined,
+            "fillStyle": "solid",
+            "frameId": null,
+            "groupIds": [
+              "outer",
+            ],
+            "height": 100,
+            "index": "a1",
+            "isDeleted": false,
+            "link": null,
+            "locked": false,
+            "opacity": 100,
+            "roughness": 1,
+            "roundness": null,
+            "strokeColor": "#1e1e1e",
+            "strokeStyle": "solid",
+            "strokeWidth": 2,
+            "type": "rectangle",
+            "version": 2,
+            "width": 100,
+            "x": 100,
+            "y": 100,
+          },
+          "inserted": {
+            "isDeleted": true,
+            "version": 1,
+          },
+        },
+        "id2": {
+          "deleted": {
+            "angle": 0,
+            "backgroundColor": "transparent",
+            "boundElements": null,
+            "customData": undefined,
+            "fillStyle": "solid",
+            "frameId": null,
+            "groupIds": [
+              "inner",
+              "outer",
+            ],
+            "height": 100,
+            "index": "a2",
+            "isDeleted": false,
+            "link": null,
+            "locked": false,
+            "opacity": 100,
+            "roughness": 1,
+            "roundness": null,
+            "strokeColor": "#1e1e1e",
+            "strokeStyle": "solid",
+            "strokeWidth": 2,
+            "type": "rectangle",
+            "version": 2,
+            "width": 100,
+            "x": 200,
+            "y": 200,
+          },
+          "inserted": {
+            "isDeleted": true,
+            "version": 1,
+          },
+        },
+      },
+      "updated": {},
+    },
+    "id": "id5",
+  },
+  {
+    "appState": AppStateDelta {
+      "delta": Delta {
+        "deleted": {
+          "editingGroupId": "outer",
+          "selectedElementIds": {},
+          "selectedGroupIds": {
+            "inner": true,
+          },
+        },
+        "inserted": {
+          "editingGroupId": null,
+          "selectedElementIds": {
+            "id1": true,
+          },
+          "selectedGroupIds": {
+            "outer": true,
+          },
+        },
+      },
+    },
+    "elements": {
+      "added": {},
+      "removed": {},
+      "updated": {},
+    },
+    "id": "id7",
+  },
+  {
+    "appState": AppStateDelta {
+      "delta": Delta {
+        "deleted": {
+          "editingGroupId": "inner",
+          "selectedElementIds": {},
+          "selectedGroupIds": {},
+        },
+        "inserted": {
+          "editingGroupId": "outer",
+          "selectedElementIds": {
+            "id2": true,
+          },
+          "selectedGroupIds": {
+            "inner": true,
+          },
+        },
+      },
+    },
+    "elements": {
+      "added": {},
+      "removed": {},
+      "updated": {},
+    },
+    "id": "id9",
+  },
+  {
+    "appState": AppStateDelta {
+      "delta": Delta {
+        "deleted": {
+          "editingGroupId": "outer",
+          "selectedElementIds": {
+            "id2": true,
+          },
+          "selectedGroupIds": {
+            "inner": true,
+          },
+        },
+        "inserted": {
+          "editingGroupId": "inner",
+          "selectedElementIds": {},
+          "selectedGroupIds": {},
+        },
+      },
+    },
+    "elements": {
+      "added": {},
+      "removed": {},
+      "updated": {},
+    },
+    "id": "id19",
+  },
+  {
+    "appState": AppStateDelta {
+      "delta": Delta {
+        "deleted": {
+          "editingGroupId": null,
+          "selectedElementIds": {
+            "id1": true,
+          },
+          "selectedGroupIds": {
+            "outer": true,
+          },
+        },
+        "inserted": {
+          "editingGroupId": "outer",
+          "selectedElementIds": {},
+          "selectedGroupIds": {
+            "inner": true,
+          },
+        },
+      },
+    },
+    "elements": {
+      "added": {},
+      "removed": {},
+      "updated": {},
+    },
+    "id": "id20",
+  },
+  {
+    "appState": AppStateDelta {
+      "delta": Delta {
+        "deleted": {
+          "selectedElementIds": {},
+          "selectedGroupIds": {},
+        },
+        "inserted": {
+          "selectedElementIds": {
+            "id0": true,
+            "id1": true,
+            "id2": true,
+          },
+          "selectedGroupIds": {
+            "outer": true,
+          },
+        },
+      },
+    },
+    "elements": {
+      "added": {},
+      "removed": {},
+      "updated": {},
+    },
+    "id": "id21",
+  },
+]
+`;
+
 exports[`history > multiplayer undo/redo > should update history entries after remote changes on the same properties > [end of test] appState 1`] = `
 {
   "activeEmbeddable": null,

packages/excalidraw/tests/history.test.tsx

@@ -2971,6 +2971,82 @@ describe("history", () => {
       expect(h.state.editingGroupId).toBeNull();
     });
 
+    // TODO mark with "noncritical" tag once we migrate to vitest 4
+    it.skip("should support undo and redo when escape unwinds nested group editing", async () => {
+      const rectA = API.createElement({
+        type: "rectangle",
+        groupIds: ["inner", "outer"],
+        x: 0,
+      });
+      const rectB = API.createElement({
+        type: "rectangle",
+        groupIds: ["outer"],
+        x: 100,
+      });
+      const rectC = API.createElement({
+        type: "rectangle",
+        groupIds: ["inner", "outer"],
+        x: 200,
+      });
+
+      API.setElements([rectA, rectB, rectC]);
+      mouse.select(rectA);
+      mouse.doubleClickOn(rectA);
+      mouse.doubleClickOn(rectA);
+
+      assertSelectedElements([rectA]);
+      expect(h.state.editingGroupId).toBe("inner");
+      expect(API.getUndoStack().length).toBe(3);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.keyPress(KEYS.ESCAPE);
+      assertSelectedElements([rectA, rectC]);
+      expect(h.state.editingGroupId).toBe("outer");
+      expect(API.getUndoStack().length).toBe(4);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.keyPress(KEYS.ESCAPE);
+      assertSelectedElements([rectA, rectB, rectC]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+      expect(API.getUndoStack().length).toBe(5);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.keyPress(KEYS.ESCAPE);
+      expect(API.getSelectedElements()).toEqual([]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({});
+      expect(API.getUndoStack().length).toBe(6);
+      expect(API.getRedoStack().length).toBe(0);
+
+      Keyboard.undo();
+      assertSelectedElements([rectA, rectB, rectC]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+
+      Keyboard.undo();
+      assertSelectedElements([rectA, rectC]);
+      expect(h.state.editingGroupId).toBe("outer");
+
+      Keyboard.undo();
+      assertSelectedElements([rectA]);
+      expect(h.state.editingGroupId).toBe("inner");
+
+      Keyboard.redo();
+      assertSelectedElements([rectA, rectC]);
+      expect(h.state.editingGroupId).toBe("outer");
+
+      Keyboard.redo();
+      assertSelectedElements([rectA, rectB, rectC]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+
+      Keyboard.redo();
+      expect(API.getSelectedElements()).toEqual([]);
+      expect(h.state.editingGroupId).toBeNull();
+      expect(h.state.selectedGroupIds).toEqual({});
+    });
+
     it("should iterate through the history when selected or editing linear element was remotely deleted", async () => {
       // create three point arrow
       UI.clickTool("arrow");

packages/excalidraw/tests/selection.test.tsx

@@ -1,7 +1,9 @@
 import React from "react";
 import { vi } from "vitest";
 
-import { KEYS, reseed } from "@excalidraw/common";
+import { KEYS, ROUNDNESS, reseed } from "@excalidraw/common";
+import { getElementBounds, getElementLineSegments } from "@excalidraw/element";
+import { pointFrom, pointRotateRads, type LocalPoint } from "@excalidraw/math";
 
 import { SHAPES } from "../components/shapes";
 
@@ -12,6 +14,7 @@ import * as StaticScene from "../renderer/staticScene";
 import { API } from "./helpers/api";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
 import {
+  act,
   render,
   fireEvent,
   mockBoundingClientRect,
@@ -39,6 +42,19 @@ const { h } = window;
 
 const mouse = new Pointer("mouse");
 
+const getOutlineBounds = (element: ReturnType<typeof API.createElement>) => {
+  const sceneElement = API.getElement(element);
+  const elementsMap = h.scene.getNonDeletedElementsMap();
+  const points = getElementLineSegments(sceneElement, elementsMap).flat();
+
+  return [
+    Math.min(...points.map((point) => point[0])),
+    Math.min(...points.map((point) => point[1])),
+    Math.max(...points.map((point) => point[0])),
+    Math.max(...points.map((point) => point[1])),
+  ] as const;
+};
+
 describe("box-selection", () => {
   beforeEach(async () => {
     await render(<Excalidraw />);
@@ -108,6 +124,497 @@ describe("box-selection", () => {
 
     assertSelectedElements([]);
   });
+
+  it("should not select an element when the selection box only partially overlaps it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    mouse.downAt(25, -20);
+    mouse.move(-1000, -1000);
+    mouse.moveTo(75, 70);
+    mouse.up();
+
+    assertSelectedElements([]);
+  });
+});
+
+describe("lasso reselection", () => {
+  beforeEach(async () => {
+    await render(<Excalidraw />);
+  });
+
+  it("should allow ctrl+alt lasso reselection when starting inside the active common bounds", () => {
+    const rectA = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+    const rectB = API.createElement({
+      type: "rectangle",
+      x: 220,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "blue",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rectA, rectB]);
+    mouse.select([rectA, rectB]);
+    act(() => {
+      h.app.setActiveTool({ type: "lasso" });
+    });
+
+    Keyboard.withModifierKeys({ ctrl: true, alt: true }, () => {
+      mouse.downAt(110, 50);
+      mouse.moveTo(50, -20);
+
+      expect(h.app.lassoTrail.hasCurrentTrail).toBe(true);
+
+      mouse.moveTo(-20, 50);
+      mouse.moveTo(50, 120);
+      mouse.moveTo(110, 50);
+      mouse.up();
+    });
+
+    assertSelectedElements([rectA.id]);
+  });
+});
+
+describe("box-selection overlap mode", () => {
+  const boxSelect = (
+    startX: number,
+    startY: number,
+    endX: number,
+    endY: number,
+  ) => {
+    mouse.downAt(startX, startY);
+    mouse.move(-1000, -1000);
+    mouse.moveTo(endX, endY);
+    mouse.up();
+  };
+
+  const boxSelectTopLeftAabbCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneElement, elementsMap);
+
+    boxSelect(x1 + 2, y1 + 2, x1 + 12, y1 + 12);
+  };
+
+  const boxSelectTopRightAabbCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [, y1, x2] = getElementBounds(sceneElement, elementsMap);
+
+    boxSelect(x2 - 12, y1 + 2, x2 - 2, y1 + 12);
+  };
+
+  const boxSelectTopLeftRotatedLocalBoundsCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1, x2, y2] = getElementBounds(sceneElement, elementsMap, true);
+    const center = pointFrom((x1 + x2) / 2, (y1 + y2) / 2);
+    const [cornerX, cornerY] = pointRotateRads(
+      pointFrom(x1, y1),
+      center,
+      sceneElement.angle,
+    );
+
+    boxSelect(cornerX - 4, cornerY - 4, cornerX + 4, cornerY + 4);
+  };
+
+  beforeEach(async () => {
+    await render(
+      <Excalidraw
+        initialData={{ appState: { boxSelectionMode: "overlap" } }}
+      />,
+    );
+  });
+
+  it("should select an element when the selection box partially overlaps it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, -20, 75, 70);
+
+    assertSelectedElements([rect1.id]);
+  });
+
+  it("should not select a transparent rectangle when the selection box stays inside it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, 25, 75, 75);
+
+    assertSelectedElements([]);
+  });
+
+  it("should select a transparent rectangle when the selection box crosses its outline", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, 25, 125, 75);
+
+    assertSelectedElements([rect1.id]);
+  });
+
+  it("should not select a rotated transparent rectangle when the selection box stays inside it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(40, 40, 60, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should select a rotated rounded rectangle when the selection box contains its outline but not its bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 180,
+      angle: Math.PI / 6,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+      roundness: { type: ROUNDNESS.ADAPTIVE_RADIUS },
+      roughness: 0,
+    });
+
+    API.setElements([rect]);
+
+    const sceneRect = API.getElement(rect);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [boundsX1, boundsY1, boundsX2, boundsY2] = getElementBounds(
+      sceneRect,
+      elementsMap,
+    );
+    const [outlineX1, outlineY1, outlineX2, outlineY2] = getOutlineBounds(rect);
+
+    expect(outlineX1).toBeGreaterThan(boundsX1);
+    expect(outlineY1).toBeGreaterThan(boundsY1);
+    expect(outlineX2).toBeLessThan(boundsX2);
+    expect(outlineY2).toBeLessThan(boundsY2);
+
+    boxSelect(
+      outlineX1 - (outlineX1 - boundsX1) / 2,
+      outlineY1 - (outlineY1 - boundsY1) / 2,
+      outlineX2 + (boundsX2 - outlineX2) / 2,
+      outlineY2 + (boundsY2 - outlineY2) / 2,
+    );
+
+    assertSelectedElements([rect.id]);
+  });
+
+  it("should not select a filled rotated rectangle when the selection box only overlaps its axis-aligned bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect]);
+
+    boxSelectTopLeftAabbCorner(rect);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled ellipse when the selection box only overlaps its bounds corner", () => {
+    const ellipse = API.createElement({
+      type: "ellipse",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([ellipse]);
+
+    boxSelectTopRightAabbCorner(ellipse);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled diamond when the selection box only overlaps its bounds corner", () => {
+    const diamond = API.createElement({
+      type: "diamond",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([diamond]);
+
+    boxSelectTopRightAabbCorner(diamond);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled rotated ellipse when the selection box only overlaps its axis-aligned bounds", () => {
+    const ellipse = API.createElement({
+      type: "ellipse",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([ellipse]);
+
+    boxSelectTopLeftRotatedLocalBoundsCorner(ellipse);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled rotated diamond when the selection box only overlaps its rotated local bounds", () => {
+    const diamond = API.createElement({
+      type: "diamond",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([diamond]);
+
+    boxSelectTopLeftRotatedLocalBoundsCorner(diamond);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select rotated text when the selection box only overlaps its axis-aligned bounds", () => {
+    const text = API.createElement({
+      type: "text",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      text: "test",
+    });
+
+    API.setElements([text]);
+
+    boxSelect(-18, -18, -8, -8);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select rotated image when the selection box only overlaps its axis-aligned bounds", () => {
+    const image = API.createElement({
+      type: "image",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      fileId: "file_A",
+      status: "saved",
+    });
+
+    API.setElements([image]);
+
+    boxSelect(-18, -18, -8, -8);
+
+    assertSelectedElements([]);
+  });
+
+  it("should deselect a selected rotated rectangle when clicking in the empty corner of its axis-aligned bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect]);
+
+    mouse.clickAt(50, 50);
+    assertSelectedElements([rect.id]);
+
+    const sceneRect = API.getElement(rect);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneRect, elementsMap);
+
+    mouse.clickAt(x1 + 2, y1 + 2);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a line when the selection box only overlaps its bounds", () => {
+    const line = API.createElement({
+      type: "line",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(100, 100)],
+    });
+
+    API.setElements([line]);
+
+    boxSelect(20, 50, 30, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not click-select rotated freedraw in the corner of its axis-aligned bounds", () => {
+    const freedraw = API.createElement({
+      type: "freedraw",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "transparent",
+      points: [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(100, 0),
+        pointFrom<LocalPoint>(100, 100),
+        pointFrom<LocalPoint>(0, 100),
+        pointFrom<LocalPoint>(0, 0),
+      ],
+    });
+
+    API.setElements([freedraw]);
+
+    const sceneFreedraw = API.getElement(freedraw);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneFreedraw, elementsMap);
+
+    mouse.clickAt(x1 + 2, y1 + 2);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a freedraw when the selection box only overlaps its bounds", () => {
+    const freedraw = API.createElement({
+      type: "freedraw",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      points: [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(50, 50),
+        pointFrom<LocalPoint>(100, 100),
+      ],
+    });
+
+    API.setElements([freedraw]);
+
+    boxSelect(20, 50, 30, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a transparent framed element when the selection box stays inside its clipped bounds", () => {
+    const frame = API.createElement({
+      type: "frame",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 50,
+      y: 10,
+      width: 100,
+      height: 80,
+      frameId: frame.id,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([frame, rect1]);
+
+    boxSelect(60, 20, 90, 60);
+
+    assertSelectedElements([]);
+  });
 });
 
 describe("inner box-selection", () => {
@@ -326,7 +833,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(6);
+    expect(renderStaticScene).toHaveBeenCalledTimes(7);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -359,7 +866,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(6);
+    expect(renderStaticScene).toHaveBeenCalledTimes(7);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -392,7 +899,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(6);
+    expect(renderStaticScene).toHaveBeenCalledTimes(7);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -438,7 +945,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(10);
-    expect(renderStaticScene).toHaveBeenCalledTimes(8);
+    expect(renderStaticScene).toHaveBeenCalledTimes(9);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -483,7 +990,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(10);
-    expect(renderStaticScene).toHaveBeenCalledTimes(8);
+    expect(renderStaticScene).toHaveBeenCalledTimes(9);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -558,3 +1065,58 @@ describe("selectedElementIds stability", () => {
     expect(h.state.selectedElementIds).toBe(selectedElementIds_2);
   });
 });
+
+describe("deselecting", () => {
+  beforeEach(async () => {
+    await render(<Excalidraw handleKeyboardGlobally={true} />);
+  });
+
+  it("esc unwinds nested group editing before deselecting", () => {
+    const rectA = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      groupIds: ["inner", "outer"],
+    });
+    const rectB = API.createElement({
+      type: "rectangle",
+      x: 100,
+      y: 0,
+      groupIds: ["outer"],
+    });
+    const rectC = API.createElement({
+      type: "rectangle",
+      x: 200,
+      y: 0,
+      groupIds: ["inner", "outer"],
+    });
+
+    API.setElements([rectA, rectB, rectC]);
+
+    mouse.select(rectA);
+    assertSelectedElements(rectA, rectB, rectC);
+    expect(h.state.editingGroupId).toBeNull();
+
+    mouse.doubleClickOn(rectA);
+    assertSelectedElements(rectA, rectC);
+    expect(h.state.editingGroupId).toBe("outer");
+
+    mouse.doubleClickOn(rectA);
+    assertSelectedElements(rectA);
+    expect(h.state.editingGroupId).toBe("inner");
+
+    Keyboard.keyPress(KEYS.ESCAPE);
+    assertSelectedElements(rectA, rectC);
+    expect(h.state.editingGroupId).toBe("outer");
+
+    Keyboard.keyPress(KEYS.ESCAPE);
+    assertSelectedElements(rectA, rectB, rectC);
+    expect(h.state.editingGroupId).toBeNull();
+    expect(h.state.selectedGroupIds).toEqual({ outer: true });
+
+    Keyboard.keyPress(KEYS.ESCAPE);
+    expect(API.getSelectedElements()).toEqual([]);
+    expect(h.state.editingGroupId).toBeNull();
+    expect(h.state.selectedGroupIds).toEqual({});
+  });
+});

packages/excalidraw/types.ts

@@ -269,6 +269,8 @@ export type ObservedElementsAppState = {
   activeLockedId: AppState["activeLockedId"];
 };
 
+export type BoxSelectionMode = "contain" | "overlap";
+
 export interface AppState {
   contextMenu: {
     items: ContextMenuItems;
@@ -307,6 +309,8 @@ export interface AppState {
    * `bindingPreference` and keyboard modifiers (ctrl/alt)
    */
   isBindingEnabled: boolean;
+  /** user box selection preference; defaults to "contain" when unset */
+  boxSelectionMode?: BoxSelectionMode;
   /** user arrow binding preference */
   bindingPreference: "enabled" | "disabled";
   /** user preference whether arrow snap to midpoints while binding */

packages/excalidraw/wysiwyg/textWysiwyg.test.tsx

@@ -45,6 +45,28 @@ unmountComponent();
 const tab = "    ";
 const mouse = new Pointer("mouse");
 
+const exitTextEditorAndAssertSelection = async ({
+  editor,
+  selectedIds,
+  nextText,
+}: {
+  editor: HTMLTextAreaElement;
+  selectedIds: string[];
+  nextText?: string;
+}) => {
+  if (nextText !== undefined) {
+    updateTextEditor(editor, nextText);
+  }
+
+  Keyboard.exitTextEditor(editor);
+
+  expect(await getTextEditor({ waitForEditor: false })).toBe(null);
+  expect(window.h.state.editingTextElement).toBeNull();
+  expect(API.getSelectedElements().map((element) => element.id)).toEqual(
+    selectedIds,
+  );
+};
+
 describe("textWysiwyg", () => {
   describe("start text editing", () => {
     const { h } = window;
@@ -271,6 +293,33 @@ describe("textWysiwyg", () => {
       expect(h.elements.length).toBe(1);
     });
 
+    it("should reselect text after exiting wysiwyg with escape", async () => {
+      const text = API.createElement({
+        type: "text",
+        text: "ola",
+        x: 60,
+        y: 0,
+        width: 100,
+        height: 100,
+      });
+
+      API.setElements([text]);
+      API.setSelectedElements([text]);
+      UI.clickTool("selection");
+
+      Keyboard.keyPress(KEYS.ENTER);
+
+      const editor = await getTextEditor();
+
+      expect(editor).not.toBe(null);
+      expect(h.state.editingTextElement?.id).toBe(text.id);
+
+      await exitTextEditorAndAssertSelection({
+        editor,
+        selectedIds: [text.id],
+      });
+    });
+
     it("should edit selected bound text on single click", async () => {
       const container = API.createElement({
         type: "rectangle",
@@ -1305,6 +1354,40 @@ describe("textWysiwyg", () => {
       );
     });
 
+    it.each([
+      {
+        label: "container",
+        createElements: () => API.createTextContainer(),
+      },
+      {
+        label: "arrow",
+        createElements: () => API.createLabeledArrow(),
+      },
+    ])(
+      "should reselect $label after deleting bound text with escape",
+      async ({ createElements }) => {
+        const [selectedElement, text] = createElements();
+        API.setElements([selectedElement, text]);
+        API.setSelectedElements([selectedElement]);
+
+        Keyboard.keyPress(KEYS.ENTER);
+        const editor = await getTextEditor();
+
+        await exitTextEditorAndAssertSelection({
+          editor,
+          nextText: "",
+          selectedIds: [selectedElement.id],
+        });
+
+        expect(selectedElement.boundElements).toStrictEqual([]);
+        expect(h.elements[1]).toEqual(
+          expect.objectContaining({
+            isDeleted: true,
+          }),
+        );
+      },
+    );
+
     it("should restore original container height and clear cache once text is unbind", async () => {
       const container = API.createElement({
         type: "rectangle",

packages/math/src/segment.ts

@@ -40,7 +40,7 @@ export const isLineSegment = <Point extends GlobalPoint | LocalPoint>(
   Array.isArray(segment) &&
   segment.length === 2 &&
   isPoint(segment[0]) &&
-  isPoint(segment[0]);
+  isPoint(segment[1]);
 
 /**
  * Return the coordinates resulting from rotating the given line about an origin by an angle in radians

packages/math/src/types.ts

@@ -1,3 +1,14 @@
+//
+// 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/math/tests/segment.test.ts

@@ -1,5 +1,9 @@
 import { pointFrom } from "../src/point";
-import { lineSegment, lineSegmentIntersectionPoints } from "../src/segment";
+import {
+  lineSegment,
+  lineSegmentIntersectionPoints,
+  isLineSegment,
+} from "../src/segment";
 
 describe("line-segment intersections", () => {
   it("should correctly detect intersection", () => {
@@ -19,3 +23,23 @@ describe("line-segment intersections", () => {
     ).toEqual(null);
   });
 });
+describe("isLineSegment validation", () => {
+  it("should return true for a valid segment", () => {
+    expect(
+      isLineSegment([
+        [0, 0],
+        [1, 1],
+      ]),
+    ).toBe(true);
+  });
+
+  it("should return false if second element is not a point", () => {
+    const invalidSegment = [[0, 0], "not-a-point"] as any;
+
+    expect(isLineSegment(invalidSegment)).toBe(false);
+  });
+
+  it("should return false for wrong length", () => {
+    expect(isLineSegment([[0, 0]])).toBe(false);
+  });
+});

packages/utils/src/withinBounds.ts

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

yarn.lock

@@ -1531,10 +1531,10 @@
   resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
   integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==
 
-"@excalidraw/mermaid-to-excalidraw@2.1.1":
+"@excalidraw/mermaid-to-excalidraw@2.2.2":
-  version "2.1.1"
+  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.1.tgz#659c934a607dd2cf57f2a69282588ee2b0722959"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.2.2.tgz#ee6b597a0d95b9a76f7ae41ce0e3733a9b96e4a0"
-  integrity sha512-jU+frqcxazsY+t5yOBf2mgrQy+WUrbrzA36if3SQB/Vwaf2qOJjnWxucNafgZZk/3+9xGmRotUeOviSOJG+wYA==
+  integrity sha512-5VKQq5CdRocC82vOIUpQ5ufJOVV9FpBTdHGA+ULqazeIVV+cr299877omQCibsdS3Bpitz2fsnTwnIXEmLVDSg==
   dependencies:
     "@excalidraw/markdown-to-text" "0.1.2"
     "@mermaid-js/parser" "^0.6.3"