debuggs

.codesandbox/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24-bullseye
+FROM node:18-bullseye
 
 # Vite wants to open the browser using `open`, so we
 # need to install those utils.

.github/workflows/cancel.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: styfle/cancel-workflow-action@ce177499ccf9fd2aded3b0426c97e5434c2e8a73 # 0.6.0
+      - uses: styfle/cancel-workflow-action@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@1b35a6dcd84d81aa0bc1889610efdcde7f37b0c0 # v1.0.1
+        uses: kt3k/update-pr-description@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@465a07811f14bebb1938fbed4728c6a1ff8901fc # v2
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
+        uses: docker/setup-buildx-action@v3
       - name: Build and push
-        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true

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

@@ -6,97 +6,11 @@ on:
       - opened
       - edited
       - synchronize
-      - labeled
-      - unlabeled
 
 jobs:
   semantic:
     runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
     steps:
-      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
+      - uses: amannn/action-semantic-pull-request@v5
-        with:
-          requireScope: true
-          scopes: |
-            app
-            editor
-            packages/excalidraw
-            packages/utils
-            docker
-            repo
-          ignoreLabels: |
-            skip-semantic-title
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  label-scope:
-    needs: semantic
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-    steps:
-      - name: Label scoped PR
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_TITLE: ${{ github.event.pull_request.title }}
-          REPOSITORY: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-
-          scope_labels=(s-app s-editor s-package)
-
-          readarray -t desired_labels < <(
-            node <<'NODE'
-          const title = process.env.PR_TITLE;
-          const match = title.match(/^[a-z]+(?:\(([^)]+)\))?!?:/i);
-          const scopes = match?.[1]?.split(",").map((scope) => scope.trim()) ?? [];
-          const labels = new Set();
-
-          for (const scope of scopes) {
-            if (scope === "app") {
-              labels.add("s-app");
-            } else if (scope === "editor") {
-              labels.add("s-editor");
-            } else if (scope.startsWith("packages/")) {
-              labels.add("s-package");
-            }
-          }
-
-          process.stdout.write([...labels].join("\n"));
-          NODE
-          )
-
-          should_apply_label() {
-            local label="$1"
-
-            for desired_label in "${desired_labels[@]}"; do
-              if [[ "$desired_label" == "$label" ]]; then
-                return 0
-              fi
-            done
-
-            return 1
-          }
-
-          for label in "${scope_labels[@]}"; do
-            if ! should_apply_label "$label"; then
-              gh api \
-                --method DELETE \
-                "repos/${REPOSITORY}/issues/${PR_NUMBER}/labels/${label}" \
-                --silent 2>/dev/null || true
-            fi
-          done
-
-          for label in "${desired_labels[@]}"; do
-            if ! gh api \
-              --method POST \
-              "repos/${REPOSITORY}/issues/${PR_NUMBER}/labels" \
-              --field "labels[]=${label}" \
-              --silent; then
-              echo "::warning::Could not apply ${label}. The workflow token likely does not have issues:write permission for this PR."
-            fi
-          done

.github/workflows/size-limit.yml

@@ -20,7 +20,7 @@ jobs:
         working-directory: packages/excalidraw
         env:
           CI: true
-      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
+      - uses: andresz1/size-limit-action@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@2500dafcee7dd64f85ab689c0b83798a8359770e # v2
+        uses: davelosert/vitest-coverage-report-action@v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=${BUILDPLATFORM} node:24 AS build
+FROM --platform=${BUILDPLATFORM} node:18 AS build
 
 WORKDIR /opt/node_app
 
@@ -13,7 +13,7 @@ ARG NODE_ENV=production
 
 RUN npm_config_target_arch=${TARGETARCH} yarn build:app:docker
 
-FROM nginx:1.27-alpine
+FROM --platform=${TARGETPLATFORM} nginx:1.27-alpine
 
 COPY --from=build /opt/node_app/excalidraw-app/build /usr/share/nginx/html
 

README.md

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

dev-docs/docs/@excalidraw/excalidraw/api/excalidraw-element-skeleton.mdx

