improve balls

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

.github/workflows/cancel.yml

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

.github/workflows/locales-coverage.yml

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

.github/workflows/publish-docker.yml

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

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

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

.github/workflows/size-limit.yml

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

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

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

packages/common/src/constants.ts

@@ -405,8 +405,9 @@ export const ROUGHNESS = {
 
 export const STROKE_WIDTH = {
   thin: 1,
-  bold: 2,
+  medium: 2,
-  extraBold: 4,
+  bold: 4,
+  extraBold: 8,
 } as const;
 
 export const DEFAULT_ELEMENT_PROPS: {
@@ -429,6 +430,8 @@ export const DEFAULT_ELEMENT_PROPS: {
   locked: false,
 };
 
+export const DEFAULT_FREE_DRAW_STROKE_SHAPE = "variable" as const;
+
 export const LIBRARY_SIDEBAR_TAB = "library";
 export const CANVAS_SEARCH_TAB = "search";
 

packages/element/src/bounds.ts

@@ -168,12 +168,14 @@ export class ElementBounds {
           ),
         ),
       );
+      const padding =
+        element.strokeShape === "fixed" ? element.strokeWidth / 2 : 0;
 
       return [
-        minX + element.x,
+        minX + element.x - padding,
-        minY + element.y,
+        minY + element.y - padding,
-        maxX + element.x,
+        maxX + element.x + padding,
-        maxY + element.y,
+        maxY + element.y + padding,
       ];
     } else if (isLinearElement(element)) {
       bounds = getLinearElementRotatedBounds(element, cx, cy, elementsMap);
@@ -680,8 +682,9 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = (
+export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
-  points: ExcalidrawFreeDrawElement["points"],
+  points: readonly P[],
+  padding: number = 0,
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -695,17 +698,18 @@ export const getBoundsFromPoints = (
     maxY = Math.max(maxY, y);
   }
 
-  return [minX, minY, maxX, maxY];
+  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
   element: ExcalidrawFreeDrawElement,
 ): [number, number, number, number, number, number] => {
   const [minX, minY, maxX, maxY] = getBoundsFromPoints(element.points);
-  const x1 = minX + element.x;
+  const padding = element.strokeShape === "fixed" ? element.strokeWidth / 2 : 0;
-  const y1 = minY + element.y;
+  const x1 = minX + element.x - padding;
-  const x2 = maxX + element.x;
+  const y1 = minY + element.y - padding;
-  const y2 = maxY + element.y;
+  const x2 = maxX + element.x + padding;
+  const y2 = maxY + element.y + padding;
   return [x1, y1, x2, y2, (x1 + x2) / 2, (y1 + y2) / 2];
 };
 
@@ -1261,6 +1265,17 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
   p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
 
+// TODO make pointInsideBounds inclusive and remove this function once we
+// test nothing is breaking
+export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
+  p: P,
+  bounds: Bounds,
+): boolean =>
+  p[0] >= bounds[0] &&
+  p[0] <= bounds[2] &&
+  p[1] >= bounds[1] &&
+  p[1] <= bounds[3];
+
 export const doBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
@@ -1275,13 +1290,21 @@ export const doBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
+export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
+  [
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
+  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
+
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   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

@@ -27,6 +27,7 @@ import type {
 
 import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
 
+import { isLoopFreeDrawElement } from "./freedraw";
 import { isPathALoop } from "./utils";
 import {
   doBoundsIntersect,
@@ -93,7 +94,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   if (element.type === "freedraw") {
-    return isDraggableFromInside && isPathALoop(element.points);
+    return isDraggableFromInside && isLoopFreeDrawElement(element);
   }
 
   return isDraggableFromInside || isImageElement(element);
@@ -154,14 +155,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 +190,32 @@ export const hitElementItself = ({
   return result;
 };
 
+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;
-  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -465,7 +477,12 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
+      return intersectLinearOrFreeDrawWithLineSegment(
+        element,
+        line,
+        elementsMap,
+        onlyFirst,
+      );
   }
 };
 
@@ -532,11 +549,15 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
   segment: LineSegment<GlobalPoint>,
+  elementsMap: ElementsMap,
   onlyFirst = false,
 ): GlobalPoint[] => {
   // NOTE: This is the only one which return the decomposed elements
   // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    element,
+    elementsMap,
+  );
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {
@@ -564,7 +585,9 @@ const intersectLinearOrFreeDrawWithLineSegment = (
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment);
+    const hits = curveIntersectLineSegment(c, segment, {
+      iterLimit: 10,
+    });
 
     if (hits.length > 0) {
       intersections.push(...hits);
@@ -732,8 +755,8 @@ export const isPointInElement = (
   elementsMap: ElementsMap,
 ) => {
   if (
-    (isLinearElement(element) || isFreeDrawElement(element)) &&
+    (isLinearElement(element) && !isPathALoop(element.points)) ||
-    !isPathALoop(element.points)
+    (isFreeDrawElement(element) && !isLoopFreeDrawElement(element))
   ) {
     // There isn't any "inside" for a non-looping path
     return false;

packages/element/src/distance.ts

@@ -48,7 +48,7 @@ export const distanceToElement = (
     case "line":
     case "arrow":
     case "freedraw":
-      return distanceToLinearOrFreeDraElement(element, p);
+      return distanceToLinearOrFreeDraElement(element, elementsMap, p);
   }
 };
 
@@ -133,9 +133,13 @@ const distanceToEllipseElement = (
 
 const distanceToLinearOrFreeDraElement = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
+  elementsMap: ElementsMap,
   p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    element,
+    elementsMap,
+  );
   return Math.min(
     ...lines.map((s) => distanceToLineSegment(p, s)),
     ...curves.map((a) => curvePointDistance(a, p)),

packages/element/src/frame.ts

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

packages/element/src/freedraw.ts

@@ -0,0 +1,181 @@
+import {
+  pointDistance,
+  vectorCross,
+  vectorDot,
+  vectorFromPoint,
+} from "@excalidraw/math";
+
+import type { LocalPoint } from "@excalidraw/math";
+
+import { isPathALoop } from "./utils";
+
+import type { ExcalidrawFreeDrawElement } from "./types";
+
+type ZoomValue = NonNullable<Parameters<typeof isPathALoop>[1]>;
+
+type FixedFreeDrawSimplificationProfile = {
+  minPointDistancePx: number;
+  maxPointDistance: number;
+  strokeDistanceFactor: number;
+  collinearityFactor: number;
+  minAlignment: number;
+  zoomScaling: "sqrt" | "none";
+};
+
+const FIXED_FREEDRAW_CAPTURE_PROFILE: FixedFreeDrawSimplificationProfile = {
+  minPointDistancePx: 0.35,
+  maxPointDistance: 0.85,
+  strokeDistanceFactor: 0.08,
+  collinearityFactor: 0.3,
+  minAlignment: 0.985,
+  zoomScaling: "sqrt",
+};
+
+const hasSyntheticLoopClosure = (
+  points: readonly LocalPoint[],
+): points is readonly [LocalPoint, LocalPoint, ...LocalPoint[]] => {
+  if (points.length < 3) {
+    return false;
+  }
+
+  const firstPoint = points[0];
+  const lastPoint = points[points.length - 1];
+
+  return firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1];
+};
+
+const stripSyntheticLoopClosure = (points: readonly LocalPoint[]) =>
+  hasSyntheticLoopClosure(points) ? points.slice(0, -1) : points;
+
+export const isLoopFreeDrawElement = (
+  element: ExcalidrawFreeDrawElement,
+  zoomValue: ZoomValue = 1 as ZoomValue,
+) => element.strokeShape !== "fixed" && isPathALoop(element.points, zoomValue);
+
+export const getFixedFreeDrawPoints = (
+  element: ExcalidrawFreeDrawElement,
+): readonly LocalPoint[] => stripSyntheticLoopClosure(element.points);
+
+export const getFixedFreeDrawPointSamplingDistance = (
+  strokeWidth: number,
+  zoomValue: ZoomValue = 1 as ZoomValue,
+  profile: FixedFreeDrawSimplificationProfile = FIXED_FREEDRAW_CAPTURE_PROFILE,
+) =>
+  Math.min(
+    Math.max(
+      profile.minPointDistancePx /
+        (profile.zoomScaling === "sqrt"
+          ? Math.max(1, Math.sqrt(zoomValue))
+          : 1),
+      strokeWidth * profile.strokeDistanceFactor,
+    ),
+    profile.maxPointDistance,
+  );
+
+const isRedundantFixedFreeDrawPoint = (
+  previousPoint: LocalPoint,
+  currentPoint: LocalPoint,
+  nextPoint: LocalPoint,
+  strokeWidth: number,
+  zoomValue: ZoomValue,
+  profile: FixedFreeDrawSimplificationProfile,
+) => {
+  const previousSegmentLength = pointDistance(previousPoint, currentPoint);
+  const nextSegmentLength = pointDistance(currentPoint, nextPoint);
+
+  if (!previousSegmentLength || !nextSegmentLength) {
+    return true;
+  }
+
+  const previousVector = vectorFromPoint(currentPoint, previousPoint);
+  const nextVector = vectorFromPoint(nextPoint, currentPoint);
+  const alignment =
+    vectorDot(previousVector, nextVector) /
+    (previousSegmentLength * nextSegmentLength);
+
+  if (alignment < profile.minAlignment) {
+    return false;
+  }
+
+  const chord = vectorFromPoint(nextPoint, previousPoint);
+  const chordLength = pointDistance(previousPoint, nextPoint);
+
+  if (!chordLength) {
+    return true;
+  }
+
+  const distanceToChord =
+    Math.abs(vectorCross(vectorFromPoint(currentPoint, previousPoint), chord)) /
+    chordLength;
+
+  return (
+    distanceToChord <=
+    getFixedFreeDrawPointSamplingDistance(strokeWidth, zoomValue, profile) *
+      profile.collinearityFactor
+  );
+};
+
+export const getFixedFreeDrawPointAction = ({
+  points,
+  nextPoint,
+  strokeWidth,
+  zoomValue,
+  isFinalPoint = false,
+  profile,
+}: {
+  points: readonly LocalPoint[];
+  nextPoint: LocalPoint;
+  strokeWidth: number;
+  zoomValue: ZoomValue;
+  isFinalPoint?: boolean;
+  profile?: FixedFreeDrawSimplificationProfile;
+}) => {
+  const simplificationProfile = profile ?? FIXED_FREEDRAW_CAPTURE_PROFILE;
+  const lastPoint = points[points.length - 1];
+
+  if (!lastPoint) {
+    return "append" as const;
+  }
+
+  if (lastPoint[0] === nextPoint[0] && lastPoint[1] === nextPoint[1]) {
+    return "discard" as const;
+  }
+
+  const samplingDistance = getFixedFreeDrawPointSamplingDistance(
+    strokeWidth,
+    zoomValue,
+    simplificationProfile,
+  );
+
+  if (points.length === 1) {
+    return !isFinalPoint &&
+      pointDistance(lastPoint, nextPoint) < samplingDistance
+      ? ("discard" as const)
+      : ("append" as const);
+  }
+
+  const previousPoint = points[points.length - 2];
+
+  if (
+    isRedundantFixedFreeDrawPoint(
+      previousPoint,
+      lastPoint,
+      nextPoint,
+      strokeWidth,
+      zoomValue,
+      simplificationProfile,
+    )
+  ) {
+    return "replace" as const;
+  }
+
+  if (!isFinalPoint && pointDistance(lastPoint, nextPoint) < samplingDistance) {
+    return "discard" as const;
+  }
+
+  return "append" as const;
+};
+
+export const getRenderableFixedFreeDrawPoints = (
+  element: ExcalidrawFreeDrawElement,
+): readonly LocalPoint[] => getFixedFreeDrawPoints(element);

packages/element/src/index.ts

@@ -69,6 +69,7 @@ export * from "./duplicate";
 export * from "./elbowArrow";
 export * from "./elementLink";
 export * from "./embeddable";
+export * from "./freedraw";
 export * from "./flowchart";
 export * from "./arrows/focus";
 export * from "./fractionalIndex";

packages/element/src/linearElementEditor.ts

@@ -476,16 +476,22 @@ export class LinearElementEditor {
       });
     }
 
-    invariant(
+    if (
-      lastClickedPoint > -1 &&
+      lastClickedPoint < 0 ||
-        selectedPointsIndices.includes(lastClickedPoint) &&
+      !selectedPointsIndices.includes(lastClickedPoint) ||
-        element.points[lastClickedPoint],
+      !element.points[lastClickedPoint]
-      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+    ) {
-        selectedPointsIndices,
+      console.error(
-      )}) points(0..${
+        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-        element.points.length - 1
+          selectedPointsIndices,
-      }) lastClickedPoint(${lastClickedPoint})`,
+        )}) points(0..${
-    );
+          element.points.length - 1
+        }) lastClickedPoint(${lastClickedPoint})`,
+      );
+
+      // Fall back to the actual last point as a last resort.
+      lastClickedPoint = element.points.length - 1;
+    }
 
     // point that's being dragged (out of all selected points)
     const draggingPoint = element.points[lastClickedPoint];
@@ -794,6 +800,7 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
+          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -803,6 +810,7 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
+        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -890,6 +898,7 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
+    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -904,7 +913,10 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(
+        element,
+        elementsMap,
+      );
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -924,6 +936,7 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
+    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -936,7 +949,10 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(
+      element,
+      elementsMap,
+    );
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1851,6 +1867,7 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
+        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2400,7 +2417,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        element,
+        nextArrow,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2431,7 +2448,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          element,
+          nextArrow,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/mutateElement.ts

@@ -1,4 +1,5 @@
 import {
+  DEFAULT_FREE_DRAW_STROKE_SHAPE,
   getSizeFromPoints,
   randomInteger,
   getUpdatedTimestamp,
@@ -18,6 +19,8 @@ import type {
   ElementsMap,
   ExcalidrawElbowArrowElement,
   ExcalidrawElement,
+  ExcalidrawFreeDrawElement,
+  FreeDrawStrokeShape,
   NonDeletedSceneElementsMap,
 } from "./types";
 
@@ -177,6 +180,30 @@ export const newElementWith = <TElement extends ExcalidrawElement>(
   };
 };
 
+export const newFreeDrawElementWithStrokeShape = <
+  TElement extends ExcalidrawFreeDrawElement,
+>(
+  element: TElement,
+  strokeShape: FreeDrawStrokeShape,
+): TElement => {
+  if (strokeShape === DEFAULT_FREE_DRAW_STROKE_SHAPE) {
+    if (!("strokeShape" in element)) {
+      return element;
+    }
+    const nextElement = newElementWith(
+      element,
+      {} as ElementUpdate<TElement>,
+      true,
+    );
+    delete (nextElement as Mutable<Partial<TElement>>).strokeShape;
+    return nextElement;
+  }
+
+  return newElementWith(element, {
+    strokeShape,
+  } as ElementUpdate<TElement>);
+};
+
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

packages/element/src/newElement.ts

@@ -445,6 +445,7 @@ export const newFreeDrawElement = (
     points?: ExcalidrawFreeDrawElement["points"];
     simulatePressure: boolean;
     pressures?: ExcalidrawFreeDrawElement["pressures"];
+    strokeShape?: ExcalidrawFreeDrawElement["strokeShape"];
   } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawFreeDrawElement> => {
   return {
@@ -452,6 +453,7 @@ export const newFreeDrawElement = (
     points: opts.points || [],
     pressures: opts.pressures || [],
     simulatePressure: opts.simulatePressure,
+    ...(opts.strokeShape === "fixed" ? { strokeShape: opts.strokeShape } : {}),
   };
 };
 

packages/element/src/renderElement.ts

@@ -417,16 +417,27 @@ const drawElementOnCanvas = (
     case "freedraw": {
       // Draw directly to canvas
       context.save();
+      context.lineJoin = "round";
+      context.lineCap = "round";
 
       const shapes = ShapeCache.generateElementShape(element, renderConfig);
+      const isFixedStroke = element.strokeShape === "fixed";
 
       for (const shape of shapes) {
         if (typeof shape === "string") {
-          context.fillStyle =
+          const strokeColor =
             renderConfig.theme === THEME.DARK
               ? applyDarkModeFilter(element.strokeColor)
               : element.strokeColor;
-          context.fill(new Path2D(shape));
+
+          if (isFixedStroke) {
+            context.strokeStyle = strokeColor;
+            context.lineWidth = element.strokeWidth;
+            context.stroke(new Path2D(shape));
+          } else {
+            context.fillStyle = strokeColor;
+            context.fill(new Path2D(shape));
+          }
         } else {
           rc.draw(shape);
         }

packages/element/src/selection.ts

@@ -1,15 +1,32 @@
-import { arrayToMap, isShallowEqual } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import {
+  lineSegment,
+  pointFrom,
+  pointRotateRads,
+  type GlobalPoint,
+} from "@excalidraw/math";
 
 import type {
   AppState,
+  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
+import {
+  boundsContainBounds,
+  doBoundsIntersect,
+  elementCenterPoint,
+  getElementAbsoluteCoords,
+  getElementBounds,
+  pointInsideBounds,
+} from "./bounds";
+import { intersectElementWithLineSegment } from "./collision";
 import { isElementInViewport } from "./sizeHelpers";
 import {
+  isArrowElement,
   isBoundToContainer,
   isFrameLikeElement,
+  isFreeDrawElement,
   isLinearElement,
   isTextElement,
 } from "./typeChecks";
@@ -17,19 +34,38 @@ import {
   elementOverlapsWithFrame,
   getContainingFrame,
   getFrameChildren,
+  isElementIntersectingFrame,
 } from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
+import { getBoundTextElement } from "./textElement";
 
 import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
+  ExcalidrawFrameLikeElement,
   NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
+const shouldIgnoreElementFromSelection = (
+  element: NonDeletedExcalidrawElement,
+) => element.locked || isBoundToContainer(element);
+
+const excludeElementsFromFrames = <T extends ExcalidrawElement>(
+  selectedElements: readonly T[],
+  framesInSelection: Set<ExcalidrawFrameLikeElement["id"]>,
+) => {
+  return selectedElements.filter((element) => {
+    if (element.frameId && framesInSelection.has(element.frameId)) {
+      return false;
+    }
+    return true;
+  });
+};
+
 /**
  * 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
@@ -49,55 +85,243 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return selectedElements.filter((element) => {
+  return excludeElementsFromFrames(selectedElements, framesInSelection);
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
+  // TODO remove (this flag is effectively unused AFAIK)
   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;
+  const selectionEdges = [
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY1),
+      pointFrom(selectionX2, selectionY1),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY1),
+      pointFrom(selectionX2, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY2),
+      pointFrom(selectionX1, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY2),
+      pointFrom(selectionX1, selectionY1),
+    ),
+  ];
 
-  let elementsInSelection = elements.filter((element) => {
+  const framesInSelection = excludeElementsInFrames
-    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+    ? new Set<NonDeletedExcalidrawElement["id"]>()
-      element,
+    : null;
-      elementsMap,
+  let elementsInSelection: NonDeletedExcalidrawElement[] = [];
-    );
 
-    const containingFrame = getContainingFrame(element, elementsMap);
+  for (const element of elements) {
-    if (containingFrame) {
+    if (shouldIgnoreElementFromSelection(element)) {
-      const [fx1, fy1, fx2, fy2] = getElementBounds(
+      continue;
-        containingFrame,
-        elementsMap,
-      );
-
-      elementX1 = Math.max(fx1, elementX1);
-      elementY1 = Math.max(fy1, elementY1);
-      elementX2 = Math.min(fx2, elementX2);
-      elementY2 = Math.min(fy2, elementY2);
     }
 
-    return (
+    const strokeWidth = element.strokeWidth;
-      element.locked === false &&
+    let labelAABB: Bounds | null = null;
-      element.type !== "selection" &&
+    let elementAABB = getElementBounds(element, elementsMap);
-      !isBoundToContainer(element) &&
-      selectionX1 <= elementX1 &&
-      selectionY1 <= elementY1 &&
-      selectionX2 >= elementX2 &&
-      selectionY2 >= elementY2
-    );
-  });
 
-  elementsInSelection = excludeElementsInFrames
+    elementAABB = [
-    ? excludeElementsInFramesFromSelection(elementsInSelection)
+      elementAABB[0] - strokeWidth / 2,
+      elementAABB[1] - strokeWidth / 2,
+      elementAABB[2] + strokeWidth / 2,
+      elementAABB[3] + strokeWidth / 2,
+    ] as Bounds;
+
+    // Whether the element bounds should include the bound text element bounds
+    const boundTextElement =
+      isArrowElement(element) && getBoundTextElement(element, elementsMap);
+    if (boundTextElement) {
+      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
+        element,
+        boundTextElement,
+        elementsMap,
+      );
+      labelAABB = [
+        x,
+        y,
+        x + boundTextElement.width,
+        y + boundTextElement.height,
+      ] as Bounds;
+    }
+
+    // Clip element bounds by its containing frame (if any), since only the
+    // visible (frame-clipped) portion of the element is relevant for selection.
+    const associatedFrame = getContainingFrame(element, elementsMap);
+    if (
+      associatedFrame &&
+      isElementIntersectingFrame(element, associatedFrame, elementsMap)
+    ) {
+      const frameAABB = getElementBounds(associatedFrame, elementsMap);
+      elementAABB = [
+        Math.max(elementAABB[0], frameAABB[0]),
+        Math.max(elementAABB[1], frameAABB[1]),
+        Math.min(elementAABB[2], frameAABB[2]),
+        Math.min(elementAABB[3], frameAABB[3]),
+      ] as Bounds;
+
+      labelAABB = labelAABB
+        ? ([
+            Math.max(labelAABB[0], frameAABB[0]),
+            Math.max(labelAABB[1], frameAABB[1]),
+            Math.min(labelAABB[2], frameAABB[2]),
+            Math.min(labelAABB[3], frameAABB[3]),
+          ] as Bounds)
+        : null;
+    }
+
+    const commonAABB = labelAABB
+      ? ([
+          Math.min(labelAABB[0], elementAABB[0]),
+          Math.min(labelAABB[1], elementAABB[1]),
+          Math.max(labelAABB[2], elementAABB[2]),
+          Math.max(labelAABB[3], elementAABB[3]),
+        ] as Bounds)
+      : elementAABB;
+
+    // ============== Evaluation ==============
+
+    // 1. If the selection box WRAPs the element's AABB, then add it to the
+    //    selection and move on, regardless of the selection mode.
+    //
+    //    PERF: This trick only works with axis-aligned box selection and the
+    //          current convex element shapes!
+    if (boundsContainBounds(selectionBounds, commonAABB)) {
+      if (framesInSelection && isFrameLikeElement(element)) {
+        framesInSelection.add(element.id);
+      } else {
+        elementsInSelection.push(element);
+        continue;
+      }
+    }
+
+    // 2. Handle the case where the label is overlapped by the selection box
+    if (
+      boxSelectionMode === "overlap" &&
+      labelAABB &&
+      doBoundsIntersect(selectionBounds, labelAABB)
+    ) {
+      elementsInSelection.push(element);
+      continue;
+    }
+
+    // 3. Handle the case where the selection is not wrapping the element, but
+    //    it does intersect the element's outline (non-AABB).
+    if (
+      boxSelectionMode === "overlap" &&
+      doBoundsIntersect(selectionBounds, elementAABB)
+    ) {
+      let hasIntersection = false;
+
+      // Preliminary check potential intersection imprecision
+      if (isLinearElement(element) || isFreeDrawElement(element)) {
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = element.points.some((point) => {
+          const rotatedPoint = pointRotateRads(
+            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
+            center,
+            element.angle,
+          );
+
+          return pointInsideBounds(rotatedPoint, selectionBounds);
+        });
+      } else {
+        const nonRotatedElementBounds = getElementBounds(
+          element,
+          elementsMap,
+          true,
+        );
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = [
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[1],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[2],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[3],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[0],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+        ].some((point) => {
+          return pointInsideBounds(
+            pointRotateRads(point, center, element.angle),
+            selectionBounds,
+          );
+        });
+      }
+
+      if (!hasIntersection) {
+        hasIntersection = selectionEdges.some(
+          (selectionEdge) =>
+            intersectElementWithLineSegment(
+              element,
+              elementsMap,
+              selectionEdge,
+              strokeWidth / 2,
+              true, // Stop at first hit for better performance
+            ).length > 0,
+        );
+      }
+
+      if (hasIntersection) {
+        if (framesInSelection && isFrameLikeElement(element)) {
+          framesInSelection.add(element.id);
+        }
+
+        elementsInSelection.push(element);
+        continue;
+      }
+    }
+
+    // 4. We don't need to handle when the selection is inside the element
+    //    as it is separately handled in App.
+  }
+
+  elementsInSelection = framesInSelection
+    ? excludeElementsFromFrames(elementsInSelection, framesInSelection)
     : elementsInSelection;
 
   elementsInSelection = elementsInSelection.filter((element) => {

packages/element/src/shape.ts

@@ -1,4 +1,5 @@
 import { simplify } from "points-on-curve";
+import { DEFAULT_FREE_DRAW_STROKE_SHAPE } from "@excalidraw/common";
 import { getStroke } from "perfect-freehand";
 
 import {
@@ -13,6 +14,7 @@ import {
 import {
   pointFrom,
   pointDistance,
+  round,
   type LocalPoint,
   pointRotateRads,
 } from "@excalidraw/math";
@@ -52,13 +54,17 @@ import {
   isIframeLikeElement,
   isLinearElement,
 } from "./typeChecks";
+import {
+  getRenderableFixedFreeDrawPoints,
+  isLoopFreeDrawElement,
+} from "./freedraw";
 import { getCornerRadius, isPathALoop } from "./utils";
 import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
 import {
+  elementCenterPoint,
   getArrowheadPoints,
-  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -244,7 +250,12 @@ export const generateRoughOptions = (
     }
     case "line":
     case "freedraw": {
-      if (isPathALoop(element.points)) {
+      const isLoop =
+        element.type === "freedraw"
+          ? isLoopFreeDrawElement(element)
+          : isPathALoop(element.points);
+
+      if (isLoop) {
         options.fillStyle = element.fillStyle;
         options.fill =
           element.backgroundColor === "transparent"
@@ -583,7 +594,11 @@ const getArrowheadShapes = (
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-) => {
+  elementsMap: ElementsMap,
+): {
+  op: string;
+  data: number[];
+}[] => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -592,20 +607,7 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = getCenterForBounds(
+  const center = elementCenterPoint(element, elementsMap);
-    // Need a non-rotated center point
-    element.points.reduce(
-      (acc, point) => {
-        return [
-          Math.min(element.x + point[0], acc[0]),
-          Math.min(element.y + point[1], acc[1]),
-          Math.max(element.x + point[0], acc[2]),
-          Math.max(element.y + point[1], acc[3]),
-        ];
-      },
-      [Infinity, Infinity, -Infinity, -Infinity],
-    ),
-  );
 
   switch (element.type) {
     case "line":
@@ -975,7 +977,7 @@ const _generateElementShape = (
       const shapes: ElementShapes[typeof element.type] = [];
 
       // (1) background fill (rc shape), optional
-      if (isPathALoop(element.points)) {
+      if (isLoopFreeDrawElement(element)) {
         // generate rough polygon to fill freedraw shape
         const simplifiedPoints = simplify(
           element.points as Mutable<LocalPoint[]>,
@@ -1182,6 +1184,13 @@ export const toggleLinePolygonState = (
 
 // NOTE not cached (-> for SVG export)
 const getFreeDrawSvgPath = (element: ExcalidrawFreeDrawElement) => {
+  if (element.strokeShape === "fixed") {
+    return getSvgPathFromFixedFreeDrawPoints(
+      getRenderableFixedFreeDrawPoints(element),
+      element.strokeWidth,
+    ) as SVGPathString;
+  }
+
   return getSvgPathFromStroke(
     getFreedrawOutlinePoints(element),
   ) as SVGPathString;
@@ -1190,34 +1199,243 @@ const getFreeDrawSvgPath = (element: ExcalidrawFreeDrawElement) => {
 export const getFreedrawOutlinePoints = (
   element: ExcalidrawFreeDrawElement,
 ) => {
+  const strokeShape = element.strokeShape ?? DEFAULT_FREE_DRAW_STROKE_SHAPE;
+  const isFixedStroke = strokeShape === "fixed";
   // If input points are empty (should they ever be?) return a dot
-  const inputPoints = element.simulatePressure
+  const inputPoints = isFixedStroke
+    ? element.points.length
+      ? element.points
+      : [[0, 0]]
+    : element.simulatePressure
     ? element.points
     : element.points.length
     ? element.points.map(([x, y], i) => [x, y, element.pressures[i]])
     : [[0, 0, 0.5]];
 
   return getStroke(inputPoints as number[][], {
-    simulatePressure: element.simulatePressure,
+    simulatePressure: isFixedStroke ? false : element.simulatePressure,
-    size: element.strokeWidth * 4.25,
+    size: isFixedStroke ? element.strokeWidth : element.strokeWidth * 4.25,
-    thinning: 0.6,
+    thinning: isFixedStroke ? 0 : 0.6,
     smoothing: 0.5,
     streamline: 0.5,
-    easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
+    easing: isFixedStroke ? (t) => t : (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
     last: true,
   }) as [number, number][];
 };
 
-const med = (A: number[], B: number[]) => {
+const med = (A: readonly number[], B: readonly number[]) => {
   return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
 };
 
+const roundPoint = (point: readonly number[]) =>
+  `${round(point[0], 2)},${round(point[1], 2)} `;
+
+const averagePoint = (A: readonly number[], B: readonly number[]) =>
+  `${round((A[0] + B[0]) / 2, 2)},${round((A[1] + B[1]) / 2, 2)} `;
+
+const getReadonlyPointDistance = (
+  pointA: readonly number[],
+  pointB: readonly number[],
+) => Math.hypot(pointA[0] - pointB[0], pointA[1] - pointB[1]);
+
 // Trim SVG path data so number are each two decimal points. This
 // improves SVG exports, and prevents rendering errors on points
 // with long decimals.
 const TO_FIXED_PRECISION = /(\s?[A-Z]?,?-?[0-9]*\.[0-9]{0,2})(([0-9]|e|-)*)/g;
 
-const getSvgPathFromStroke = (points: number[][]): string => {
+const getSvgPathFromPoints = (
+  points: ReadonlyArray<readonly number[]>,
+  closed = false,
+): string => {
+  const len = points.length;
+
+  if (len < 2) {
+    return "";
+  }
+
+  const path = points
+    .slice(1)
+    .map((point) => `L${roundPoint(point)}`)
+    .join("");
+
+  return `M${roundPoint(points[0])}${path}${closed ? "Z" : ""}`;
+};
+
+const FIXED_FREEDRAW_MIN_SMOOTH_ALIGNMENT = 0.6;
+const FIXED_FREEDRAW_MIN_SMOOTH_SEGMENT_LENGTH = 0.2;
+const FIXED_FREEDRAW_MIN_CORNER_ALIGNMENT = -0.25;
+const FIXED_FREEDRAW_MIN_CORNER_ROUNDING = 0.75;
+const FIXED_FREEDRAW_MAX_CORNER_ROUNDING = 6;
+const FIXED_FREEDRAW_CORNER_ROUNDING_FACTOR = 0.35;
+const FIXED_FREEDRAW_CORNER_ROUNDING_WIDTH_FACTOR = 1.5;
+const FIXED_FREEDRAW_MIN_TERMINAL_STUB = 0.75;
+const FIXED_FREEDRAW_MAX_TERMINAL_STUB = 2.5;
+const FIXED_FREEDRAW_TERMINAL_STUB_WIDTH_FACTOR = 1.5;
+
+const shouldSmoothFixedFreeDrawPoint = (
+  previousPoint: readonly number[],
+  currentPoint: readonly number[],
+  nextPoint: readonly number[],
+) => {
+  const previousDeltaX = currentPoint[0] - previousPoint[0];
+  const previousDeltaY = currentPoint[1] - previousPoint[1];
+  const nextDeltaX = nextPoint[0] - currentPoint[0];
+  const nextDeltaY = nextPoint[1] - currentPoint[1];
+  const previousSegmentLength = Math.hypot(previousDeltaX, previousDeltaY);
+  const nextSegmentLength = Math.hypot(nextDeltaX, nextDeltaY);
+
+  if (
+    previousSegmentLength < FIXED_FREEDRAW_MIN_SMOOTH_SEGMENT_LENGTH ||
+    nextSegmentLength < FIXED_FREEDRAW_MIN_SMOOTH_SEGMENT_LENGTH
+  ) {
+    return false;
+  }
+
+  const alignment =
+    (previousDeltaX * nextDeltaX + previousDeltaY * nextDeltaY) /
+    (previousSegmentLength * nextSegmentLength);
+
+  return alignment >= FIXED_FREEDRAW_MIN_SMOOTH_ALIGNMENT;
+};
+
+const getFixedFreeDrawRoundedCorner = (
+  previousPoint: readonly number[],
+  currentPoint: readonly number[],
+  nextPoint: readonly number[],
+  strokeWidth: number,
+) => {
+  const previousDeltaX = currentPoint[0] - previousPoint[0];
+  const previousDeltaY = currentPoint[1] - previousPoint[1];
+  const nextDeltaX = nextPoint[0] - currentPoint[0];
+  const nextDeltaY = nextPoint[1] - currentPoint[1];
+  const previousSegmentLength = Math.hypot(previousDeltaX, previousDeltaY);
+  const nextSegmentLength = Math.hypot(nextDeltaX, nextDeltaY);
+
+  if (!previousSegmentLength || !nextSegmentLength) {
+    return null;
+  }
+
+  const alignment =
+    (previousDeltaX * nextDeltaX + previousDeltaY * nextDeltaY) /
+    (previousSegmentLength * nextSegmentLength);
+
+  if (
+    alignment >= FIXED_FREEDRAW_MIN_SMOOTH_ALIGNMENT ||
+    alignment <= FIXED_FREEDRAW_MIN_CORNER_ALIGNMENT
+  ) {
+    return null;
+  }
+
+  const cornerRounding = Math.min(
+    Math.max(
+      strokeWidth * FIXED_FREEDRAW_CORNER_ROUNDING_WIDTH_FACTOR,
+      FIXED_FREEDRAW_MIN_CORNER_ROUNDING,
+    ),
+    previousSegmentLength * FIXED_FREEDRAW_CORNER_ROUNDING_FACTOR,
+    nextSegmentLength * FIXED_FREEDRAW_CORNER_ROUNDING_FACTOR,
+    FIXED_FREEDRAW_MAX_CORNER_ROUNDING,
+  );
+
+  if (!cornerRounding) {
+    return null;
+  }
+
+  return {
+    entryPoint: [
+      currentPoint[0] - (previousDeltaX / previousSegmentLength) * cornerRounding,
+      currentPoint[1] - (previousDeltaY / previousSegmentLength) * cornerRounding,
+    ] as const,
+    exitPoint: [
+      currentPoint[0] + (nextDeltaX / nextSegmentLength) * cornerRounding,
+      currentPoint[1] + (nextDeltaY / nextSegmentLength) * cornerRounding,
+    ] as const,
+  };
+};
+
+const getFixedFreeDrawTerminalStubThreshold = (strokeWidth: number) =>
+  Math.min(
+    Math.max(
+      strokeWidth * FIXED_FREEDRAW_TERMINAL_STUB_WIDTH_FACTOR,
+      FIXED_FREEDRAW_MIN_TERMINAL_STUB,
+    ),
+    FIXED_FREEDRAW_MAX_TERMINAL_STUB,
+  );
+
+const getSvgPathFromFixedFreeDrawPoints = (
+  points: ReadonlyArray<readonly number[]>,
+  strokeWidth: number,
+): string => {
+  const len = points.length;
+
+  if (len < 2) {
+    return "";
+  }
+
+  if (len === 2) {
+    return `M${roundPoint(points[0])}L${roundPoint(points[1])}`;
+  }
+
+  let path = `M${roundPoint(points[0])}`;
+  const lastPoint = points[len - 1];
+  let endsAtLastPoint = false;
+
+  for (let index = 1; index < len - 1; index++) {
+    const previousPoint = points[index - 1];
+    const currentPoint = points[index];
+    const nextPoint = points[index + 1];
+    const isLastCurveSegment = index === len - 2;
+    const terminalStubThreshold = getFixedFreeDrawTerminalStubThreshold(
+      strokeWidth,
+    );
+    const shouldSmooth = shouldSmoothFixedFreeDrawPoint(
+      previousPoint,
+      currentPoint,
+      nextPoint,
+    );
+    const roundedCorner = shouldSmooth
+      ? null
+      : getFixedFreeDrawRoundedCorner(
+          previousPoint,
+          currentPoint,
+          nextPoint,
+          strokeWidth,
+        );
+    const shouldCollapseSmoothTerminalStub =
+      isLastCurveSegment &&
+      shouldSmooth &&
+      getReadonlyPointDistance(currentPoint, nextPoint) / 2 <=
+        terminalStubThreshold;
+    const shouldCollapseRoundedTerminalStub =
+      isLastCurveSegment &&
+      !!roundedCorner &&
+      getReadonlyPointDistance(roundedCorner.exitPoint, lastPoint) <=
+        terminalStubThreshold;
+
+    path += shouldSmooth
+      ? `Q${roundPoint(currentPoint)}${
+          shouldCollapseSmoothTerminalStub
+            ? roundPoint(lastPoint)
+            : averagePoint(currentPoint, nextPoint)
+        }`
+      : roundedCorner
+        ? `L${roundPoint(roundedCorner.entryPoint)}Q${roundPoint(
+            currentPoint,
+          )}${
+            shouldCollapseRoundedTerminalStub
+              ? roundPoint(lastPoint)
+              : roundPoint(roundedCorner.exitPoint)
+          }`
+        : `L${roundPoint(currentPoint)}`;
+    endsAtLastPoint =
+      shouldCollapseSmoothTerminalStub || shouldCollapseRoundedTerminalStub;
+  }
+
+  return endsAtLastPoint ? path : `${path}L${roundPoint(lastPoint)}`;
+};
+
+const getSvgPathFromStroke = (
+  points: ReadonlyArray<readonly number[]>,
+): string => {
   if (!points.length) {
     return "";
   }

packages/element/src/textElement.ts

@@ -347,6 +347,7 @@ export const getContainerCenter = (
     midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
       container,
       index + 1,
+      elementsMap,
     );
   }
   return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };

packages/element/src/types.ts

@@ -26,6 +26,7 @@ export type PointerType = "mouse" | "pen" | "touch";
 export type StrokeRoundness = "round" | "sharp";
 export type RoundnessType = ValueOf<typeof ROUNDNESS>;
 export type StrokeStyle = "solid" | "dashed" | "dotted";
+export type FreeDrawStrokeShape = "variable" | "fixed";
 export type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 
 type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
@@ -390,6 +391,7 @@ export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase &
     points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
+    strokeShape?: FreeDrawStrokeShape;
   }>;
 
 export type FileId = string & { _brand: "FileId" };

packages/element/src/utils.ts

@@ -124,6 +124,7 @@ const setElementShapesCacheEntry = <T extends ExcalidrawElement>(
  */
 export function deconstructLinearOrFreeDrawElement(
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
+  elementsMap: ElementsMap,
 ): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
   const cachedShape = getElementShapesCacheEntry(element, 0);
 
@@ -131,10 +132,7 @@ export function deconstructLinearOrFreeDrawElement(
     return cachedShape;
   }
 
-  const ops = generateLinearCollisionShape(element) as {
+  const ops = generateLinearCollisionShape(element, elementsMap);
-    op: string;
-    data: number[];
-  }[];
   const lines = [];
   const curves = [];
 

packages/element/tests/bounds.test.ts

@@ -6,7 +6,11 @@ import type { LocalPoint } from "@excalidraw/math";
 
 import { getElementAbsoluteCoords, getElementBounds } from "../src/bounds";
 
-import type { ExcalidrawElement, ExcalidrawLinearElement } from "../src/types";
+import type {
+  ExcalidrawElement,
+  ExcalidrawFreeDrawElement,
+  ExcalidrawLinearElement,
+} from "../src/types";
 
 const _ce = ({
   x,
@@ -117,6 +121,31 @@ describe("getElementBounds", () => {
     expect(y2).toEqual(42.90569415042095);
   });
 
+  it("fixed freedraw", () => {
+    const element = {
+      ..._ce({
+        x: 40,
+        y: 30,
+        w: 10,
+        h: 0,
+        a: 0,
+        t: "freedraw",
+      }),
+      strokeWidth: 8,
+      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(10, 0)],
+      pressures: [],
+      simulatePressure: true,
+      strokeShape: "fixed",
+    } as unknown as ExcalidrawFreeDrawElement;
+
+    const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
+
+    expect(x1).toEqual(36);
+    expect(y1).toEqual(26);
+    expect(x2).toEqual(54);
+    expect(y2).toEqual(34);
+  });
+
   it("curved line", () => {
     const element = {
       ..._ce({

packages/element/tests/collision.test.tsx

@@ -1,4 +1,4 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMap, reseed } from "@excalidraw/common";
 import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";
 import { Excalidraw } from "@excalidraw/excalidraw";
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
@@ -12,6 +12,7 @@ import { hitElementItself } from "../src/collision";
 describe("check rotated elements can be hit:", () => {
   beforeEach(async () => {
     localStorage.clear();
+    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 
@@ -56,6 +57,7 @@ describe("hitElementItself cache", () => {
     });
 
     localStorage.clear();
+    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 

packages/element/tests/shape.test.ts

@@ -0,0 +1,160 @@
+import { pointFrom } from "@excalidraw/math";
+import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+import { vi } from "vitest";
+
+vi.mock("perfect-freehand", () => ({
+  getStroke: vi.fn(() => []),
+}));
+
+import { getStroke } from "perfect-freehand";
+
+import { getFreedrawOutlinePoints, ShapeCache } from "../src/shape";
+
+describe("freedraw stroke shape", () => {
+  beforeEach(() => {
+    vi.mocked(getStroke).mockClear();
+    ShapeCache.destroy();
+  });
+
+  it("renders fixed strokes from the centerline path", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
+    });
+
+    const shapes = ShapeCache.generateElementShape(element, null);
+
+    expect(shapes).toEqual([expect.any(String)]);
+    expect(shapes[0]).not.toContain("Z");
+    expect(vi.mocked(getStroke)).not.toHaveBeenCalled();
+  });
+
+  it("rounds fixed stroke corners without flattening them", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      strokeWidth: 1,
+      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(10, 10)],
+    });
+
+    const [path] = ShapeCache.generateElementShape(element, null);
+
+    expect(path).toBe("M0,0 L8.5,0 Q10,0 10,1.5 L10,10 ");
+  });
+
+  it("does not round fixed stroke hairpin turns", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      strokeWidth: 1,
+      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(9, 1)],
+    });
+
+    const [path] = ShapeCache.generateElementShape(element, null);
+
+    expect(path).toBe("M0,0 L10,0 L9,1 ");
+  });
+
+  it("curves directly to the endpoint for tiny final smooth segments", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      strokeWidth: 1,
+      points: [pointFrom(0, 0), pointFrom(0.5, 0.1), pointFrom(0.8, 0.3)],
+    });
+
+    const [path] = ShapeCache.generateElementShape(element, null);
+
+    expect(path).toBe("M0,0 Q0.5,0.1 0.8,0.3 ");
+  });
+
+  it("curves directly to the endpoint for tiny final rounded corners", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      strokeWidth: 1,
+      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(10, 1)],
+    });
+
+    const [path] = ShapeCache.generateElementShape(element, null);
+
+    expect(path).toBe("M0,0 L9.65,0 Q10,0 10,1 ");
+  });
+
+  it("smooths dense fixed stroke points without dropping them", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      points: [
+        pointFrom(0, 0),
+        pointFrom(0.3, 0.1),
+        pointFrom(0.6, 0.35),
+        pointFrom(1, 0.9),
+      ],
+    });
+
+    const [path] = ShapeCache.generateElementShape(element, null);
+
+    expect(path).toContain("Q0.3,0.1 ");
+    expect(path).toContain("Q0.6,0.35 ");
+  });
+
+  it("drops synthetic loop closure for fixed strokes", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(0, 0)],
+    });
+
+    const [path] = ShapeCache.generateElementShape(element, null);
+
+    expect(path).toBe("M0,0 L10,0 ");
+  });
+
+  it("uses fixed perfect-freehand settings for fixed strokes", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      strokeShape: "fixed",
+      strokeWidth: 8,
+      points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
+    });
+
+    getFreedrawOutlinePoints(element);
+
+    expect(vi.mocked(getStroke)).toHaveBeenCalledWith(
+      element.points,
+      expect.objectContaining({
+        simulatePressure: false,
+        size: element.strokeWidth,
+        thinning: 0,
+      }),
+    );
+  });
+
+  it("keeps pressure-aware perfect-freehand settings for variable strokes", () => {
+    const element = API.createElement({
+      type: "freedraw",
+      points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
+    });
+
+    getFreedrawOutlinePoints({
+      ...element,
+      simulatePressure: false,
+      pressures: [0.2, 0.8, 0.4],
+    });
+
+    expect(vi.mocked(getStroke)).toHaveBeenCalledWith(
+      [
+        [0, 0, 0.2],
+        [10, 10, 0.8],
+        [20, 15, 0.4],
+      ],
+      expect.objectContaining({
+        simulatePressure: false,
+        size: element.strokeWidth * 4.25,
+        thinning: 0.6,
+      }),
+    );
+  });
+});

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

@@ -2,6 +2,7 @@ import { pointFrom } from "@excalidraw/math";
 
 import { bindOrUnbindBindingElement } from "@excalidraw/element/binding";
 import {
+  isLoopFreeDrawElement,
   isValidPolygon,
   LinearElementEditor,
   newElementWith,
@@ -242,7 +243,11 @@ export const actionFinalize = register<FormData>({
         // If the multi point line closes the loop,
         // set the last point to first point.
         // This ensures that loop remains closed at different scales.
-        const isLoop = isPathALoop(element.points, appState.zoom.value);
+        const isLoop = isLineElement(element)
+          ? isPathALoop(element.points, appState.zoom.value)
+          : isFreeDrawElement(element)
+          ? isLoopFreeDrawElement(element, appState.zoom.value)
+          : false;
 
         if (isLoop && (isLineElement(element) || isFreeDrawElement(element))) {
           const linePoints = element.points;
@@ -348,9 +353,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/actionProperties.test.tsx

@@ -1,4 +1,5 @@
 import { queryByTestId } from "@testing-library/react";
+import { pointFrom } from "@excalidraw/math";
 
 import {
   COLOR_PALETTE,
@@ -10,7 +11,7 @@ import {
 import { Excalidraw } from "../index";
 import { API } from "../tests/helpers/api";
 import { UI } from "../tests/helpers/ui";
-import { render } from "../tests/test-utils";
+import { act, render } from "../tests/test-utils";
 
 describe("element locking", () => {
   beforeEach(async () => {
@@ -80,6 +81,20 @@ describe("element locking", () => {
       const centerTextAlign = queryByTestId(document.body, `align-right`);
       expect(centerTextAlign).toBeChecked();
     });
+
+    it("should show the active freedraw stroke type", () => {
+      UI.clickTool("freedraw");
+
+      API.setAppState({
+        currentItemStrokeShape: "fixed",
+      });
+
+      const fixedStrokeShape = queryByTestId(
+        document.body,
+        "strokeShape-fixed",
+      );
+      expect(fixedStrokeShape).toBeChecked();
+    });
   });
 
   describe("properties when elements selected", () => {
@@ -144,6 +159,9 @@ describe("element locking", () => {
       expect(
         queryByTestId(document.body, `strokeWidth-thin`),
       ).not.toBeChecked();
+      expect(
+        queryByTestId(document.body, `strokeWidth-medium`),
+      ).not.toBeChecked();
       expect(
         queryByTestId(document.body, `strokeWidth-bold`),
       ).not.toBeChecked();
@@ -159,6 +177,7 @@ describe("element locking", () => {
       });
       const text = API.createElement({
         type: "text",
+        strokeWidth: STROKE_WIDTH.bold,
         fontFamily: FONT_FAMILY["Comic Shanns"],
       });
       API.setElements([rect, text]);
@@ -169,5 +188,35 @@ describe("element locking", () => {
         "active",
       );
     });
+
+    it("should highlight the fixed freedraw stroke type for selected elements", () => {
+      const freedraw = API.createElement({
+        type: "freedraw",
+        strokeShape: "fixed",
+        points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
+      });
+      API.setElements([freedraw]);
+      API.setSelectedElements([freedraw]);
+
+      const fixedStrokeShape = queryByTestId(
+        document.body,
+        "strokeShape-fixed",
+      );
+      expect(fixedStrokeShape).toBeChecked();
+    });
+
+    it("should apply fixed freedraw stroke type to newly drawn strokes", () => {
+      UI.clickTool("freedraw");
+
+      act(() => {
+        queryByTestId(document.body, "strokeShape-fixed")?.click();
+      });
+
+      const freedraw = UI.createElement("freedraw", {
+        points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
+      });
+
+      expect(freedraw.strokeShape).toBe("fixed");
+    });
   });
 });

packages/excalidraw/actions/actionProperties.tsx

@@ -3,6 +3,7 @@ import { pointFrom } from "@excalidraw/math";
 import { useEffect, useMemo, useRef, useState } from "react";
 
 import {
+  DEFAULT_FREE_DRAW_STROKE_SHAPE,
   DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE,
   DEFAULT_ELEMENT_BACKGROUND_PICKS,
   DEFAULT_ELEMENT_STROKE_COLOR_PALETTE,
@@ -36,6 +37,7 @@ import {
 import { LinearElementEditor } from "@excalidraw/element";
 
 import { newElementWith } from "@excalidraw/element";
+import { newFreeDrawElementWithStrokeShape } from "@excalidraw/element";
 import { getArrowheadForPicker } from "@excalidraw/element";
 
 import {
@@ -47,6 +49,7 @@ import {
   isArrowElement,
   isBoundToContainer,
   isElbowArrow,
+  isFreeDrawElement,
   isLinearElement,
   isLineElement,
   isTextElement,
@@ -70,6 +73,7 @@ import type {
   ElementsMap,
   ExcalidrawBindableElement,
   ExcalidrawElement,
+  ExcalidrawFreeDrawElement,
   ExcalidrawLinearElement,
   ExcalidrawTextElement,
   FontFamilyValues,
@@ -105,8 +109,11 @@ import {
   SloppinessArtistIcon,
   SloppinessCartoonistIcon,
   StrokeWidthBaseIcon,
+  StrokeWidthMediumIcon,
   StrokeWidthBoldIcon,
   StrokeWidthExtraBoldIcon,
+  StrokeShapeFixedIcon,
+  StrokeShapeVariableIcon,
   FontSizeSmallIcon,
   FontSizeMediumIcon,
   FontSizeLargeIcon,
@@ -187,6 +194,29 @@ export const changeProperty = (
   });
 };
 
+const getFreeDrawStrokeShape = (item: {
+  strokeShape?: ExcalidrawFreeDrawElement["strokeShape"];
+  currentItemStrokeShape?: AppState["currentItemStrokeShape"];
+}) =>
+  item.strokeShape ??
+  item.currentItemStrokeShape ??
+  DEFAULT_FREE_DRAW_STROKE_SHAPE;
+
+const getAppStateWithCurrentItemStrokeShape = (
+  appState: AppState,
+  strokeShape: NonNullable<ExcalidrawFreeDrawElement["strokeShape"]>,
+) => {
+  // if (strokeShape === DEFAULT_FREE_DRAW_STROKE_SHAPE) {
+  //   const { currentItemStrokeShape, ...nextAppState } = appState;
+  //   return nextAppState;
+  // }
+
+  return {
+    ...appState,
+    currentItemStrokeShape: strokeShape,
+  };
+};
+
 export const getFormValue = function <T extends Primitive>(
   elements: readonly ExcalidrawElement[],
   app: AppClassProperties,
@@ -574,6 +604,12 @@ export const actionChangeStrokeWidth = register<
               icon: StrokeWidthBaseIcon,
               testId: "strokeWidth-thin",
             },
+            {
+              value: STROKE_WIDTH.medium,
+              text: t("labels.medium"),
+              icon: StrokeWidthMediumIcon,
+              testId: "strokeWidth-medium",
+            },
             {
               value: STROKE_WIDTH.bold,
               text: t("labels.bold"),
@@ -602,6 +638,60 @@ export const actionChangeStrokeWidth = register<
   ),
 });
 
+export const actionChangeStrokeShape = register<
+  NonNullable<ExcalidrawFreeDrawElement["strokeShape"]>
+>({
+  name: "changeStrokeShape",
+  label: "labels.strokeShape",
+  trackEvent: false,
+  perform: (elements, appState, value) => {
+    invariant(value, "actionChangeStrokeShape: value must be defined");
+    return {
+      elements: changeProperty(elements, appState, (el) =>
+        isFreeDrawElement(el)
+          ? newFreeDrawElementWithStrokeShape(el, value)
+          : el,
+      ),
+      appState: getAppStateWithCurrentItemStrokeShape(appState, value),
+      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
+    };
+  },
+  PanelComponent: ({ elements, appState, updateData, app }) => (
+    <fieldset>
+      <legend>{t("labels.strokeShape")}</legend>
+      <div className="buttonList">
+        <RadioSelection
+          group="stroke-shape"
+          options={[
+            {
+              value: "variable",
+              text: t("labels.strokeShape_variable"),
+              icon: StrokeShapeVariableIcon,
+              testId: "strokeShape-variable",
+            },
+            {
+              value: "fixed",
+              text: t("labels.strokeShape_fixed"),
+              icon: StrokeShapeFixedIcon,
+              testId: "strokeShape-fixed",
+            },
+          ]}
+          value={getFormValue(
+            elements,
+            app,
+            (element) =>
+              getFreeDrawStrokeShape(element as ExcalidrawFreeDrawElement),
+            isFreeDrawElement,
+            (hasSelection) =>
+              hasSelection ? null : getFreeDrawStrokeShape(appState),
+          )}
+          onChange={(value) => updateData(value)}
+        />
+      </div>
+    </fieldset>
+  ),
+});
+
 export const actionChangeSloppiness = register<ExcalidrawElement["roughness"]>({
   name: "changeSloppiness",
   label: "labels.sloppiness",

packages/excalidraw/actions/actionStyles.ts

@@ -1,4 +1,5 @@
 import {
+  DEFAULT_FREE_DRAW_STROKE_SHAPE,
   DEFAULT_FONT_SIZE,
   DEFAULT_FONT_FAMILY,
   DEFAULT_TEXT_ALIGN,
@@ -10,6 +11,7 @@ import {
 import { newElementWith } from "@excalidraw/element";
 
 import {
+  isFreeDrawElement,
   hasBoundTextElement,
   canApplyRoundnessTypeToElement,
   getDefaultRoundnessTypeForElement,
@@ -18,6 +20,7 @@ import {
   isExcalidrawElement,
   isTextElement,
 } from "@excalidraw/element";
+import { newFreeDrawElementWithStrokeShape } from "@excalidraw/element";
 
 import {
   getBoundTextElement,
@@ -154,6 +157,17 @@ export const actionPasteStyles = register({
             });
           }
 
+          if (
+            isFreeDrawElement(newElement) &&
+            isFreeDrawElement(elementStylesToCopyFrom)
+          ) {
+            newElement = newFreeDrawElementWithStrokeShape(
+              newElement,
+              elementStylesToCopyFrom.strokeShape ??
+                DEFAULT_FREE_DRAW_STROKE_SHAPE,
+            );
+          }
+
           if (isFrameLikeElement(element)) {
             newElement = newElementWith(newElement, {
               roundness: null,

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

@@ -128,6 +128,7 @@ export const getDefaultAppState = (): Omit<
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
+    boxSelectionMode: "contain",
   };
 };
 
@@ -171,6 +172,7 @@ const APP_STATE_STORAGE_CONF = (<
   currentItemStrokeColor: { browser: true, export: false, server: false },
   currentItemStrokeStyle: { browser: true, export: false, server: false },
   currentItemStrokeWidth: { browser: true, export: false, server: false },
+  currentItemStrokeShape: { browser: true, export: false, server: false },
   currentItemTextAlign: { browser: true, export: false, server: false },
   currentHoveredFontFamily: { browser: false, export: false, server: false },
   cursorButton: { browser: true, export: false, server: false },
@@ -193,6 +195,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/Actions.tsx

@@ -394,6 +394,11 @@ const CombinedShapeProperties = ({
                   hasStrokeWidth(element.type),
                 )) &&
                 renderAction("changeStrokeWidth")}
+              {(appState.activeTool.type === "freedraw" ||
+                targetElements.some(
+                  (element) => element.type === "freedraw",
+                )) &&
+                renderAction("changeStrokeShape")}
               {(hasStrokeStyle(appState.activeTool.type) ||
                 targetElements.some((element) =>
                   hasStrokeStyle(element.type),

packages/excalidraw/components/App.tsx

@@ -9,6 +9,7 @@ import {
   clamp,
   pointFrom,
   pointDistance,
+  round,
   vector,
   pointRotateRads,
   vectorFromPoint,
@@ -27,6 +28,7 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
+  DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -118,6 +120,7 @@ import {
   getElementAbsoluteCoords,
   bindOrUnbindBindingElements,
   fixBindingsAfterDeletion,
+  getFixedFreeDrawPointAction,
   getHoveredElementForBinding,
   isBindingEnabled,
   updateBoundElements,
@@ -614,6 +617,19 @@ const gesture: Gesture = {
   initialScale: null,
 };
 
+const FREEDRAW_POINT_DECIMALS = 2;
+const FREEDRAW_PRESSURE_DECIMALS = 3;
+const FREEDRAW_DOT_EPSILON = 1 / 10 ** FREEDRAW_POINT_DECIMALS;
+
+const roundFreeDrawCoordinate = (value: number) =>
+  round(value, FREEDRAW_POINT_DECIMALS);
+
+const roundFreeDrawPressure = (value: number) =>
+  round(value, FREEDRAW_PRESSURE_DECIMALS);
+
+const getRoundedFreeDrawPoint = (x: number, y: number) =>
+  pointFrom<LocalPoint>(roundFreeDrawCoordinate(x), roundFreeDrawCoordinate(y));
+
 class App extends React.Component<AppProps, AppState> {
   canvas: AppClassProperties["canvas"];
   interactiveCanvas: AppClassProperties["interactiveCanvas"] = null;
@@ -2524,6 +2540,7 @@ class App extends React.Component<AppProps, AppState> {
     const magicFrameChildren = getElementsOverlappingFrame(
       this.scene.getNonDeletedElements(),
       magicFrame,
+      this.scene.getNonDeletedElementsMap(),
     ).filter((el) => !isMagicFrameElement(el));
 
     if (!magicFrameChildren.length) {
@@ -5725,13 +5742,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
@@ -6995,27 +7012,23 @@ class App extends React.Component<AppProps, AppState> {
           },
           { informMutation: false, isDragging: false },
         );
+        const newLastIdx = multiElement.points.length - 1;
         this.setState({
           selectedLinearElement: {
             ...selectedLinearElement,
-            selectedPointsIndices:
+            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
-              selectedLinearElement.selectedPointsIndices?.includes(
+              ? [
-                multiElement.points.length,
+                  ...new Set(
-              )
+                    selectedLinearElement.selectedPointsIndices.map((idx) =>
-                ? [
+                      Math.min(idx, newLastIdx),
-                    ...selectedLinearElement.selectedPointsIndices.filter(
-                      (idx) =>
-                        idx !== multiElement.points.length &&
-                        idx !== multiElement.points.length - 1,
                     ),
-                    multiElement.points.length - 1,
+                  ),
-                  ]
+                ]
-                : selectedLinearElement.selectedPointsIndices,
+              : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint:
+            lastCommittedPoint: multiElement.points[newLastIdx],
-              multiElement.points[multiElement.points.length - 1],
             initialState: {
               ...selectedLinearElement.initialState,
-              lastClickedPoint: multiElement.points.length - 1,
+              lastClickedPoint: newLastIdx,
             },
           },
         });
@@ -7243,6 +7256,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") {
@@ -7734,17 +7755,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)
@@ -8067,7 +8095,7 @@ class App extends React.Component<AppProps, AppState> {
 
     setCursor(this.interactiveCanvas, CURSOR_TYPE.GRABBING);
     let { clientX: lastX, clientY: lastY } = event;
-    const onPointerMove = withBatchedUpdatesThrottled((event: PointerEvent) => {
+    const onPointerMove = ((event: PointerEvent) => {
       const deltaX = lastX - event.clientX;
       const deltaY = lastY - event.clientY;
       lastX = event.clientX;
@@ -8133,7 +8161,7 @@ class App extends React.Component<AppProps, AppState> {
         window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);
         window.removeEventListener(EVENT.POINTER_UP, teardown);
         window.removeEventListener(EVENT.BLUR, teardown);
-        onPointerMove.flush();
+        // onPointerMove.flush();
       }),
     );
     window.addEventListener(EVENT.BLUR, teardown);
@@ -8243,14 +8271,14 @@ class App extends React.Component<AppProps, AppState> {
     isDraggingScrollBar = true;
     pointerDownState.lastCoords.x = event.clientX;
     pointerDownState.lastCoords.y = event.clientY;
-    const onPointerMove = withBatchedUpdatesThrottled((event: PointerEvent) => {
+    const onPointerMove = (event: PointerEvent) => {
       const target = event.target;
       if (!(target instanceof HTMLElement)) {
         return;
       }
 
       this.handlePointerMoveOverScrollbars(event, pointerDownState);
-    });
+    };
     const onPointerUp = withBatchedUpdates(() => {
       lastPointerUp = null;
       isDraggingScrollBar = false;
@@ -8261,7 +8289,7 @@ class App extends React.Component<AppProps, AppState> {
       this.savePointer(event.clientX, event.clientY, "up");
       window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);
       window.removeEventListener(EVENT.POINTER_UP, onPointerUp);
-      onPointerMove.flush();
+      // onPointerMove.flush();
     });
 
     lastPointerUp = onPointerUp;
@@ -8733,12 +8761,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
     );
   }
 
@@ -8818,10 +8848,13 @@ class App extends React.Component<AppProps, AppState> {
       opacity: this.state.currentItemOpacity,
       roundness: null,
       simulatePressure,
+      strokeShape: this.state.currentItemStrokeShape,
       locked: false,
       frameId: topLayerFrame ? topLayerFrame.id : null,
       points: [pointFrom<LocalPoint>(0, 0)],
-      pressures: simulatePressure ? [] : [event.pressure],
+      pressures: simulatePressure
+        ? []
+        : [roundFreeDrawPressure(event.pressure)],
     });
 
     this.scene.insertElement(element);
@@ -9463,7 +9496,7 @@ class App extends React.Component<AppProps, AppState> {
   private onPointerMoveFromPointerDownHandler(
     pointerDownState: PointerDownState,
   ) {
-    return withBatchedUpdatesThrottled((event: PointerEvent) => {
+    return (event: PointerEvent) => {
       if (this.state.openDialog?.name === "elementLinkSelector") {
         return;
       }
@@ -10159,20 +10192,36 @@ class App extends React.Component<AppProps, AppState> {
           const points = newElement.points;
           const dx = pointerCoords.x - newElement.x;
           const dy = pointerCoords.y - newElement.y;
+          const nextPoint = getRoundedFreeDrawPoint(dx, dy);
+          const pressure = roundFreeDrawPressure(event.pressure);
+          const pointAction =
+            newElement.strokeShape === "fixed"
+              ? getFixedFreeDrawPointAction({
+                  points,
+                  nextPoint,
+                  strokeWidth: newElement.strokeWidth,
+                  zoomValue: this.state.zoom.value,
+                })
+              : points.length > 0 &&
+                points[points.length - 1][0] === nextPoint[0] &&
+                points[points.length - 1][1] === nextPoint[1]
+              ? "discard"
+              : "append";
 
-          const lastPoint = points.length > 0 && points[points.length - 1];
+          if (pointAction !== "discard") {
-          const discardPoint =
-            lastPoint && lastPoint[0] === dx && lastPoint[1] === dy;
-
-          if (!discardPoint) {
             const pressures = newElement.simulatePressure
               ? newElement.pressures
-              : [...newElement.pressures, event.pressure];
+              : pointAction === "replace"
+              ? [...newElement.pressures.slice(0, -1), pressure]
+              : [...newElement.pressures, pressure];
 
             this.scene.mutateElement(
               newElement,
               {
-                points: [...points, pointFrom<LocalPoint>(dx, dy)],
+                points:
+                  pointAction === "replace"
+                    ? [...points.slice(0, -1), nextPoint]
+                    : [...points, nextPoint],
                 pressures,
               },
               {
@@ -10271,6 +10320,7 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
+                this.state.boxSelectionMode,
               )
             : [];
 
@@ -10329,7 +10379,7 @@ class App extends React.Component<AppProps, AppState> {
           });
         }
       }
-    });
+    };
   }
 
   // Returns whether the pointer move happened over either scrollbar
@@ -10374,7 +10424,7 @@ class App extends React.Component<AppProps, AppState> {
       this.removePointer(childEvent);
       pointerDownState.drag.blockDragging = false;
       if (pointerDownState.eventListeners.onMove) {
-        pointerDownState.eventListeners.onMove.flush();
+        // pointerDownState.eventListeners.onMove.flush();
       }
       const {
         newElement,
@@ -10611,23 +10661,48 @@ class App extends React.Component<AppProps, AppState> {
         );
 
         const points = newElement.points;
-        let dx = pointerCoords.x - newElement.x;
+        const dx = pointerCoords.x - newElement.x;
-        let dy = pointerCoords.y - newElement.y;
+        const dy = pointerCoords.y - newElement.y;
+        let nextPoint = getRoundedFreeDrawPoint(dx, dy);
 
         // Allows dots to avoid being flagged as infinitely small
-        if (dx === points[0][0] && dy === points[0][1]) {
+        if (nextPoint[0] === points[0][0] && nextPoint[1] === points[0][1]) {
-          dy += 0.0001;
+          nextPoint = getRoundedFreeDrawPoint(
-          dx += 0.0001;
+            dx + FREEDRAW_DOT_EPSILON,
+            dy + FREEDRAW_DOT_EPSILON,
+          );
         }
 
-        const pressures = newElement.simulatePressure
+        const lastPoint = points[points.length - 1];
-          ? []
+        const pressure = roundFreeDrawPressure(childEvent.pressure);
-          : [...newElement.pressures, childEvent.pressure];
+        const pointAction =
+          newElement.strokeShape === "fixed"
+            ? getFixedFreeDrawPointAction({
+                points,
+                nextPoint,
+                strokeWidth: newElement.strokeWidth,
+                zoomValue: this.state.zoom.value,
+                isFinalPoint: true,
+              })
+            : !lastPoint ||
+              lastPoint[0] !== nextPoint[0] ||
+              lastPoint[1] !== nextPoint[1]
+            ? "append"
+            : "discard";
 
-        this.scene.mutateElement(newElement, {
+        if (pointAction !== "discard") {
-          points: [...points, pointFrom<LocalPoint>(dx, dy)],
+          this.scene.mutateElement(newElement, {
-          pressures,
+            points:
-        });
+              pointAction === "replace"
+                ? [...points.slice(0, -1), nextPoint]
+                : [...points, nextPoint],
+            pressures: newElement.simulatePressure
+              ? []
+              : pointAction === "replace"
+              ? [...newElement.pressures.slice(0, -1), pressure]
+              : [...newElement.pressures, pressure],
+          });
+        }
 
         this.actionManager.executeAction(actionFinalize);
 

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/Stats/stats.test.tsx

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

packages/excalidraw/components/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/icons.tsx

@@ -1164,7 +1164,7 @@ export const StrokeWidthBaseIcon = createIcon(
   modifiedTablerIconProps,
 );
 
-export const StrokeWidthBoldIcon = createIcon(
+export const StrokeWidthMediumIcon = createIcon(
   <path
     d="M5 10h10"
     stroke="currentColor"
@@ -1175,7 +1175,7 @@ export const StrokeWidthBoldIcon = createIcon(
   modifiedTablerIconProps,
 );
 
-export const StrokeWidthExtraBoldIcon = createIcon(
+export const StrokeWidthBoldIcon = createIcon(
   <path
     d="M5 10h10"
     stroke="currentColor"
@@ -1186,6 +1186,48 @@ export const StrokeWidthExtraBoldIcon = createIcon(
   modifiedTablerIconProps,
 );
 
+export const StrokeWidthExtraBoldIcon = createIcon(
+  <path
+    d="M5 10h10"
+    stroke="currentColor"
+    strokeWidth="5"
+    strokeLinecap="round"
+    strokeLinejoin="round"
+  />,
+  modifiedTablerIconProps,
+);
+
+export const StrokeShapeVariableIcon = createIcon(
+  <>
+    <path
+      d="M3.5 12.5c1.8-3.5 4.1-5.2 6.8-5.2 2.4 0 4.4 1.3 6.2 3.9"
+      stroke="currentColor"
+      strokeWidth="1.25"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    />
+    <path
+      d="M7.75 10.8c1-.9 2-1.35 3.05-1.35 1.2 0 2.4.57 3.7 1.72"
+      stroke="currentColor"
+      strokeWidth="2.5"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    />
+  </>,
+  modifiedTablerIconProps,
+);
+
+export const StrokeShapeFixedIcon = createIcon(
+  <path
+    d="M3.5 12h13"
+    stroke="currentColor"
+    strokeWidth="2.5"
+    strokeLinecap="round"
+    strokeLinejoin="round"
+  />,
+  modifiedTablerIconProps,
+);
+
 export const StrokeStyleSolidIcon = React.memo(({ theme }: { theme: Theme }) =>
   createIcon(
     <path

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,39 @@ const PreferencesToggleToolLockItem = () => {
   );
 };
 
+const PreferencesBoxSelectionModeItem = () => {
+  const { t } = useI18n();
+  const appState = useUIAppState();
+  const setAppState = useExcalidrawSetAppState();
+
+  return (
+    <DropdownMenuItemContentRadio<"contain" | "overlap">
+      name="boxSelectionMode"
+      icon={emptyIcon}
+      value={appState.boxSelectionMode}
+      onChange={(value) => {
+        setAppState({
+          boxSelectionMode: 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 +607,7 @@ export const Preferences = ({
       <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
         {children || (
           <>
+            <PreferencesBoxSelectionModeItem />
             <PreferencesToggleToolLockItem />
             <PreferencesToggleSnapModeItem />
             <PreferencesToggleGridModeItem />
@@ -585,6 +625,7 @@ export const Preferences = ({
 };
 
 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
+Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;

packages/excalidraw/data/index.ts

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

packages/excalidraw/data/restore.ts

@@ -96,6 +96,13 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
+const normalizeFreeDrawStrokeShape = (
+  strokeShape: unknown,
+): AppState["currentItemStrokeShape"] =>
+  strokeShape === "fixed" || strokeShape === "stable"
+    ? "fixed"
+    : undefined;
+
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -251,7 +258,9 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(`could not repair binding for element`);
+    console.error(
+      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
+    );
   } catch (error) {
     console.error("Error repairing binding:", error);
   }
@@ -410,10 +419,12 @@ export const restoreElement = (
 
       return element;
     case "freedraw": {
+      const strokeShape = normalizeFreeDrawStrokeShape(element.strokeShape);
       return restoreElementWithProperties(element, {
         points: element.points,
         simulatePressure: element.simulatePressure,
         pressures: element.pressures,
+        ...(strokeShape ? { strokeShape } : {}),
       });
     }
     case "image":
@@ -934,8 +945,24 @@ export const restoreAppState = (
         : defaultValue;
   }
 
+  const boxSelectionMode =
+    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
+  if (boxSelectionMode !== undefined) {
+    nextAppState.boxSelectionMode = boxSelectionMode;
+  }
+
   return {
     ...nextAppState,
+    ...(normalizeFreeDrawStrokeShape(
+      appState.currentItemStrokeShape ?? localAppState?.currentItemStrokeShape,
+    )
+      ? {
+          currentItemStrokeShape: normalizeFreeDrawStrokeShape(
+            appState.currentItemStrokeShape ??
+              localAppState?.currentItemStrokeShape,
+          ),
+        }
+      : {}),
     cursorButton: localAppState?.cursorButton || "up",
     // reset on fresh restore so as to hide the UI button if penMode not active
     penDetected:

packages/excalidraw/index.tsx

@@ -382,6 +382,8 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 
+export { Fonts } from "./fonts/Fonts";
+
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";

packages/excalidraw/locales/en.json

@@ -30,6 +30,9 @@
     "changeBackground": "Change background color",
     "fill": "Fill",
     "strokeWidth": "Stroke width",
+    "strokeShape": "Stroke type",
+    "strokeShape_variable": "Variable",
+    "strokeShape_fixed": "Fixed",
     "strokeStyle": "Stroke style",
     "strokeStyle_solid": "Solid",
     "strokeStyle_dashed": "Dashed",
@@ -185,6 +188,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 +667,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/reactUtils.ts

@@ -11,10 +11,10 @@ export const withBatchedUpdates = <
   TFunction extends ((event: any) => void) | (() => void),
 >(
   func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never,
-) =>
+) => func;
-  ((event) => {
+// ((event) => {
-    unstable_batchedUpdates(func as TFunction, event);
+//   unstable_batchedUpdates(func as TFunction, event);
-  }) as TFunction;
+// }) as TFunction;
 
 /**
  * barches React state updates and throttles the calls to a single call per

packages/excalidraw/renderer/interactiveScene.ts

@@ -1156,6 +1156,7 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
+          elementsMap,
         )
       ) {
         renderSingleLinearPoint(

packages/excalidraw/renderer/staticSvgScene.ts

@@ -376,6 +376,11 @@ const renderElementToSvg = (
     }
     case "freedraw": {
       const wrapper = svgRoot.ownerDocument.createElementNS(SVG_NS, "g");
+      const isFixedStroke = element.strokeShape === "fixed";
+      const strokeColor =
+        renderConfig.theme === THEME.DARK
+          ? applyDarkModeFilter(element.strokeColor)
+          : element.strokeColor;
 
       const shapes = ShapeCache.generateElementShape(element, renderConfig);
       // always ordered as [background, stroke]
@@ -384,12 +389,15 @@ const renderElementToSvg = (
           // stroke (SVGPathString)
 
           const path = svgRoot.ownerDocument.createElementNS(SVG_NS, "path");
-          path.setAttribute(
+          if (isFixedStroke) {
-            "fill",
+            path.setAttribute("fill", "none");
-            renderConfig.theme === THEME.DARK
+            path.setAttribute("stroke", strokeColor);
-              ? applyDarkModeFilter(element.strokeColor)
+            path.setAttribute("stroke-width", `${element.strokeWidth}`);
-              : element.strokeColor,
+            path.setAttribute("stroke-linecap", "round");
-          );
+            path.setAttribute("stroke-linejoin", "round");
+          } else {
+            path.setAttribute("fill", strokeColor);
+          }
           path.setAttribute("d", shape);
           wrapper.appendChild(path);
         } else {

packages/excalidraw/scene/export.ts

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

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

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

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

@@ -13,6 +13,7 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -439,6 +440,7 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -855,6 +857,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1421,6 +1424,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1628,6 +1632,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2012,6 +2017,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2257,6 +2263,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2437,6 +2444,7 @@ exports[`regression tests > can drag element that covers another element, while
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2762,6 +2770,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3017,6 +3026,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3258,6 +3268,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3494,6 +3505,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3752,6 +3764,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4066,6 +4079,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4502,6 +4516,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4785,6 +4800,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5061,6 +5077,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5269,6 +5286,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5469,6 +5487,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5862,6 +5881,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6159,6 +6179,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6947,6 +6968,7 @@ exports[`regression tests > given a group of selected elements with an element t
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7281,6 +7303,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7560,6 +7583,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7795,6 +7819,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8035,6 +8060,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8215,6 +8241,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8395,6 +8422,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8575,6 +8603,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8807,6 +8836,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9037,6 +9067,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9229,6 +9260,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9461,6 +9493,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9641,6 +9674,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9871,6 +9905,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10051,6 +10086,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10243,6 +10279,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10423,6 +10460,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10954,6 +10992,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11234,6 +11273,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11357,6 +11397,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11557,6 +11598,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11876,6 +11918,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12305,6 +12348,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12945,6 +12989,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13071,6 +13116,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13702,6 +13748,7 @@ exports[`regression tests > switches from group of selected elements to another
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14041,6 +14088,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14305,6 +14353,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14428,6 +14477,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14792,6 +14842,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14915,6 +14966,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,

packages/excalidraw/tests/data/restore.test.ts

@@ -160,6 +160,40 @@ describe("restoreElements", () => {
     });
   });
 
+  it("should restore fixed freedraw element correctly", () => {
+    const freedrawElement = API.createElement({
+      type: "freedraw",
+      id: "id-freedraw02",
+      strokeShape: "fixed",
+      points: [pointFrom(0, 0), pointFrom(10, 10)],
+    });
+
+    const restoredFreedraw = restore.restoreElements(
+      [freedrawElement],
+      null,
+    )[0] as ExcalidrawFreeDrawElement;
+
+    expect(restoredFreedraw.strokeShape).toBe("fixed");
+  });
+
+  it("should restore legacy stable freedraw element as fixed", () => {
+    const restoredFreedraw = restore.restoreElements(
+      [
+        {
+          ...API.createElement({
+            type: "freedraw",
+            id: "id-freedraw03",
+            points: [pointFrom(0, 0), pointFrom(10, 10)],
+          }),
+          strokeShape: "stable",
+        } as any,
+      ],
+      null,
+    )[0] as ExcalidrawFreeDrawElement;
+
+    expect(restoredFreedraw.strokeShape).toBe("fixed");
+  });
+
   it("should restore line and draw elements correctly", () => {
     const lineElement = API.createElement({ type: "line", id: "id-line01" });
 
@@ -641,6 +675,26 @@ describe("restoreAppState", () => {
     expect(restoredAppState.name).toBe(stubImportedAppState.name);
   });
 
+  it("should restore fixed freedraw stroke type from app state", () => {
+    const restoredAppState = restore.restoreAppState(
+      { currentItemStrokeShape: "fixed" } as ImportedDataState["appState"],
+      null,
+    );
+
+    expect(restoredAppState.currentItemStrokeShape).toBe("fixed");
+  });
+
+  it("should restore legacy stable freedraw stroke type from app state as fixed", () => {
+    const restoredAppState = restore.restoreAppState(
+      {
+        currentItemStrokeShape: "stable",
+      } as unknown as ImportedDataState["appState"],
+      null,
+    );
+
+    expect(restoredAppState.currentItemStrokeShape).toBe("fixed");
+  });
+
   it("should return local app state when imported data state is null", () => {
     const stubLocalAppState = getDefaultAppState();
     stubLocalAppState.cursorButton = "down";

packages/excalidraw/tests/freedraw.test.tsx

@@ -0,0 +1,78 @@
+import React from "react";
+
+import { Excalidraw } from "../index";
+import { API } from "./helpers/api";
+import { Pointer, UI } from "./helpers/ui";
+import { render } from "./test-utils";
+
+describe("freedraw", () => {
+  beforeEach(async () => {
+    await render(<Excalidraw />);
+  });
+
+  it("rounds stored points and drops duplicates after rounding", () => {
+    const mouse = new Pointer("mouse");
+
+    UI.clickTool("freedraw");
+    mouse.downAt(10, 20);
+    mouse.moveTo(10.1234, 20.5678);
+    mouse.moveTo(10.1249, 20.5681);
+    mouse.upAt(20.9999, 30.0001);
+
+    const freedraw = window.h.elements.at(-1);
+
+    expect(freedraw).toEqual(expect.objectContaining({ type: "freedraw" }));
+    expect((freedraw as any).points).toEqual([
+      [0, 0],
+      [0.12, 0.57],
+      [11, 10],
+    ]);
+  });
+
+  it("does not snap fixed strokes closed when ending near the start point", () => {
+    const mouse = new Pointer("mouse");
+
+    API.setAppState({ currentItemStrokeShape: "fixed" });
+    UI.clickTool("freedraw");
+    mouse.downAt(10, 10);
+    mouse.moveTo(40, 10);
+    mouse.moveTo(30, 30);
+    mouse.upAt(12, 12);
+
+    const freedraw = window.h.elements.at(-1) as any;
+
+    expect(freedraw.points[0]).toEqual([0, 0]);
+    expect(freedraw.points.at(-1)).not.toEqual([0, 0]);
+  });
+
+  it("coalesces nearly straight fixed freedraw points at the tip", () => {
+    const mouse = new Pointer("mouse");
+
+    API.setAppState({ currentItemStrokeShape: "fixed" });
+    UI.clickTool("freedraw");
+    mouse.downAt(10, 10);
+
+    [
+      [10.2, 10.01],
+      [10.4, 10.03],
+      [10.6, 10.02],
+      [10.8, 10.04],
+      [11, 10.03],
+      [11.2, 10.05],
+      [11.4, 10.04],
+      [11.6, 10.06],
+      [11.8, 10.05],
+    ].forEach(([x, y]) => {
+      mouse.moveTo(x, y);
+    });
+    mouse.upAt(12, 10.05);
+
+    const freedraw = window.h.elements.at(-1) as any;
+
+    expect(freedraw.points.length).toBeLessThan(5);
+    expect(freedraw.points).toEqual([
+      [0, 0],
+      [2, 0.05],
+    ]);
+  });
+});

packages/excalidraw/tests/helpers/api.ts

@@ -201,6 +201,9 @@ export class API {
       ? ExcalidrawTextElement["containerId"]
       : never;
     points?: T extends "arrow" | "line" | "freedraw" ? readonly LocalPoint[] : never;
+    strokeShape?: T extends "freedraw"
+      ? ExcalidrawFreeDrawElement["strokeShape"]
+      : never;
     locked?: boolean;
     fileId?: T extends "image" ? string : never;
     scale?: T extends "image" ? ExcalidrawImageElement["scale"] : never;
@@ -318,6 +321,7 @@ export class API {
           type: type as "freedraw",
           simulatePressure: true,
           points: rest.points,
+          strokeShape: rest.strokeShape ?? appState.currentItemStrokeShape,
           ...base,
         });
         break;

packages/excalidraw/tests/helpers/ui.ts

@@ -28,6 +28,7 @@ import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
 import type { TransformHandleType } from "@excalidraw/element";
 import type {
   ExcalidrawElement,
+  ExcalidrawFreeDrawElement,
   ExcalidrawLinearElement,
   ExcalidrawTextElement,
   ExcalidrawArrowElement,
@@ -432,8 +433,10 @@ type DrawingToolName = Exclude<
   "lock" | "selection" | "eraser" | "lasso"
 >;
 
-type Element<T extends DrawingToolName> = T extends "line" | "freedraw"
+type Element<T extends DrawingToolName> = T extends "line"
   ? ExcalidrawLinearElement
+  : T extends "freedraw"
+  ? ExcalidrawFreeDrawElement
   : T extends "arrow"
   ? ExcalidrawArrowElement
   : T extends "text"

packages/excalidraw/tests/history.test.tsx

@@ -314,7 +314,7 @@ describe("history", () => {
         expect.objectContaining({ id: rect2.id, isDeleted: true }),
       ]);
 
-      mouse.downAt(0, 0);
+      mouse.downAt(-10, -10);
       mouse.moveTo(25, 25);
       mouse.moveTo(50, 50);
       mouse.upAt(50, 50);
@@ -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/regressionTests.test.tsx

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

packages/excalidraw/tests/selection.test.tsx

@@ -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 - 1);
+    expect(outlineY1).toBeGreaterThan(boundsY1 - 1);
+    expect(outlineX2).toBeLessThan(boundsX2 + 1);
+    expect(outlineY2).toBeLessThan(boundsY2 + 1);
+
+    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

@@ -33,6 +33,7 @@ import type {
   ExcalidrawNonSelectionElement,
   BindMode,
   ExcalidrawTextElement,
+  FreeDrawStrokeShape,
 } from "@excalidraw/element/types";
 
 import type {
@@ -269,6 +270,8 @@ export type ObservedElementsAppState = {
   activeLockedId: AppState["activeLockedId"];
 };
 
+export type BoxSelectionMode = "contain" | "overlap";
+
 export interface AppState {
   contextMenu: {
     items: ContextMenuItems;
@@ -307,6 +310,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 */
@@ -354,6 +359,7 @@ export interface AppState {
   currentItemFillStyle: ExcalidrawElement["fillStyle"];
   currentItemStrokeWidth: number;
   currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
+  currentItemStrokeShape?: FreeDrawStrokeShape;
   currentItemRoughness: number;
   currentItemOpacity: number;
   currentItemFontFamily: FontFamilyValues;
@@ -884,7 +890,7 @@ export type PointerDownState = Readonly<{
   // We need to have these in the state so that we can unsubscribe them
   eventListeners: {
     // It's defined on the initial pointer down event
-    onMove: null | ReturnType<typeof throttleRAF>;
+    onMove: null | ((event: PointerEvent) => void);
     // It's defined on the initial pointer down event
     onUp: null | ((event: PointerEvent) => void);
     // It's defined on the initial pointer down event

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

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

packages/math/src/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/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/tests/__snapshots__/export.test.ts.snap

@@ -13,6 +13,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,

scripts/woff2/woff2-vite-plugins.js

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

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.0":
+"@excalidraw/mermaid-to-excalidraw@2.2.2":
-  version "2.1.0"
+  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.0.tgz#a5b9cf87c3185558cda7f9687d87b9937f452358"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.2.2.tgz#ee6b597a0d95b9a76f7ae41ce0e3733a9b96e4a0"
-  integrity sha512-RMd+c2b7WzzUjhERMpKwp8PhF2/XlHDjr/zK+Gxfp8K9sVlafPYJ5OEa/GkN6edi2rBUXRfW+41WdO6L56b6Kw==
+  integrity sha512-5VKQq5CdRocC82vOIUpQ5ufJOVV9FpBTdHGA+ULqazeIVV+cr299877omQCibsdS3Bpitz2fsnTwnIXEmLVDSg==
   dependencies:
     "@excalidraw/markdown-to-text" "0.1.2"
     "@mermaid-js/parser" "^0.6.3"