@@ -172,7 +172,7 @@ convertToExcalidrawElements([
     type: "arrow",
     x: 450,
     y: 20,
-    startArrowhead: "circle",
+    startArrowhead: "dot",
     endArrowhead: "triangle",
     strokeColor: "#1971c2",
     strokeWidth: 2,

dev-docs/docusaurus.config.js

@@ -97,8 +97,8 @@ const config = {
                 href: "https://discord.gg/UexuTaE",
               },
               {
-                label: "𝕏",
+                label: "Twitter",
-                href: "https://x.com/excalidraw",
+                href: "https://twitter.com/excalidraw",
               },
               {
                 label: "Linkedin",

examples/with-script-in-browser/initialData.tsx

@@ -1,4 +1,4 @@
-import type { ExcalidrawElementSkeleton } from "@excalidraw/excalidraw/element/transform";
+import type { ExcalidrawElementSkeleton } from "@excalidraw/excalidraw/data/transform";
 import type { FileId } from "@excalidraw/excalidraw/element/types";
 
 const elements: ExcalidrawElementSkeleton[] = [

excalidraw-app/data/LocalData.ts

@@ -26,6 +26,7 @@ import {
   get,
 } from "idb-keyval";
 
+import { appJotaiStore, atom } from "excalidraw-app/app-jotai";
 import { getNonDeletedElements } from "@excalidraw/element";
 
 import type { LibraryPersistedData } from "@excalidraw/excalidraw/data/library";
@@ -38,7 +39,6 @@ import type {
 } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "@excalidraw/common/utility-types";
 
-import { appJotaiStore, atom } from "../app-jotai";
 import { SAVE_TO_LOCAL_STORAGE_TIMEOUT, STORAGE_KEYS } from "../app_constants";
 
 import { FileManager } from "./FileManager";

excalidraw-app/vite.config.mts

@@ -75,13 +75,6 @@ export default defineConfig(({ mode }) => {
           find: /^@excalidraw\/utils\/(.*?)/,
           replacement: path.resolve(__dirname, "../packages/utils/src/$1"),
         },
-        {
-          find: /^@excalidraw\/fractional-indexing$/,
-          replacement: path.resolve(
-            __dirname,
-            "../packages/fractional-indexing/src/index.ts",
-          ),
-        },
       ],
     },
     build: {

package.json

@@ -56,8 +56,7 @@
     "build:element": "yarn --cwd ./packages/element build:esm",
     "build:excalidraw": "yarn --cwd ./packages/excalidraw build:esm",
     "build:math": "yarn --cwd ./packages/math build:esm",
-    "build:fractional-indexing": "yarn --cwd ./packages/fractional-indexing build:esm",
+    "build:packages": "yarn build:common && yarn build:math && yarn build:element && yarn build:excalidraw",
-    "build:packages": "yarn build:common && yarn build:fractional-indexing && yarn build:math && yarn build:element && yarn build:excalidraw",
     "build:version": "yarn --cwd ./excalidraw-app build:version",
     "build": "yarn --cwd ./excalidraw-app build",
     "build:preview": "yarn --cwd ./excalidraw-app build:preview",

packages/element/package.json

@@ -64,7 +64,6 @@
   },
   "dependencies": {
     "@excalidraw/common": "0.18.0",
-    "@excalidraw/math": "0.18.0",
+    "@excalidraw/math": "0.18.0"
-    "@excalidraw/fractional-indexing": "3.3.0"
   }
 }

packages/element/src/Scene.ts

@@ -338,18 +338,27 @@ export class Scene {
     this.callbacks.clear();
   }
 
-  /** low-level - generally use app.insertNewElements() */
+  insertElementAtIndex(element: ExcalidrawElement, index: number) {
-  insertElementsAtIndex(
+    if (!Number.isFinite(index) || index < 0) {
-    elements: ExcalidrawElement[],
+      throw new Error(
-    /** null indicates end of the array */
+        "insertElementAtIndex can only be called with index >= 0",
-    index: number | null,
+      );
-  ) {
-    if (!elements.length) {
-      return;
     }
 
-    if (index === null) {
+    const nextElements = [
-      index = this.elements.length;
+      ...this.elements.slice(0, index),
+      element,
+      ...this.elements.slice(index),
+    ];
+
+    syncMovedIndices(nextElements, arrayToMap([element]));
+
+    this.replaceAllElements(nextElements);
+  }
+
+  insertElementsAtIndex(elements: ExcalidrawElement[], index: number) {
+    if (!elements.length) {
+      return;
     }
 
     if (!Number.isFinite(index) || index < 0) {
@@ -369,9 +378,24 @@ export class Scene {
     this.replaceAllElements(nextElements);
   }
 
-  /** low-level - generally use app.insertNewElement() */
   insertElement = (element: ExcalidrawElement) => {
-    this.insertElementsAtIndex([element], null);
+    const index = element.frameId
+      ? this.getElementIndex(element.frameId)
+      : this.elements.length;
+
+    this.insertElementAtIndex(element, index);
+  };
+
+  insertElements = (elements: ExcalidrawElement[]) => {
+    if (!elements.length) {
+      return;
+    }
+
+    const index = elements[0]?.frameId
+      ? this.getElementIndex(elements[0].frameId)
+      : this.elements.length;
+
+    this.insertElementsAtIndex(elements, index);
   };
 
   getElementIndex(elementId: string) {

packages/element/src/arrowheads.ts

@@ -1,32 +0,0 @@
-import type { Arrowhead, AnyArrowhead } from "./types";
-
-export const normalizeArrowhead = (
-  arrowhead: AnyArrowhead | null | undefined,
-): Arrowhead | null => {
-  switch (arrowhead) {
-    case undefined:
-    case null:
-      return null;
-    case "dot":
-      return "circle";
-    case "crowfoot_one":
-      return "cardinality_one";
-    case "crowfoot_many":
-      return "cardinality_many";
-    case "crowfoot_one_or_many":
-      return "cardinality_one_or_many";
-    default:
-      return arrowhead;
-  }
-};
-
-export const getArrowheadForPicker = (
-  arrowhead: AnyArrowhead | null | undefined,
-): Arrowhead | null => {
-  const normalizedArrowhead = normalizeArrowhead(arrowhead);
-  if (normalizedArrowhead === null) {
-    return null;
-  }
-
-  return normalizedArrowhead;
-};

packages/element/src/binding.ts

@@ -734,11 +734,12 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
     });
 
   // Handle outside-outside binding to the same element
-  if (
+  if (otherBinding && otherBinding.elementId === hit?.id) {
-    otherBinding &&
+    invariant(
-    otherBinding.elementId === hit?.id &&
+      !opts?.newArrow || appState.selectedLinearElement?.initialState.origin,
-    (!opts?.newArrow || appState.selectedLinearElement?.initialState.origin)
+      "appState.selectedLinearElement.initialState.origin must be defined for new arrows",
-  ) {
+    );
+
     return {
       start: {
         mode: "inside",
@@ -1942,9 +1943,9 @@ export const calculateFixedPointForElbowArrowBinding = (
   return {
     fixedPoint: normalizeFixedPoint([
       (nonRotatedSnappedGlobalPoint[0] - hoveredElement.x) /
-        Math.max(hoveredElement.width, PRECISION),
+        hoveredElement.width,
       (nonRotatedSnappedGlobalPoint[1] - hoveredElement.y) /
-        Math.max(hoveredElement.height, PRECISION),
+        hoveredElement.height,
     ]),
   };
 };
@@ -1975,11 +1976,9 @@ export const calculateFixedPointForNonElbowArrowBinding = (
 
   // Calculate the ratio relative to the element's bounds
   const fixedPointX =
-    (nonRotatedPoint[0] - hoveredElement.x) /
+    (nonRotatedPoint[0] - hoveredElement.x) / hoveredElement.width;
-    Math.max(hoveredElement.width, PRECISION);
   const fixedPointY =
-    (nonRotatedPoint[1] - hoveredElement.y) /
+    (nonRotatedPoint[1] - hoveredElement.y) / hoveredElement.height;
-    Math.max(hoveredElement.height, PRECISION);
 
   return {
     fixedPoint: normalizeFixedPoint([fixedPointX, fixedPointY]),

packages/element/src/bounds.ts

@@ -680,9 +680,8 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
+export const getBoundsFromPoints = (
-  points: readonly P[],
+  points: ExcalidrawFreeDrawElement["points"],
-  padding: number = 0,
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -696,7 +695,7 @@ export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
     maxY = Math.max(maxY, y);
   }
 
-  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
+  return [minX, minY, maxX, maxY];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -710,9 +709,6 @@ const getFreeDrawElementAbsoluteCoords = (
   return [x1, y1, x2, y2, (x1 + x2) / 2, (y1 + y2) / 2];
 };
 
-const CARDINALITY_MARKER_SIZE = 20;
-const CROWFOOT_ARROWHEAD_SIZE = 15;
-
 /** @returns number in pixels */
 export const getArrowheadSize = (arrowhead: Arrowhead): number => {
   switch (arrowhead) {
@@ -721,14 +717,10 @@ export const getArrowheadSize = (arrowhead: Arrowhead): number => {
     case "diamond":
     case "diamond_outline":
       return 12;
-    case "cardinality_many":
+    case "crowfoot_many":
-    case "cardinality_one_or_many":
+    case "crowfoot_one":
-    case "cardinality_zero_or_many":
+    case "crowfoot_one_or_many":
-      return CROWFOOT_ARROWHEAD_SIZE;
+      return 20;
-    case "cardinality_one":
-    case "cardinality_exactly_one":
-    case "cardinality_zero_or_one":
-      return CARDINALITY_MARKER_SIZE;
     default:
       return 15;
   }
@@ -751,12 +743,7 @@ export const getArrowheadPoints = (
   shape: Drawable[],
   position: "start" | "end",
   arrowhead: Arrowhead,
-  offsetMultiplier = 0,
 ) => {
-  if (arrowhead === null) {
-    return null;
-  }
-
   if (shape.length < 1) {
     return null;
   }
@@ -837,30 +824,29 @@ export const getArrowheadPoints = (
   const lengthMultiplier =
     arrowhead === "diamond" || arrowhead === "diamond_outline" ? 0.25 : 0.5;
   const minSize = Math.min(size, length * lengthMultiplier);
-  const tx = x2 - nx * minSize * offsetMultiplier;
+  const xs = x2 - nx * minSize;
-  const ty = y2 - ny * minSize * offsetMultiplier;
+  const ys = y2 - ny * minSize;
-  const xs = tx - nx * minSize;
-  const ys = ty - ny * minSize;
 
-  if (arrowhead === "circle" || arrowhead === "circle_outline") {
+  if (
-    const diameter = Math.hypot(ys - ty, xs - tx) + element.strokeWidth - 2;
+    arrowhead === "dot" ||
-    return [tx, ty, diameter];
+    arrowhead === "circle" ||
+    arrowhead === "circle_outline"
+  ) {
+    const diameter = Math.hypot(ys - y2, xs - x2) + element.strokeWidth - 2;
+    return [x2, y2, diameter];
   }
 
   const angle = getArrowheadAngle(arrowhead);
 
-  if (
+  if (arrowhead === "crowfoot_many" || arrowhead === "crowfoot_one_or_many") {
-    arrowhead === "cardinality_many" ||
-    arrowhead === "cardinality_one_or_many"
-  ) {
     // swap (xs, ys) with (x2, y2)
     const [x3, y3] = pointRotateRads(
-      pointFrom(tx, ty),
+      pointFrom(x2, y2),
       pointFrom(xs, ys),
       degreesToRadians(-angle as Degrees),
     );
     const [x4, y4] = pointRotateRads(
-      pointFrom(tx, ty),
+      pointFrom(x2, y2),
       pointFrom(xs, ys),
       degreesToRadians(angle),
     );
@@ -870,12 +856,12 @@ export const getArrowheadPoints = (
   // Return points
   const [x3, y3] = pointRotateRads(
     pointFrom(xs, ys),
-    pointFrom(tx, ty),
+    pointFrom(x2, y2),
     ((-angle * Math.PI) / 180) as Radians,
   );
   const [x4, y4] = pointRotateRads(
     pointFrom(xs, ys),
-    pointFrom(tx, ty),
+    pointFrom(x2, y2),
     degreesToRadians(angle),
   );
 
@@ -888,9 +874,9 @@ export const getArrowheadPoints = (
       const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];
 
       [ox, oy] = pointRotateRads(
-        pointFrom(tx + minSize * 2, ty),
+        pointFrom(x2 + minSize * 2, y2),
-        pointFrom(tx, ty),
+        pointFrom(x2, y2),
-        Math.atan2(py - ty, px - tx) as Radians,
+        Math.atan2(py - y2, px - x2) as Radians,
       );
     } else {
       const [px, py] =
@@ -899,16 +885,16 @@ export const getArrowheadPoints = (
           : [0, 0];
 
       [ox, oy] = pointRotateRads(
-        pointFrom(tx - minSize * 2, ty),
+        pointFrom(x2 - minSize * 2, y2),
-        pointFrom(tx, ty),
+        pointFrom(x2, y2),
-        Math.atan2(ty - py, tx - px) as Radians,
+        Math.atan2(y2 - py, x2 - px) as Radians,
       );
     }
 
-    return [tx, ty, x3, y3, ox, oy, x4, y4];
+    return [x2, y2, x3, y3, ox, oy, x4, y4];
   }
 
-  return [tx, ty, x3, y3, x4, y4];
+  return [x2, y2, x3, y3, x4, y4];
 };
 
 // TODO reuse shape.ts
@@ -1262,17 +1248,6 @@ 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,
@@ -1287,21 +1262,13 @@ 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) || isFreeDrawElement(element)) {
+  if (isLinearElement(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

@@ -61,8 +61,6 @@ import { distanceToElement } from "./distance";
 
 import { getBindingGap } from "./binding";
 
-import { hasBackground } from "./comparisons";
-
 import type {
   ElementsMap,
   ExcalidrawArrowElement,
@@ -85,7 +83,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   const isDraggableFromInside =
-    (hasBackground(element.type) && !isTransparent(element.backgroundColor)) ||
+    !isTransparent(element.backgroundColor) ||
     hasBoundTextElement(element) ||
     isIframeLikeElement(element) ||
     isTextElement(element);
@@ -156,11 +154,14 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointInRotatedBounds(
+  const hitBounds = isPointWithinBounds(
-    point,
+    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
-    bounds,
+    pointRotateRads(
-    element.angle,
+      point,
-    threshold,
+      getCenterForBounds(bounds),
+      -element.angle as Radians,
+    ),
+    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -191,32 +192,18 @@ 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,
 ) => {
-  const bounds = getElementBounds(element, elementsMap, true);
+  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
-  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
+  x1 -= tolerance;
+  y1 -= tolerance;
+  x2 += tolerance;
+  y2 += tolerance;
+  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -326,10 +313,7 @@ export const getAllHoveredElementAtPoint = (
     ) {
       candidateElements.push(element);
 
-      if (
+      if (!isTransparent(element.backgroundColor)) {
-        hasBackground(element.type) &&
-        !isTransparent(element.backgroundColor)
-      ) {
         break;
       }
     }
@@ -359,18 +343,12 @@ export const getHoveredElementForBinding = (
     return candidateElements[0];
   }
 
-  // Prefer closer shapes
+  // Prefer smaller shapes
   return candidateElements
     .sort(
-      (a, b) =>
+      (a, b) => b.width ** 2 + b.height ** 2 - (a.width ** 2 + a.height ** 2),
-        (isPointInElement(point, a, elementsMap)
-          ? Infinity
-          : distanceToElement(a, elementsMap, point)) -
-        (isPointInElement(point, b, elementsMap)
-          ? Infinity
-          : distanceToElement(b, elementsMap, point)),
     )
-    .shift() as NonDeleted<ExcalidrawBindableElement>;
+    .pop() as NonDeleted<ExcalidrawBindableElement>;
 };
 
 export const getHoveredElementForFocusPoint = (
@@ -487,12 +465,7 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
   }
 };
 
@@ -559,15 +532,11 @@ 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(
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-    element,
-    elementsMap,
-  );
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {
@@ -595,9 +564,7 @@ const intersectLinearOrFreeDrawWithLineSegment = (
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment, {
+    const hits = curveIntersectLineSegment(c, segment);
-      iterLimit: 10,
-    });
 
     if (hits.length > 0) {
       intersections.push(...hits);

packages/element/src/distance.ts

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

packages/element/src/duplicate.ts

@@ -111,9 +111,6 @@ export const duplicateElements = (
          * user interaction.
          */
         type: "everything";
-        // TODO remove/review this once we add frame children order migration
-        // and invariant checks
-        preserveFrameChildrenOrder?: boolean;
       }
     | {
         /**
@@ -173,8 +170,6 @@ export const duplicateElements = (
     opts.type === "in-place"
       ? opts.idsOfElementsToDuplicate
       : new Map(elements.map((el) => [el.id, el]));
-  const preserveFrameChildrenOrder =
-    opts.type === "everything" && opts.preserveFrameChildrenOrder;
 
   // For sanity
   if (opts.type === "in-place") {
@@ -255,9 +250,6 @@ export const duplicateElements = (
     elementsWithDuplicates.splice(index + 1, 0, ...castArray(elements));
   };
 
-  // main
-  // ---------------------------------------------------------------------------
-
   const frameIdsToDuplicate = new Set(
     elements
       .filter(
@@ -282,7 +274,7 @@ export const duplicateElements = (
     if (groupId) {
       const groupElements = getElementsInGroup(elements, groupId).flatMap(
         (element) =>
-          isFrameLikeElement(element) && !preserveFrameChildrenOrder
+          isFrameLikeElement(element)
             ? [...getFrameChildren(elements, element.id), element]
             : [element],
       );
@@ -298,25 +290,13 @@ export const duplicateElements = (
     // frame duplication
     // -------------------------------------------------------------------------
 
-    if (
+    if (element.frameId && frameIdsToDuplicate.has(element.frameId)) {
-      !preserveFrameChildrenOrder &&
-      element.frameId &&
-      frameIdsToDuplicate.has(element.frameId)
-    ) {
       continue;
     }
 
     if (isFrameLikeElement(element)) {
       const frameId = element.id;
 
-      if (preserveFrameChildrenOrder) {
-        insertBeforeOrAfterIndex(
-          findLastIndex(elementsWithDuplicates, (el) => el.id === frameId),
-          copyElements(element),
-        );
-        continue;
-      }
-
       const frameChildren = getFrameChildren(elements, frameId);
 
       const targetIndex = findLastIndex(elementsWithDuplicates, (el) => {

packages/element/src/elbowArrow.ts

@@ -2124,8 +2124,8 @@ const normalizeArrowElementUpdate = (
     offsetY < -MAX_POS ||
     offsetY > MAX_POS ||
     offsetX + points[points.length - 1][0] < -MAX_POS ||
-    offsetX + points[points.length - 1][0] > MAX_POS ||
+    offsetY + points[points.length - 1][0] > MAX_POS ||
-    offsetY + points[points.length - 1][1] < -MAX_POS ||
+    offsetX + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(

packages/element/src/fractionalIndex.ts

@@ -1,9 +1,6 @@
-import { arrayToMap } from "@excalidraw/common";
+import { generateNKeysBetween } from "fractional-indexing";
 
-import {
+import { arrayToMap } from "@excalidraw/common";
-  validateOrderKey,
-  generateNKeysBetween,
-} from "@excalidraw/fractional-indexing";
 
 import { mutateElement, newElementWith } from "./mutateElement";
 import { getBoundTextElement } from "./textElement";
@@ -385,13 +382,6 @@ const isValidFractionalIndex = (
     return false;
   }
 
-  try {
-    // Format validation
-    validateOrderKey(index);
-  } catch {
-    return false;
-  }
-
   if (predecessor && successor) {
     return predecessor < index && index < successor;
   }

packages/element/src/frame.ts

@@ -1,6 +1,7 @@
 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,
@@ -17,13 +18,9 @@ import {
   getElementLineSegments,
   getCommonBounds,
   getElementAbsoluteCoords,
-  doBoundsIntersect,
-  getElementBounds,
-  boundsContainBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
-import { syncMovedIndices } from "./fractionalIndex";
 import {
   isFrameElement,
   isFrameLikeElement,
@@ -103,9 +100,8 @@ export const isElementContainingFrame = (
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
 ) => {
-  return boundsContainBounds(
+  return getElementsWithinSelection([frame], element, elementsMap).some(
-    getElementBounds(element, elementsMap),
+    (e) => e.id === frame.id,
-    getElementBounds(frame, elementsMap),
   );
 };
 
@@ -492,44 +488,10 @@ export const filterElementsEligibleAsFrameChildren = (
   return eligibleElements;
 };
 
-export const getCommonFrameId = (elements: readonly ExcalidrawElement[]) => {
-  let commonFrameId: ExcalidrawElement["frameId"] | undefined;
-
-  for (const element of elements) {
-    if (isFrameLikeElement(element) || !element.frameId) {
-      return null;
-    }
-
-    if (commonFrameId === undefined) {
-      commonFrameId = element.frameId;
-    } else if (commonFrameId !== element.frameId) {
-      return null;
-    }
-  }
-
-  return commonFrameId ?? null;
-};
-
-export const getFrameChildrenInsertionIndex = (
-  elements: readonly ExcalidrawElement[],
-  frameId: ExcalidrawFrameLikeElement["id"],
-): number | null => {
-  for (let index = elements.length - 1; index >= 0; index--) {
-    const element = elements[index];
-
-    if (element.id === frameId) {
-      return index;
-    } else if (element.frameId === frameId) {
-      return index + 1;
-    }
-  }
-
-  return null;
-};
-
 /**
- * Adds elements and their bound elements to frame. Reorders added elements to
+ * Retains (or repairs for target frame) the ordering invriant where children
- * be just below frame, or just above its highest child (whichever is higher).
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
  *
  * @returns mutated allElements (same data structure)
  */
@@ -537,11 +499,19 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   allElements: T,
   elementsToAdd: NonDeletedExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  appState: AppState,
 ): T => {
   const elementsMap = arrayToMap(allElements);
-  const commonFrameId = getCommonFrameId(elementsToAdd);
+  const currTargetFrameChildrenMap = new Map<ExcalidrawElement["id"], true>();
+  for (const element of allElements.values()) {
+    if (element.frameId === frame.id) {
+      currTargetFrameChildrenMap.set(element.id, true);
+    }
+  }
 
-  const finalElementsToAdd = new Set<ExcalidrawElement>();
+  const suppliedElementsToAddSet = new Set(elementsToAdd.map((el) => el.id));
+
+  const finalElementsToAdd: ExcalidrawElement[] = [];
 
   const otherFrames = new Set<ExcalidrawFrameLikeElement["id"]>();
 
@@ -552,8 +522,7 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   }
 
   // - add bound text elements if not already in the array
-  // - keep elements already in the frame so mixed selections can be reordered
+  // - filter out elements that are already in the frame
-  //   together
   for (const element of omitGroupsContainingFrameLikes(
     allElements,
     elementsToAdd,
@@ -566,68 +535,38 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
       continue;
     }
 
-    if (element.frameId && element.frameId !== frame.id) {
+    // if the element is already in another frame (which is also in elementsToAdd),
+    // it means that frame and children are selected at the same time
+    // => keep original frame membership, do not add to the target frame
+    if (
+      element.frameId &&
+      appState.selectedElementIds[element.id] &&
+      appState.selectedElementIds[element.frameId]
+    ) {
       continue;
     }
 
-    finalElementsToAdd.add(element);
+    if (!currTargetFrameChildrenMap.has(element.id)) {
+      finalElementsToAdd.push(element);
+    }
 
     const boundTextElement = getBoundTextElement(element, elementsMap);
-    if (boundTextElement && !finalElementsToAdd.has(boundTextElement)) {
+    if (
-      finalElementsToAdd.add(boundTextElement);
+      boundTextElement &&
+      !suppliedElementsToAddSet.has(boundTextElement.id) &&
+      !currTargetFrameChildrenMap.has(boundTextElement.id)
+    ) {
+      finalElementsToAdd.push(boundTextElement);
     }
   }
 
   for (const element of finalElementsToAdd) {
-    // we don't always need to update the element if it's already in the frame,
+    mutateElement(element, elementsMap, {
-    // but we still need to accumulate in finalElementsToAdd so we potentially
+      frameId: frame.id,
-    // reorder them if added together
+    });
-    if (element.frameId !== frame.id) {
-      mutateElement(element, elementsMap, {
-        frameId: frame.id,
-      });
-    }
   }
 
-  // (re)order elements to be just below the frame,
+  return allElements;
-  // or just above the highest child if that is higher
-  // (latter case is denormalized order until we migrate)
-  // ---------------------------------------------------------------------------
-
-  if (
-    !finalElementsToAdd.size ||
-    // if all elements to add already belong to the frame, then we don't want to
-    // reorder (case: we're dragging element children within the frame)
-    commonFrameId === frame.id
-  ) {
-    return allElements;
-  }
-
-  const otherElements = Array.from(allElements.values()).filter(
-    (element) => !finalElementsToAdd.has(element),
-  );
-  const insertionIndex = getFrameChildrenInsertionIndex(
-    otherElements,
-    frame.id,
-  );
-
-  if (insertionIndex === null) {
-    return allElements;
-  }
-
-  const reorderedElements = [
-    ...otherElements.slice(0, insertionIndex),
-    ...finalElementsToAdd,
-    ...otherElements.slice(insertionIndex),
-  ];
-
-  syncMovedIndices(reorderedElements, arrayToMap([...finalElementsToAdd]));
-
-  return (
-    Array.isArray(allElements)
-      ? reorderedElements
-      : new Map(reorderedElements.map((element) => [element.id, element]))
-  ) as T;
 };
 
 export const removeElementsFromFrame = (
@@ -681,11 +620,13 @@ export const replaceAllElementsInFrame = <T extends ExcalidrawElement>(
   allElements: readonly T[],
   nextElementsInFrame: ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  app: AppClassProperties,
 ): T[] => {
   return addElementsToFrame(
     removeAllElementsFromFrame(allElements, frame),
     nextElementsInFrame,
     frame,
+    app.state,
   ).slice();
 };
 
@@ -979,17 +920,16 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
 ) => {
-  return elements.filter(
+  return (
-    (el) =>
+    elementsOverlappingBBox({
-      // exclude elements which are overlapping, but are in a different frame,
+      elements,
+      bounds: frame,
+      type: "overlap",
+    })
+      // removes elements who are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      (!el.frameId || el.frameId === frame.id) &&
+      .filter((el) => !el.frameId || el.frameId === frame.id)
-      doBoundsIntersect(
-        getElementBounds(el, elementsMap),
-        getElementBounds(frame, elementsMap),
-      ),
   );
 };
 

packages/element/src/index.ts

@@ -99,4 +99,3 @@ export * from "./typeChecks";
 export * from "./utils";
 export * from "./zindex";
 export * from "./arrows/helpers";
-export * from "./arrowheads";

packages/element/src/linearElementEditor.ts

@@ -476,22 +476,16 @@ export class LinearElementEditor {
       });
     }
 
-    if (
+    invariant(
-      lastClickedPoint < 0 ||
+      lastClickedPoint > -1 &&
-      !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(
-      console.error(
+        selectedPointsIndices,
-        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+      )}) points(0..${
-          selectedPointsIndices,
+        element.points.length - 1
-        )}) points(0..${
+      }) lastClickedPoint(${lastClickedPoint})`,
-          element.points.length - 1
+    );
-        }) lastClickedPoint(${lastClickedPoint}) isElbowArrow: ${elbowed}`,
-      );
-
-      // 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];
@@ -800,7 +794,6 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
-          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -810,7 +803,6 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -898,7 +890,6 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
-    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -913,10 +904,7 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-        element,
-        elementsMap,
-      );
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -936,7 +924,6 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
-    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -949,10 +936,7 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-      element,
-      elementsMap,
-    );
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1867,7 +1851,6 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2139,13 +2122,13 @@ const pointDraggingUpdates = (
 } => {
   const naiveDraggingPoints = new Map(
     selectedPointsIndices.map((pointIndex) => {
-      // NOTE: Avoid stale point index issue potentially caused by elbow
-      // arrows unpredictably changing the number of points during dragging
-      const point = element.points[pointIndex] ?? element.points.at(-1);
       return [
         pointIndex,
         {
-          point: pointFrom<LocalPoint>(point[0] + deltaX, point[1] + deltaY),
+          point: pointFrom<LocalPoint>(
+            element.points[pointIndex][0] + deltaX,
+            element.points[pointIndex][1] + deltaY,
+          ),
           isDragging: true,
         },
       ];
@@ -2417,7 +2400,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        nextArrow,
+        element,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2448,7 +2431,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          nextArrow,
+          element,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/selection.ts

@@ -1,34 +1,16 @@
-import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual } from "@excalidraw/common";
-import {
-  lineSegment,
-  pointFrom,
-  pointRotateRads,
-  type GlobalPoint,
-} from "@excalidraw/math";
 
 import type {
   AppState,
-  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import {
+import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
-  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";
 import {
   elementOverlapsWithFrame,
@@ -38,33 +20,14 @@ import {
 
 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
@@ -84,286 +47,68 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return excludeElementsFromFrames(selectedElements, framesInSelection);
+  return selectedElements.filter((element) => {
+    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",
+) => {
-): NonDeletedExcalidrawElement[] => {
+  const [selectionX1, selectionY1, selectionX2, selectionY2] =
-  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),
-    ),
-  ];
 
-  const framesInSelection = excludeElementsInFrames
+  let elementsInSelection = elements.filter((element) => {
-    ? new Set<NonDeletedExcalidrawElement["id"]>()
+    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
-    : null;
+      element,
-  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
+      elementsMap,
-  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
+    );
 
-  for (const element of elements) {
+    const containingFrame = getContainingFrame(element, elementsMap);
-    if (shouldIgnoreElementFromSelection(element)) {
+    if (containingFrame) {
-      continue;
+      const [fx1, fy1, fx2, fy2] = getElementBounds(
-    }
+        containingFrame,
-
-    // Track only selectable top-level group members, so ignored elements such
-    // as bound text and locked elements don't affect group selection.
-    const groupId = element.groupIds.at(-1);
-    if (groupId) {
-      if (!groups[groupId]) {
-        groups[groupId] = [];
-      }
-      groups[groupId].push(element);
-    }
-
-    const strokeWidth = element.strokeWidth;
-    let labelAABB: Bounds | null = null;
-    let elementAABB = getElementBounds(element, elementsMap);
-
-    elementAABB = [
-      elementAABB[0] - strokeWidth / 2,
-      elementAABB[1] - strokeWidth / 2,
-      elementAABB[2] + strokeWidth / 2,
-      elementAABB[3] + strokeWidth / 2,
-    ] as Bounds;
-
-    // Whether the element bounds should include the bound text element bounds
-    const boundTextElement =
-      isArrowElement(element) && getBoundTextElement(element, elementsMap);
-    if (boundTextElement) {
-      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
-        element,
-        boundTextElement,
         elementsMap,
       );
-      labelAABB = [
+
-        x,
+      elementX1 = Math.max(fx1, elementX1);
-        y,
+      elementY1 = Math.max(fy1, elementY1);
-        x + boundTextElement.width,
+      elementX2 = Math.min(fx2, elementX2);
-        y + boundTextElement.height,
+      elementY2 = Math.min(fy2, elementY2);
-      ] as Bounds;
     }
 
-    // Clip element bounds by its containing frame (if any), since only the
+    return (
-    // visible (frame-clipped) portion of the element is relevant for selection.
+      element.locked === false &&
-    const associatedFrame = getContainingFrame(element, elementsMap);
+      element.type !== "selection" &&
-    if (
+      !isBoundToContainer(element) &&
-      associatedFrame &&
+      selectionX1 <= elementX1 &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
+      selectionY1 <= elementY1 &&
-    ) {
+      selectionX2 >= elementX2 &&
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
+      selectionY2 >= elementY2
-      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
+  elementsInSelection = excludeElementsInFrames
-        ? ([
+    ? excludeElementsInFramesFromSelection(elementsInSelection)
-            Math.max(labelAABB[0], frameAABB[0]),
+    : elementsInSelection;
-            Math.max(labelAABB[1], frameAABB[1]),
+
-            Math.min(labelAABB[2], frameAABB[2]),
+  elementsInSelection = elementsInSelection.filter((element) => {
-            Math.min(labelAABB[3], frameAABB[3]),
+    const containingFrame = getContainingFrame(element, elementsMap);
-          ] as Bounds)
+
-        : null;
+    if (containingFrame) {
+      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
     }
 
-    const commonAABB = labelAABB
+    return true;
-      ? ([
+  });
-          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 ==============
+  return elementsInSelection;
-
-    // 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);
-      }
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 2. Handle the case where the label is overlapped by the selection box
-    if (
-      boxSelectionMode === "overlap" &&
-      labelAABB &&
-      doBoundsIntersect(selectionBounds, labelAABB)
-    ) {
-      elementsInSelection.add(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.add(element);
-        continue;
-      }
-    }
-
-    // 4. We don't need to handle when the selection is inside the element
-    //    as it is separately handled in App.
-  }
-
-  if (framesInSelection) {
-    elementsInSelection.forEach((element) => {
-      if (element.frameId && framesInSelection.has(element.frameId)) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  if (boxSelectionMode === "overlap") {
-    Array.from(elementsInSelection).forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
-    });
-  } else if (boxSelectionMode === "contain") {
-    elementsInSelection.forEach((element) => {
-      // note: currently we only support top-level group handling since
-      // we don't support box selecting while editing the group/subgroup
-      // see https://github.com/excalidraw/excalidraw/pull/11234#issuecomment-4387654451
-      const groupId = element.groupIds.at(-1);
-
-      const group = groupId ? groups[groupId] : null;
-
-      if (
-        group &&
-        !group.every((groupElement) => elementsInSelection.has(groupElement))
-      ) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  // to maintain original order elements (namely for group selection)
-  return elements.filter((element) => elementsInSelection.has(element));
 };
 
 export const getVisibleAndNonSelectedElements = (
@@ -543,19 +288,3 @@ export const getSelectionStateForElements = (
     ),
   };
 };
-
-/**
- * Returns editing or single-selected text element, if any.
- */
-export const getActiveTextElement = (
-  selectedElements: readonly NonDeleted<ExcalidrawElement>[],
-  appState: Pick<AppState, "editingTextElement">,
-) => {
-  const activeTextElement =
-    appState.editingTextElement ||
-    (selectedElements.length === 1 &&
-      isTextElement(selectedElements[0]) &&
-      selectedElements[0]);
-
-  return activeTextElement || null;
-};

packages/element/src/shape.ts

@@ -57,8 +57,8 @@ import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
 import {
-  elementCenterPoint,
   getArrowheadPoints,
+  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -69,10 +69,10 @@ import type {
   NonDeletedExcalidrawElement,
   ExcalidrawSelectionElement,
   ExcalidrawLinearElement,
+  Arrowhead,
   ExcalidrawFreeDrawElement,
   ElementsMap,
   ExcalidrawLineElement,
-  Arrowhead,
 } from "./types";
 
 import type { Drawable, Options } from "roughjs/bin/core";
@@ -296,82 +296,6 @@ const modifyIframeLikeForRoughOptions = (
   return element;
 };
 
-const generateArrowheadCardinalityOne = (
-  generator: RoughGenerator,
-  arrowheadPoints: number[] | null,
-  lineOptions: Options,
-) => {
-  if (arrowheadPoints === null) {
-    return [];
-  }
-
-  const [, , x3, y3, x4, y4] = arrowheadPoints;
-
-  return [generator.line(x3, y3, x4, y4, lineOptions)];
-};
-
-const generateArrowheadLinesToTip = (
-  generator: RoughGenerator,
-  arrowheadPoints: number[] | null,
-  lineOptions: Options,
-) => {
-  if (arrowheadPoints === null) {
-    return [];
-  }
-
-  const [x2, y2, x3, y3, x4, y4] = arrowheadPoints;
-
-  return [
-    generator.line(x3, y3, x2, y2, lineOptions),
-    generator.line(x4, y4, x2, y2, lineOptions),
-  ];
-};
-
-const getArrowheadLineOptions = (
-  element: ExcalidrawLinearElement,
-  options: Options,
-) => {
-  const lineOptions = { ...options };
-
-  if (element.strokeStyle === "dotted") {
-    // for dotted arrows caps, reduce gap to make it more legible
-    const dash = getDashArrayDotted(element.strokeWidth - 1);
-    lineOptions.strokeLineDash = [dash[0], dash[1] - 1];
-  } else {
-    // for solid/dashed, keep solid arrow cap
-    delete lineOptions.strokeLineDash;
-  }
-  lineOptions.roughness = Math.min(1, lineOptions.roughness || 0);
-
-  return lineOptions;
-};
-
-const generateArrowheadOutlineCircle = (
-  generator: RoughGenerator,
-  options: Options,
-  strokeColor: string,
-  arrowheadPoints: number[] | null,
-  fill: string,
-  diameterScale = 1,
-) => {
-  if (arrowheadPoints === null) {
-    return [];
-  }
-
-  const [x, y, diameter] = arrowheadPoints;
-  const circleOptions = {
-    ...options,
-    fill,
-    fillStyle: "solid" as const,
-    stroke: strokeColor,
-    roughness: Math.min(0.5, options.roughness || 0),
-  };
-
-  delete circleOptions.strokeLineDash;
-
-  return [generator.circle(x, y, diameter * diameterScale, circleOptions)];
-};
-
 const getArrowheadShapes = (
   element: ExcalidrawLinearElement,
   shape: Drawable[],
@@ -382,54 +306,63 @@ const getArrowheadShapes = (
   canvasBackgroundColor: string,
   isDarkMode: boolean,
 ) => {
-  if (arrowhead === null) {
+  const arrowheadPoints = getArrowheadPoints(
+    element,
+    shape,
+    position,
+    arrowhead,
+  );
+
+  if (arrowheadPoints === null) {
     return [];
   }
 
+  const generateCrowfootOne = (
+    arrowheadPoints: number[] | null,
+    options: Options,
+  ) => {
+    if (arrowheadPoints === null) {
+      return [];
+    }
+
+    const [, , x3, y3, x4, y4] = arrowheadPoints;
+
+    return [generator.line(x3, y3, x4, y4, options)];
+  };
+
   const strokeColor = isDarkMode
     ? applyDarkModeFilter(element.strokeColor)
     : element.strokeColor;
-  const backgroundFillColor = isDarkMode
-    ? applyDarkModeFilter(canvasBackgroundColor)
-    : canvasBackgroundColor;
-  const cardinalityOneOrManyOffset = -0.25;
-  const cardinalityZeroCircleScale = 0.8;
 
   switch (arrowhead) {
+    case "dot":
     case "circle":
     case "circle_outline": {
-      return generateArrowheadOutlineCircle(
+      const [x, y, diameter] = arrowheadPoints;
-        generator,
+
-        options,
+      // always use solid stroke for arrowhead
-        strokeColor,
+      delete options.strokeLineDash;
-        getArrowheadPoints(element, shape, position, arrowhead),
+
-        arrowhead === "circle_outline" ? backgroundFillColor : strokeColor,
+      return [
-      );
+        generator.circle(x, y, diameter, {
+          ...options,
+          fill:
+            arrowhead === "circle_outline"
+              ? canvasBackgroundColor
+              : strokeColor,
+
+          fillStyle: "solid",
+          stroke: strokeColor,
+          roughness: Math.min(0.5, options.roughness || 0),
+        }),
+      ];
     }
     case "triangle":
     case "triangle_outline": {
-      const arrowheadPoints = getArrowheadPoints(
-        element,
-        shape,
-        position,
-        arrowhead,
-      );
-
-      if (arrowheadPoints === null) {
-        return [];
-      }
-
       const [x, y, x2, y2, x3, y3] = arrowheadPoints;
-      const triangleOptions = {
-        ...options,
-        fill:
-          arrowhead === "triangle_outline" ? backgroundFillColor : strokeColor,
-        fillStyle: "solid" as const,
-        roughness: Math.min(1, options.roughness || 0),
-      };
 
       // always use solid stroke for arrowhead
-      delete triangleOptions.strokeLineDash;
+      delete options.strokeLineDash;
 
       return [
         generator.polygon(
@@ -439,34 +372,24 @@ const getArrowheadShapes = (
             [x3, y3],
             [x, y],
           ],
-          triangleOptions,
+          {
+            ...options,
+            fill:
+              arrowhead === "triangle_outline"
+                ? canvasBackgroundColor
+                : strokeColor,
+            fillStyle: "solid",
+            roughness: Math.min(1, options.roughness || 0),
+          },
         ),
       ];
     }
     case "diamond":
     case "diamond_outline": {
-      const arrowheadPoints = getArrowheadPoints(
-        element,
-        shape,
-        position,
-        arrowhead,
-      );
-
-      if (arrowheadPoints === null) {
-        return [];
-      }
-
       const [x, y, x2, y2, x3, y3, x4, y4] = arrowheadPoints;
-      const diamondOptions = {
-        ...options,
-        fill:
-          arrowhead === "diamond_outline" ? backgroundFillColor : strokeColor,
-        fillStyle: "solid" as const,
-        roughness: Math.min(1, options.roughness || 0),
-      };
 
       // always use solid stroke for arrowhead
-      delete diamondOptions.strokeLineDash;
+      delete options.strokeLineDash;
 
       return [
         generator.polygon(
@@ -477,117 +400,53 @@ const getArrowheadShapes = (
             [x4, y4],
             [x, y],
           ],
-          diamondOptions,
+          {
-        ),
+            ...options,
-      ];
+            fill:
-    }
+              arrowhead === "diamond_outline"
-    case "cardinality_one":
+                ? canvasBackgroundColor
-      return generateArrowheadCardinalityOne(
+                : strokeColor,
-        generator,
+            fillStyle: "solid",
-        getArrowheadPoints(element, shape, position, arrowhead),
+            roughness: Math.min(1, options.roughness || 0),
-        getArrowheadLineOptions(element, options),
+          },
-      );
-    case "cardinality_many":
-      return generateArrowheadLinesToTip(
-        generator,
-        getArrowheadPoints(element, shape, position, arrowhead),
-        getArrowheadLineOptions(element, options),
-      );
-    case "cardinality_one_or_many": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadLinesToTip(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_many"),
-          lineOptions,
-        ),
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(
-            element,
-            shape,
-            position,
-            "cardinality_one",
-            cardinalityOneOrManyOffset,
-          ),
-          lineOptions,
-        ),
-      ];
-    }
-    case "cardinality_exactly_one": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_one", -0.5),
-          lineOptions,
-        ),
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_one"),
-          lineOptions,
-        ),
-      ];
-    }
-    case "cardinality_zero_or_one": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadOutlineCircle(
-          generator,
-          options,
-          strokeColor,
-          getArrowheadPoints(element, shape, position, "circle_outline", 1.5),
-          backgroundFillColor,
-          cardinalityZeroCircleScale,
-        ),
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_one", -0.5),
-          lineOptions,
-        ),
-      ];
-    }
-    case "cardinality_zero_or_many": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadLinesToTip(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_many"),
-          lineOptions,
-        ),
-        ...generateArrowheadOutlineCircle(
-          generator,
-          options,
-          strokeColor,
-          getArrowheadPoints(element, shape, position, "circle_outline", 1.5),
-          backgroundFillColor,
-          cardinalityZeroCircleScale,
         ),
       ];
     }
+    case "crowfoot_one":
+      return generateCrowfootOne(arrowheadPoints, options);
     case "bar":
     case "arrow":
+    case "crowfoot_many":
+    case "crowfoot_one_or_many":
     default: {
-      return generateArrowheadLinesToTip(
+      const [x2, y2, x3, y3, x4, y4] = arrowheadPoints;
-        generator,
+
-        getArrowheadPoints(element, shape, position, arrowhead),
+      if (element.strokeStyle === "dotted") {
-        getArrowheadLineOptions(element, options),
+        // for dotted arrows caps, reduce gap to make it more legible
-      );
+        const dash = getDashArrayDotted(element.strokeWidth - 1);
+        options.strokeLineDash = [dash[0], dash[1] - 1];
+      } else {
+        // for solid/dashed, keep solid arrow cap
+        delete options.strokeLineDash;
+      }
+      options.roughness = Math.min(1, options.roughness || 0);
+      return [
+        generator.line(x3, y3, x2, y2, options),
+        generator.line(x4, y4, x2, y2, options),
+        ...(arrowhead === "crowfoot_one_or_many"
+          ? generateCrowfootOne(
+              getArrowheadPoints(element, shape, position, "crowfoot_one"),
+              options,
+            )
+          : []),
+      ];
     }
   }
 };
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
+) => {
-): {
-  op: string;
-  data: number[];
-}[] => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -596,7 +455,20 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = elementCenterPoint(element, elementsMap);
+  const center = getCenterForBounds(
+    // 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":

packages/element/src/sortElements.ts

@@ -1,56 +1,59 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMapWithIndex } from "@excalidraw/common";
 
 import type { ExcalidrawElement } from "./types";
 
-const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
+const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
-  const groupIdAtLevel = (element: ExcalidrawElement, level: number) => {
+  const origElements: ExcalidrawElement[] = elements.slice();
-    return element.groupIds[element.groupIds.length - level - 1];
+  const sortedElements = new Set<ExcalidrawElement>();
-  };
 
-  const orderLevel = (
+  const orderInnerGroups = (
-    levelElements: readonly ExcalidrawElement[],
+    elements: readonly ExcalidrawElement[],
-    level: number,
   ): ExcalidrawElement[] => {
-    const buckets = new Map<string, ExcalidrawElement[]>();
+    const firstGroupSig = elements[0]?.groupIds?.join("");
-    // Slots preserve first-occurrence order: a groupId reserves its slot
+    const aGroup: ExcalidrawElement[] = [elements[0]];
-    // the first time one of its members is seen; loose elements occupy
+    const bGroup: ExcalidrawElement[] = [];
-    // their own slot. Groups are then expanded (and recursed into) in place.
+    for (const element of elements.slice(1)) {
-    const slots: (ExcalidrawElement | string)[] = [];
+      if (element.groupIds?.join("") === firstGroupSig) {
-
+        aGroup.push(element);
-    for (const element of levelElements) {
+      } else {
-      const groupId = groupIdAtLevel(element, level);
+        bGroup.push(element);
-      if (groupId === undefined) {
-        slots.push(element);
-        continue;
       }
-      let bucket = buckets.get(groupId);
-      if (!bucket) {
-        bucket = [];
-        buckets.set(groupId, bucket);
-        slots.push(groupId);
-      }
-      bucket.push(element);
     }
-
+    return bGroup.length ? [...aGroup, ...orderInnerGroups(bGroup)] : aGroup;
-    return slots.flatMap((slot) =>
-      typeof slot === "string"
-        ? orderLevel(buckets.get(slot)!, level + 1)
-        : [slot],
-    );
   };
 
-  // `groupIds` is stored innermost-first, so the outermost group is the
+  const groupHandledElements = new Map<string, true>();
-  // last entry. We recurse from level 0 (outermost) inward.
+
-  const sortedElements = orderLevel(elements, 0);
+  origElements.forEach((element, idx) => {
+    if (groupHandledElements.has(element.id)) {
+      return;
+    }
+    if (element.groupIds?.length) {
+      const topGroup = element.groupIds[element.groupIds.length - 1];
+      const groupElements = origElements.slice(idx).filter((element) => {
+        const ret = element?.groupIds?.some((id) => id === topGroup);
+        if (ret) {
+          groupHandledElements.set(element!.id, true);
+        }
+        return ret;
+      });
+
+      for (const elem of orderInnerGroups(groupElements)) {
+        sortedElements.add(elem);
+      }
+    } else {
+      sortedElements.add(element);
+    }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
-  if (sortedElements.length !== elements.length) {
+  if (sortedElements.size !== elements.length) {
-    console.error("defragmentGroups: lost some elements... bailing!");
+    console.error("normalizeGroupElementOrder: lost some elements... bailing!");
     return elements;
   }
 
-  return sortedElements;
+  return [...sortedElements];
 };
 
 /**
@@ -65,40 +68,39 @@ const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
 const normalizeBoundElementsOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  const elementsMap = arrayToMap(elements);
+  const elementsMap = arrayToMapWithIndex(elements);
 
+  const origElements: (ExcalidrawElement | null)[] = elements.slice();
   const sortedElements = new Set<ExcalidrawElement>();
 
-  for (const element of elements) {
+  origElements.forEach((element, idx) => {
-    if (sortedElements.has(element)) {
+    if (!element) {
-      continue;
+      return;
     }
-
     if (element.boundElements?.length) {
       sortedElements.add(element);
-      for (const boundElement of element.boundElements) {
+      origElements[idx] = null;
+      element.boundElements.forEach((boundElement) => {
         const child = elementsMap.get(boundElement.id);
         if (child && boundElement.type === "text") {
-          sortedElements.add(child);
+          sortedElements.add(child[0]);
+          origElements[child[1]] = null;
         }
+      });
+    } else if (element.type === "text" && element.containerId) {
+      const parent = elementsMap.get(element.containerId);
+      if (!parent?.[0].boundElements?.find((x) => x.id === element.id)) {
+        sortedElements.add(element);
+        origElements[idx] = null;
+
+        // if element has a container and container lists it, skip this element
+        // as it'll be taken care of by the container
       }
-      continue;
+    } else {
+      sortedElements.add(element);
+      origElements[idx] = null;
     }
-
+  });
-    // if element has a container and container lists it, skip this element
-    // as it'll be taken care of by the container
-    if (
-      element.type === "text" &&
-      element.containerId &&
-      elementsMap
-        .get(element.containerId)
-        ?.boundElements?.some((el) => el.id === element.id)
-    ) {
-      continue;
-    }
-
-    sortedElements.add(element);
-  }
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
@@ -115,5 +117,5 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(defragmentGroups(elements));
+  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
 };

packages/element/src/textElement.ts

@@ -347,7 +347,6 @@ export const getContainerCenter = (
     midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
       container,
       index + 1,
-      elementsMap,
     );
   }
   return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };
@@ -442,8 +441,7 @@ const VALID_CONTAINER_TYPES = new Set([
 
 export const isValidTextContainer = (element: {
   type: ExcalidrawElementType;
-}): element is ExcalidrawTextContainer =>
+}) => VALID_CONTAINER_TYPES.has(element.type);
-  VALID_CONTAINER_TYPES.has(element.type);
 
 export const computeContainerDimensionForBoundText = (
   dimension: number,

packages/element/src/textWrapping.ts

@@ -4,22 +4,6 @@ import { charWidth, getLineWidth } from "./textMeasurements";
 
 import type { FontString } from "./types";
 
-/**
- * This module approximates browser-like soft wrapping for Excalidraw text.
- *
- * The flow is:
- * 1. `parseTokens()` splits a hard line into breakable tokens using a unicode-aware regex.
- * 2. `getWrappedTextLines()` reflows each hard line into one or more visual lines and
- *    records where each visual line came from in the source text.
- * 3. `wrapLine()` assembles tokens into lines, and `wrapWord()` handles a single token
- *    that is wider than the available width.
- * 4. `trimLine()` / `trimLineEndAtSoftBreak()` mirror browser behavior around trailing
- *    whitespace so the rendered text stays consistent with what users see on canvas.
- *
- * Mostly, you'll want to use wrapText(). getWrappedTextLines() is for callers
- * that need metadata such as mapping visual lines back to `originalText`
- * for caret placement or future editor features.
- */
 let cachedCjkRegex: RegExp | undefined;
 let cachedLineBreakRegex: RegExp | undefined;
 let cachedEmojiRegex: RegExp | undefined;
@@ -374,10 +358,6 @@ const Break = {
 
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
- *
- * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
- * their composed variants for wrapping. Any code that needs exact source offsets should
- * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export const parseTokens = (line: string) => {
   const breakLineRegex = getLineBreakRegex();
@@ -390,120 +370,56 @@ export const parseTokens = (line: string) => {
 
 /**
  * Wraps the original text into the lines based on the given width.
- *
- * This is a convenience adapter over `getWrappedTextLines()` for call sites
- * that only need the rendered wrapped string and not the source offsets.
  */
 export const wrapText = (
   text: string,
   font: FontString,
   maxWidth: number,
 ): string => {
-  return getWrappedTextLines(text, font, maxWidth)
-    .map((line) => line.text)
-    .join("\n");
-};
-
-/**
- * A single rendered visual line produced from the original text.
- *
- * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
- * not include synthetic soft line breaks inserted by this module. If trailing whitespace
- * was trimmed away at a wrap boundary, `end` points to the last rendered character.
- */
-export type WrappedTextLine = {
-  text: string;
-  start: number;
-  end: number;
-};
-
-/**
- * Splits only on existing hard line breaks and preserves original offsets.
- */
-const getHardLineBreaks = (text: string): WrappedTextLine[] => {
-  let offset = 0;
-
-  return text.split("\n").map((line) => {
-    const start = offset;
-    const end = start + line.length;
-
-    offset = end + 1;
-
-    return {
-      text: line,
-      start,
-      end,
-    };
-  });
-};
-
-/**
- * Returns the rendered visual lines together with their source offsets.
- *
- * This is the source-of-truth wrapping pipeline for callers that need more than the
- * final wrapped string, for example caret placement or future editor/rich-text mapping.
- */
-export const getWrappedTextLines = (
-  text: string,
-  font: FontString,
-  maxWidth: number,
-): WrappedTextLine[] => {
   // if maxWidth is not finite or NaN which can happen in case of bugs in
   // computation, we need to make sure we don't continue as we'll end up
   // in an infinite loop
   if (!Number.isFinite(maxWidth) || maxWidth < 0) {
-    return getHardLineBreaks(text);
+    return text;
   }
 
-  const lines: WrappedTextLine[] = [];
+  const lines: Array<string> = [];
-  let offset = 0;
+  const originalLines = text.split("\n");
 
-  for (const originalLine of text.split("\n")) {
+  for (const originalLine of originalLines) {
-    const originalLineWidth = getLineWidth(originalLine, font);
+    const currentLineWidth = getLineWidth(originalLine, font);
 
-    if (originalLineWidth <= maxWidth) {
+    if (currentLineWidth <= maxWidth) {
-      lines.push({
+      lines.push(originalLine);
-        text: originalLine,
+      continue;
-        start: offset,
-        end: offset + originalLine.length,
-      });
-    } else {
-      lines.push(...wrapLine(originalLine, font, maxWidth, offset));
     }
 
-    offset += originalLine.length + 1;
+    const wrappedLine = wrapLine(originalLine, font, maxWidth);
+    lines.push(...wrappedLine);
   }
 
-  return lines;
+  return lines.join("\n");
 };
 
 /**
- * Wraps a single hard line into one or more visual lines.
+ * Wraps the original line into the lines based on the given width.
- *
- * The line-local offsets are tracked in original-text code units so
- * we can map the visual line back to the source.
  */
 const wrapLine = (
   line: string,
   font: FontString,
   maxWidth: number,
-  lineStart: number,
+): string[] => {
-): WrappedTextLine[] => {
+  const lines: Array<string> = [];
-  const lines: WrappedTextLine[] = [];
   const tokens = parseTokens(line);
+  const tokenIterator = tokens[Symbol.iterator]();
 
   let currentLine = "";
-  let currentLineStart = lineStart;
-  let currentLineEnd = lineStart;
   let currentLineWidth = 0;
-  // Tracks the next token's code-unit position in the original source string.
-  let tokenOffset = lineStart;
-  let tokenIndex = 0;
 
-  while (tokenIndex < tokens.length) {
+  let iterator = tokenIterator.next();
-    const token = tokens[tokenIndex];
+
-    const tokenStart = tokenOffset;
+  while (!iterator.done) {
-    const tokenEnd = tokenStart + token.length;
+    const token = iterator.value;
     const testLine = currentLine + token;
 
     // cache single codepoint whitespace, CJK or emoji width calc. as kerning should not apply here
@@ -513,59 +429,37 @@ const wrapLine = (
 
     // build up the current line, skipping length check for possibly trailing whitespaces
     if (/\s/.test(token) || testLineWidth <= maxWidth) {
-      if (!currentLine) {
-        currentLineStart = tokenStart;
-      }
       currentLine = testLine;
-      currentLineEnd = tokenEnd;
       currentLineWidth = testLineWidth;
-      tokenOffset = tokenEnd;
+      iterator = tokenIterator.next();
-      tokenIndex++;
       continue;
     }
 
     // current line is empty => just the token (word) is longer than `maxWidth` and needs to be wrapped
     if (!currentLine) {
-      const wrappedWord = wrapWord(token, font, maxWidth, tokenStart);
+      const wrappedWord = wrapWord(token, font, maxWidth);
-      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? {
+      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? "";
-        text: "",
-        start: tokenStart,
-        end: tokenStart,
-      };
       const precedingLines = wrappedWord.slice(0, -1);
 
       lines.push(...precedingLines);
 
       // trailing line of the wrapped word might still be joined with next token/s
-      currentLine = trailingLine.text;
+      currentLine = trailingLine;
-      currentLineStart = trailingLine.start;
+      currentLineWidth = getLineWidth(trailingLine, font);
-      currentLineEnd = trailingLine.end;
+      iterator = tokenIterator.next();
-      currentLineWidth = getLineWidth(trailingLine.text, font);
-      tokenOffset = tokenEnd;
-      tokenIndex++;
     } else {
       // push & reset, but don't iterate on the next token, as we didn't use it yet!
-      lines.push(
+      lines.push(currentLine.trimEnd());
-        trimLineEndAtSoftBreak(currentLine, currentLineStart, currentLineEnd),
-      );
 
       // purposefully not iterating and not setting `currentLine` to `token`, so that we could use a simple !currentLine check above
       currentLine = "";
-      currentLineStart = tokenStart;
-      currentLineEnd = tokenStart;
       currentLineWidth = 0;
     }
   }
 
   // iterator done, push the trailing line if exists
   if (currentLine) {
-    const trailingLine = trimLine(
+    const trailingLine = trimLine(currentLine, font, maxWidth);
-      currentLine,
-      currentLineStart,
-      currentLineEnd,
-      font,
-      maxWidth,
-    );
     lines.push(trailingLine);
   }
 
@@ -573,100 +467,59 @@ const wrapLine = (
 };
 
 /**
- * Wraps a single word that could not be placed on an empty line as-is.
+ * Wraps the word into the lines based on the given width.
  */
 const wrapWord = (
   word: string,
   font: FontString,
   maxWidth: number,
-  wordStart: number,
+): Array<string> => {
-): WrappedTextLine[] => {
   // multi-codepoint emojis are already broken apart and shouldn't be broken further
   if (getEmojiRegex().test(word)) {
-    return [
+    return [word];
-      {
-        text: word,
-        start: wordStart,
-        end: wordStart + word.length,
-      },
-    ];
   }
 
   satisfiesWordInvariant(word);
 
-  const lines: WrappedTextLine[] = [];
+  const lines: Array<string> = [];
   const chars = Array.from(word);
 
   let currentLine = "";
-  let currentLineStart = wordStart;
-  let currentLineEnd = wordStart;
   let currentLineWidth = 0;
-  let offset = wordStart;
 
   for (const char of chars) {
-    const charStart = offset;
-    const charEnd = charStart + char.length;
     const _charWidth = charWidth.calculate(char, font);
     const testLineWidth = currentLineWidth + _charWidth;
 
     if (testLineWidth <= maxWidth) {
-      if (!currentLine) {
-        currentLineStart = charStart;
-      }
       currentLine = currentLine + char;
-      currentLineEnd = charEnd;
       currentLineWidth = testLineWidth;
-      offset = charEnd;
       continue;
     }
 
     if (currentLine) {
-      lines.push({
+      lines.push(currentLine);
-        text: currentLine,
-        start: currentLineStart,
-        end: currentLineEnd,
-      });
     }
 
     currentLine = char;
-    currentLineStart = charStart;
-    currentLineEnd = charEnd;
     currentLineWidth = _charWidth;
-    offset = charEnd;
   }
 
   if (currentLine) {
-    lines.push({
+    lines.push(currentLine);
-      text: currentLine,
-      start: currentLineStart,
-      end: currentLineEnd,
-    });
   }
 
   return lines;
 };
 
 /**
- * Trims trailing whitespace that is exceeding the `maxWidth`.
+ * Similarly to browsers, does not trim all trailing whitespaces, but only those exceeding the `maxWidth`.
- *
- * Used for the trailing visual line of a hard line, where some trailing
- * whitespace may still be visible if it fits into the available width.
  */
-const trimLine = (
+const trimLine = (line: string, font: FontString, maxWidth: number) => {
-  line: string,
-  start: number,
-  end: number,
-  font: FontString,
-  maxWidth: number,
-): WrappedTextLine => {
   const shouldTrimWhitespaces = getLineWidth(line, font) > maxWidth;
 
   if (!shouldTrimWhitespaces) {
-    return {
+    return line;
-      text: line,
-      start,
-      end,
-    };
   }
 
   // defensively default to `trimeEnd` in case the regex does not match
@@ -690,30 +543,7 @@ const trimLine = (
     trimmedLineWidth = testLineWidth;
   }
 
-  return {
+  return trimmedLine;
-    text: trimmedLine,
-    start,
-    end: end - (line.length - trimmedLine.length),
-  };
-};
-
-/**
- * Used for internal soft-wrap boundaries, where trailing whitespace should not
- * survive into the rendered line even though it still exists in the original
- * text.
- */
-const trimLineEndAtSoftBreak = (
-  line: string,
-  start: number,
-  end: number,
-): WrappedTextLine => {
-  const trimmedLine = line.trimEnd();
-
-  return {
-    text: trimmedLine,
-    start,
-    end: end - (line.length - trimmedLine.length),
-  };
 };
 
 /**

packages/element/src/typeChecks.ts

@@ -392,23 +392,3 @@ export const canBecomePolygon = (
     (points.length === 3 && !pointsEqual(points[0], points[points.length - 1]))
   );
 };
-
-export const isEligibleFrameChildType = (type: ElementOrToolType) => {
-  switch (type) {
-    case "rectangle":
-    case "diamond":
-    case "ellipse":
-    case "arrow":
-    case "line":
-    case "freedraw":
-    case "text":
-    case "image":
-    case "frame":
-    case "embeddable": {
-      return true;
-    }
-    default: {
-      return false;
-    }
-  }
-};

packages/element/src/types.ts

@@ -303,32 +303,19 @@ export type PointsPositionUpdates = Map<
   { point: LocalPoint; isDragging?: boolean }
 >;
 
-export type CardinalityArrowhead =
-  | "cardinality_one"
-  | "cardinality_many"
-  | "cardinality_one_or_many"
-  | "cardinality_exactly_one"
-  | "cardinality_zero_or_one"
-  | "cardinality_zero_or_many";
-
-export type ArrowheadLegacy =
-  | "dot"
-  | "crowfoot_one"
-  | "crowfoot_many"
-  | "crowfoot_one_or_many";
-
 export type Arrowhead =
   | "arrow"
   | "bar"
+  | "dot" // legacy. Do not use for new elements.
   | "circle"
   | "circle_outline"
   | "triangle"
   | "triangle_outline"
   | "diamond"
   | "diamond_outline"
-  | CardinalityArrowhead;
+  | "crowfoot_one"
-
+  | "crowfoot_many"
-export type AnyArrowhead = Arrowhead | ArrowheadLegacy;
+  | "crowfoot_one_or_many";
 
 export type ExcalidrawLinearElement = _ExcalidrawElementBase &
   Readonly<{

packages/element/src/utils.ts

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

packages/element/tests/collision.test.tsx

@@ -1,4 +1,4 @@
-import { arrayToMap, reseed } from "@excalidraw/common";
+import { arrayToMap } 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,7 +12,6 @@ import { hitElementItself } from "../src/collision";
 describe("check rotated elements can be hit:", () => {
   beforeEach(async () => {
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 
@@ -57,7 +56,6 @@ describe("hitElementItself cache", () => {
     });
 
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 

packages/element/tests/fractionalIndex.test.ts

@@ -1,8 +1,9 @@
 /* eslint-disable no-lone-blocks */
+import { generateKeyBetween } from "fractional-indexing";
+
 import { arrayToMap } from "@excalidraw/common";
 
 import {
-  InvalidFractionalIndexError,
   syncInvalidIndices,
   syncMovedIndices,
   validateFractionalIndices,
@@ -12,34 +13,13 @@ import { deepCopyElement } from "@excalidraw/element";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 
-import {
-  generateKeyBetween,
-  validateOrderKey,
-} from "@excalidraw/fractional-indexing";
-
 import type {
   ElementsMap,
   ExcalidrawElement,
   FractionalIndex,
 } from "@excalidraw/element/types";
 
-describe("fractional index format validation", () => {
+import { InvalidFractionalIndexError } from "../src/fractionalIndex";
-  it("should reject malformed base62 order keys", () => {
-    expect(() => validateOrderKey("a!")).toThrow();
-    expect(() => validateOrderKey("a_")).toThrow();
-    expect(() => validateOrderKey("a1!")).toThrow();
-    expect(() => validateOrderKey("a1_")).toThrow();
-    expect(() => validateOrderKey("zd0032")).toThrow();
-  });
-
-  it("should accept valid base62 order keys", () => {
-    expect(() => validateOrderKey("Zz")).not.toThrow();
-    expect(() => validateOrderKey("a0")).not.toThrow();
-    expect(() => validateOrderKey("a1")).not.toThrow();
-    expect(() => validateOrderKey("a1V")).not.toThrow();
-    expect(() => validateOrderKey("z".padEnd(28, "z"))).not.toThrow();
-  });
-});
 
 describe("sync invalid indices with array order", () => {
   describe("should NOT sync empty array", () => {
@@ -124,46 +104,6 @@ describe("sync invalid indices with array order", () => {
     });
   });
 
-  describe("should sync when fractional index is malformed", () => {
-    // "zd0032" has head "z" which requires length 28 per getIntegerLength,
-    // but the string is far too short, so validateOrderKey throws for it
-    testInvalidIndicesSync({
-      elements: [{ id: "A", index: "zd0032" }],
-      expect: {
-        unchangedElements: [],
-      },
-    });
-
-    testInvalidIndicesSync({
-      elements: [
-        { id: "A", index: "a1" },
-        { id: "B", index: "zd0032" },
-        { id: "C", index: "a3" },
-      ],
-      expect: {
-        unchangedElements: ["A", "C"],
-      },
-    });
-
-    testInvalidIndicesSync({
-      elements: [{ id: "A", index: "a!" }],
-      expect: {
-        unchangedElements: [],
-      },
-    });
-
-    testInvalidIndicesSync({
-      elements: [
-        { id: "A", index: "a1" },
-        { id: "B", index: "a!" },
-        { id: "C", index: "a2" },
-      ],
-      expect: {
-        unchangedElements: ["A", "C"],
-      },
-    });
-  });
-
   describe("should sync when fractional indices are duplicated", () => {
     testInvalidIndicesSync({
       elements: [

packages/element/tests/frame.test.tsx

@@ -2,24 +2,15 @@ import {
   convertToExcalidrawElements,
   Excalidraw,
 } from "@excalidraw/excalidraw";
-import { arrayToMap } from "@excalidraw/common";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
-import { Keyboard, Pointer, UI } from "@excalidraw/excalidraw/tests/helpers/ui";
+import { Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";
-import { getTextEditor } from "@excalidraw/excalidraw/tests/queries/dom";
 import {
   getCloneByOrigId,
   render,
 } from "@excalidraw/excalidraw/tests/test-utils";
 
-import { getSelectedElements } from "@excalidraw/excalidraw/scene";
+import type { ExcalidrawElement } from "../src/types";
-
-import { elementOverlapsWithFrame } from "../src/frame";
-
-import type {
-  ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-} from "../src/types";
 
 const { h } = window;
 const mouse = new Pointer("mouse");
@@ -134,250 +125,6 @@ describe("adding elements to frames", () => {
     });
   });
 
-  it("should treat an element fully containing a frame as overlapping the frame", () => {
-    const containingRect = API.createElement({
-      type: "rectangle",
-      x: -50,
-      y: -50,
-      width: 250,
-      height: 250,
-    });
-
-    API.setElements([containingRect, frame]);
-
-    expect(
-      elementOverlapsWithFrame(
-        containingRect,
-        frame as ExcalidrawFrameLikeElement,
-        arrayToMap(h.elements),
-      ),
-    ).toBe(true);
-  });
-
-  it("should not add a newly created element to a frame behind a non-frame element", () => {
-    const cover = API.createElement({
-      id: "cover",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-    });
-
-    API.setElements([frame, cover]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) => element.id !== frame.id && element.id !== cover.id,
-    );
-
-    expect(createdElement?.frameId).toBe(null);
-    expect(h.elements.map((element) => element.id)).toEqual([
-      frame.id,
-      cover.id,
-      createdElement?.id,
-    ]);
-  });
-
-  it("should add a newly created element to a frame over a non-frame element", () => {
-    const cover = API.createElement({
-      id: "cover",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-    });
-
-    API.setElements([cover, frame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) => element.id !== frame.id && element.id !== cover.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-  });
-
-  it("should highlight the target frame while creating a new element", () => {
-    API.setElements([frame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-
-    expect(h.state.frameToHighlight?.id).toBe(frame.id);
-
-    mouse.upAt(40, 40);
-
-    expect(h.state.frameToHighlight).toBe(null);
-  });
-
-  it("should highlight the target frame while hovering with a creation tool", () => {
-    API.setElements([frame]);
-
-    UI.clickTool("rectangle");
-    mouse.moveTo(20, 20);
-
-    expect(h.state.frameToHighlight?.id).toBe(frame.id);
-
-    mouse.moveTo(200, 200);
-
-    expect(h.state.frameToHighlight).toBe(null);
-  });
-
-  it("should not add grid-snapped text outside the frame to the clicked frame", async () => {
-    const offsetFrame = API.createElement({
-      id: "offsetFrame",
-      type: "frame",
-      x: 10,
-      y: 0,
-      width: 150,
-      height: 150,
-    });
-
-    API.setElements([offsetFrame]);
-    API.setAppState({
-      gridModeEnabled: true,
-    });
-
-    UI.clickTool("text");
-    mouse.clickAt(12, 0);
-
-    await getTextEditor();
-
-    const createdText = h.elements.find(
-      (element) => element.id !== offsetFrame.id,
-    );
-
-    expect(createdText?.x).toBe(0);
-    expect(createdText?.y).toBe(0);
-    expect(createdText?.frameId).toBe(null);
-  });
-
-  it("should add a newly created element to a frame behind another frame", () => {
-    const lockedFrame = API.createElement({
-      id: "lockedFrame",
-      type: "frame",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      locked: true,
-    });
-
-    API.setElements([frame, lockedFrame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) => element.id !== frame.id && element.id !== lockedFrame.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-  });
-
-  it("should insert a newly created frame child just below its frame", () => {
-    const frameChildUnderCursor = API.createElement({
-      id: "frameChildUnderCursor",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-      frameId: frame.id,
-    });
-    const otherFrameChild = API.createElement({
-      id: "otherFrameChild",
-      type: "rectangle",
-      x: 100,
-      y: 20,
-      width: 20,
-      height: 20,
-      frameId: frame.id,
-    });
-
-    API.setElements([frameChildUnderCursor, otherFrameChild, frame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) =>
-        element.id !== frame.id &&
-        element.id !== frameChildUnderCursor.id &&
-        element.id !== otherFrameChild.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-    expect(h.elements.map((element) => element.id)).toEqual([
-      frameChildUnderCursor.id,
-      otherFrameChild.id,
-      createdElement?.id,
-      frame.id,
-    ]);
-  });
-
-  it("should insert a newly created frame child above the highest frame child", () => {
-    const frameChildUnderCursor = API.createElement({
-      id: "frameChildUnderCursor",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-      frameId: frame.id,
-    });
-    const otherFrameChild = API.createElement({
-      id: "otherFrameChild",
-      type: "rectangle",
-      x: 100,
-      y: 20,
-      width: 20,
-      height: 20,
-      frameId: frame.id,
-    });
-
-    API.setElements([frame, frameChildUnderCursor, otherFrameChild]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) =>
-        element.id !== frame.id &&
-        element.id !== frameChildUnderCursor.id &&
-        element.id !== otherFrameChild.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-    expect(h.elements.map((element) => element.id)).toEqual([
-      frame.id,
-      frameChildUnderCursor.id,
-      otherFrameChild.id,
-      createdElement?.id,
-    ]);
-  });
-
   const commonTestCases = async (
     func: typeof resizeFrameOverElement | typeof dragElementIntoFrame,
   ) => {
@@ -668,345 +415,6 @@ describe("adding elements to frames", () => {
   describe("dragging elements into the frame", async () => {
     await commonTestCases(dragElementIntoFrame);
 
-    it("should add a dragged element fully containing the frame", () => {
-      const containingRect = API.createElement({
-        type: "rectangle",
-        x: 220,
-        y: 20,
-        width: 300,
-        height: 300,
-      });
-
-      API.setElements([frame, containingRect]);
-
-      dragElementIntoFrame(frame, containingRect);
-
-      expect(API.getElement(containingRect).frameId).toBe(frame.id);
-    });
-
-    it("should drag an element into a frame", () => {
-      API.setElements([rect2, frame]);
-
-      dragElementIntoFrame(frame, rect2);
-
-      expect(rect2.frameId).toBe(frame.id);
-    });
-
-    it("should layer a dragged element above the highest frame child", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, frameChild, rect2]);
-
-      dragElementIntoFrame(frame, rect2);
-
-      expect(rect2.frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frame.id,
-        frameChild.id,
-        rect2.id,
-      ]);
-      expect(rect2.index! > frameChild.index!).toBe(true);
-      expect(rect2.index! > frame.index!).toBe(true);
-    });
-
-    it("should preview a dragged element above the highest frame child before pointerup", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([rect2, frame, frameChild]);
-      API.setSelectedElements([rect2]);
-      API.updateElement(rect2, {
-        x: 10,
-        y: 10,
-      });
-
-      const getRenderableElementIds = (
-        selectedElementsAreBeingDragged: boolean,
-      ) => {
-        return h.app.renderer
-          .getRenderableElements({
-            zoom: h.state.zoom,
-            offsetLeft: 0,
-            offsetTop: 0,
-            scrollX: 0,
-            scrollY: 0,
-            height: 1000,
-            width: 1000,
-            editingTextElement: h.state.editingTextElement,
-            newElement: h.state.newElement,
-            selectedElements: getSelectedElements(h.elements, h.state),
-            selectedElementsAreBeingDragged,
-            frameToHighlight: frame as ExcalidrawFrameLikeElement,
-          })
-          .visibleElements.map((element) => element.id);
-      };
-
-      expect(h.elements.map((element) => element.id)).toEqual([
-        rect2.id,
-        frame.id,
-        frameChild.id,
-      ]);
-      expect(getRenderableElementIds(false)).toEqual([
-        rect2.id,
-        frame.id,
-        frameChild.id,
-      ]);
-      expect(getRenderableElementIds(true)).toEqual([
-        frame.id,
-        frameChild.id,
-        rect2.id,
-      ]);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        rect2.id,
-        frame.id,
-        frameChild.id,
-      ]);
-      expect(rect2.frameId).toBe(null);
-    });
-
-    it("should not preview reorder dragged elements already in the highlighted frame", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-      const otherFrameChild = API.createElement({
-        id: "otherFrameChild",
-        type: "rectangle",
-        x: 40,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frameChild, frame, otherFrameChild]);
-      API.setSelectedElements([frameChild]);
-
-      const renderableElementIds = h.app.renderer
-        .getRenderableElements({
-          zoom: h.state.zoom,
-          offsetLeft: 0,
-          offsetTop: 0,
-          scrollX: 0,
-          scrollY: 0,
-          height: 1000,
-          width: 1000,
-          editingTextElement: h.state.editingTextElement,
-          newElement: h.state.newElement,
-          selectedElements: getSelectedElements(h.elements, h.state),
-          selectedElementsAreBeingDragged: true,
-          frameToHighlight: frame as ExcalidrawFrameLikeElement,
-        })
-        .visibleElements.map((element) => element.id);
-
-      expect(renderableElementIds).toEqual([
-        frameChild.id,
-        frame.id,
-        otherFrameChild.id,
-      ]);
-    });
-
-    it("should put a dragged mixed selection above the highest frame child", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 50,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-        boundElements: [{ id: "boundText", type: "text" }],
-      });
-      const boundText = API.createElement({
-        id: "boundText",
-        type: "text",
-        x: 50,
-        y: 10,
-        width: 20,
-        height: 20,
-        containerId: frameChild.id,
-        frameId: frame.id,
-      });
-      const otherFrameChild = API.createElement({
-        id: "otherFrameChild",
-        type: "rectangle",
-        x: 80,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-      const nonFrameElement = API.createElement({
-        id: "nonFrameElement",
-        type: "rectangle",
-        x: 155,
-        y: 10,
-        width: 20,
-        height: 20,
-      });
-
-      API.setElements([
-        frame,
-        frameChild,
-        boundText,
-        otherFrameChild,
-        nonFrameElement,
-      ]);
-      API.setSelectedElements([frameChild, nonFrameElement]);
-
-      mouse.downAt(
-        nonFrameElement.x + nonFrameElement.width / 2,
-        nonFrameElement.y + nonFrameElement.height / 2,
-      );
-      mouse.moveTo(frame.x + frame.width - 5, nonFrameElement.y + 10);
-      mouse.up();
-
-      expect(frameChild.frameId).toBe(frame.id);
-      expect(boundText.frameId).toBe(frame.id);
-      expect(nonFrameElement.frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frame.id,
-        otherFrameChild.id,
-        frameChild.id,
-        boundText.id,
-        nonFrameElement.id,
-      ]);
-    });
-
-    it("should not reorder dragged elements already in the highlighted frame", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 50,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-      const otherFrameChild = API.createElement({
-        id: "otherFrameChild",
-        type: "rectangle",
-        x: 80,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, frameChild, otherFrameChild]);
-      API.setSelectedElements([frameChild]);
-
-      mouse.downAt(
-        frameChild.x + frameChild.width / 2,
-        frameChild.y + frameChild.height / 2,
-      );
-      mouse.moveTo(frameChild.x + frameChild.width / 2 + 5, frameChild.y + 10);
-      mouse.up();
-
-      expect(frameChild.frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frame.id,
-        frameChild.id,
-        otherFrameChild.id,
-      ]);
-    });
-
-    it("should not drag an element into a frame behind a non-frame element", () => {
-      const cover = API.createElement({
-        id: "cover",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 80,
-        height: 80,
-        backgroundColor: "#ffc9c9",
-      });
-      API.setElements([frame, cover, rect2]);
-
-      mouse.clickAt(rect2.x, rect2.y);
-      mouse.downAt(rect2.x + rect2.width / 2, rect2.y + rect2.height / 2);
-      mouse.moveTo(20, 20);
-      mouse.upAt(20, 20);
-
-      expect(rect2.frameId).toBe(null);
-    });
-
-    it("should drag an element into a frame over a non-frame element", () => {
-      const cover = API.createElement({
-        id: "cover",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 80,
-        height: 80,
-        backgroundColor: "#ffc9c9",
-      });
-      API.setElements([cover, rect2, frame]);
-
-      mouse.clickAt(rect2.x, rect2.y);
-      mouse.downAt(rect2.x + rect2.width / 2, rect2.y + rect2.height / 2);
-      mouse.moveTo(20, 20);
-      mouse.upAt(20, 20);
-
-      expect(rect2.frameId).toBe(frame.id);
-    });
-
-    it("should keep dragging a frame child over a non-frame element above its frame", () => {
-      const cover = API.createElement({
-        id: "cover",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 80,
-        height: 80,
-        backgroundColor: "#ffc9c9",
-      });
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 100,
-        y: 20,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frameChild, frame, cover]);
-      API.setSelectedElements([frameChild]);
-
-      mouse.downAt(
-        frameChild.x + frameChild.width / 2,
-        frameChild.y + frameChild.height / 2,
-      );
-      mouse.moveTo(20, 20);
-
-      expect(h.state.frameToHighlight?.id).toBe(frame.id);
-
-      mouse.upAt(20, 20);
-
-      expect(frameChild.frameId).toBe(frame.id);
-    });
-
     it.skip("should drag element inside, duplicate it and keep it in frame", () => {
       API.setElements([frame, rect2]);
 

packages/element/tests/sortElements.test.ts

@@ -326,59 +326,19 @@ describe("normalizeElementsOrder", () => {
       ]),
       [
         "BA_rect1",
-        "CBA_rect3",
-        "CBA_rect7",
         "BA_rect5",
         "BA_rect6",
         "A_rect2",
         "A_rect5",
+        "CBA_rect3",
+        "CBA_rect7",
         "rect4",
         "X_rect8",
-        "YX_rect10",
         "X_rect11",
+        "YX_rect10",
         "rect9",
       ],
     );
-    assertOrder(
-      normalizeElementOrder([
-        API.createElement({
-          id: "A_rect1",
-          type: "rectangle",
-          groupIds: ["A"],
-        }),
-        API.createElement({
-          id: "CBA_rect2",
-          type: "rectangle",
-          groupIds: ["C", "B", "A"],
-        }),
-        API.createElement({
-          id: "A_rect3",
-          type: "rectangle",
-          groupIds: ["A"],
-        }),
-      ]),
-      ["A_rect1", "CBA_rect2", "A_rect3"],
-    );
-    assertOrder(
-      normalizeElementOrder([
-        API.createElement({
-          id: "abcT_rect1",
-          type: "rectangle",
-          groupIds: ["ab", "c", "T"],
-        }),
-        API.createElement({
-          id: "abcT_rect2",
-          type: "rectangle",
-          groupIds: ["a", "bc", "T"],
-        }),
-        API.createElement({
-          id: "abcT_rect3",
-          type: "rectangle",
-          groupIds: ["ab", "c", "T"],
-        }),
-      ]),
-      ["abcT_rect1", "abcT_rect3", "abcT_rect2"],
-    );
   });
 
   // TODO

packages/element/tests/textWrapping.test.ts

@@ -1,8 +1,4 @@
-import {
+import { wrapText, parseTokens } from "../src/textWrapping";
-  getWrappedTextLines,
-  parseTokens,
-  wrapText,
-} from "../src/textWrapping";
 
 import type { FontString } from "../src/types";
 
@@ -106,71 +102,6 @@ describe("Test wrapText", () => {
     expect(res2).toBe(`\tA)\none\ntab\n- two\ntabs\n- 8\nspace\ns`);
   });
 
-  it("should retain original text offsets for wrapped lines", () => {
-    expect(getWrappedTextLines("Hello World!", font, 60)).toEqual([
-      {
-        text: "Hello",
-        start: 0,
-        end: 5,
-      },
-      {
-        text: "World!",
-        start: 6,
-        end: 12,
-      },
-    ]);
-  });
-
-  it("should exclude whitespace trimmed away at soft-wrap boundaries from line offsets", () => {
-    expect(getWrappedTextLines("  Hello  World", font, 90)).toEqual([
-      {
-        text: "  Hello",
-        start: 0,
-        end: 7,
-      },
-      {
-        text: "World",
-        start: 9,
-        end: 14,
-      },
-    ]);
-  });
-
-  it("should retain offsets when wrapping a single long token", () => {
-    expect(getWrappedTextLines("Excalidraw", font, 50)).toEqual([
-      {
-        text: "Excal",
-        start: 0,
-        end: 5,
-      },
-      {
-        text: "idraw",
-        start: 5,
-        end: 10,
-      },
-    ]);
-  });
-
-  it("should preserve empty hard lines in metadata", () => {
-    expect(getWrappedTextLines("A\n\nB", font, 100)).toEqual([
-      {
-        text: "A",
-        start: 0,
-        end: 1,
-      },
-      {
-        text: "",
-        start: 2,
-        end: 2,
-      },
-      {
-        text: "B",
-        start: 3,
-        end: 4,
-      },
-    ]);
-  });
-
   describe("When text is CJK", () => {
     it("should break each CJK character when width is very small", () => {
       // "안녕하세요" (Hangul) + "こんにちは世界" (Hiragana, Kanji) + "ｺﾝﾆﾁハ" (Katakana) + "你好" (Han) = "Hello Hello World Hello Hi"

packages/excalidraw/CHANGELOG.md

@@ -18,13 +18,22 @@ Please add the latest change on the top under the correct section.
 ### Breaking changes
 
 - Renamed the `excalidrawAPI` prop to `onExcalidrawAPI`.
-  - `onExcalidrawAPI` is now called on mount (instead of during constructor), and later on unmount (with `null` value). The API may be removed altogether in the future (you can use `onMount` & `onUmount` to manage the `ExcalidrawAPI` object (e.g. to cache it to a global state), already).
 
 ### Features
 
-- Added `ExcalidrawAPI.isDestroyed` flag. Set to `true` once the editor unmounts. Calling any `get*` method, `onStateChange`, or `onEvent` on a destroyed API instance will throw in development and `console.error` in production. The `ExcalidrawAPI` will be reset to `null` on umount, but to be extra safe, you should check `ExcalidrawAPI.isDestroyed` before calling these methods to guard against subtle race conditions in your code.
+- Added `onMount` and `onInitialize` props. `onMount` receives `{ excalidrawAPI, container }` once the editor root is mounted, and `onInitialize` fires once the initial scene has loaded.
 
-- Added `onMount`, `onInitialize`, and `onUnmount` props. `onMount` receives `{ excalidrawAPI, container }` once the editor root is mounted. `onInitialize` fires once the initial scene has loaded. `onUnmount` fires just before unmounting.
+  ```tsx
+  <Excalidraw
+    onMount={({ excalidrawAPI, container }) => {
+      console.log(container);
+      excalidrawAPI.scrollToContent();
+    }}
+    onInitialize={(api) => {
+      api.refresh();
+    }}
+  />
+  ```
 
 - Same events are also accessible imperatively through `api.onEvent(...)`.
 
@@ -32,6 +41,7 @@ Please add the latest change on the top under the correct section.
   <Excalidraw
     onExcalidrawAPI={(api) => {
       api.onEvent("editor:mount", ({ excalidrawAPI, container }) => {
+        excalidrawAPI.scrollToContent();
         console.log(container);
       });
 
@@ -44,9 +54,7 @@ Please add the latest change on the top under the correct section.
 
   Note that in future releases, most, if not all, `excalidrawAPI.on*` subscriptions will be removed in favor of `excalidrawAPI.onEvent(name)`.
 
-- Also added `"editor:unmount"` lifecycle event, only accessible via `api.onEvent("editor:unmount")`.
+- Exported `ExcalidrawAPIProvider`, `useExcalidrawAPI`, and `useAppStateValue` from the package entrypoint. The imperative API also now exposes `onStateChange`.
-
-- Exported `<ExcalidrawAPIProvider/>`, `useExcalidrawAPI()`, `useAppStateValue(prop | props | selectorFunction)`, and `useOnExcalidrawStateChange(prop | props | selectorFunction, callback)` from the package. The imperative API also now exposes `onStateChange(prop | props | selectorFunction, callback?)`, and `onEvent(name, callback)`.
 
   ```tsx
   <ExcalidrawAPIProvider>
@@ -55,9 +63,6 @@ Please add the latest change on the top under the correct section.
   </ExcalidrawAPIProvider>;
 
   function Logger() {
-    // initially null before the ExcalidrawAPIProvider initializes ater
-    // <Excalidraw/> renders
-    // When <Excalidraw/> unmounts, is reset back to null
     const api = useExcalidrawAPI();
 
     useAppStateValue("viewModeEnabled", (viewModeEnabled) => {

packages/excalidraw/README.md

@@ -1,10 +1,10 @@
 # Excalidraw
 
-**Excalidraw** is exported as a React component that you can embed directly in your app.
+**Excalidraw** is exported as a component to be directly embedded in your project.
 
 ## Installation
 
-Install the package together with its React peer dependencies.
+Use `npm` or `yarn` to install the package.
 
 ```bash
 npm install react react-dom @excalidraw/excalidraw
@@ -12,131 +12,34 @@ npm install react react-dom @excalidraw/excalidraw
 yarn add react react-dom @excalidraw/excalidraw
 ```
 
-> **Note**: If you want to try unreleased changes, use `@excalidraw/excalidraw@next`.
+> **Note**: If you don't want to wait for the next stable release and try out the unreleased changes, use `@excalidraw/excalidraw@next`.
 
-## Quick start
+#### Self-hosting fonts
 
-The minimum working setup has two easy-to-miss requirements:
+By default, Excalidraw will try to download all the used fonts from the [CDN](https://esm.run/@excalidraw/excalidraw/dist/prod).
 
-1. Import the package CSS:
+For self-hosting purposes, you'll have to copy the content of the folder `node_modules/@excalidraw/excalidraw/dist/prod/fonts` to the path where your assets should be served from (i.e. `public/` directory in your project). In that case, you should also set `window.EXCALIDRAW_ASSET_PATH` to the very same path, i.e. `/` in case it's in the root:
 
-```ts
+```js
-import "@excalidraw/excalidraw/index.css";
+<script>window.EXCALIDRAW_ASSET_PATH = "/";</script>
 ```
 
-2. Render Excalidraw inside a container with a non-zero height.
+### Dimensions of Excalidraw
 
-```tsx
+Excalidraw takes _100%_ of `width` and `height` of the containing block so make sure the container in which you render Excalidraw has non zero dimensions.
-import { Excalidraw } from "@excalidraw/excalidraw";
-import "@excalidraw/excalidraw/index.css";
-
-export default function App() {
-  return (
-    <div style={{ height: "100vh" }}>
-      <Excalidraw />
-    </div>
-  );
-}
-```
-
-Excalidraw fills `100%` of the width and height of its parent. If the parent has no height, the canvas will not be visible.
-
-## Next.js / SSR frameworks
-
-Excalidraw should be rendered on the client. In SSR frameworks such as Next.js, use a client component and load it dynamically with SSR disabled.
-
-```tsx
-// app/components/ExcalidrawClient.tsx
-"use client";
-
-import { Excalidraw } from "@excalidraw/excalidraw";
-import "@excalidraw/excalidraw/index.css";
-
-export default function ExcalidrawClient() {
-  return (
-    <div style={{ height: "100vh" }}>
-      <Excalidraw />
-    </div>
-  );
-}
-```
-
-```tsx
-// app/page.tsx
-import dynamic from "next/dynamic";
-
-const ExcalidrawClient = dynamic(
-  () => import("./components/ExcalidrawClient"),
-  { ssr: false },
-);
-
-export default function Page() {
-  return <ExcalidrawClient />;
-}
-```
-
-See the local examples for complete setups:
-
-- [examples/with-nextjs](https://github.com/excalidraw/excalidraw/tree/master/examples/with-nextjs)
-- [examples/with-script-in-browser](https://github.com/excalidraw/excalidraw/tree/master/examples/with-script-in-browser)
-
-## LLM / agent tips
-
-If an LLM or coding agent is setting up Excalidraw, these shortcuts usually save more time than re-prompting:
-
-- Start with a plain `<Excalidraw />` in a `100vh` container. Add refs, `initialData`, persistence, or custom UI only after the base embed works.
-- If the canvas is blank, check the CSS import and parent height first. Those are the two most common integration failures.
-- In Next.js or other SSR frameworks, assume client-only rendering first. Use `"use client"` and `dynamic(..., { ssr: false })` before debugging hydration or `window is not defined` errors.
-- If imports or entrypoints are unclear, inspect `node_modules/@excalidraw/excalidraw/package.json`. The installed package exports are the source of truth.
-- Do not set `window.EXCALIDRAW_ASSET_PATH` unless you are intentionally self-hosting fonts/assets.
-- When docs and generated code drift, copy the nearest working example from this repo, especially `examples/with-nextjs` or `examples/with-script-in-browser`.
-
-## Migrating to `@excalidraw/excalidraw@0.18.x`
-
-Version `0.18.x` removes the old `types/`-prefixed deep import paths. If you were importing types from `@excalidraw/excalidraw/types/...`, switch to the new type-only subpaths below.
-
-| Old path | New path |
-| --- | --- |
-| `@excalidraw/excalidraw/types/data/transform.js` | `@excalidraw/excalidraw/element/transform` |
-| `@excalidraw/excalidraw/types/data/types.js` | `@excalidraw/excalidraw/data/types` |
-| `@excalidraw/excalidraw/types/element/types.js` | `@excalidraw/excalidraw/element/types` |
-| `@excalidraw/excalidraw/types/utility-types.js` | `@excalidraw/excalidraw/common/utility-types` |
-| `@excalidraw/excalidraw/types/types.js` | `@excalidraw/excalidraw/types` |
-
-Drop the `.js` extension. The new package `exports` map resolves these paths without it.
-
-These deep subpaths are for `import type` only. Runtime imports should come from the package root, plus `@excalidraw/excalidraw/index.css` for styles.
-
-For example:
-
-```ts
-import { exportToSvg } from "@excalidraw/excalidraw";
-```
-
-## Self-hosting fonts
-
-By default, Excalidraw downloads the fonts it needs from the [CDN](https://esm.run/@excalidraw/excalidraw/dist/prod).
-
-For self-hosting, copy the contents of `node_modules/@excalidraw/excalidraw/dist/prod/fonts` into the path where your app serves static assets, for example `public/`. Then set `window.EXCALIDRAW_ASSET_PATH` to that same path:
-
-```html
-<script>
-  window.EXCALIDRAW_ASSET_PATH = "/";
-</script>
-```
 
 ## Demo
 
-Try the [CodeSandbox example](https://codesandbox.io/p/sandbox/github/excalidraw/excalidraw/tree/master/examples/with-script-in-browser).
+Go to [CodeSandbox](https://codesandbox.io/p/sandbox/github/excalidraw/excalidraw/tree/master/examples/with-script-in-browser) example.
 
 ## Integration
 
-Read the [integration docs](https://docs.excalidraw.com/docs/@excalidraw/excalidraw/integration).
+Head over to the [docs](https://docs.excalidraw.com/docs/@excalidraw/excalidraw/integration).
 
 ## API
 
-Read the [API docs](https://docs.excalidraw.com/docs/@excalidraw/excalidraw/api).
+Head over to the [docs](https://docs.excalidraw.com/docs/@excalidraw/excalidraw/api).
 
 ## Contributing
 
-Read the [contributing docs](https://docs.excalidraw.com/docs/@excalidraw/excalidraw/contributing).
+Head over to the [docs](https://docs.excalidraw.com/docs/@excalidraw/excalidraw/contributing).

packages/excalidraw/actions/actionDeselect.ts

@@ -1,147 +0,0 @@
-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,
-          frameToHighlight: null,
-        },
-        captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-      };
-    }
-
-    return {
-      appState: {
-        ...appState,
-        activeEmbeddable: null,
-        activeTool,
-        editingGroupId: null,
-        selectedElementIds: makeNextSelectedElementIds({}, appState),
-        selectedGroupIds: {},
-        selectedLinearElement: null,
-        selectionElement: null,
-        showHyperlinkPopup: false,
-        suggestedBinding: null,
-        frameToHighlight: 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/actionExport.tsx

@@ -399,7 +399,7 @@ export const actionSaveFileToDisk = register({
         appState: {
           openDialog: null,
           fileHandle: savedFileHandle,
-          toast: { message: t("toast.fileSaved"), duration: 3000 },
+          toast: { message: t("toast.fileSaved") },
         },
       };
     } catch (error: any) {

packages/excalidraw/actions/actionFinalize.tsx

@@ -329,8 +329,8 @@ export const actionFinalize = register<FormData>({
         selectionElement: null,
         multiElement: null,
         editingTextElement: null,
+        startBoundElement: null,
         suggestedBinding: null,
-        frameToHighlight: null,
         selectedElementIds:
           element &&
           !appState.activeTool.locked &&
@@ -348,7 +348,9 @@ export const actionFinalize = register<FormData>({
     };
   },
   keyTest: (event, appState) =>
-    (event.key === KEYS.ESCAPE && appState.selectedLinearElement?.isEditing) ||
+    (event.key === KEYS.ESCAPE &&
+      (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/actionFrame.ts

@@ -205,6 +205,7 @@ export const actionWrapSelectionInFrame = register({
       [...app.scene.getElementsIncludingDeleted(), frame],
       selectedElements,
       frame,
+      appState,
     );
 
     return {

packages/excalidraw/actions/actionGroup.tsx

@@ -277,6 +277,7 @@ export const actionUngroup = register({
             elementsMap,
           ),
           frame,
+          app,
         );
       }
     });

packages/excalidraw/actions/actionHistory.tsx

@@ -1,4 +1,5 @@
 import {
+  isWindows,
   KEYS,
   matchKey,
   arrayToMap,
@@ -113,7 +114,7 @@ export const createRedoAction: ActionCreator = (history) => ({
     ),
   keyTest: (event) =>
     (event[KEYS.CTRL_OR_CMD] && event.shiftKey && matchKey(event, KEYS.Z)) ||
-    (event[KEYS.CTRL_OR_CMD] && !event.shiftKey && matchKey(event, KEYS.Y)),
+    (isWindows && event.ctrlKey && !event.shiftKey && matchKey(event, KEYS.Y)),
   PanelComponent: ({ appState, updateData, data, app }) => {
     const { isRedoStackEmpty } = useEmitter(
       history.onHistoryChangedEmitter,

packages/excalidraw/actions/actionProperties.tsx

@@ -36,7 +36,6 @@ import {
 import { LinearElementEditor } from "@excalidraw/element";
 
 import { newElementWith } from "@excalidraw/element";
-import { getArrowheadForPicker } from "@excalidraw/element";
 
 import {
   getBoundTextElement,
@@ -125,12 +124,9 @@ import {
   sharpArrowIcon,
   roundArrowIcon,
   elbowArrowIcon,
-  ArrowheadCardinalityExactlyOneIcon,
+  ArrowheadCrowfootIcon,
-  ArrowheadCardinalityManyIcon,
+  ArrowheadCrowfootOneIcon,
-  ArrowheadCardinalityOneIcon,
+  ArrowheadCrowfootOneOrManyIcon,
-  ArrowheadCardinalityOneOrManyIcon,
-  ArrowheadCardinalityZeroOrManyIcon,
-  ArrowheadCardinalityZeroOrOneIcon,
 } from "../components/icons";
 
 import { Fonts } from "../fonts";
@@ -191,7 +187,7 @@ export const getFormValue = function <T extends Primitive>(
   elements: readonly ExcalidrawElement[],
   app: AppClassProperties,
   getAttribute: (element: ExcalidrawElement) => T,
-  elementPredicate: true | ((element: ExcalidrawElement) => boolean),
+  isRelevantElement: true | ((element: ExcalidrawElement) => boolean),
   defaultValue: T | ((isSomeElementSelected: boolean) => T),
 ): T {
   const editingTextElement = app.state.editingTextElement;
@@ -209,9 +205,9 @@ export const getFormValue = function <T extends Primitive>(
     if (hasSelection) {
       const selectedElements = app.scene.getSelectedElements(app.state);
       const targetElements =
-        elementPredicate === true
+        isRelevantElement === true
           ? selectedElements
-          : selectedElements.filter((el) => elementPredicate(el));
+          : selectedElements.filter((el) => isRelevantElement(el));
 
       ret =
         reduceToCommonValue(targetElements, getAttribute) ??
@@ -730,28 +726,9 @@ export const actionChangeOpacity = register<ExcalidrawElement["opacity"]>({
       captureUpdate: CaptureUpdateAction.IMMEDIATELY,
     };
   },
-  PanelComponent: ({ elements, appState, app, updateData }) => {
+  PanelComponent: ({ app, updateData }) => (
-    const opacity = getFormValue(
+    <Range updateData={updateData} app={app} testId="opacity" />
-      elements,
+  ),
-      app,
-      (element) => element.opacity,
-      true,
-      (hasSelection) => (hasSelection ? null : appState.currentItemOpacity),
-    );
-
-    return (
-      <Range
-        label={t("labels.opacity")}
-        value={opacity ?? appState.currentItemOpacity}
-        hasCommonValue={opacity !== null}
-        onChange={updateData}
-        min={0}
-        max={100}
-        step={10}
-        testId="opacity"
-      />
-    );
-  },
 });
 
 export const actionChangeFontSize = register<ExcalidrawTextElement["fontSize"]>(
@@ -1573,117 +1550,80 @@ export const actionChangeRoundness = register<"sharp" | "round">({
 });
 
 const getArrowheadOptions = (flip: boolean) => {
-  return {
+  return [
-    visibleSections: [
+    {
-      {
+      value: null,
-        name: "default",
+      text: t("labels.arrowhead_none"),
-        options: [
+      keyBinding: "q",
-          {
+      icon: <ArrowheadNoneIcon flip={flip} />,
-            value: null,
+    },
-            text: t("labels.arrowhead_none"),
+    {
-            keyBinding: "q",
+      value: "arrow",
-            icon: <ArrowheadNoneIcon flip={flip} />,
+      text: t("labels.arrowhead_arrow"),
-          },
+      keyBinding: "w",
-          {
+      icon: <ArrowheadArrowIcon flip={flip} />,
-            value: "arrow",
+    },
-            text: t("labels.arrowhead_arrow"),
+    {
-            keyBinding: "w",
+      value: "triangle",
-            icon: <ArrowheadArrowIcon flip={flip} />,
+      text: t("labels.arrowhead_triangle"),
-          },
+      icon: <ArrowheadTriangleIcon flip={flip} />,
-          {
+      keyBinding: "e",
-            value: "triangle",
+    },
-            text: t("labels.arrowhead_triangle"),
+    {
-            icon: <ArrowheadTriangleIcon flip={flip} />,
+      value: "triangle_outline",
-            keyBinding: "e",
+      text: t("labels.arrowhead_triangle_outline"),
-          },
+      icon: <ArrowheadTriangleOutlineIcon flip={flip} />,
-          {
+      keyBinding: "r",
-            value: "triangle_outline",
+    },
-            text: t("labels.arrowhead_triangle_outline"),
+    {
-            icon: <ArrowheadTriangleOutlineIcon flip={flip} />,
+      value: "circle",
-            keyBinding: "r",
+      text: t("labels.arrowhead_circle"),
-          },
+      keyBinding: "a",
-        ],
+      icon: <ArrowheadCircleIcon flip={flip} />,
-      },
+    },
-    ],
+    {
-    hiddenSections: [
+      value: "circle_outline",
-      {
+      text: t("labels.arrowhead_circle_outline"),
-        name: "default",
+      keyBinding: "s",
-        options: [
+      icon: <ArrowheadCircleOutlineIcon flip={flip} />,
-          {
+    },
-            value: "circle",
+    {
-            text: t("labels.arrowhead_circle"),
+      value: "diamond",
-            keyBinding: "a",
+      text: t("labels.arrowhead_diamond"),
-            icon: <ArrowheadCircleIcon flip={flip} />,
+      icon: <ArrowheadDiamondIcon flip={flip} />,
-          },
+      keyBinding: "d",
-          {
+    },
-            value: "circle_outline",
+    {
-            text: t("labels.arrowhead_circle_outline"),
+      value: "diamond_outline",
-            keyBinding: "s",
+      text: t("labels.arrowhead_diamond_outline"),
-            icon: <ArrowheadCircleOutlineIcon flip={flip} />,
+      icon: <ArrowheadDiamondOutlineIcon flip={flip} />,
-          },
+      keyBinding: "f",
-          {
+    },
-            value: "diamond",
+    {
-            text: t("labels.arrowhead_diamond"),
+      value: "bar",
-            icon: <ArrowheadDiamondIcon flip={flip} />,
+      text: t("labels.arrowhead_bar"),
-            keyBinding: "d",
+      keyBinding: "z",
-          },
+      icon: <ArrowheadBarIcon flip={flip} />,
-          {
+    },
-            value: "diamond_outline",
+    {
-            text: t("labels.arrowhead_diamond_outline"),
+      value: "crowfoot_one",
-            icon: <ArrowheadDiamondOutlineIcon flip={flip} />,
+      text: t("labels.arrowhead_crowfoot_one"),
-            keyBinding: "f",
+      icon: <ArrowheadCrowfootOneIcon flip={flip} />,
-          },
+      keyBinding: "x",
-          {
+    },
-            value: "bar",
+    {
-            text: t("labels.arrowhead_bar"),
+      value: "crowfoot_many",
-            keyBinding: "z",
+      text: t("labels.arrowhead_crowfoot_many"),
-            icon: <ArrowheadBarIcon flip={flip} />,
+      icon: <ArrowheadCrowfootIcon flip={flip} />,
-          },
+      keyBinding: "c",
-        ],
+    },
-      },
+    {
-      {
+      value: "crowfoot_one_or_many",
-        name: t("labels.cardinality"),
+      text: t("labels.arrowhead_crowfoot_one_or_many"),
-        options: [
+      icon: <ArrowheadCrowfootOneOrManyIcon flip={flip} />,
-          {
+      keyBinding: "v",
-            value: "cardinality_one",
+    },
-            text: t("labels.arrowhead_cardinality_one"),
+  ] as const;
-            icon: <ArrowheadCardinalityOneIcon flip={flip} />,
-            keyBinding: "x",
-          },
-          {
-            value: "cardinality_many",
-            text: t("labels.arrowhead_cardinality_many"),
-            icon: <ArrowheadCardinalityManyIcon flip={flip} />,
-            keyBinding: "c",
-          },
-          {
-            value: "cardinality_one_or_many",
-            text: t("labels.arrowhead_cardinality_one_or_many"),
-            icon: <ArrowheadCardinalityOneOrManyIcon flip={flip} />,
-            keyBinding: "v",
-          },
-          {
-            value: "cardinality_exactly_one",
-            text: t("labels.arrowhead_cardinality_exactly_one"),
-            icon: <ArrowheadCardinalityExactlyOneIcon flip={flip} />,
-            keyBinding: null,
-          },
-          {
-            value: "cardinality_zero_or_one",
-            text: t("labels.arrowhead_cardinality_zero_or_one"),
-            icon: <ArrowheadCardinalityZeroOrOneIcon flip={flip} />,
-            keyBinding: null,
-          },
-          {
-            value: "cardinality_zero_or_many",
-            text: t("labels.arrowhead_cardinality_zero_or_many"),
-            icon: <ArrowheadCardinalityZeroOrManyIcon flip={flip} />,
-            keyBinding: null,
-          },
-        ],
-      },
-    ],
-  } as const;
 };
 
 export const actionChangeArrowhead = register<{
@@ -1727,52 +1667,45 @@ export const actionChangeArrowhead = register<{
   },
   PanelComponent: ({ elements, appState, updateData, app }) => {
     const isRTL = getLanguage().rtl;
-    const startArrowheadOptions = useMemo(
-      () => getArrowheadOptions(!isRTL),
-      [isRTL],
-    );
-    const endArrowheadOptions = useMemo(
-      () => getArrowheadOptions(!!isRTL),
-      [isRTL],
-    );
 
     return (
       <fieldset>
         <legend>{t("labels.arrowheads")}</legend>
         <div className="iconSelectList buttonList">
           <IconPicker
-            visibleSections={startArrowheadOptions.visibleSections}
-            hiddenSections={startArrowheadOptions.hiddenSections}
             label="arrowhead_start"
+            options={getArrowheadOptions(!isRTL)}
             value={getFormValue<Arrowhead | null>(
               elements,
               app,
               (element) =>
                 isLinearElement(element) && canHaveArrowheads(element.type)
-                  ? getArrowheadForPicker(element.startArrowhead)
+                  ? element.startArrowhead
                   : appState.currentItemStartArrowhead,
               true,
               (hasSelection) =>
                 hasSelection ? null : appState.currentItemStartArrowhead,
             )}
             onChange={(value) => updateData({ position: "start", type: value })}
+            numberOfOptionsToAlwaysShow={4}
           />
           <IconPicker
-            visibleSections={endArrowheadOptions.visibleSections}
-            hiddenSections={endArrowheadOptions.hiddenSections}
             label="arrowhead_end"
+            group="arrowheads"
+            options={getArrowheadOptions(!!isRTL)}
             value={getFormValue<Arrowhead | null>(
               elements,
               app,
               (element) =>
                 isLinearElement(element) && canHaveArrowheads(element.type)
-                  ? getArrowheadForPicker(element.endArrowhead)
+                  ? element.endArrowhead
                   : appState.currentItemEndArrowhead,
               true,
               (hasSelection) =>
                 hasSelection ? null : appState.currentItemEndArrowhead,
             )}
             onChange={(value) => updateData({ position: "end", type: value })}
+            numberOfOptionsToAlwaysShow={4}
           />
         </div>
       </fieldset>

packages/excalidraw/actions/actionTextAutoResize.ts

@@ -1,24 +1,24 @@
 import { getFontString } from "@excalidraw/common";
 
-import { isExcalidrawElement, newElementWith } from "@excalidraw/element";
+import { newElementWith } from "@excalidraw/element";
 import { measureText } from "@excalidraw/element";
 
 import { isTextElement } from "@excalidraw/element";
 
 import { CaptureUpdateAction } from "@excalidraw/element";
 
-import type { ExcalidrawElement } from "@excalidraw/element/types";
-
 import { getSelectedElements } from "../scene";
 
 import { register } from "./register";
 
+import type { AppClassProperties } from "../types";
+
 export const actionTextAutoResize = register({
   name: "autoResize",
   label: "labels.autoResize",
   icon: null,
   trackEvent: { category: "element" },
-  predicate: (elements, appState, _: unknown) => {
+  predicate: (elements, appState, _: unknown, app: AppClassProperties) => {
     const selectedElements = getSelectedElements(elements, appState);
     return (
       selectedElements.length === 1 &&
@@ -26,18 +26,13 @@ export const actionTextAutoResize = register({
       !selectedElements[0].autoResize
     );
   },
-  perform: (elements, appState, targetElement) => {
+  perform: (elements, appState, _, app) => {
     const selectedElements = getSelectedElements(elements, appState);
 
-    const targetTextElement =
-      isExcalidrawElement(targetElement) && isTextElement(targetElement)
-        ? targetElement
-        : (selectedElements[0] as ExcalidrawElement | undefined);
-
     return {
       appState,
       elements: elements.map((element) => {
-        if (element.id === targetTextElement?.id && isTextElement(element)) {
+        if (element.id === selectedElements[0].id && isTextElement(element)) {
           const metrics = measureText(
             element.originalText,
             getFontString(element),

packages/excalidraw/actions/index.ts

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

packages/excalidraw/actions/types.ts

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

packages/excalidraw/appState.ts

@@ -99,6 +99,7 @@ export const getDefaultAppState = (): Omit<
       open: false,
       panels: STATS_PANELS.generalStats | STATS_PANELS.elementProperties,
     },
+    startBoundElement: null,
     suggestedBinding: null,
     frameRendering: { enabled: true, clip: true, name: true, outline: true },
     frameToHighlight: null,
@@ -127,7 +128,6 @@ export const getDefaultAppState = (): Omit<
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
-    boxSelectionMode: "contain",
   };
 };
 
@@ -193,7 +193,6 @@ 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: {
@@ -230,6 +229,7 @@ const APP_STATE_STORAGE_CONF = (<
   selectionElement: { browser: false, export: false, server: false },
   shouldCacheIgnoreZoom: { browser: true, export: false, server: false },
   stats: { browser: true, export: false, server: false },
+  startBoundElement: { browser: false, export: false, server: false },
   suggestedBinding: { browser: false, export: false, server: false },
   frameRendering: { browser: false, export: false, server: false },
   frameToHighlight: { browser: false, export: false, server: false },

packages/excalidraw/components/FontPicker/FontPickerList.tsx

@@ -46,7 +46,6 @@ import {
 import { fontPickerKeyHandler } from "./keyboardNavHandlers";
 
 import type { JSX } from "react";
-import type { ExcalidrawFontFace } from "../../fonts/ExcalidrawFontFace";
 
 export interface FontDescriptor {
   value: number;
@@ -87,15 +86,6 @@ 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,
@@ -124,7 +114,7 @@ export const FontPickerList = React.memo(
             const fontDescriptor = {
               value: familyId,
               icon: getFontFamilyIcon(familyId),
-              text: getFontFamilyLabel(familyId, fontFaces),
+              text: fontFaces[0]?.fontFace?.family ?? "Unknown",
             };
 
             if (metadata.deprecated) {

packages/excalidraw/components/IconPicker.scss

@@ -6,20 +6,14 @@
     padding: 0.5rem;
     background: var(--popup-bg-color);
     border: 0 solid color.adjust(#fff, $alpha: -0.75);
-    box-shadow: var(--shadow-island-stronger);
+    box-shadow: var(--shadow-island);
     border-radius: 4px;
+    position: absolute;
     :root[dir="rtl"] & {
       padding: 0.4rem;
     }
   }
 
-  .picker-sections,
-  .picker-section {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-  }
-
   .picker-container button,
   .picker button {
     position: relative;
@@ -68,13 +62,7 @@
 
   .picker-collapsible {
     font-size: 0.75rem;
-    padding: 0;
+    padding: 0.5rem 0;
-    color: var(--text-primary-color);
-  }
-
-  .picker-section-label {
-    font-size: 0.75rem;
-    color: var(--text-primary-color);
   }
 
   .picker-keybinding {

packages/excalidraw/components/IconPicker.tsx

@@ -1,6 +1,6 @@
 import { Popover } from "radix-ui";
 import clsx from "clsx";
-import React, { useEffect, useMemo } from "react";
+import React, { useEffect } from "react";
 
 import { isArrowKey, KEYS } from "@excalidraw/common";
 
@@ -8,15 +8,13 @@ import { atom, useAtom } from "../editor-jotai";
 import { getLanguage, t } from "../i18n";
 
 import Collapsible from "./Stats/Collapsible";
-import { useExcalidrawContainer } from "./App";
+import { useEditorInterface, useExcalidrawContainer } from "./App";
 
 import "./IconPicker.scss";
 
 import type { JSX } from "react";
 
 const moreOptionsAtom = atom(false);
-const PICKER_COLUMNS = 4;
-const DEFAULT_SECTION_NAME = "default";
 
 type Option<T> = {
   value: T;
@@ -25,73 +23,28 @@ type Option<T> = {
   keyBinding: string | null;
 };
 
-type PickerSection<T> = {
-  name: string;
-  options: readonly Option<T>[];
-};
-
-const flattenOptions = <T,>(sections: readonly PickerSection<T>[]) =>
-  sections.flatMap((section) => section.options);
-
-const findOption = <T,>(
-  sections: readonly PickerSection<T>[],
-  predicate: (option: Option<T>) => boolean,
-) => {
-  for (const section of sections) {
-    const option = section.options.find(predicate);
-    if (option) {
-      return option;
-    }
-  }
-
-  return null;
-};
-
-const hasOption = <T,>(
-  sections: readonly PickerSection<T>[],
-  predicate: (option: Option<T>) => boolean,
-) => sections.some((section) => section.options.some(predicate));
-
-const getNavigationRows = <T,>(sections: readonly PickerSection<T>[]) =>
-  sections.flatMap((section) =>
-    Array.from(
-      { length: Math.ceil(section.options.length / PICKER_COLUMNS) },
-      (_, index) =>
-        section.options.slice(
-          index * PICKER_COLUMNS,
-          index * PICKER_COLUMNS + PICKER_COLUMNS,
-        ),
-    ),
-  );
-
 function Picker<T>({
-  visibleSections,
+  options,
-  hiddenSections = [],
   value,
   label,
   onChange,
   onClose,
+  numberOfOptionsToAlwaysShow = options.length,
 }: {
   label: string;
   value: T;
-  visibleSections: readonly PickerSection<T>[];
+  options: readonly Option<T>[];
-  hiddenSections?: readonly PickerSection<T>[];
   onChange: (value: T) => void;
   onClose: () => void;
+  numberOfOptionsToAlwaysShow?: number;
 }) {
+  const editorInterface = useEditorInterface();
   const { container } = useExcalidrawContainer();
-  const [showMoreOptions, setShowMoreOptions] = useAtom(moreOptionsAtom);
-  const allSections = [...visibleSections, ...hiddenSections];
-  const allOptions = flattenOptions(allSections);
-  const navigationRows = getNavigationRows([
-    ...visibleSections,
-    ...(showMoreOptions ? hiddenSections : []),
-  ]);
 
   const handleKeyDown = (event: React.KeyboardEvent) => {
-    const pressedOption = allOptions.find(
+    const pressedOption = options.find(
       (option) => option.keyBinding === event.key.toLowerCase(),
-    );
+    )!;
 
     if (!(event.metaKey || event.altKey || event.ctrlKey) && pressedOption) {
       // Keybinding navigation
@@ -99,17 +52,17 @@ function Picker<T>({
 
       event.preventDefault();
     } else if (event.key === KEYS.TAB) {
-      const index = allOptions.findIndex((option) => option.value === value);
+      const index = options.findIndex((option) => option.value === value);
       const nextIndex = event.shiftKey
-        ? (allOptions.length + index - 1) % allOptions.length
+        ? (options.length + index - 1) % options.length
-        : (index + 1) % allOptions.length;
+        : (index + 1) % options.length;
-      onChange(allOptions[nextIndex].value);
+      onChange(options[nextIndex].value);
     } else if (isArrowKey(event.key)) {
       // Arrow navigation
       const isRTL = getLanguage().rtl;
-      const index = allOptions.findIndex((option) => option.value === value);
+      const index = options.findIndex((option) => option.value === value);
       if (index !== -1) {
-        const length = allOptions.length;
+        const length = options.length;
         let nextIndex = index;
 
         switch (event.key) {
@@ -123,60 +76,18 @@ function Picker<T>({
             break;
           // Go the next row
           case KEYS.ARROW_DOWN: {
-            const currentRowIndex = navigationRows.findIndex((row) =>
+            nextIndex = (index + (numberOfOptionsToAlwaysShow ?? 1)) % length;
-              row.some((option) => option.value === value),
-            );
-            const currentRow = navigationRows[currentRowIndex];
-
-            if (currentRowIndex !== -1 && currentRow) {
-              const column = currentRow.findIndex(
-                (option) => option.value === value,
-              );
-              const nextRow =
-                navigationRows[(currentRowIndex + 1) % navigationRows.length];
-              const nextOption =
-                nextRow[Math.min(column, nextRow.length - 1)] ??
-                allOptions[index];
-
-              onChange(nextOption.value);
-              event.preventDefault();
-              event.nativeEvent.stopImmediatePropagation();
-              event.stopPropagation();
-              return;
-            }
             break;
           }
           // Go the previous row
           case KEYS.ARROW_UP: {
-            const currentRowIndex = navigationRows.findIndex((row) =>
+            nextIndex =
-              row.some((option) => option.value === value),
+              (length + index - (numberOfOptionsToAlwaysShow ?? 1)) % length;
-            );
-            const currentRow = navigationRows[currentRowIndex];
-
-            if (currentRowIndex !== -1 && currentRow) {
-              const column = currentRow.findIndex(
-                (option) => option.value === value,
-              );
-              const previousRow =
-                navigationRows[
-                  (navigationRows.length + currentRowIndex - 1) %
-                    navigationRows.length
-                ];
-              const previousOption =
-                previousRow[Math.min(column, previousRow.length - 1)] ??
-                allOptions[index];
-
-              onChange(previousOption.value);
-              event.preventDefault();
-              event.nativeEvent.stopImmediatePropagation();
-              event.stopPropagation();
-              return;
-            }
             break;
           }
         }
 
-        onChange(allOptions[nextIndex].value);
+        onChange(options[nextIndex].value);
       }
       event.preventDefault();
     } else if (event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) {
@@ -188,29 +99,38 @@ function Picker<T>({
     event.stopPropagation();
   };
 
+  const [showMoreOptions, setShowMoreOptions] = useAtom(moreOptionsAtom);
+
+  const alwaysVisibleOptions = React.useMemo(
+    () => options.slice(0, numberOfOptionsToAlwaysShow),
+    [options, numberOfOptionsToAlwaysShow],
+  );
+  const moreOptions = React.useMemo(
+    () => options.slice(numberOfOptionsToAlwaysShow),
+    [options, numberOfOptionsToAlwaysShow],
+  );
+
   useEffect(() => {
-    if (hasOption(hiddenSections, (option) => option.value === value)) {
+    if (!alwaysVisibleOptions.some((option) => option.value === value)) {
       setShowMoreOptions(true);
     }
-  }, [value, hiddenSections, setShowMoreOptions]);
+  }, [value, alwaysVisibleOptions, setShowMoreOptions]);
 
-  const renderOptions = (options: readonly Option<T>[]) => {
+  const renderOptions = (options: Option<T>[]) => {
     return (
       <div className="picker-content">
-        {options.map((option) => (
+        {options.map((option, i) => (
           <button
             type="button"
             className={clsx("picker-option", {
               active: value === option.value,
             })}
-            onClick={() => {
+            onClick={(event) => {
               onChange(option.value);
             }}
-            title={
+            title={`${option.text} ${
-              option.keyBinding
+              option.keyBinding && `— ${option.keyBinding.toUpperCase()}`
-                ? `${option.text} — ${option.keyBinding.toUpperCase()}`
+            }`}
-                : option.text
-            }
             aria-label={option.text || "none"}
             aria-keyshortcuts={option.keyBinding || undefined}
             key={option.text}
@@ -233,38 +153,26 @@ function Picker<T>({
     );
   };
 
-  const renderSections = (sections: readonly PickerSection<T>[]) =>
+  const isMobile = editorInterface.formFactor === "phone";
-    sections.map((section, index) =>
-      section.name === DEFAULT_SECTION_NAME ? (
-        <React.Fragment key={`${section.name}-${index}`}>
-          {renderOptions(section.options)}
-        </React.Fragment>
-      ) : (
-        <div className="picker-section" key={`${section.name}-${index}`}>
-          <div className="picker-section-label">{section.name}</div>
-          {renderOptions(section.options)}
-        </div>
-      ),
-    );
 
   return (
     <Popover.Content
-      className="picker"
+      side={isMobile ? "right" : "bottom"}
-      role="dialog"
-      aria-modal="true"
-      aria-label={label}
-      side={"bottom"}
       align="start"
-      sideOffset={12}
+      sideOffset={isMobile ? 8 : 12}
-      alignOffset={12}
       style={{ zIndex: "var(--zIndex-ui-styles-popup)" }}
       onKeyDown={handleKeyDown}
       collisionBoundary={container ?? undefined}
     >
-      <div className="picker-sections">
+      <div
-        {renderSections(visibleSections)}
+        className={`picker`}
+        role="dialog"
+        aria-modal="true"
+        aria-label={label}
+      >
+        {renderOptions(alwaysVisibleOptions)}
 
-        {hiddenSections.length > 0 && (
+        {moreOptions.length > 0 && (
           <Collapsible
             label={t("labels.more_options")}
             open={showMoreOptions}
@@ -273,9 +181,7 @@ function Picker<T>({
             }}
             className="picker-collapsible"
           >
-            <div className="picker-sections">
+            {renderOptions(moreOptions)}
-              {renderSections(hiddenSections)}
-            </div>
           </Collapsible>
         )}
       </div>
@@ -286,45 +192,49 @@ function Picker<T>({
 export function IconPicker<T>({
   value,
   label,
-  visibleSections,
+  options,
-  hiddenSections,
   onChange,
+  group = "",
+  numberOfOptionsToAlwaysShow,
 }: {
   label: string;
   value: T;
-  visibleSections: readonly PickerSection<T>[];
+  options: readonly {
-  hiddenSections?: readonly PickerSection<T>[];
+    value: T;
+    text: string;
+    icon: JSX.Element;
+    keyBinding: string | null;
+  }[];
   onChange: (value: T) => void;
+  numberOfOptionsToAlwaysShow?: number;
+  group?: string;
 }) {
   const [isActive, setActive] = React.useState(false);
-  const selectedOption = useMemo(
+  const rPickerButton = React.useRef<any>(null);
-    () =>
-      findOption(visibleSections, (option) => option.value === value) ??
-      findOption(hiddenSections ?? [], (option) => option.value === value),
-    [visibleSections, hiddenSections, value],
-  );
 
   return (
     <div>
       <Popover.Root open={isActive} onOpenChange={(open) => setActive(open)}>
         <Popover.Trigger
+          name={group}
           type="button"
           aria-label={label}
           onClick={() => setActive(!isActive)}
+          ref={rPickerButton}
           className={isActive ? "active" : ""}
         >
-          {selectedOption?.icon}
+          {options.find((option) => option.value === value)?.icon}
         </Popover.Trigger>
         {isActive && (
           <Picker
-            visibleSections={visibleSections}
+            options={options}
-            hiddenSections={hiddenSections}
             value={value}
             label={label}
             onChange={onChange}
             onClose={() => {
               setActive(false);
             }}
+            numberOfOptionsToAlwaysShow={numberOfOptionsToAlwaysShow}
           />
         )}
       </Popover.Root>

packages/excalidraw/components/LayerUI.tsx

@@ -650,7 +650,8 @@ const LayerUI = ({
 };
 
 const stripIrrelevantAppStateProps = (appState: AppState): UIAppState => {
-  const { cursorButton, scrollX, scrollY, ...ret } = appState;
+  const { startBoundElement, cursorButton, scrollX, scrollY, ...ret } =
+    appState;
   return ret;
 };
 

packages/excalidraw/components/LibraryMenuItems.tsx

@@ -199,7 +199,6 @@ export default function LibraryMenuItems({
             type: "everything",
             elements: item.elements,
             randomizeSeed: true,
-            preserveFrameChildrenOrder: true,
           }).duplicatedElements,
         };
       });

packages/excalidraw/components/RadioGroup.scss

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

packages/excalidraw/components/Range.tsx

@@ -1,78 +1,74 @@
 import React, { useEffect } from "react";
 
+import { t } from "../i18n";
+
 import "./Range.scss";
 
+import type { AppClassProperties } from "../types";
+
 export type RangeProps = {
-  label: React.ReactNode;
+  updateData: (value: number) => void;
-  value: number;
+  app: AppClassProperties;
-  onChange: (value: number) => void;
-  min?: number;
-  max?: number;
-  step?: number;
-  minLabel?: React.ReactNode;
-  hasCommonValue?: boolean;
   testId?: string;
 };
 
-export const Range = ({
+export const Range = ({ updateData, app, testId }: RangeProps) => {
-  label,
-  value,
-  onChange,
-  min = 0,
-  max = 100,
-  step = 10,
-  minLabel = min,
-  hasCommonValue = true,
-  testId,
-}: RangeProps) => {
   const rangeRef = React.useRef<HTMLInputElement>(null);
   const valueRef = React.useRef<HTMLDivElement>(null);
+  const selectedElements = app.scene.getSelectedElements(app.state);
+  let hasCommonOpacity = true;
+  const firstElement = selectedElements.at(0);
+  const leastCommonOpacity = selectedElements.reduce((acc, element) => {
+    if (acc != null && acc !== element.opacity) {
+      hasCommonOpacity = false;
+    }
+    if (acc == null || acc > element.opacity) {
+      return element.opacity;
+    }
+    return acc;
+  }, firstElement?.opacity ?? null);
+
+  const value = leastCommonOpacity ?? app.state.currentItemOpacity;
 
   useEffect(() => {
     if (rangeRef.current && valueRef.current) {
       const rangeElement = rangeRef.current;
       const valueElement = valueRef.current;
       const inputWidth = rangeElement.offsetWidth;
-      const thumbWidth =
+      const thumbWidth = 15; // 15 is the width of the thumb
-        parseFloat(
-          getComputedStyle(rangeElement).getPropertyValue(
-            "--slider-thumb-size",
-          ),
-        ) || 16;
-      const progress = ((value - min) / (max - min || 1)) * 100;
       const position =
-        (progress / 100) * (inputWidth - thumbWidth) + thumbWidth / 2;
+        (value / 100) * (inputWidth - thumbWidth) + thumbWidth / 2;
       valueElement.style.left = `${position}px`;
-      rangeElement.style.background = `linear-gradient(to right, var(--color-slider-track) 0%, var(--color-slider-track) ${progress}%, var(--button-bg) ${progress}%, var(--button-bg) 100%)`;
+      rangeElement.style.background = `linear-gradient(to right, var(--color-slider-track) 0%, var(--color-slider-track) ${value}%, var(--button-bg) ${value}%, var(--button-bg) 100%)`;
     }
-  }, [max, min, value]);
+  }, [value]);
 
   return (
     <label className="control-label">
-      {label}
+      {t("labels.opacity")}
       <div className="range-wrapper">
         <input
           style={{
-            ["--color-slider-track" as string]: hasCommonValue
+            ["--color-slider-track" as string]: hasCommonOpacity
               ? undefined
               : "var(--button-bg)",
           }}
           ref={rangeRef}
           type="range"
-          min={min}
+          min="0"
-          max={max}
+          max="100"
-          step={step}
+          step="10"
           onChange={(event) => {
-            onChange(+event.target.value);
+            updateData(+event.target.value);
           }}
           value={value}
           className="range-input"
           data-testid={testId}
         />
         <div className="value-bubble" ref={valueRef}>
-          {value !== min ? value : null}
+          {value !== 0 ? value : null}
         </div>
-        <div className="zero-label">{minLabel}</div>
+        <div className="zero-label">0</div>
       </div>
     </label>
   );

packages/excalidraw/components/Stats/Dimension.tsx

@@ -206,6 +206,7 @@ const handleDimensionChange: DragInputCallbackType<
           scene.getElementsIncludingDeleted(),
           nextElementsInFrame,
           latestElement,
+          app,
         );
 
         scene.replaceAllElements(updatedElements);
@@ -301,6 +302,7 @@ const handleDragFinished: DragFinishedCallbackType = ({
       app.scene.getElementsIncludingDeleted(),
       nextElementsInFrame,
       latestElement,
+      app,
     );
 
     app.scene.replaceAllElements(updatedElements);

packages/excalidraw/components/Stats/MultiDimension.tsx

@@ -261,6 +261,7 @@ const handleDimensionChange: DragInputCallbackType<
               scene.getElementsIncludingDeleted(),
               nextElementsInFrame,
               latestElement,
+              app,
             );
 
             scene.replaceAllElements(updatedElements);
@@ -415,6 +416,7 @@ const handleDragFinished: DragFinishedCallbackType = ({
       app.scene.getElementsIncludingDeleted(),
       nextElementsInFrame,
       latestElement,
+      app,
     );
 
     app.scene.replaceAllElements(updatedElements);

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

@@ -361,10 +361,12 @@ describe("stats for a non-generic element", () => {
     mouse.clickAt(20, 30);
     const editor = await getTextEditor();
     updateTextEditor(editor, "Hello!");
-    Keyboard.exitTextEditor(editor);
+    act(() => {
+      editor.blur();
+    });
 
     const text = h.elements[0] as ExcalidrawTextElement;
-    API.setSelectedElements([text]);
+    mouse.clickOn(text);
 
     elementStats = stats?.querySelector("#elementStats");
 
@@ -750,7 +752,7 @@ describe("frame resizing behavior", () => {
       x: 0,
       y: 0,
       width: 100,
-      height: 103,
+      height: 100,
     });
 
     // Create a rectangle outside the frame

packages/excalidraw/components/TTDDialog/MermaidToExcalidraw.tsx

@@ -236,40 +236,15 @@ const MermaidToExcalidraw = ({
         <Trans
           i18nKey="mermaid.description"
           flowchartLink={(el) => (
-            <a
+            <a href="https://mermaid.js.org/syntax/flowchart.html">{el}</a>
-              href="https://mermaid.js.org/syntax/flowchart.html"
-              target="_blank"
-              rel="noreferrer"
-            >
-              {el}
-            </a>
           )}
           sequenceLink={(el) => (
-            <a
+            <a href="https://mermaid.js.org/syntax/sequenceDiagram.html">
-              href="https://mermaid.js.org/syntax/sequenceDiagram.html"
-              target="_blank"
-              rel="noreferrer"
-            >
               {el}
             </a>
           )}
           classLink={(el) => (
-            <a
+            <a href="https://mermaid.js.org/syntax/classDiagram.html">{el}</a>
-              href="https://mermaid.js.org/syntax/classDiagram.html"
-              target="_blank"
-              rel="noreferrer"
-            >
-              {el}
-            </a>
-          )}
-          erdLink={(el) => (
-            <a
-              href="https://mermaid.js.org/syntax/entityRelationshipDiagram.html"
-              target="_blank"
-              rel="noreferrer"
-            >
-              {el}
-            </a>
           )}
         />
       </div>

packages/excalidraw/components/TTDDialog/common.ts

@@ -94,7 +94,7 @@ export const convertMermaidToExcalidraw = async ({
       }
     }
 
-    const { elements, files = {} } = ret;
+    const { elements, files } = ret;
     setError(null);
 
     data.current = {

packages/excalidraw/components/canvases/InteractiveCanvas.tsx

@@ -39,7 +39,7 @@ type InteractiveCanvasProps = {
   visibleElements: readonly NonDeletedExcalidrawElement[];
   selectedElements: readonly NonDeletedExcalidrawElement[];
   allElementsMap: NonDeletedSceneElementsMap;
-  canvasNonce: string;
+  sceneNonce: number | undefined;
   selectionNonce: number | undefined;
   scale: number;
   appState: InteractiveCanvasAppState;
@@ -54,7 +54,6 @@ type InteractiveCanvasProps = {
     DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"],
     undefined
   >;
-  onClick: Exclude<DOMAttributes<HTMLCanvasElement>["onClick"], undefined>;
   onPointerMove: Exclude<
     DOMAttributes<HTMLCanvasElement>["onPointerMove"],
     undefined
@@ -214,7 +213,6 @@ const InteractiveCanvas = (props: InteractiveCanvasProps) => {
       height={props.appState.height * props.scale}
       ref={props.handleCanvasRef}
       onContextMenu={props.onContextMenu}
-      onClick={props.onClick}
       onPointerMove={props.onPointerMove}
       onPointerUp={props.onPointerUp}
       onPointerCancel={props.onPointerCancel}
@@ -279,10 +277,10 @@ const areEqual = (
   // This could be further optimised if needed, as we don't have to render interactive canvas on each scene mutation
   if (
     prevProps.selectionNonce !== nextProps.selectionNonce ||
-    prevProps.canvasNonce !== nextProps.canvasNonce ||
+    prevProps.sceneNonce !== nextProps.sceneNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if canvasNonce didn't change (e.g. we filter elements out based
+    // even if sceneNonce didn't change (e.g. we filter elements out based
     // on appState)
     prevProps.elementsMap !== nextProps.elementsMap ||
     prevProps.visibleElements !== nextProps.visibleElements ||

packages/excalidraw/components/canvases/NewElementCanvas.tsx

@@ -14,7 +14,6 @@ import type { RoughCanvas } from "roughjs/bin/canvas";
 
 interface NewElementCanvasProps {
   appState: AppState;
-  newElement: NonNullable<AppState["newElement"]>;
   elementsMap: RenderableElementsMap;
   allElementsMap: NonDeletedSceneElementsMap;
   scale: number;
@@ -32,7 +31,7 @@ const NewElementCanvas = (props: NewElementCanvasProps) => {
       {
         canvas: canvasRef.current,
         scale: props.scale,
-        newElement: props.newElement,
+        newElement: props.appState.newElement,
         elementsMap: props.elementsMap,
         allElementsMap: props.allElementsMap,
         rc: props.rc,

packages/excalidraw/components/canvases/StaticCanvas.tsx

@@ -23,7 +23,7 @@ type StaticCanvasProps = {
   elementsMap: RenderableElementsMap;
   allElementsMap: NonDeletedSceneElementsMap;
   visibleElements: readonly NonDeletedExcalidrawElement[];
-  canvasNonce: string;
+  sceneNonce: number | undefined;
   selectionNonce: number | undefined;
   scale: number;
   appState: StaticCanvasAppState;
@@ -110,10 +110,10 @@ const areEqual = (
   nextProps: StaticCanvasProps,
 ) => {
   if (
-    prevProps.canvasNonce !== nextProps.canvasNonce ||
+    prevProps.sceneNonce !== nextProps.sceneNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if canvasNonce didn't change (e.g. we filter elements out based
+    // even if sceneNonce didn't change (e.g. we filter elements out based
     // on appState)
     prevProps.elementsMap !== nextProps.elementsMap ||
     prevProps.visibleElements !== nextProps.visibleElements

packages/excalidraw/components/dropdownMenu/DropdownMenu.scss

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

packages/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.tsx

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

packages/excalidraw/components/icons.tsx

@@ -69,11 +69,6 @@ const modifiedTablerIconProps: Opts = {
   strokeLinejoin: "round",
 } as const;
 
-const arrowheadPreviewIconProps: Opts = {
-  width: 40,
-  height: 20,
-} as const;
-
 // -----------------------------------------------------------------------------
 
 // tabler-icons: present
@@ -1296,17 +1291,16 @@ export const ArrowheadNoneIcon = React.memo(
   ({ flip = false }: { flip?: boolean }) =>
     createIcon(
       <g
-        transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
+        transform={flip ? "translate(24, 0) scale(-1, 1)" : ""}
         stroke="currentColor"
         opacity={0.3}
         strokeWidth={2}
-        fill="none"
-        strokeLinecap="round"
       >
-        <path d="M7,11 H19" />
+        <path d="M12 12l-9 0" />
-        <path d="M25,6 L33,16 M33,6 L25,16" />
+        <path d="M21 9l-6 6" />
+        <path d="M21 15l-6 -6" />
       </g>,
-      arrowheadPreviewIconProps,
+      tablerIconProps,
     ),
 );
 
@@ -1318,46 +1312,11 @@ export const ArrowheadArrowIcon = React.memo(
         stroke="currentColor"
         strokeWidth={2}
         fill="none"
-        strokeLinecap="round"
-        strokeLinejoin="round"
       >
-        <path d="M7,11 H33 M23,5 L33,11 L23,17" />
+        <path d="M34 10H6M34 10L27 5M34 10L27 15" />
+        <path d="M27.5 5L34.5 10L27.5 15" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
-    ),
-);
-
-export const ArrowheadTriangleIcon = React.memo(
-  ({ flip = false }: { flip?: boolean }) =>
-    createIcon(
-      <g
-        stroke="currentColor"
-        fill="currentColor"
-        transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
-        strokeLinejoin="round"
-      >
-        <path d="M7,11 H23" strokeWidth={2} strokeLinecap="round" />
-        <path d="M23,5 L35,11 L23,17 Z" />
-      </g>,
-      arrowheadPreviewIconProps,
-    ),
-);
-
-export const ArrowheadTriangleOutlineIcon = React.memo(
-  ({ flip = false }: { flip?: boolean }) =>
-    createIcon(
-      <g
-        stroke="currentColor"
-        fill="none"
-        transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
-        strokeWidth={2}
-        strokeLinejoin="round"
-        strokeLinecap="round"
-      >
-        <path d="M7,11 H23" />
-        <path d="M23,5 L35,11 L23,17 Z" />
-      </g>,
-      arrowheadPreviewIconProps,
     ),
 );
 
@@ -1369,10 +1328,10 @@ export const ArrowheadCircleIcon = React.memo(
         fill="currentColor"
         transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
       >
-        <path d="M7,11 H25" strokeWidth={2} strokeLinecap="round" />
+        <path d="M32 10L6 10" strokeWidth={2} />
-        <circle cx="29" cy="11" r="4" />
+        <circle r="4" transform="matrix(-1 0 0 1 30 10)" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
     ),
 );
 
@@ -1385,10 +1344,58 @@ export const ArrowheadCircleOutlineIcon = React.memo(
         transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
         strokeWidth={2}
       >
-        <path d="M7,11 H25" strokeLinecap="round" />
+        <path d="M26 10L6 10" />
-        <circle cx="29" cy="11" r="4" />
+        <circle r="4" transform="matrix(-1 0 0 1 30 10)" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
+    ),
+);
+
+export const ArrowheadBarIcon = React.memo(
+  ({ flip = false }: { flip?: boolean }) =>
+    createIcon(
+      <g transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}>
+        <path
+          d="M34 10H5.99996M34 10L34 5M34 10L34 15"
+          stroke="currentColor"
+          strokeWidth={2}
+          fill="none"
+        />
+      </g>,
+      { width: 40, height: 20 },
+    ),
+);
+
+export const ArrowheadTriangleIcon = React.memo(
+  ({ flip = false }: { flip?: boolean }) =>
+    createIcon(
+      <g
+        stroke="currentColor"
+        fill="currentColor"
+        transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
+      >
+        <path d="M32 10L6 10" strokeWidth={2} />
+        <path d="M27.5 5.5L34.5 10L27.5 14.5L27.5 5.5" />
+      </g>,
+      { width: 40, height: 20 },
+    ),
+);
+
+export const ArrowheadTriangleOutlineIcon = React.memo(
+  ({ flip = false }: { flip?: boolean }) =>
+    createIcon(
+      <g
+        stroke="currentColor"
+        fill="none"
+        transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
+        strokeWidth={2}
+        strokeLinejoin="round"
+      >
+        <path d="M6,9.5H27" />
+        <path d="M27,5L34,10L27,14Z" fill="none" />
+      </g>,
+
+      { width: 40, height: 20 },
     ),
 );
 
@@ -1400,11 +1407,12 @@ export const ArrowheadDiamondIcon = React.memo(
         fill="currentColor"
         transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
         strokeLinejoin="round"
+        strokeWidth={2}
       >
-        <path d="M7,11 H21" strokeWidth={2} strokeLinecap="round" />
+        <path d="M6,9.5H20" />
-        <path d="M21,11 L28,5 L35,11 L28,17 Z" />
+        <path d="M27,5L34,10L27,14L20,9.5Z" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
     ),
 );
 
@@ -1417,32 +1425,15 @@ export const ArrowheadDiamondOutlineIcon = React.memo(
         transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
         strokeLinejoin="round"
         strokeWidth={2}
-        strokeLinecap="round"
       >
-        <path d="M7,11 H21" />
+        <path d="M6,9.5H20" />
-        <path d="M21,11 L28,5 L35,11 L28,17 Z" />
+        <path d="M27,5L34,10L27,14L20,9.5Z" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
     ),
 );
 
-export const ArrowheadBarIcon = React.memo(
+export const ArrowheadCrowfootIcon = React.memo(
-  ({ flip = false }: { flip?: boolean }) =>
-    createIcon(
-      <g
-        transform={flip ? "translate(40, 0) scale(-1, 1)" : ""}
-        stroke="currentColor"
-        strokeWidth={2}
-        fill="none"
-        strokeLinecap="round"
-      >
-        <path d="M11,11 H31 M31,5 V17" />
-      </g>,
-      arrowheadPreviewIconProps,
-    ),
-);
-
-export const ArrowheadCardinalityOneIcon = React.memo(
   ({ flip = false }: { flip?: boolean }) =>
     createIcon(
       <g
@@ -1452,13 +1443,13 @@ export const ArrowheadCardinalityOneIcon = React.memo(
         strokeLinejoin="round"
         strokeWidth={2}
       >
-        <path d="M35,11 H7 M15,5 V17" />
+        <path d="M34,10 H6 M15,10 L7,5 M15,10 L7,15" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
     ),
 );
 
-export const ArrowheadCardinalityManyIcon = React.memo(
+export const ArrowheadCrowfootOneIcon = React.memo(
   ({ flip = false }: { flip?: boolean }) =>
     createIcon(
       <g
@@ -1468,13 +1459,13 @@ export const ArrowheadCardinalityManyIcon = React.memo(
         strokeLinejoin="round"
         strokeWidth={2}
       >
-        <path d="M35,11 H7 M15,11 L7,5 M15,11 L7,17" />
+        <path d="M34,10 H6 M15,10 L15,15 L15,5" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
     ),
 );
 
-export const ArrowheadCardinalityOneOrManyIcon = React.memo(
+export const ArrowheadCrowfootOneOrManyIcon = React.memo(
   ({ flip = false }: { flip?: boolean }) =>
     createIcon(
       <g
@@ -1484,59 +1475,9 @@ export const ArrowheadCardinalityOneOrManyIcon = React.memo(
         strokeLinejoin="round"
         strokeWidth={2}
       >
-        <path d="M35,11 H7 M23,5 V17 M15,11 L7,5 M15,11 L7,17" />
+        <path d="M34,10 H6 M15,10 L15,16 L15,4 M15,10 L7,5 M15,10 L7,15" />
       </g>,
-      arrowheadPreviewIconProps,
+      { width: 40, height: 20 },
-    ),
-);
-
-export const ArrowheadCardinalityExactlyOneIcon = React.memo(
-  ({ flip = false }: { flip?: boolean }) =>
-    createIcon(
-      <g
-        stroke="currentColor"
-        fill="none"
-        transform={flip ? "" : "translate(40, 0) scale(-1, 1)"}
-        strokeLinejoin="round"
-        strokeWidth={2}
-      >
-        <path d="M35,11 H7 M15,5 V17 M7,5 V17" />
-      </g>,
-      arrowheadPreviewIconProps,
-    ),
-);
-
-export const ArrowheadCardinalityZeroOrOneIcon = React.memo(
-  ({ flip = false }: { flip?: boolean }) =>
-    createIcon(
-      <g
-        stroke="currentColor"
-        fill="none"
-        transform={flip ? "" : "translate(40, 0) scale(-1, 1)"}
-        strokeLinejoin="round"
-        strokeWidth={2}
-      >
-        <path d="M35,11 H19 M11,11 H7 M7,5 V17" />
-        <circle cx="15" cy="11" r="4" />
-      </g>,
-      arrowheadPreviewIconProps,
-    ),
-);
-
-export const ArrowheadCardinalityZeroOrManyIcon = React.memo(
-  ({ flip = false }: { flip?: boolean }) =>
-    createIcon(
-      <g
-        stroke="currentColor"
-        fill="none"
-        transform={flip ? "" : "translate(40, 0) scale(-1, 1)"}
-        strokeLinejoin="round"
-        strokeWidth={2}
-      >
-        <path d="M35,11 H27 M19,11 H7 M15,11 L7,5 M15,11 L7,17" />
-        <circle cx="23" cy="11" r="4" />
-      </g>,
-      arrowheadPreviewIconProps,
     ),
 );
 

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

@@ -39,13 +39,7 @@ import DropdownMenuItemCheckbox from "../dropdownMenu/DropdownMenuItemCheckbox";
 import DropdownMenuItemContentRadio from "../dropdownMenu/DropdownMenuItemContentRadio";
 import DropdownMenuItemLink from "../dropdownMenu/DropdownMenuItemLink";
 import DropdownMenuSub from "../dropdownMenu/DropdownMenuSub";
-import {
+import { GithubIcon, DiscordIcon, XBrandIcon, settingsIcon } from "../icons";
-  GithubIcon,
-  DiscordIcon,
-  XBrandIcon,
-  settingsIcon,
-  emptyIcon,
-} from "../icons";
 import {
   boltIcon,
   DeviceDesktopIcon,
@@ -433,39 +427,6 @@ 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();
@@ -607,7 +568,6 @@ export const Preferences = ({
       <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
         {children || (
           <>
-            <PreferencesBoxSelectionModeItem />
             <PreferencesToggleToolLockItem />
             <PreferencesToggleSnapModeItem />
             <PreferencesToggleGridModeItem />
@@ -625,7 +585,6 @@ export const Preferences = ({
 };
 
 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
-Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;

packages/excalidraw/components/shapes.tsx

@@ -119,12 +119,15 @@ export const SHAPES = [
 export const getToolbarTools = (app: AppClassProperties) => {
   return app.state.preferredSelectionTool.type === "lasso"
     ? ([
-        SHAPES[0],
         {
-          ...SHAPES[1],
           value: "lasso",
+          icon: SelectionIcon,
+          key: KEYS.V,
+          numericKey: KEYS["1"],
+          fillable: true,
+          toolbar: true,
         },
-        ...SHAPES.slice(2),
+        ...SHAPES.slice(1),
       ] as const)
     : SHAPES;
 };

packages/excalidraw/css/styles.scss

@@ -814,14 +814,6 @@ body.excalidraw-cursor-resize * {
   .excalidraw__embeddable__outer {
     width: 100%;
     height: 100%;
-  }
-
-  .excalidraw__embeddable__content {
-    width: 100%;
-    height: 100%;
-    transform-origin: top left;
-
-    &,
     & > * {
       border-radius: var(--embeddable-radius);
     }

packages/excalidraw/css/theme.scss

@@ -34,10 +34,9 @@
   --popup-text-color: #000;
   --popup-text-inverted-color: #fff;
   --select-highlight-color: #{$color-blue-5};
-  --shadow-island: 0px 0px 1px 0px rgba(0, 0, 0, 0.17),
+  --shadow-island: 0px 0px 0.9310142993927002px 0px rgba(0, 0, 0, 0.17),
-    0px 0px 3px 0px rgba(0, 0, 0, 0.08), 0px 7px 14px 0px rgba(0, 0, 0, 0.05);
+    0px 0px 3.1270833015441895px 0px rgba(0, 0, 0, 0.08),
-  --shadow-island-stronger: 0px 0px 1px 0px rgba(0, 0, 0, 0.17),
+    0px 7px 14px 0px rgba(0, 0, 0, 0.05);
-    0px 0px 3px 0px rgba(0, 0, 0, 0.08), 0px 7px 14px 0px rgb(0 0 0 / 18%);
 
   --button-hover-bg: var(--color-surface-high);
   --button-active-bg: var(--color-surface-high);
@@ -211,6 +210,9 @@
     --popup-text-color: #{$color-gray-4};
     --popup-text-inverted-color: #2c2c2c;
     --select-highlight-color: #{$color-blue-4};
+    --shadow-island: 0px 0px 0.9310142993927002px 0px rgba(0, 0, 0, 0.17),
+      0px 0px 3.1270833015441895px 0px rgba(0, 0, 0, 0.08),
+      0px 7px 14px 0px rgba(0, 0, 0, 0.05);
 
     --modal-shadow: 0px 100px 80px rgba(0, 0, 0, 0.07),
       0px 41.7776px 33.4221px rgba(0, 0, 0, 0.0503198),

packages/excalidraw/data/index.ts

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

packages/excalidraw/data/resave.ts

@@ -20,6 +20,10 @@ export const resaveAsImageWithScene = async (
 ) => {
   const fileHandleType = getFileHandleType(fileHandle);
 
+  if (Math.random() < 1) {
+    throw new Error("OLALALALA");
+  }
+
   if (!isImageFileHandleType(fileHandleType)) {
     throw new Error(
       "fileHandle should exist and should be of type svg or png when resaving",

packages/excalidraw/data/restore.ts

@@ -22,7 +22,6 @@ import {
 import {
   calculateFixedPointForNonElbowArrowBinding,
   getNonDeletedElements,
-  normalizeArrowhead,
   isPointInElement,
   isValidPolygon,
   projectFixedPointOntoDiagonal,
@@ -96,8 +95,6 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
-const MAX_ARROW_PX = 75_000;
-
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -253,9 +250,7 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(
+    console.error(`could not repair binding for element`);
-      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
-    );
   } catch (error) {
     console.error("Error repairing binding:", error);
   }
@@ -431,8 +426,7 @@ export const restoreElement = (
     // @ts-ignore LEGACY type
     // eslint-disable-next-line no-fallthrough
     case "draw":
-      const startArrowhead = normalizeArrowhead(element.startArrowhead);
+      const { startArrowhead = null, endArrowhead = null } = element;
-      const endArrowhead = normalizeArrowhead(element.endArrowhead);
       let x = element.x;
       let y = element.y;
       let points = // migrate old arrow model to new one
@@ -464,13 +458,9 @@ export const restoreElement = (
         ...getSizeFromPoints(points),
       });
     case "arrow": {
-      const startArrowhead = normalizeArrowhead(element.startArrowhead);
+      const { startArrowhead = null, endArrowhead = "arrow" } = element;
-      const endArrowhead =
+      const x: number | undefined = element.x;
-        element.endArrowhead === undefined
+      const y: number | undefined = element.y;
-          ? "arrow"
-          : normalizeArrowhead(element.endArrowhead);
-      const x = element.x as number | undefined;
-      const y = element.y as number | undefined;
       const points: readonly LocalPoint[] | undefined = // migrate old arrow model to new one
         !Array.isArray(element.points) || element.points.length < 2
           ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
@@ -495,8 +485,8 @@ export const restoreElement = (
         startArrowhead,
         endArrowhead,
         points,
-        x: x ?? 0,
+        x,
-        y: y ?? 0,
+        y,
         elbowed: (element as ExcalidrawArrowElement).elbowed,
         ...getSizeFromPoints(points),
       };
@@ -515,44 +505,12 @@ export const restoreElement = (
           })
         : restoreElementWithProperties(element as ExcalidrawArrowElement, base);
 
-      const normalizedRestoredElement = {
+      return {
         ...restoredElement,
         ...LinearElementEditor.getNormalizeElementPointsAndCoords(
           restoredElement,
         ),
       };
-
-      // Last resort fix for extremely large arrows
-      if (
-        normalizedRestoredElement.width > MAX_ARROW_PX ||
-        normalizedRestoredElement.height > MAX_ARROW_PX
-      ) {
-        console.error(
-          `Removing extremely large arrow ${
-            normalizedRestoredElement.id
-          } (type: ${
-            isElbowArrow(normalizedRestoredElement) ? "elbow" : "simple"
-          }, width: ${normalizedRestoredElement.width}, height: ${
-            normalizedRestoredElement.height
-          }, x: ${normalizedRestoredElement.x}, y: ${
-            normalizedRestoredElement.y
-          })`,
-        );
-        return {
-          ...normalizedRestoredElement,
-          x: 0,
-          y: 0,
-          width: 100,
-          height: 100,
-          points: [
-            pointFrom<LocalPoint>(0, 0),
-            pointFrom<LocalPoint>(100, 100),
-          ],
-          isDeleted: true,
-        };
-      }
-
-      return normalizedRestoredElement;
     }
 
     // generic elements
@@ -700,7 +658,6 @@ export const restoreElements = <T extends ExcalidrawElement>(
   const existingElementsMap = existingElements
     ? arrayToMap(existingElements)
     : null;
-
   const restoredElements = syncInvalidIndices(
     (targetElements || []).reduce((elements, element) => {
       // filtering out selection, which is legacy, no longer kept in elements,
@@ -797,7 +754,7 @@ export const restoreElements = <T extends ExcalidrawElement>(
     }
   }
 
-  // NOTE (mtolmacs): Temporary fix for invalid/self-bound elbow arrows
+  // NOTE (mtolmacs): Temporary fix for extremely large arrows
   // Need to iterate again so we have attached text nodes in elementsMap
   return restoredElements.map((element) => {
     if (
@@ -971,12 +928,6 @@ export const restoreAppState = (
         : defaultValue;
   }
 
-  const boxSelectionMode =
-    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
-  if (boxSelectionMode !== undefined) {
-    nextAppState.boxSelectionMode = boxSelectionMode;
-  }
-
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/hooks/useAppStateValue.ts

@@ -6,51 +6,6 @@ import { getDefaultAppState } from "../appState";
 
 import type { AppState } from "../types";
 
-type AppStateSelector =
-  | keyof AppState
-  | (keyof AppState)[]
-  | ((appState: AppState) => unknown);
-
-const getSelectedValue = (appState: AppState, selector: AppStateSelector) => {
-  if (typeof selector === "function") {
-    return selector(appState);
-  }
-  if (Array.isArray(selector)) {
-    return appState;
-  }
-  return appState[selector];
-};
-
-const getLatestValue = (
-  api: ReturnType<typeof useExcalidrawAPI>,
-  selector: AppStateSelector,
-  _internal: boolean,
-) => {
-  if (api?.isDestroyed) {
-    return;
-  }
-
-  let appState = api?.getAppState();
-  if (!appState) {
-    if (!_internal) {
-      return undefined;
-    }
-
-    console.warn(
-      "useAppStateValue: excalidrawAPI not defined yet for internal component while it should always be defined. Are you sure you're rendering inside of <Excalidraw/> component tree?",
-    );
-    // fall back in case there's a bug so we don't break the app
-    // (internal components using this internal useAppStateValue expect
-    //  non-undefined values on init)
-    appState = Object.assign(
-      { width: 0, height: 0, offsetLeft: 0, offsetTop: 0 },
-      getDefaultAppState(),
-    );
-  }
-
-  return getSelectedValue(appState, selector);
-};
-
 /**
  * Subscribes to specific appState changes. The component re-renders
  * only when the specified prop(s) change — not on every appState update.
@@ -64,109 +19,92 @@ const getLatestValue = (
  *  - `(keyof AppState)[]` → whole `AppState`
  *  - selector function → selector's return type `T`
  *
+ * Calls the optional callback with the latest value on every change (not called
+ * on initial render).
+ *
  * If excalidrawAPI is not ready yet (host apps), hook is rerendered with latest
  * value once available.
  */
 export function useAppStateValue<K extends keyof AppState>(
   prop: K,
+  callback?: (value: AppState[K], appState: AppState) => void,
   _internal?: boolean,
 ): AppState[K];
 export function useAppStateValue(
   props: (keyof AppState)[],
+  callback?: (props: AppState, appState: AppState) => void,
   _internal?: boolean,
 ): AppState;
 export function useAppStateValue<T>(
   selector: (appState: AppState) => T,
+  callback?: (value: T, appState: AppState) => void,
   _internal?: boolean,
 ): T;
 export function useAppStateValue(
-  selector: AppStateSelector,
+  selector:
+    | keyof AppState
+    | (keyof AppState)[]
+    | ((appState: AppState) => unknown),
+  callback?: (value: any, appState: AppState) => void,
   _internal: boolean = true,
 ): unknown {
   const api = useExcalidrawAPI();
-  const [, rerender] = useState(0);
 
-  const stateRef = useRef<{
+  const getLatestValue = () => {
-    selector: AppStateSelector;
+    let appState = api?.getAppState();
-    isInitialized: boolean;
+    if (!appState) {
-    latestValue: unknown;
+      if (!_internal) {
-  } | null>(null);
+        return undefined;
-  if (!stateRef.current) {
+      }
-    stateRef.current = {
+      console.warn(
-      selector,
+        "useAppStateValue: excalidrawAPI not defined yet for internal component in which case it should always be defined. Are you sure you're rendering inside of <Excalidraw/> component tree?",
-      isInitialized: !!api,
+      );
-      latestValue: getLatestValue(api, selector, _internal),
+      // fall back in case there's a bug so we don't break the app
-    };
+      // (internal components using this internal useAppStateValue expect
-  }
+      //  non-undefined values on init)
-  stateRef.current.selector = selector;
+      appState = Object.assign(
-  if (!stateRef.current.isInitialized && api && !api.isDestroyed) {
+        { width: 0, height: 0, offsetLeft: 0, offsetTop: 0 },
-    stateRef.current.isInitialized = true;
+        getDefaultAppState(),
-    stateRef.current.latestValue = getLatestValue(api, selector, _internal);
+      );
-  }
-
-  useEffect(() => {
-    const currentStateRef = stateRef.current;
-    if (!api || api.isDestroyed || !currentStateRef) {
-      return;
     }
+    if (typeof selector === "function") {
+      return selector(appState);
+    }
+    if (Array.isArray(selector)) {
+      return appState;
+    }
+    return appState[selector];
+  };
 
-    return api.onStateChange(currentStateRef.selector, (newValue: any) => {
+  const [value, setValue] = useState<unknown>(getLatestValue);
-      currentStateRef.latestValue = newValue;
-      rerender((value) => value + 1);
-    });
-  }, [api]);
-
-  return stateRef.current.latestValue;
-}
-
-/**
- * Subscribes to specific appState changes without causing component rerenders.
- *
- * The callback is called on every matching change, but also on initial render
- * so you can initialize your state.
- */
-export function useOnAppStateChange<K extends keyof AppState>(
-  prop: K,
-  callback: (value: AppState[K], appState: AppState) => void,
-): undefined;
-export function useOnAppStateChange(
-  props: (keyof AppState)[],
-  callback: (props: AppState, appState: AppState) => void,
-): undefined;
-export function useOnAppStateChange<T>(
-  selector: (appState: AppState) => T,
-  callback: (value: T, appState: AppState) => void,
-): undefined;
-export function useOnAppStateChange(
-  selector: AppStateSelector,
-  callback: (value: any, appState: AppState) => void,
-): undefined {
-  const api = useExcalidrawAPI();
 
   const stateRef = useRef({
     selector,
     callback,
+    isInitialized: !!api,
+    latestValue: value,
   });
   stateRef.current.selector = selector;
   stateRef.current.callback = callback;
+  if (!stateRef.current.isInitialized && api) {
+    stateRef.current.isInitialized = true;
+    stateRef.current.latestValue = getLatestValue();
+  }
 
   useEffect(() => {
-    if (!api || api.isDestroyed) {
+    if (!api) {
       return;
     }
 
-    stateRef.current.callback(
-      getLatestValue(api, stateRef.current.selector, true),
-      api.getAppState(),
-    );
-
     return api.onStateChange(
       stateRef.current.selector,
       (newValue: any, state: AppState) => {
-        stateRef.current.callback(newValue, state);
+        stateRef.current.latestValue = newValue;
+        stateRef.current.callback?.(newValue, state);
+        setValue(newValue);
       },
     );
   }, [api]);
 
-  return undefined;
+  return stateRef.current.latestValue;
 }

packages/excalidraw/index.tsx

@@ -1,10 +1,4 @@
-import React, {
+import React, { useCallback, useContext, useEffect, useState } from "react";
-  useCallback,
-  useContext,
-  useEffect,
-  useRef,
-  useState,
-} from "react";
 
 import { DEFAULT_UI_OPTIONS, isShallowEqual } from "@excalidraw/common";
 
@@ -18,10 +12,7 @@ import LiveCollaborationTrigger from "./components/live-collaboration/LiveCollab
 import MainMenu from "./components/main-menu/MainMenu";
 import WelcomeScreen from "./components/welcome-screen/WelcomeScreen";
 import { defaultLang } from "./i18n";
-import {
+import { useAppStateValue as _useAppStateValue } from "./hooks/useAppStateValue";
-  useAppStateValue as _useAppStateValue,
-  useOnAppStateChange as _useOnAppStateChange,
-} from "./hooks/useAppStateValue";
 import { EditorJotaiProvider, editorJotaiStore } from "./editor-jotai";
 import polyfill from "./polyfill";
 
@@ -40,8 +31,8 @@ polyfill();
 
 /**
  * Stateless provider that allows `useExcalidrawAPI()` (and hooks built
- * on it, such as `useAppStateValue()` and `useOnAppStateChange()`) to work
+ * on it, such as `useAppStateValue()`) to work outside the <Excalidraw>
- * outside the <Excalidraw> component tree.
+ * component tree.
  */
 export const ExcalidrawAPIProvider = ({
   children,
@@ -66,7 +57,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
     initialData,
     onExcalidrawAPI,
     onMount,
-    onUnmount,
     onInitialize,
     isCollaborating = false,
     onPointerUpdate,
@@ -129,16 +119,12 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
   }
 
   const setExcalidrawAPI = useContext(ExcalidrawAPISetContext);
-
-  const onExcalidrawAPIRef = useRef(onExcalidrawAPI);
-  onExcalidrawAPIRef.current = onExcalidrawAPI;
-
   const handleExcalidrawAPI = useCallback(
-    (api: ExcalidrawImperativeAPI | null) => {
+    (api: ExcalidrawImperativeAPI) => {
       setExcalidrawAPI?.(api);
-      onExcalidrawAPIRef.current?.(api);
+      onExcalidrawAPI?.(api);
     },
-    [setExcalidrawAPI],
+    [onExcalidrawAPI, setExcalidrawAPI],
   );
 
   useEffect(() => {
@@ -176,7 +162,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
           initialData={initialData}
           onExcalidrawAPI={handleExcalidrawAPI}
           onMount={onMount}
-          onUnmount={onUnmount}
           onInitialize={onInitialize}
           isCollaborating={isCollaborating}
           onPointerUpdate={onPointerUpdate}
@@ -382,8 +367,6 @@ 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";
@@ -395,7 +378,7 @@ export {
 } from "./charts";
 
 // -----------------------------------------------------------------------------
-// useExcalidrawStateValue() wrapper for host apps for the return type to reflect the
+// useAppStateValue() wrapper for host apps for the return type to reflect the
 // the potentially `undefined` value for initial render before the excalidrawAPI
 // is ready.
 //
@@ -405,23 +388,25 @@ export {
  * @param prop - appState prop(s) to subscribe to, or a selector function.
  * NOTE `prop/selector` is memoized and will not change after initial render
  */
-export function useExcalidrawStateValue<K extends keyof AppState>(
+export function useAppStateValue<K extends keyof AppState>(
   prop: K,
+  callback?: (value: AppState[K], appState: AppState) => void,
 ): AppState[K] | undefined;
-export function useExcalidrawStateValue<T extends keyof AppState>(
+export function useAppStateValue<T extends keyof AppState>(
   props: T[],
+  callback?: (values: AppState, appState: AppState) => void,
 ): AppState | undefined;
-export function useExcalidrawStateValue<T>(
+export function useAppStateValue<T>(
   selector: (appState: AppState) => T,
+  callback?: (value: T, appState: AppState) => void,
 ): T | undefined;
-export function useExcalidrawStateValue(
+export function useAppStateValue(
   selector:
     | keyof AppState
     | (keyof AppState)[]
     | ((appState: AppState) => unknown),
+  callback?: (value: any, appState: AppState) => void,
 ) {
-  return _useAppStateValue(selector as any, false);
+  return _useAppStateValue(selector as any, callback, false);
 }
 // -----------------------------------------------------------------------------
-
-export { _useOnAppStateChange as useOnExcalidrawStateChange };

packages/excalidraw/locales/en.json

@@ -53,14 +53,7 @@
     "arrowhead_crowfoot_many": "Crow's foot (many)",
     "arrowhead_crowfoot_one": "Crow's foot (one)",
     "arrowhead_crowfoot_one_or_many": "Crow's foot (one or many)",
-    "arrowhead_cardinality_one": "Cardinality (one)",
-    "arrowhead_cardinality_many": "Cardinality (many)",
-    "arrowhead_cardinality_one_or_many": "Cardinality (one or many)",
-    "arrowhead_cardinality_exactly_one": "Cardinality (exactly one)",
-    "arrowhead_cardinality_zero_or_one": "Cardinality (zero or one)",
-    "arrowhead_cardinality_zero_or_many": "Cardinality (zero or many)",
     "more_options": "More options",
-    "cardinality": "Cardinality",
     "arrowtypes": "Arrow type",
     "arrowtype_sharp": "Sharp arrow",
     "arrowtype_round": "Curved arrow",
@@ -185,9 +178,6 @@
     "shapeSwitch": "Switch shape",
     "preferences": "Preferences",
     "preferences_toolLock": "Tool lock",
-    "boxSelectionMode": "Select on",
-    "boxSelectionContain": "Wrap",
-    "boxSelectionOverlap": "Overlap",
     "arrowBinding": "Arrow binding",
     "midpointSnapping": "Snap to midpoints"
   },
@@ -634,7 +624,7 @@
   "mermaid": {
     "title": "Mermaid to Excalidraw",
     "button": "Insert",
-    "description": "Currently only <flowchartLink>Flowchart</flowchartLink>, <sequenceLink>Sequence</sequenceLink>, <classLink>Class</classLink>, and <erdLink>Entity Relationship</erdLink> Diagrams are supported. The other types will be rendered as image in Excalidraw.",
+    "description": "Currently only <flowchartLink>Flowchart</flowchartLink>,<sequenceLink> Sequence, </sequenceLink> and <classLink>Class </classLink>Diagrams are supported. The other types will be rendered as image in Excalidraw.",
     "syntax": "Mermaid Syntax",
     "preview": "Preview",
     "label": "Mermaid",
@@ -664,7 +654,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, State, and Entity Relationship diagrams."
+      "hint": "At the moment we know Flowchart, Sequence, and Class diagrams."
     },
     "preview": "Preview",
     "insert": "Insert",

packages/excalidraw/package.json

@@ -88,13 +88,14 @@
     "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
     "@excalidraw/math": "0.18.0",
-    "@excalidraw/mermaid-to-excalidraw": "2.2.2",
+    "@excalidraw/mermaid-to-excalidraw": "2.0.0-rc4",
     "@excalidraw/random-username": "1.1.0",
     "browser-fs-access": "0.38.0",
     "canvas-roundrect-polyfill": "0.0.1",
     "clsx": "1.1.1",
     "cross-env": "7.0.3",
     "es6-promise-pool": "2.5.0",
+    "fractional-indexing": "3.2.0",
     "fuzzy": "0.1.3",
     "image-blob-reduce": "3.0.1",
     "jotai": "2.11.0",

packages/excalidraw/polyfill.ts

@@ -23,94 +23,6 @@ const polyfill = () => {
     });
   }
 
-  if (!Array.prototype.findLast) {
-    Object.defineProperty(Array.prototype, "findLast", {
-      value: function <T>(
-        this: T[],
-        predicate: (value: T, index: number, array: T[]) => unknown,
-        thisArg?: unknown,
-      ) {
-        return this
-          .slice()
-          .reverse()
-          .find((value, index) =>
-            predicate.call(thisArg, value, this.length - index - 1, this),
-          );
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.findIndex) {
-    Object.defineProperty(Array.prototype, "findIndex", {
-      value: function <T>(
-        this: T[],
-        predicate: (value: T, index: number, array: T[]) => unknown,
-        thisArg?: unknown,
-      ) {
-        for (let index = 0; index < this.length; index++) {
-          if (predicate.call(thisArg, this[index], index, this)) {
-            return index;
-          }
-        }
-
-        return -1;
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.findLastIndex) {
-    Object.defineProperty(Array.prototype, "findLastIndex", {
-      value: function <T>(
-        this: T[],
-        predicate: (value: T, index: number, array: T[]) => unknown,
-        thisArg?: unknown,
-      ) {
-        const index = this
-          .slice()
-          .reverse()
-          .findIndex((value, index) =>
-            predicate.call(thisArg, value, this.length - index - 1, this),
-          );
-
-        return index === -1 ? -1 : this.length - index - 1;
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.toReversed) {
-    Object.defineProperty(Array.prototype, "toReversed", {
-      value: function <T>(this: T[]) {
-        return this.slice().reverse();
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.toSorted) {
-    Object.defineProperty(Array.prototype, "toSorted", {
-      value: function <T>(
-        this: T[],
-        compareFn?: (a: T, b: T) => number,
-      ) {
-        return this.slice().sort(compareFn);
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
   if (!Element.prototype.replaceChildren) {
     Element.prototype.replaceChildren = function (...nodes) {
       this.innerHTML = "";

packages/excalidraw/renderer/interactiveScene.ts

@@ -41,7 +41,6 @@ import {
   maxBindingDistance_simple,
   isTextElement,
   LinearElementEditor,
-  getActiveTextElement,
 } from "@excalidraw/element";
 
 import { renderSelectionElement } from "@excalidraw/element";
@@ -59,8 +58,6 @@ import {
   isFocusPointVisible,
 } from "@excalidraw/element";
 
-import type { EditorInterface } from "@excalidraw/common";
-
 import type {
   TransformHandles,
   TransformHandleType,
@@ -89,10 +86,6 @@ import {
 } from "../scene/scrollbars";
 
 import { getClientColor, renderRemoteCursors } from "../clients";
-import {
-  getTextAutoResizeHandle,
-  getTextBoxPadding,
-} from "../textAutoResizeHandle";
 
 import {
   bootstrapCanvas,
@@ -1156,7 +1149,6 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
-          elementsMap,
         )
       ) {
         renderSingleLinearPoint(
@@ -1497,58 +1489,21 @@ const renderTextBox = (
   selectionColor: InteractiveCanvasRenderConfig["selectionColor"],
 ) => {
   context.save();
-  const padding = getTextBoxPadding(appState.zoom.value);
+  const padding = (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / appState.zoom.value;
   const width = text.width + padding * 2;
   const height = text.height + padding * 2;
-  const cx = text.x + text.width / 2;
+  const cx = text.x + width / 2;
-  const cy = text.y + text.height / 2;
+  const cy = text.y + height / 2;
-  const shiftX = -(text.width / 2 + padding);
+  const shiftX = -(width / 2 + padding);
-  const shiftY = -(text.height / 2 + padding);
+  const shiftY = -(height / 2 + padding);
   context.translate(cx + appState.scrollX, cy + appState.scrollY);
   context.rotate(text.angle);
   context.lineWidth = 1 / appState.zoom.value;
   context.strokeStyle = selectionColor;
-  context.globalAlpha = 0.5;
-  context.setLineDash([6 / appState.zoom.value, 4 / appState.zoom.value]);
   context.strokeRect(shiftX, shiftY, width, height);
   context.restore();
 };
 
-const renderResetAutoResizeHandle = (
-  text: NonDeleted<ExcalidrawTextElement>,
-  context: CanvasRenderingContext2D,
-  appState: InteractiveCanvasAppState,
-  selectionColor: InteractiveCanvasRenderConfig["selectionColor"],
-  formFactor: EditorInterface["formFactor"],
-) => {
-  const autoResizeHandle = getTextAutoResizeHandle(
-    text,
-    appState.zoom.value,
-    formFactor,
-  );
-
-  if (!autoResizeHandle) {
-    return;
-  }
-
-  context.save();
-  context.globalAlpha = 0.5;
-  context.lineWidth = 1.5 / appState.zoom.value;
-  context.lineCap = "round";
-  context.strokeStyle = selectionColor;
-  context.beginPath();
-  context.moveTo(
-    autoResizeHandle.start[0] + appState.scrollX,
-    autoResizeHandle.start[1] + appState.scrollY,
-  );
-  context.lineTo(
-    autoResizeHandle.end[0] + appState.scrollX,
-    autoResizeHandle.end[1] + appState.scrollY,
-  );
-  context.stroke();
-  context.restore();
-};
-
 const _renderInteractiveScene = ({
   app,
   canvas,
@@ -1629,19 +1584,10 @@ const _renderInteractiveScene = ({
     }
   }
 
-  const activeTextElement = getActiveTextElement(selectedElements, appState);
+  if (
-
+    appState.editingTextElement &&
-  if (activeTextElement && !activeTextElement.autoResize) {
+    isTextElement(appState.editingTextElement)
-    renderResetAutoResizeHandle(
+  ) {
-      activeTextElement,
-      context,
-      appState,
-      renderConfig.selectionColor,
-      editorInterface.formFactor,
-    );
-  }
-
-  if (appState.editingTextElement) {
     const textElement = allElementsMap.get(appState.editingTextElement.id) as
       | ExcalidrawTextElement
       | undefined;

packages/excalidraw/scene/Renderer.ts

@@ -1,15 +1,9 @@
-import {
+import { isElementInViewport } from "@excalidraw/element";
-  getCommonFrameId,
-  getFrameChildrenInsertionIndex,
-  isElementInViewport,
-} from "@excalidraw/element";
 
-import { arrayToMap, memoize, toBrandedType } from "@excalidraw/common";
+import { memoize, toBrandedType } from "@excalidraw/common";
 
 import type {
   ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-  NonDeleted,
   NonDeletedElementsMap,
   NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
@@ -22,21 +16,6 @@ import type { RenderableElementsMap } from "./types";
 
 import type { AppState } from "../types";
 
-type GetRenderableElementsOpts = {
-  zoom: AppState["zoom"];
-  offsetLeft: AppState["offsetLeft"];
-  offsetTop: AppState["offsetTop"];
-  scrollX: AppState["scrollX"];
-  scrollY: AppState["scrollY"];
-  height: AppState["height"];
-  width: AppState["width"];
-  editingTextElement: AppState["editingTextElement"];
-  newElement: AppState["newElement"];
-  selectedElements: readonly NonDeletedExcalidrawElement[];
-  selectedElementsAreBeingDragged: AppState["selectedElementsAreBeingDragged"];
-  frameToHighlight: AppState["frameToHighlight"];
-};
-
 export class Renderer {
   private scene: Scene;
 
@@ -44,121 +23,9 @@ export class Renderer {
     this.scene = scene;
   }
 
-  private getVisibleCanvasElements({
+  public getRenderableElements = (() => {
-    elementsMap,
+    const getVisibleCanvasElements = ({
-    zoom,
+      elementsMap,
-    offsetLeft,
-    offsetTop,
-    scrollX,
-    scrollY,
-    height,
-    width,
-  }: {
-    elementsMap: NonDeletedElementsMap;
-    zoom: AppState["zoom"];
-    offsetLeft: AppState["offsetLeft"];
-    offsetTop: AppState["offsetTop"];
-    scrollX: AppState["scrollX"];
-    scrollY: AppState["scrollY"];
-    height: AppState["height"];
-    width: AppState["width"];
-  }): readonly NonDeletedExcalidrawElement[] {
-    const visibleElements: NonDeletedExcalidrawElement[] = [];
-    for (const element of elementsMap.values()) {
-      if (
-        isElementInViewport(
-          element,
-          width,
-          height,
-          {
-            zoom,
-            offsetLeft,
-            offsetTop,
-            scrollX,
-            scrollY,
-          },
-          elementsMap,
-        )
-      ) {
-        visibleElements.push(element);
-      }
-    }
-    return visibleElements;
-  }
-
-  private getRenderableElementsMap({
-    elements,
-    editingTextElement,
-    newElement,
-  }: {
-    elements: readonly NonDeletedExcalidrawElement[];
-    editingTextElement: AppState["editingTextElement"];
-    newElement: AppState["newElement"];
-  }) {
-    const elementsMap = toBrandedType<RenderableElementsMap>(new Map());
-    const newElementCanvasElement = newElement?.frameId ? null : newElement;
-
-    for (const element of elements) {
-      if (newElementCanvasElement?.id === element.id) {
-        continue;
-      }
-
-      // we don't want to render text element that's being currently edited
-      // (it's rendered on remote only)
-      if (
-        !editingTextElement ||
-        editingTextElement.type !== "text" ||
-        element.id !== editingTextElement.id
-      ) {
-        elementsMap.set(element.id, element);
-      }
-    }
-    return { elementsMap, newElementCanvasElement };
-  }
-
-  private sortSelectedElementsIntoHighlightedFrame<
-    T extends ExcalidrawElement,
-  >({
-    visibleElements,
-    selectedElements,
-    frameToHighlight,
-  }: {
-    selectedElements: readonly NonDeletedExcalidrawElement[];
-    visibleElements: readonly T[];
-    frameToHighlight: NonDeleted<ExcalidrawFrameLikeElement>;
-  }): readonly T[] {
-    if (!selectedElements.length) {
-      return visibleElements;
-    }
-
-    // we assume all selected elements are eligible frame children if
-    // frameToHighlight is defined
-    const selectedElementsMap = arrayToMap(selectedElements);
-
-    // thus, all deselected elements are the ones we won't reorder
-    const deselectedElements = visibleElements.filter(
-      (element) => !selectedElementsMap.has(element.id),
-    );
-
-    const insertionIndex = getFrameChildrenInsertionIndex(
-      deselectedElements,
-      frameToHighlight.id,
-    );
-
-    if (insertionIndex === null) {
-      return visibleElements;
-    }
-
-    return [
-      ...deselectedElements.slice(0, insertionIndex),
-      ...selectedElements,
-      ...deselectedElements.slice(insertionIndex),
-    ] as readonly T[];
-  }
-
-  private _getRenderableElements = memoize(
-    ({
-      canvasNonce,
       zoom,
       offsetLeft,
       offsetTop,
@@ -166,27 +33,70 @@ export class Renderer {
       scrollY,
       height,
       width,
+    }: {
+      elementsMap: NonDeletedElementsMap;
+      zoom: AppState["zoom"];
+      offsetLeft: AppState["offsetLeft"];
+      offsetTop: AppState["offsetTop"];
+      scrollX: AppState["scrollX"];
+      scrollY: AppState["scrollY"];
+      height: AppState["height"];
+      width: AppState["width"];
+    }): readonly NonDeletedExcalidrawElement[] => {
+      const visibleElements: NonDeletedExcalidrawElement[] = [];
+      for (const element of elementsMap.values()) {
+        if (
+          isElementInViewport(
+            element,
+            width,
+            height,
+            {
+              zoom,
+              offsetLeft,
+              offsetTop,
+              scrollX,
+              scrollY,
+            },
+            elementsMap,
+          )
+        ) {
+          visibleElements.push(element);
+        }
+      }
+      return visibleElements;
+    };
+
+    const getRenderableElements = ({
+      elements,
       editingTextElement,
-      newElement,
+      newElementId,
-    }: Omit<
+    }: {
-      GetRenderableElementsOpts,
+      elements: readonly NonDeletedExcalidrawElement[];
-      | "selectedElements"
+      editingTextElement: AppState["editingTextElement"];
-      | "selectedElementsAreBeingDragged"
+      newElementId: ExcalidrawElement["id"] | undefined;
-      | "frameToHighlight"
-    > & {
-      canvasNonce: string;
     }) => {
-      const elements = this.scene.getNonDeletedElements();
+      const elementsMap = toBrandedType<RenderableElementsMap>(new Map());
 
-      const { elementsMap, newElementCanvasElement } =
+      for (const element of elements) {
-        this.getRenderableElementsMap({
+        if (newElementId === element.id) {
-          elements,
+          continue;
-          editingTextElement,
+        }
-          newElement,
-        });
 
-      const visibleElements = this.getVisibleCanvasElements({
+        // we don't want to render text element that's being currently edited
-        elementsMap,
+        // (it's rendered on remote only)
+        if (
+          !editingTextElement ||
+          editingTextElement.type !== "text" ||
+          element.id !== editingTextElement.id
+        ) {
+          elementsMap.set(element.id, element);
+        }
+      }
+      return elementsMap;
+    };
+
+    return memoize(
+      ({
         zoom,
         offsetLeft,
         offsetTop,
@@ -194,69 +104,52 @@ export class Renderer {
         scrollY,
         height,
         width,
-      });
+        editingTextElement,
+        newElementId,
+        // cache-invalidation nonce
+        sceneNonce: _sceneNonce,
+      }: {
+        zoom: AppState["zoom"];
+        offsetLeft: AppState["offsetLeft"];
+        offsetTop: AppState["offsetTop"];
+        scrollX: AppState["scrollX"];
+        scrollY: AppState["scrollY"];
+        height: AppState["height"];
+        width: AppState["width"];
+        editingTextElement: AppState["editingTextElement"];
+        /** note: first render of newElement will always bust the cache
+         * (we'd have to prefilter elements outside of this function) */
+        newElementId: ExcalidrawElement["id"] | undefined;
+        sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
+      }) => {
+        const elements = this.scene.getNonDeletedElements();
 
-      return {
+        const elementsMap = getRenderableElements({
-        elementsMap,
+          elements,
-        visibleElements,
+          editingTextElement,
-        newElementCanvasElement,
+          newElementId,
-        canvasNonce,
-      };
-    },
-  );
-
-  public getRenderableElements = (opts: GetRenderableElementsOpts) => {
-    const { newElement } = opts;
-    const canvasNonce = `${this.scene.getSceneNonce()}${
-      newElement?.frameId ? `:${newElement.versionNonce}` : ""
-    }`;
-
-    const ret = this._getRenderableElements({
-      canvasNonce,
-
-      // don't spread `opts` because we don't want to memoize on some props
-
-      zoom: opts.zoom,
-      offsetLeft: opts.offsetLeft,
-      offsetTop: opts.offsetTop,
-      scrollX: opts.scrollX,
-      scrollY: opts.scrollY,
-      height: opts.height,
-      width: opts.width,
-      editingTextElement: opts.editingTextElement,
-      newElement: opts.newElement,
-    });
-
-    // if we're dragging elements over a frame, reorder the selected elements
-    // inside the frame during render (we don't set the `element.frameId` until
-    // pointerup else we'd have to painstainly restore the orig index if user
-    // didn't end up adding elements to the frame)
-    if (
-      opts.frameToHighlight &&
-      opts.selectedElementsAreBeingDragged &&
-      // if all dragged elements are already in the frame, don't reorder
-      getCommonFrameId(opts.selectedElements) !== opts.frameToHighlight.id
-    ) {
-      const reorderedVisibleElements =
-        this.sortSelectedElementsIntoHighlightedFrame({
-          visibleElements: ret.visibleElements,
-          selectedElements: opts.selectedElements,
-          frameToHighlight: opts.frameToHighlight,
         });
 
-      return {
+        const visibleElements = getVisibleCanvasElements({
-        ...ret,
+          elementsMap,
-        visibleElements: reorderedVisibleElements,
+          zoom,
-      };
+          offsetLeft,
-    }
+          offsetTop,
+          scrollX,
+          scrollY,
+          height,
+          width,
+        });
 
-    return ret;
+        return { elementsMap, visibleElements };
-  };
+      },
+    );
+  })();
 
   // NOTE Doesn't destroy everything (scene, rc, etc.) because it may not be
   // safe to break TS contract here (for upstream cases)
   public destroy() {
     renderStaticSceneThrottled.cancel();
-    this._getRenderableElements.clear();
+    this.getRenderableElements.clear();
   }
 }

packages/excalidraw/scene/export.ts

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

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

@@ -1,6 +1,6 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`Test <MermaidToExcalidraw/> > should open mermaid popup when active tool is mermaid 1`] = `"<div class="Modal Dialog ttd-dialog" role="dialog" aria-modal="true" aria-labelledby="dialog-title"><div class="Modal__background"></div><div class="Modal__content" style="--max-width: 1520px;" tabindex="0"><div class="Island"><div class="Dialog__content"><div dir="ltr" data-orientation="horizontal" class="ttd-dialog-tabs-root"><p class="dialog-mermaid-title">Mermaid to Excalidraw</p><div data-state="active" data-orientation="horizontal" role="tabpanel" aria-labelledby="radix-:r4:-trigger-mermaid" id="radix-:r4:-content-mermaid" tabindex="0" class="ttd-dialog-content" style=""><div class="ttd-dialog-desc">Currently only <a href="https://mermaid.js.org/syntax/flowchart.html" target="_blank" rel="noreferrer">Flowchart</a>, <a href="https://mermaid.js.org/syntax/sequenceDiagram.html" target="_blank" rel="noreferrer">Sequence</a>, <a href="https://mermaid.js.org/syntax/classDiagram.html" target="_blank" rel="noreferrer">Class</a>, and <a href="https://mermaid.js.org/syntax/entityRelationshipDiagram.html" target="_blank" rel="noreferrer">Entity Relationship</a> Diagrams are supported. The other types will be rendered as image in Excalidraw.</div><div class="ttd-dialog-panels"><div class="ttd-dialog-panel"><div class="ttd-dialog-panel-button-container invisible" style="justify-content: flex-start;"></div></div><div class="ttd-dialog-panel"><div class="ttd-dialog-output-wrapper "><div class="ttd-dialog-output-canvas-container"><div class="ttd-dialog-output-canvas-content"><canvas width="89" height="158" dir="ltr"></canvas></div></div></div><div class="ttd-dialog-panel-button-container" style="justify-content: flex-start;"><button type="button" class="excalidraw-button ttd-dialog-panel-button"><div class="">Insert<span><svg aria-hidden="true" focusable="false" role="img" viewBox="0 0 20 20" class="" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"><g stroke-width="1.25"><path d="M4.16602 10H15.8327"></path><path d="M12.5 13.3333L15.8333 10"></path><path d="M12.5 6.66666L15.8333 9.99999"></path></g></svg></span></div></button><div class="ttd-dialog-submit-shortcut"><div class="ttd-dialog-submit-shortcut__key">Ctrl</div><div class="ttd-dialog-submit-shortcut__key">Enter</div></div></div></div></div></div></div></div></div></div></div>"`;
+exports[`Test <MermaidToExcalidraw/> > should open mermaid popup when active tool is mermaid 1`] = `"<div class="Modal Dialog ttd-dialog" role="dialog" aria-modal="true" aria-labelledby="dialog-title"><div class="Modal__background"></div><div class="Modal__content" style="--max-width: 1520px;" tabindex="0"><div class="Island"><div class="Dialog__content"><div dir="ltr" data-orientation="horizontal" class="ttd-dialog-tabs-root"><p class="dialog-mermaid-title">Mermaid to Excalidraw</p><div data-state="active" data-orientation="horizontal" role="tabpanel" aria-labelledby="radix-:r4:-trigger-mermaid" id="radix-:r4:-content-mermaid" tabindex="0" class="ttd-dialog-content" style=""><div class="ttd-dialog-desc">Currently only <a href="https://mermaid.js.org/syntax/flowchart.html">Flowchart</a>,<a href="https://mermaid.js.org/syntax/sequenceDiagram.html"> Sequence, </a> and <a href="https://mermaid.js.org/syntax/classDiagram.html">Class </a>Diagrams are supported. The other types will be rendered as image in Excalidraw.</div><div class="ttd-dialog-panels"><div class="ttd-dialog-panel"><div class="ttd-dialog-panel-button-container invisible" style="justify-content: flex-start;"></div></div><div class="ttd-dialog-panel"><div class="ttd-dialog-output-wrapper "><div class="ttd-dialog-output-canvas-container"><div class="ttd-dialog-output-canvas-content"><canvas width="89" height="158" dir="ltr"></canvas></div></div></div><div class="ttd-dialog-panel-button-container" style="justify-content: flex-start;"><button type="button" class="excalidraw-button ttd-dialog-panel-button"><div class="">Insert<span><svg aria-hidden="true" focusable="false" role="img" viewBox="0 0 20 20" class="" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"><g stroke-width="1.25"><path d="M4.16602 10H15.8327"></path><path d="M12.5 13.3333L15.8333 10"></path><path d="M12.5 6.66666L15.8333 9.99999"></path></g></svg></span></div></button><div class="ttd-dialog-submit-shortcut"><div class="ttd-dialog-submit-shortcut__key">Ctrl</div><div class="ttd-dialog-submit-shortcut__key">Enter</div></div></div></div></div></div></div></div></div></div></div>"`;
 
 exports[`Test <MermaidToExcalidraw/> > should show error in preview when mermaid library throws error 1`] = `
 "flowchart TD

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

@@ -13,7 +13,6 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -979,6 +978,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1086,7 +1086,6 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1172,6 +1171,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1300,7 +1300,6 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1386,6 +1385,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1631,7 +1631,6 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1717,6 +1716,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1962,7 +1962,6 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2048,6 +2047,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2176,7 +2176,6 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2260,6 +2259,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2417,7 +2417,6 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2503,6 +2502,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2715,7 +2715,6 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2806,6 +2805,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3087,7 +3087,6 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3173,6 +3172,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3580,7 +3580,6 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3666,6 +3665,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3903,7 +3903,6 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3989,6 +3988,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4226,7 +4226,6 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4315,6 +4314,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4358,7 +4358,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 1006504105,
+  "versionNonce": 760410951,
   "width": 20,
   "x": -10,
   "y": 0,
@@ -4383,14 +4383,14 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 400692809,
+  "seed": 238820263,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 289600103,
+  "versionNonce": 1006504105,
   "width": 20,
   "x": 20,
   "y": 30,
@@ -4637,7 +4637,6 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -5600,6 +5599,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5854,7 +5854,6 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -6819,6 +6818,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6864,7 +6864,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 1723083209,
+  "versionNonce": 747212839,
   "width": 10,
   "x": -10,
   "y": 0,
@@ -6891,14 +6891,14 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 400692809,
+  "seed": 238820263,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 760410951,
+  "versionNonce": 1723083209,
   "width": 10,
   "x": 12,
   "y": 0,
@@ -7122,7 +7122,6 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -7772,6 +7771,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7811,7 +7811,6 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -8771,6 +8770,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8802,7 +8802,6 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -9765,6 +9764,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,

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

@@ -13,7 +13,6 @@ 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,
@@ -106,6 +105,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -439,7 +439,6 @@ 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,
@@ -534,6 +533,7 @@ exports[`given element A and group of elements B and given both are selected whe
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -855,7 +855,6 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -941,6 +940,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1421,7 +1421,6 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1507,6 +1506,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1628,7 +1628,6 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1719,6 +1718,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2012,7 +2012,6 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2100,6 +2099,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2257,7 +2257,6 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2343,6 +2342,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2437,7 +2437,6 @@ exports[`regression tests > can drag element that covers another element, while
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2525,6 +2524,7 @@ exports[`regression tests > can drag element that covers another element, while
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2762,7 +2762,6 @@ 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,
@@ -2848,6 +2847,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3017,7 +3017,6 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3105,6 +3104,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3258,7 +3258,6 @@ 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,
@@ -3346,6 +3345,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3494,7 +3494,6 @@ 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,
@@ -3582,6 +3581,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3752,7 +3752,6 @@ 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,
@@ -3841,6 +3840,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4066,7 +4066,6 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4154,6 +4153,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4502,7 +4502,6 @@ exports[`regression tests > deselects group of selected elements on pointer down
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4617,6 +4616,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4785,7 +4785,6 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4872,6 +4871,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5061,7 +5061,6 @@ exports[`regression tests > deselects selected element on pointer down when poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5175,6 +5174,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5269,7 +5269,6 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5355,6 +5354,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5469,7 +5469,6 @@ 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,
@@ -5555,6 +5554,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5862,7 +5862,6 @@ exports[`regression tests > drags selected elements from point inside common bou
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5952,6 +5951,7 @@ exports[`regression tests > drags selected elements from point inside common bou
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6159,7 +6159,6 @@ 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,
@@ -6948,7 +6947,6 @@ 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,
@@ -7037,6 +7035,7 @@ exports[`regression tests > given a group of selected elements with an element t
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7282,7 +7281,6 @@ 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,
@@ -7371,6 +7369,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7561,7 +7560,6 @@ 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,
@@ -7649,6 +7647,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7796,7 +7795,6 @@ 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,
@@ -7884,6 +7882,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8036,7 +8035,6 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8122,6 +8120,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8216,7 +8215,6 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8302,6 +8300,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8396,7 +8395,6 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8482,6 +8480,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8576,7 +8575,6 @@ 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,
@@ -8809,7 +8807,6 @@ 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,
@@ -9040,7 +9037,6 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9124,6 +9120,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9232,7 +9229,6 @@ 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,
@@ -9465,7 +9461,6 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9551,6 +9546,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9645,7 +9641,6 @@ 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,
@@ -9876,7 +9871,6 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9962,6 +9956,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10056,7 +10051,6 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10140,6 +10134,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10248,7 +10243,6 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10334,6 +10328,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10428,7 +10423,6 @@ 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,
@@ -10522,6 +10516,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10959,7 +10954,6 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11047,6 +11041,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11239,7 +11234,6 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11323,6 +11317,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11362,7 +11357,6 @@ exports[`regression tests > shift click on selected element should deselect it o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11448,6 +11442,7 @@ exports[`regression tests > shift click on selected element should deselect it o
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11562,7 +11557,6 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11652,6 +11646,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11881,7 +11876,6 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11973,6 +11967,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12310,7 +12305,6 @@ 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,
@@ -12406,6 +12400,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12950,7 +12945,6 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13037,6 +13031,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13076,7 +13071,6 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13164,6 +13158,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13707,7 +13702,6 @@ exports[`regression tests > switches from group of selected elements to another
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13824,6 +13818,7 @@ exports[`regression tests > switches from group of selected elements to another
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14046,7 +14041,6 @@ exports[`regression tests > switches selected element on pointer down > [end of
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14162,6 +14156,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14310,7 +14305,6 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14394,6 +14388,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14433,7 +14428,6 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14798,7 +14792,6 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14882,6 +14875,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14921,7 +14915,6 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15008,6 +15001,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
+  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,

packages/excalidraw/tests/appStateHooks.test.tsx

@@ -1,111 +0,0 @@
-import { act, cleanup, render, screen } from "@testing-library/react";
-import { vi } from "vitest";
-
-import { getDefaultAppState } from "../appState";
-import { ExcalidrawAPIContext } from "../components/App";
-import { AppStateObserver } from "../components/AppStateObserver";
-import {
-  useAppStateValue,
-  useOnAppStateChange,
-} from "../hooks/useAppStateValue";
-
-import type { AppState, ExcalidrawImperativeAPI } from "../types";
-
-const createAppState = (): AppState => ({
-  ...getDefaultAppState(),
-  width: 0,
-  height: 0,
-  offsetLeft: 0,
-  offsetTop: 0,
-});
-
-const createMockAPI = (initialState: AppState) => {
-  let state = initialState;
-  const observer = new AppStateObserver(() => state);
-
-  return {
-    api: {
-      isDestroyed: false,
-      getAppState: () => state,
-      onStateChange: observer.onStateChange,
-    } as Pick<
-      ExcalidrawImperativeAPI,
-      "isDestroyed" | "getAppState" | "onStateChange"
-    > as ExcalidrawImperativeAPI,
-    updateAppState: (partial: Partial<AppState>) => {
-      const prevState = state;
-      state = { ...state, ...partial };
-      observer.flush(prevState);
-    },
-  };
-};
-
-describe("app state hooks", () => {
-  afterEach(() => {
-    cleanup();
-  });
-
-  it("useAppStateValue rerenders when the selected value changes", () => {
-    const renderSpy = vi.fn();
-    const { api, updateAppState } = createMockAPI(createAppState());
-
-    const ValueConsumer = () => {
-      const value = useAppStateValue("viewModeEnabled");
-      renderSpy(value);
-      return <div data-testid="value">{String(value)}</div>;
-    };
-
-    render(
-      <ExcalidrawAPIContext.Provider value={api}>
-        <ValueConsumer />
-      </ExcalidrawAPIContext.Provider>,
-    );
-
-    expect(screen.getByTestId("value").textContent).toBe("false");
-    expect(renderSpy).toHaveBeenCalledTimes(1);
-
-    act(() => {
-      updateAppState({ viewModeEnabled: true });
-    });
-
-    expect(screen.getByTestId("value").textContent).toBe("true");
-    expect(renderSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("useOnAppStateChange notifies without rerendering", () => {
-    const renderSpy = vi.fn();
-    const callback = vi.fn();
-    const { api, updateAppState } = createMockAPI(createAppState());
-
-    const ChangeConsumer = () => {
-      const value = useOnAppStateChange("viewModeEnabled", callback);
-      renderSpy(value);
-      return <div data-testid="value">{String(value)}</div>;
-    };
-
-    render(
-      <ExcalidrawAPIContext.Provider value={api}>
-        <ChangeConsumer />
-      </ExcalidrawAPIContext.Provider>,
-    );
-
-    expect(screen.getByTestId("value").textContent).toBe("undefined");
-    expect(renderSpy).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(
-      false,
-      expect.objectContaining({ viewModeEnabled: false }),
-    );
-
-    act(() => {
-      updateAppState({ viewModeEnabled: true });
-    });
-
-    expect(renderSpy).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenLastCalledWith(
-      true,
-      expect.objectContaining({ viewModeEnabled: true }),
-    );
-  });
-});

packages/excalidraw/tests/clipboard.test.tsx

@@ -305,88 +305,8 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(2);
-      expect(h.elements[0].type).toBe(rect.type);
-      expect(h.elements[0].frameId).toBe(frame.id);
-      expect(h.elements[1].id).toBe(frame.id);
-      expect(h.elements[0].index! < frame.index!).toBe(true);
-    });
-  });
-
-  it("should layer pasted elements above the highest frame child", async () => {
-    const frame = API.createElement({
-      type: "frame",
-      width: 100,
-      height: 100,
-      x: 0,
-      y: 0,
-    });
-    const frameChild = API.createElement({
-      id: "frameChild",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 20,
-      height: 20,
-      frameId: frame.id,
-    });
-    const rect = API.createElement({ type: "rectangle" });
-
-    API.setElements([frameChild, frame]);
-
-    const clipboardJSON = await serializeAsClipboardJSON({
-      elements: [rect],
-      files: null,
-    });
-
-    mouse.moveTo(50, 50);
-
-    pasteWithCtrlCmdV(clipboardJSON);
-
-    await waitFor(() => {
-      expect(h.elements.length).toBe(3);
       expect(h.elements[1].type).toBe(rect.type);
       expect(h.elements[1].frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frameChild.id,
-        h.elements[1].id,
-        frame.id,
-      ]);
-      expect(h.elements[1].index! > frameChild.index!).toBe(true);
-      expect(h.elements[1].index! < frame.index!).toBe(true);
-    });
-  });
-
-  it("should preserve denormalized pasted frame child order", async () => {
-    const frame = API.createElement({
-      type: "frame",
-      width: 100,
-      height: 100,
-      x: 0,
-      y: 0,
-    });
-    const frameChild = API.createElement({
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 20,
-      height: 20,
-      frameId: frame.id,
-    });
-
-    const clipboardJSON = await serializeAsClipboardJSON({
-      elements: [frame, frameChild],
-      files: null,
-    });
-
-    mouse.moveTo(200, 200);
-
-    pasteWithCtrlCmdV(clipboardJSON);
-
-    await waitFor(() => {
-      expect(h.elements.length).toBe(2);
-      expect(h.elements[0].type).toBe(frame.type);
-      expect(h.elements[1].type).toBe(frameChild.type);
-      expect(h.elements[1].frameId).toBe(h.elements[0].id);
     });
   });
 
@@ -459,9 +379,8 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(3);
-      expect(h.elements[0].type).toBe(rect.type);
+      expect(h.elements[1].type).toBe(rect.type);
-      expect(h.elements[0].frameId).toBe(frame.id);
+      expect(h.elements[1].frameId).toBe(frame.id);
-      expect(h.elements[1].id).toBe(frame.id);
       expect(h.elements[2].type).toBe(rect2.type);
       expect(h.elements[2].frameId).toBe(null);
     });
@@ -503,11 +422,10 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(3);
-      expect(h.elements[0].type).toBe(rect.type);
+      expect(h.elements[1].type).toBe(rect.type);
-      expect(h.elements[0].frameId).toBe(frame.id);
-      expect(h.elements[1].type).toBe(rect2.type);
       expect(h.elements[1].frameId).toBe(frame.id);
-      expect(h.elements[2].id).toBe(frame.id);
+      expect(h.elements[2].type).toBe(rect2.type);
+      expect(h.elements[2].frameId).toBe(frame.id);
     });
   });
 
@@ -555,9 +473,8 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(4);
-      expect(h.elements[0].type).toBe(rect.type);
+      expect(h.elements[1].type).toBe(rect.type);
-      expect(h.elements[0].frameId).toBe(frame.id);
+      expect(h.elements[1].frameId).toBe(frame.id);
-      expect(h.elements[1].id).toBe(frame.id);
       expect(h.elements[2].type).toBe(rect2.type);
       expect(h.elements[2].frameId).toBe(h.elements[3].id);
       expect(h.elements[3].type).toBe(frame2.type);

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

@@ -200,26 +200,6 @@ describe("restoreElements", () => {
     });
   });
 
-  it("should normalize legacy crowfoot arrowheads on restore", () => {
-    const arrowElement = API.createElement({
-      type: "arrow",
-    });
-
-    const restoredArrow = restore.restoreElements(
-      [
-        {
-          ...arrowElement,
-          startArrowhead: "crowfoot_one",
-          endArrowhead: "crowfoot_one_or_many",
-        } as any,
-      ],
-      null,
-    )[0] as ExcalidrawLinearElement;
-
-    expect(restoredArrow.startArrowhead).toBe("cardinality_one");
-    expect(restoredArrow.endArrowhead).toBe("cardinality_one_or_many");
-  });
-
   it("should strip element if restore fails", () => {
     const rect1 = API.createElement({
       type: "rectangle",

packages/excalidraw/tests/helpers/polyfills.ts

@@ -94,42 +94,3 @@ export const testPolyfills = {
   // https://github.com/vitest-dev/vitest/pull/4164#issuecomment-2172729965
   URL,
 };
-
-export const PolyfillLocalStorage = () => {
-  // Node.js 25+ provides a native localStorage global that shadows jsdom's,
-  // and jsdom's own localStorage also uses the native one -- both are broken
-  // (empty objects without Storage methods). On older Node versions, jsdom
-  // provides a working localStorage. This polyfill replaces localStorage on
-  // all supported versions with a standard Storage implementation backed by
-  // a Map, ensuring consistent behavior regardless of the Node.js version.
-  const storage = new Map<string, string>();
-  const storagePolyfill: Storage = {
-    get length() {
-      return storage.size;
-    },
-    clear() {
-      storage.clear();
-    },
-    key(index) {
-      return Array.from(storage.keys())[index] ?? null;
-    },
-    getItem(key) {
-      return storage.get(key) ?? null;
-    },
-    setItem(key, value) {
-      storage.set(key, value);
-    },
-    removeItem(key) {
-      storage.delete(key);
-    },
-    *[Symbol.iterator]() {
-      yield* storage.entries();
-    },
-  };
-
-  Object.defineProperty(window, "localStorage", {
-    value: storagePolyfill,
-    writable: true,
-    configurable: true,
-  });
-};

packages/excalidraw/tests/helpers/ui.ts

@@ -4,7 +4,6 @@ import {
   elementCenterPoint,
   getCommonBounds,
   getElementPointsCoords,
-  getLineHeightInPx,
 } from "@excalidraw/element";
 import { cropElement } from "@excalidraw/element";
 import {
@@ -21,7 +20,7 @@ import {
   isTextElement,
   isFrameLikeElement,
 } from "@excalidraw/element";
-import { KEYS, arrayToMap, getLineHeight } from "@excalidraw/common";
+import { KEYS, arrayToMap } from "@excalidraw/common";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
 
@@ -517,17 +516,8 @@ export class UI {
     UI.clickTool(type);
 
     if (type === "text") {
-      const clickY = h.state.gridModeEnabled
-        ? y
-        : y +
-          getLineHeightInPx(
-            h.state.currentItemFontSize,
-            getLineHeight(h.state.currentItemFontFamily),
-          ) /
-            2;
-
       mouse.reset();
-      mouse.click(x, clickY);
+      mouse.click(x, y);
     } else if ((type === "line" || type === "arrow") && points.length > 2) {
       points.forEach((point) => {
         mouse.reset();

packages/excalidraw/tests/history.test.tsx

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

@@ -41,15 +41,13 @@ describe("event callbacks", () => {
 
     await render(
       <Excalidraw
-        onExcalidrawAPI={(api) => {
+        onExcalidrawAPI={(api) =>
-          if (api) {
+          lifecyclePromise.resolve({
-            lifecyclePromise.resolve({
+            api: api as ExcalidrawImperativeAPI,
-              api,
+            mount: api.onEvent("editor:mount"),
-              mount: api.onEvent("editor:mount"),
+            initialize: api.onEvent("editor:initialize"),
-              initialize: api.onEvent("editor:initialize"),
+          })
-            });
+        }
-          }
-        }}
       />,
     );
 

packages/excalidraw/tests/regressionTests.test.tsx

@@ -468,7 +468,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(end[0] + 3, end[1] + 3);
+    mouse.restorePosition(...end);
     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[0] + 3, end[1] + 3);
+    mouse.restorePosition(...end);
     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[0] + 3, end[1] + 3);
+    mouse.restorePosition(...end);
     mouse.up();
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {