feat: support google maps

Co-authored-by: chulkin-mdb <oleksandr.chulkin@mongodb.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

.codesandbox/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:18-bullseye
+FROM node:24-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@0.6.0
+      - uses: styfle/cancel-workflow-action@ce177499ccf9fd2aded3b0426c97e5434c2e8a73 # 0.6.0
         with:
           workflow_id: 400555, 400556, 905313, 1451724, 1710116, 3185001, 3438604
           access_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/locales-coverage.yml

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

.github/workflows/publish-docker.yml

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

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

@@ -6,11 +6,97 @@ on:
       - opened
       - edited
       - synchronize
+      - labeled
+      - unlabeled
 
 jobs:
   semantic:
     runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
     steps:
-      - uses: amannn/action-semantic-pull-request@v5
+      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # 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@v1
+      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           build_script: build:esm

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

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

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=${BUILDPLATFORM} node:18 AS build
+FROM --platform=${BUILDPLATFORM} node:24 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 --platform=${TARGETPLATFORM} nginx:1.27-alpine
+FROM 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&widge=false"/></a>
+    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widget=false"/></a>
   <a href="https://deepwiki.com/excalidraw/excalidraw">
     <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></a>
   <a href="https://twitter.com/excalidraw">

dev-docs/docusaurus.config.js

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

excalidraw-app/data/LocalData.ts

@@ -26,7 +26,6 @@ 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";
@@ -39,6 +38,7 @@ 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,6 +75,13 @@ 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,7 +56,8 @@
     "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:packages": "yarn build:common && yarn build:math && yarn build:element && yarn build:excalidraw",
+    "build:fractional-indexing": "yarn --cwd ./packages/fractional-indexing build:esm",
+    "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,6 +64,7 @@
   },
   "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,29 +338,20 @@ export class Scene {
     this.callbacks.clear();
   }
 
-  insertElementAtIndex(element: ExcalidrawElement, index: number) {
+  /** low-level - generally use app.insertNewElements() */
-    if (!Number.isFinite(index) || index < 0) {
+  insertElementsAtIndex(
-      throw new Error(
+    elements: ExcalidrawElement[],
-        "insertElementAtIndex can only be called with index >= 0",
+    /** null indicates end of the array */
-      );
+    index: number | null,
-    }
+  ) {
-
-    const nextElements = [
-      ...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 (index === null) {
+      index = this.elements.length;
+    }
+
     if (!Number.isFinite(index) || index < 0) {
       throw new Error(
         "insertElementAtIndex can only be called with index >= 0",
@@ -378,24 +369,9 @@ export class Scene {
     this.replaceAllElements(nextElements);
   }
 
+  /** low-level - generally use app.insertNewElement() */
   insertElement = (element: ExcalidrawElement) => {
-    const index = element.frameId
+    this.insertElementsAtIndex([element], null);
-      ? 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/binding.ts

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

packages/element/src/bounds.ts

@@ -680,8 +680,9 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = (
+export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
-  points: ExcalidrawFreeDrawElement["points"],
+  points: readonly P[],
+  padding: number = 0,
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -695,7 +696,7 @@ export const getBoundsFromPoints = (
     maxY = Math.max(maxY, y);
   }
 
-  return [minX, minY, maxX, maxY];
+  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -1261,6 +1262,17 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
   p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
 
+// TODO make pointInsideBounds inclusive and remove this function once we
+// test nothing is breaking
+export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
+  p: P,
+  bounds: Bounds,
+): boolean =>
+  p[0] >= bounds[0] &&
+  p[0] <= bounds[2] &&
+  p[1] >= bounds[1] &&
+  p[1] <= bounds[3];
+
 export const doBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
@@ -1275,13 +1287,21 @@ export const doBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
+export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
+  [
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
+    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
+  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
+
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   xOffset: number = 0,
   yOffset: number = 0,
 ) => {
-  if (isLinearElement(element)) {
+  if (isLinearElement(element) || isFreeDrawElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
 

packages/element/src/collision.ts

@@ -61,6 +61,8 @@ import { distanceToElement } from "./distance";
 
 import { getBindingGap } from "./binding";
 
+import { hasBackground } from "./comparisons";
+
 import type {
   ElementsMap,
   ExcalidrawArrowElement,
@@ -83,7 +85,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   const isDraggableFromInside =
-    !isTransparent(element.backgroundColor) ||
+    (hasBackground(element.type) && !isTransparent(element.backgroundColor)) ||
     hasBoundTextElement(element) ||
     isIframeLikeElement(element) ||
     isTextElement(element);
@@ -154,14 +156,11 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointWithinBounds(
+  const hitBounds = isPointInRotatedBounds(
-    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
+    point,
-    pointRotateRads(
+    bounds,
-      point,
+    element.angle,
-      getCenterForBounds(bounds),
+    threshold,
-      -element.angle as Radians,
-    ),
-    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -192,18 +191,32 @@ export const hitElementItself = ({
   return result;
 };
 
+const isPointInRotatedBounds = (
+  point: GlobalPoint,
+  bounds: Bounds,
+  angle: Radians,
+  tolerance = 0,
+) => {
+  const adjustedPoint =
+    angle === 0
+      ? point
+      : pointRotateRads(point, getCenterForBounds(bounds), -angle as Radians);
+
+  return isPointWithinBounds(
+    pointFrom(bounds[0] - tolerance, bounds[1] - tolerance),
+    adjustedPoint,
+    pointFrom(bounds[2] + tolerance, bounds[3] + tolerance),
+  );
+};
+
 export const hitElementBoundingBox = (
   point: GlobalPoint,
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   tolerance = 0,
 ) => {
-  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
+  const bounds = getElementBounds(element, elementsMap, true);
-  x1 -= tolerance;
+  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
-  y1 -= tolerance;
-  x2 += tolerance;
-  y2 += tolerance;
-  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -313,7 +326,10 @@ export const getAllHoveredElementAtPoint = (
     ) {
       candidateElements.push(element);
 
-      if (!isTransparent(element.backgroundColor)) {
+      if (
+        hasBackground(element.type) &&
+        !isTransparent(element.backgroundColor)
+      ) {
         break;
       }
     }
@@ -573,7 +589,9 @@ 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/duplicate.ts

@@ -111,6 +111,9 @@ export const duplicateElements = (
          * user interaction.
          */
         type: "everything";
+        // TODO remove/review this once we add frame children order migration
+        // and invariant checks
+        preserveFrameChildrenOrder?: boolean;
       }
     | {
         /**
@@ -170,6 +173,8 @@ 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") {
@@ -250,6 +255,9 @@ export const duplicateElements = (
     elementsWithDuplicates.splice(index + 1, 0, ...castArray(elements));
   };
 
+  // main
+  // ---------------------------------------------------------------------------
+
   const frameIdsToDuplicate = new Set(
     elements
       .filter(
@@ -274,7 +282,7 @@ export const duplicateElements = (
     if (groupId) {
       const groupElements = getElementsInGroup(elements, groupId).flatMap(
         (element) =>
-          isFrameLikeElement(element)
+          isFrameLikeElement(element) && !preserveFrameChildrenOrder
             ? [...getFrameChildren(elements, element.id), element]
             : [element],
       );
@@ -290,13 +298,25 @@ export const duplicateElements = (
     // frame duplication
     // -------------------------------------------------------------------------
 
-    if (element.frameId && frameIdsToDuplicate.has(element.frameId)) {
+    if (
+      !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 ||
-    offsetY + points[points.length - 1][0] > MAX_POS ||
+    offsetX + points[points.length - 1][0] > MAX_POS ||
-    offsetX + points[points.length - 1][1] < -MAX_POS ||
+    offsetY + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(

packages/element/src/embeddable.ts

@@ -130,6 +130,86 @@ const parseGoogleDriveVideoLink = (
   }
 };
 
+const isGoogleMapsURL = (url: string): boolean => {
+  try {
+    const { hostname, pathname } = new URL(
+      url.startsWith("http") ? url : `https://${url}`,
+    );
+    const bareHostname = hostname.replace(/^www\./, "");
+
+    return (
+      (bareHostname === "google.com" || bareHostname === "maps.google.com") &&
+      (pathname === "/maps" || pathname.startsWith("/maps/"))
+    );
+  } catch (error) {
+    return false;
+  }
+};
+
+const getGoogleMapsZoom = (zoomOrDistance: string): string | null => {
+  const match = zoomOrDistance.match(/^(\d+(?:\.\d+)?)(z|km|m)$/);
+  if (!match) {
+    return null;
+  }
+  const value = Number(match[1]);
+  if (match[2] === "z") {
+    return `${Math.round(value)}`;
+  }
+  const meters = value * (match[2] === "km" ? 1000 : 1);
+  return `${Math.max(
+    3,
+    Math.min(21, Math.round(16 - Math.log2(meters / 500))),
+  )}`;
+};
+
+const parseGoogleMapsLink = (url: string): string | null => {
+  if (!isGoogleMapsURL(url)) {
+    return null;
+  }
+
+  try {
+    const urlObj = new URL(url.startsWith("http") ? url : `https://${url}`);
+
+    if (
+      urlObj.pathname.startsWith("/maps/embed") ||
+      urlObj.searchParams.get("output") === "embed"
+    ) {
+      return urlObj.toString();
+    }
+
+    const [, lat, lng, zoomOrDistance] =
+      urlObj.pathname.match(
+        /@(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?),([^/?#,]+)/,
+      ) || [];
+    const place = urlObj.pathname.match(/^\/maps\/place\/([^/]+)/)?.[1];
+    const query =
+      urlObj.searchParams.get("q") ||
+      (place ? decodeURIComponent(place).replace(/\+/g, " ") : null) ||
+      (lat && lng ? `${lat},${lng}` : null);
+
+    if (!query) {
+      return null;
+    }
+
+    const embedURL = new URL("https://www.google.com/maps");
+    embedURL.searchParams.set("q", query);
+    embedURL.searchParams.set("output", "embed");
+
+    if (lat && lng) {
+      embedURL.searchParams.set("ll", `${lat},${lng}`);
+    }
+
+    const zoom = zoomOrDistance ? getGoogleMapsZoom(zoomOrDistance) : null;
+    if (zoom) {
+      embedURL.searchParams.set("z", zoom);
+    }
+
+    return embedURL.toString();
+  } catch (error) {
+    return null;
+  }
+};
+
 const ALLOWED_DOMAINS = new Set([
   "youtube.com",
   "youtu.be",
@@ -147,6 +227,8 @@ const ALLOWED_DOMAINS = new Set([
   "giphy.com",
   "reddit.com",
   "forms.microsoft.com",
+  "wikipedia.org",
+  "*.wikipedia.org",
 ]);
 
 const ALLOW_SAME_ORIGIN = new Set([
@@ -278,6 +360,27 @@ export const getEmbedLink = (
     };
   }
 
+  if (isGoogleMapsURL(link)) {
+    const googleMapsLink = parseGoogleMapsLink(link);
+    if (googleMapsLink) {
+      link = googleMapsLink;
+      aspectRatio = { w: 600, h: 450 };
+      embeddedLinkCache.set(originalLink, {
+        link,
+        intrinsicSize: aspectRatio,
+        type,
+        sandbox: { allowSameOrigin },
+      });
+      return {
+        link,
+        intrinsicSize: aspectRatio,
+        type,
+        sandbox: { allowSameOrigin },
+      };
+    }
+    return null;
+  }
+
   const figmaLink = link.match(RE_FIGMA);
   if (figmaLink) {
     type = "generic";
@@ -506,6 +609,7 @@ export const embeddableURLValidator = (
   if (!url) {
     return false;
   }
+
   if (validateEmbeddable != null) {
     if (typeof validateEmbeddable === "function") {
       const ret = validateEmbeddable(url);
@@ -531,5 +635,5 @@ export const embeddableURLValidator = (
     }
   }
 
-  return !!matchHostname(url, ALLOWED_DOMAINS);
+  return isGoogleMapsURL(url) || !!matchHostname(url, ALLOWED_DOMAINS);
 };

packages/element/src/fractionalIndex.ts

@@ -1,7 +1,10 @@
-import { generateNKeysBetween } from "fractional-indexing";
-
 import { arrayToMap } from "@excalidraw/common";
 
+import {
+  validateOrderKey,
+  generateNKeysBetween,
+} from "@excalidraw/fractional-indexing";
+
 import { mutateElement, newElementWith } from "./mutateElement";
 import { getBoundTextElement } from "./textElement";
 import { hasBoundTextElement } from "./typeChecks";
@@ -382,6 +385,13 @@ 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,7 +1,6 @@
 import { arrayToMap } from "@excalidraw/common";
 import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
 import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
-import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";
 
 import type {
   AppClassProperties,
@@ -18,9 +17,13 @@ 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,
@@ -100,8 +103,9 @@ export const isElementContainingFrame = (
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
 ) => {
-  return getElementsWithinSelection([frame], element, elementsMap).some(
+  return boundsContainBounds(
-    (e) => e.id === frame.id,
+    getElementBounds(element, elementsMap),
+    getElementBounds(frame, elementsMap),
   );
 };
 
@@ -488,10 +492,44 @@ 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;
+};
+
 /**
- * Retains (or repairs for target frame) the ordering invriant where children
+ * Adds elements and their bound elements to frame. Reorders added elements to
- * elements come right before the parent frame:
+ * be just below frame, or just above its highest child (whichever is higher).
- * [el, el, child, child, frame, el]
  *
  * @returns mutated allElements (same data structure)
  */
@@ -499,19 +537,11 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   allElements: T,
   elementsToAdd: NonDeletedExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
-  appState: AppState,
 ): T => {
   const elementsMap = arrayToMap(allElements);
-  const currTargetFrameChildrenMap = new Map<ExcalidrawElement["id"], true>();
+  const commonFrameId = getCommonFrameId(elementsToAdd);
-  for (const element of allElements.values()) {
-    if (element.frameId === frame.id) {
-      currTargetFrameChildrenMap.set(element.id, true);
-    }
-  }
 
-  const suppliedElementsToAddSet = new Set(elementsToAdd.map((el) => el.id));
+  const finalElementsToAdd = new Set<ExcalidrawElement>();
-
-  const finalElementsToAdd: ExcalidrawElement[] = [];
 
   const otherFrames = new Set<ExcalidrawFrameLikeElement["id"]>();
 
@@ -522,7 +552,8 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   }
 
   // - add bound text elements if not already in the array
-  // - filter out elements that are already in the frame
+  // - keep elements already in the frame so mixed selections can be reordered
+  //   together
   for (const element of omitGroupsContainingFrameLikes(
     allElements,
     elementsToAdd,
@@ -535,38 +566,68 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
       continue;
     }
 
-    // if the element is already in another frame (which is also in elementsToAdd),
+    if (element.frameId && element.frameId !== frame.id) {
-    // 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;
     }
 
-    if (!currTargetFrameChildrenMap.has(element.id)) {
+    finalElementsToAdd.add(element);
-      finalElementsToAdd.push(element);
-    }
 
     const boundTextElement = getBoundTextElement(element, elementsMap);
-    if (
+    if (boundTextElement && !finalElementsToAdd.has(boundTextElement)) {
-      boundTextElement &&
+      finalElementsToAdd.add(boundTextElement);
-      !suppliedElementsToAddSet.has(boundTextElement.id) &&
-      !currTargetFrameChildrenMap.has(boundTextElement.id)
-    ) {
-      finalElementsToAdd.push(boundTextElement);
     }
   }
 
   for (const element of finalElementsToAdd) {
-    mutateElement(element, elementsMap, {
+    // we don't always need to update the element if it's already in the frame,
-      frameId: frame.id,
+    // but we still need to accumulate in finalElementsToAdd so we potentially
-    });
+    // reorder them if added together
+    if (element.frameId !== frame.id) {
+      mutateElement(element, elementsMap, {
+        frameId: frame.id,
+      });
+    }
   }
 
-  return allElements;
+  // (re)order elements to be just below the frame,
+  // 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 = (
@@ -620,13 +681,11 @@ 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();
 };
 
@@ -920,16 +979,17 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  elementsMap: ElementsMap,
 ) => {
-  return (
+  return elements.filter(
-    elementsOverlappingBBox({
+    (el) =>
-      elements,
+      // exclude elements which are overlapping, but are in a different frame,
-      bounds: frame,
-      type: "overlap",
-    })
-      // removes elements who are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      .filter((el) => !el.frameId || el.frameId === frame.id)
+      (!el.frameId || el.frameId === frame.id) &&
+      doBoundsIntersect(
+        getElementBounds(el, elementsMap),
+        getElementBounds(frame, elementsMap),
+      ),
   );
 };
 

packages/element/src/linearElementEditor.ts

@@ -486,7 +486,7 @@ export class LinearElementEditor {
           selectedPointsIndices,
         )}) points(0..${
           element.points.length - 1
-        }) lastClickedPoint(${lastClickedPoint})`,
+        }) lastClickedPoint(${lastClickedPoint}) isElbowArrow: ${elbowed}`,
       );
 
       // Fall back to the actual last point as a last resort.
@@ -2139,13 +2139,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: pointFrom<LocalPoint>(point[0] + deltaX, point[1] + deltaY),
-            element.points[pointIndex][0] + deltaX,
-            element.points[pointIndex][1] + deltaY,
-          ),
           isDragging: true,
         },
       ];

packages/element/src/selection.ts

@@ -1,15 +1,32 @@
-import { arrayToMap, isShallowEqual } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import {
+  lineSegment,
+  pointFrom,
+  pointRotateRads,
+  type GlobalPoint,
+} from "@excalidraw/math";
 
 import type {
   AppState,
+  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
+import {
+  boundsContainBounds,
+  doBoundsIntersect,
+  elementCenterPoint,
+  getElementAbsoluteCoords,
+  getElementBounds,
+  pointInsideBounds,
+} from "./bounds";
+import { intersectElementWithLineSegment } from "./collision";
 import { isElementInViewport } from "./sizeHelpers";
 import {
+  isArrowElement,
   isBoundToContainer,
   isFrameLikeElement,
+  isFreeDrawElement,
   isLinearElement,
   isTextElement,
 } from "./typeChecks";
@@ -21,15 +38,33 @@ 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
@@ -49,68 +84,286 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return selectedElements.filter((element) => {
+  return excludeElementsFromFrames(selectedElements, framesInSelection);
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
+  // TODO remove (this flag is effectively unused AFAIK)
   excludeElementsInFrames: boolean = true,
-) => {
+  boxSelectionMode: BoxSelectionMode = "contain",
-  const [selectionX1, selectionY1, selectionX2, selectionY2] =
+): NonDeletedExcalidrawElement[] => {
+  const [selectionStartX, selectionStartY, selectionEndX, selectionEndY] =
     getElementAbsoluteCoords(selection, elementsMap);
+  const selectionX1 = Math.min(selectionStartX, selectionEndX);
+  const selectionY1 = Math.min(selectionStartY, selectionEndY);
+  const selectionX2 = Math.max(selectionStartX, selectionEndX);
+  const selectionY2 = Math.max(selectionStartY, selectionEndY);
+  const selectionBounds = [
+    selectionX1,
+    selectionY1,
+    selectionX2,
+    selectionY2,
+  ] as Bounds;
+  const selectionEdges = [
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY1),
+      pointFrom(selectionX2, selectionY1),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY1),
+      pointFrom(selectionX2, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY2),
+      pointFrom(selectionX1, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY2),
+      pointFrom(selectionX1, selectionY1),
+    ),
+  ];
 
-  let elementsInSelection = elements.filter((element) => {
+  const framesInSelection = excludeElementsInFrames
-    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+    ? new Set<NonDeletedExcalidrawElement["id"]>()
-      element,
+    : null;
-      elementsMap,
+  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
-    );
+  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
 
-    const containingFrame = getContainingFrame(element, elementsMap);
+  for (const element of elements) {
-    if (containingFrame) {
+    if (shouldIgnoreElementFromSelection(element)) {
-      const [fx1, fy1, fx2, fy2] = getElementBounds(
+      continue;
-        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 = [
-      elementX1 = Math.max(fx1, elementX1);
+        x,
-      elementY1 = Math.max(fy1, elementY1);
+        y,
-      elementX2 = Math.min(fx2, elementX2);
+        x + boundTextElement.width,
-      elementY2 = Math.min(fy2, elementY2);
+        y + boundTextElement.height,
+      ] as Bounds;
     }
 
-    return (
+    // Clip element bounds by its containing frame (if any), since only the
-      element.locked === false &&
+    // visible (frame-clipped) portion of the element is relevant for selection.
-      element.type !== "selection" &&
+    const associatedFrame = getContainingFrame(element, elementsMap);
-      !isBoundToContainer(element) &&
+    if (
-      selectionX1 <= elementX1 &&
+      associatedFrame &&
-      selectionY1 <= elementY1 &&
+      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
-      selectionX2 >= elementX2 &&
+    ) {
-      selectionY2 >= elementY2
+      const frameAABB = getElementBounds(associatedFrame, elementsMap);
-    );
+      elementAABB = [
-  });
+        Math.max(elementAABB[0], frameAABB[0]),
+        Math.max(elementAABB[1], frameAABB[1]),
+        Math.min(elementAABB[2], frameAABB[2]),
+        Math.min(elementAABB[3], frameAABB[3]),
+      ] as Bounds;
 
-  elementsInSelection = excludeElementsInFrames
+      labelAABB = labelAABB
-    ? excludeElementsInFramesFromSelection(elementsInSelection)
+        ? ([
-    : elementsInSelection;
+            Math.max(labelAABB[0], frameAABB[0]),
-
+            Math.max(labelAABB[1], frameAABB[1]),
-  elementsInSelection = elementsInSelection.filter((element) => {
+            Math.min(labelAABB[2], frameAABB[2]),
-    const containingFrame = getContainingFrame(element, elementsMap);
+            Math.min(labelAABB[3], frameAABB[3]),
-
+          ] as Bounds)
-    if (containingFrame) {
+        : null;
-      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
     }
 
-    return true;
+    const commonAABB = labelAABB
-  });
+      ? ([
+          Math.min(labelAABB[0], elementAABB[0]),
+          Math.min(labelAABB[1], elementAABB[1]),
+          Math.max(labelAABB[2], elementAABB[2]),
+          Math.max(labelAABB[3], elementAABB[3]),
+        ] as Bounds)
+      : elementAABB;
 
-  return elementsInSelection;
+    // ============== Evaluation ==============
+
+    // 1. If the selection box WRAPs the element's AABB, then add it to the
+    //    selection and move on, regardless of the selection mode.
+    //
+    //    PERF: This trick only works with axis-aligned box selection and the
+    //          current convex element shapes!
+    if (boundsContainBounds(selectionBounds, commonAABB)) {
+      if (framesInSelection && isFrameLikeElement(element)) {
+        framesInSelection.add(element.id);
+      }
+      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 = (

packages/element/src/sortElements.ts

@@ -1,59 +1,56 @@
-import { arrayToMapWithIndex } from "@excalidraw/common";
+import { arrayToMap } from "@excalidraw/common";
 
 import type { ExcalidrawElement } from "./types";
 
-const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
+const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
-  const origElements: ExcalidrawElement[] = elements.slice();
+  const groupIdAtLevel = (element: ExcalidrawElement, level: number) => {
-  const sortedElements = new Set<ExcalidrawElement>();
+    return element.groupIds[element.groupIds.length - level - 1];
-
-  const orderInnerGroups = (
-    elements: readonly ExcalidrawElement[],
-  ): ExcalidrawElement[] => {
-    const firstGroupSig = elements[0]?.groupIds?.join("");
-    const aGroup: ExcalidrawElement[] = [elements[0]];
-    const bGroup: ExcalidrawElement[] = [];
-    for (const element of elements.slice(1)) {
-      if (element.groupIds?.join("") === firstGroupSig) {
-        aGroup.push(element);
-      } else {
-        bGroup.push(element);
-      }
-    }
-    return bGroup.length ? [...aGroup, ...orderInnerGroups(bGroup)] : aGroup;
   };
 
-  const groupHandledElements = new Map<string, true>();
+  const orderLevel = (
+    levelElements: readonly ExcalidrawElement[],
+    level: number,
+  ): ExcalidrawElement[] => {
+    const buckets = new Map<string, ExcalidrawElement[]>();
+    // Slots preserve first-occurrence order: a groupId reserves its slot
+    // the first time one of its members is seen; loose elements occupy
+    // their own slot. Groups are then expanded (and recursed into) in place.
+    const slots: (ExcalidrawElement | string)[] = [];
 
-  origElements.forEach((element, idx) => {
+    for (const element of levelElements) {
-    if (groupHandledElements.has(element.id)) {
+      const groupId = groupIdAtLevel(element, level);
-      return;
+      if (groupId === undefined) {
-    }
+        slots.push(element);
-    if (element.groupIds?.length) {
+        continue;
-      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 {
+      let bucket = buckets.get(groupId);
-      sortedElements.add(element);
+      if (!bucket) {
+        bucket = [];
+        buckets.set(groupId, bucket);
+        slots.push(groupId);
+      }
+      bucket.push(element);
     }
-  });
+
+    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
+  // last entry. We recurse from level 0 (outermost) inward.
+  const sortedElements = orderLevel(elements, 0);
 
   // 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.size !== elements.length) {
+  if (sortedElements.length !== elements.length) {
-    console.error("normalizeGroupElementOrder: lost some elements... bailing!");
+    console.error("defragmentGroups: lost some elements... bailing!");
     return elements;
   }
 
-  return [...sortedElements];
+  return sortedElements;
 };
 
 /**
@@ -68,39 +65,40 @@ const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
 const normalizeBoundElementsOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  const elementsMap = arrayToMapWithIndex(elements);
+  const elementsMap = arrayToMap(elements);
 
-  const origElements: (ExcalidrawElement | null)[] = elements.slice();
   const sortedElements = new Set<ExcalidrawElement>();
 
-  origElements.forEach((element, idx) => {
+  for (const element of elements) {
-    if (!element) {
+    if (sortedElements.has(element)) {
-      return;
+      continue;
     }
+
     if (element.boundElements?.length) {
       sortedElements.add(element);
-      origElements[idx] = null;
+      for (const boundElement of element.boundElements) {
-      element.boundElements.forEach((boundElement) => {
         const child = elementsMap.get(boundElement.id);
         if (child && boundElement.type === "text") {
-          sortedElements.add(child[0]);
+          sortedElements.add(child);
-          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
       }
-    } else {
+      continue;
-      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
@@ -117,5 +115,5 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
+  return normalizeBoundElementsOrder(defragmentGroups(elements));
 };

packages/element/src/typeChecks.ts

@@ -392,3 +392,23 @@ 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/tests/collision.test.tsx

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

packages/element/tests/embeddable.test.ts

@@ -1,4 +1,8 @@
-import { embeddableURLValidator, getEmbedLink } from "../src/embeddable";
+import {
+  embeddableURLValidator,
+  getEmbedLink,
+  maybeParseEmbedSrc,
+} from "../src/embeddable";
 
 describe("YouTube timestamp parsing", () => {
   it("should parse YouTube URLs with timestamp in seconds", () => {
@@ -231,3 +235,62 @@ describe("Google Drive video embedding", () => {
     ).toBe(true);
   });
 });
+
+describe("Google Maps embedding", () => {
+  const regularUrl =
+    "https://www.google.com/maps/place/26-432+Jab%C5%82onica,+Poland/@51.356302,20.797168,1921m/data=!3m2!1e3!4b1!4m15!1m8!3m7!1s0x47186c0e0e7578fd:0xe80d19a1ef6ad853!2zMjctMTAwIEnFgsW8YSwgUG9sYW5k!3b1!8m2!3d51.16305!4d21.23991!16zL20vMGM1ZnJ3!3m5!1s0x47184db43a4a5df9:0x6a2b8e648f9dc694!8m2!3d51.3562959!4d20.8023178!16s%2Fm%2F04q6t9r?entry=ttu";
+  const officialEmbedSrc =
+    "https://www.google.com/maps/embed?pb=!1m18!1m12!1m3!1d8363.540754033738!2d20.79716795156659!3d51.356301987021546!2m3!1f0!2f0!3f0!3m2!1i1024!2i768!4f13.1!3m3!1m2!1s0x47184db43a4a5df9%3A0x6a2b8e648f9dc694!2s26-432%20Jab%C5%82onica%2C%20Poland!5e1!3m2!1sen!2scz!4v1778159513974!5m2!1sen!2scz";
+
+  it("should preserve official Google Maps embed links", () => {
+    const parsedSrc = maybeParseEmbedSrc(
+      `<iframe src="${officialEmbedSrc}" width="600" height="450"></iframe>`,
+    );
+    const result = getEmbedLink(parsedSrc);
+
+    expect(embeddableURLValidator(parsedSrc, undefined)).toBe(true);
+    expect(result).toBeTruthy();
+    expect(result?.type).toBe("generic");
+    if (result?.type === "generic") {
+      expect(result.link).toBe(officialEmbedSrc);
+    }
+    expect(result?.intrinsicSize).toEqual({ w: 600, h: 450 });
+  });
+
+  it("should normalize regular Google Maps place links", () => {
+    const result = getEmbedLink(regularUrl);
+
+    expect(embeddableURLValidator(regularUrl, undefined)).toBe(true);
+    expect(result).toBeTruthy();
+    expect(result?.type).toBe("generic");
+    if (result?.type !== "generic") {
+      return;
+    }
+
+    const embedURL = new URL(result.link);
+    expect(embedURL.origin).toBe("https://www.google.com");
+    expect(embedURL.pathname).toBe("/maps");
+    expect(embedURL.searchParams.get("q")).toBe(
+      decodeURIComponent("26-432%20Jab%C5%82onica%2C%20Poland"),
+    );
+    expect(embedURL.searchParams.get("output")).toBe("embed");
+    expect(embedURL.searchParams.get("ll")).toBe("51.356302,20.797168");
+    expect(embedURL.searchParams.get("z")).toBe("14");
+    expect(result.intrinsicSize).toEqual({ w: 600, h: 450 });
+  });
+
+  it("should reject non-Maps Google pages and fail closed for unsupported Maps pages", () => {
+    expect(
+      embeddableURLValidator("https://www.google.com/search?q=maps", undefined),
+    ).toBe(false);
+
+    const unsupportedMapsUrl = "https://www.google.com/maps/about/";
+    expect(embeddableURLValidator(unsupportedMapsUrl, undefined)).toBe(true);
+    expect(getEmbedLink(unsupportedMapsUrl)).toBe(null);
+
+    const malformedMapsUrl = `https://www.google.com/maps/@${"0,0,".repeat(
+      1000,
+    )}`;
+    expect(embeddableURLValidator(malformedMapsUrl, undefined)).toBe(true);
+  });
+});

packages/element/tests/fractionalIndex.test.ts

@@ -1,9 +1,8 @@
 /* eslint-disable no-lone-blocks */
-import { generateKeyBetween } from "fractional-indexing";
-
 import { arrayToMap } from "@excalidraw/common";
 
 import {
+  InvalidFractionalIndexError,
   syncInvalidIndices,
   syncMovedIndices,
   validateFractionalIndices,
@@ -13,13 +12,34 @@ 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";
 
-import { InvalidFractionalIndexError } from "../src/fractionalIndex";
+describe("fractional index format validation", () => {
+  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", () => {
@@ -104,6 +124,46 @@ 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,15 +2,24 @@ import {
   convertToExcalidrawElements,
   Excalidraw,
 } from "@excalidraw/excalidraw";
+import { arrayToMap } from "@excalidraw/common";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
-import { Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";
+import { Keyboard, Pointer, UI } from "@excalidraw/excalidraw/tests/helpers/ui";
+import { getTextEditor } from "@excalidraw/excalidraw/tests/queries/dom";
 import {
   getCloneByOrigId,
   render,
 } from "@excalidraw/excalidraw/tests/test-utils";
 
-import type { ExcalidrawElement } from "../src/types";
+import { getSelectedElements } from "@excalidraw/excalidraw/scene";
+
+import { elementOverlapsWithFrame } from "../src/frame";
+
+import type {
+  ExcalidrawElement,
+  ExcalidrawFrameLikeElement,
+} from "../src/types";
 
 const { h } = window;
 const mouse = new Pointer("mouse");
@@ -125,6 +134,250 @@ 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,
   ) => {
@@ -415,6 +668,345 @@ 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,19 +326,59 @@ describe("normalizeElementsOrder", () => {
       ]),
       [
         "BA_rect1",
+        "CBA_rect3",
+        "CBA_rect7",
         "BA_rect5",
         "BA_rect6",
         "A_rect2",
         "A_rect5",
-        "CBA_rect3",
-        "CBA_rect7",
         "rect4",
         "X_rect8",
-        "X_rect11",
         "YX_rect10",
+        "X_rect11",
         "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/excalidraw/actions/actionDeselect.ts

@@ -101,6 +101,7 @@ export const actionDeselect = register({
           selectionElement: null,
           showHyperlinkPopup: false,
           suggestedBinding: null,
+          frameToHighlight: null,
         },
         captureUpdate: CaptureUpdateAction.IMMEDIATELY,
       };
@@ -118,6 +119,7 @@ export const actionDeselect = register({
         selectionElement: null,
         showHyperlinkPopup: false,
         suggestedBinding: null,
+        frameToHighlight: null,
       },
       captureUpdate: CaptureUpdateAction.IMMEDIATELY,
     };

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

packages/excalidraw/actions/actionFrame.ts

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

packages/excalidraw/actions/actionGroup.tsx

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

packages/excalidraw/actions/actionHistory.tsx

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

packages/excalidraw/appState.ts

@@ -99,7 +99,6 @@ 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,
@@ -128,6 +127,7 @@ export const getDefaultAppState = (): Omit<
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
+    boxSelectionMode: "contain",
   };
 };
 
@@ -193,6 +193,7 @@ const APP_STATE_STORAGE_CONF = (<
   gridModeEnabled: { browser: true, export: true, server: true },
   height: { browser: false, export: false, server: false },
   isBindingEnabled: { browser: true, export: false, server: false },
+  boxSelectionMode: { browser: true, export: false, server: false },
   bindingPreference: { browser: true, export: false, server: false },
   isMidpointSnappingEnabled: { browser: true, export: false, server: false },
   defaultSidebarDockedPreference: {
@@ -229,7 +230,6 @@ 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/App.tsx

@@ -27,6 +27,7 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
+  DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -175,7 +176,9 @@ import {
   isValidTextContainer,
   redrawTextBoundingBox,
   hasBoundingBox,
+  getCommonFrameId,
   getFrameChildren,
+  getFrameChildrenInsertionIndex,
   isCursorInFrame,
   addElementsToFrame,
   replaceAllElementsInFrame,
@@ -258,6 +261,7 @@ import {
   maybeHandleArrowPointlikeDrag,
   getUncroppedWidthAndHeight,
   getActiveTextElement,
+  isEligibleFrameChildType,
 } from "@excalidraw/element";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
@@ -602,6 +606,8 @@ const YOUTUBE_VIDEO_STATES = new Map<
   ValueOf<typeof YOUTUBE_STATES>
 >();
 
+const MAX_EMBEDDABLE_VIEWPORT_SCALE = 4;
+
 let IS_PLAIN_PASTE = false;
 let IS_PLAIN_PASTE_TIMER = 0;
 let PLAIN_PASTE_TOAST_SHOWN = false;
@@ -1734,6 +1740,18 @@ class App extends React.Component<AppProps, AppState> {
             this.state.activeEmbeddable?.element === el &&
             this.state.activeEmbeddable?.state === "hover";
 
+          // scale video embeds based on zoom (capped) so that smaller embeds
+          // on canvas when zoomed are still of legible quality
+          // (note: for some embed types like gdrive, the quality is poor when
+          // scaling mid playback and works only when you initially start the
+          // playback at the higher zoom level)
+          const shouldScaleEmbeddableViewport = src?.type === "video";
+          const embeddableViewportScale = clamp(
+            shouldScaleEmbeddableViewport ? scale : 1,
+            0.75,
+            MAX_EMBEDDABLE_VIEWPORT_SCALE,
+          );
+
           return (
             <div
               key={el.id}
@@ -1800,31 +1818,40 @@ class App extends React.Component<AppProps, AppState> {
                     padding: `${el.strokeWidth}px`,
                   }}
                 >
-                  {(isEmbeddableElement(el)
+                  <div
-                    ? this.props.renderEmbeddable?.(el, this.state)
+                    className="excalidraw__embeddable__content"
-                    : null) ?? (
+                    style={{
-                    <iframe
+                      width: `${embeddableViewportScale * 100}%`,
-                      ref={(ref) => this.cacheEmbeddableRef(el, ref)}
+                      height: `${embeddableViewportScale * 100}%`,
-                      className="excalidraw__embeddable"
+                      transform: `scale(${1 / embeddableViewportScale})`,
-                      srcDoc={
+                    }}
-                        src?.type === "document"
+                  >
-                          ? src.srcdoc(this.state.theme)
+                    {(isEmbeddableElement(el)
-                          : undefined
+                      ? this.props.renderEmbeddable?.(el, this.state)
-                      }
+                      : null) ?? (
-                      src={
+                      <iframe
-                        src?.type !== "document" ? src?.link ?? "" : undefined
+                        ref={(ref) => this.cacheEmbeddableRef(el, ref)}
-                      }
+                        className="excalidraw__embeddable"
-                      // https://stackoverflow.com/q/18470015
+                        srcDoc={
-                      scrolling="no"
+                          src?.type === "document"
-                      referrerPolicy="no-referrer-when-downgrade"
+                            ? src.srcdoc(this.state.theme)
-                      title="Excalidraw Embedded Content"
+                            : undefined
-                      allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                        }
-                      allowFullScreen={true}
+                        src={
-                      sandbox={`${
+                          src?.type !== "document" ? src?.link ?? "" : undefined
-                        src?.sandbox?.allowSameOrigin ? "allow-same-origin" : ""
+                        }
-                      } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
+                        referrerPolicy="no-referrer-when-downgrade"
-                    />
+                        title="Excalidraw Embedded Content"
-                  )}
+                        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                        allowFullScreen={true}
+                        sandbox={`${
+                          src?.sandbox?.allowSameOrigin
+                            ? "allow-same-origin"
+                            : ""
+                        } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
+                      />
+                    )}
+                  </div>
                 </div>
               </div>
             </div>
@@ -2066,20 +2093,30 @@ class App extends React.Component<AppProps, AppState> {
     const selectedElements = this.scene.getSelectedElements(this.state);
     const { renderTopRightUI, renderTopLeftUI, renderCustomStats } = this.props;
 
-    const sceneNonce = this.scene.getSceneNonce();
+    const {
-    const { elementsMap, visibleElements } =
+      elementsMap,
-      this.renderer.getRenderableElements({
+      visibleElements,
-        sceneNonce,
+      canvasNonce,
-        zoom: this.state.zoom,
+      /**
-        offsetLeft: this.state.offsetLeft,
+       * element to draw on the <NewElementCanvas> for optimization purposes.
-        offsetTop: this.state.offsetTop,
+       * Can be null even if this.state.newElement defined
-        scrollX: this.state.scrollX,
+       * (e.g. when its zIndex isn't on top) */
-        scrollY: this.state.scrollY,
+      newElementCanvasElement,
-        height: this.state.height,
+    } = this.renderer.getRenderableElements({
-        width: this.state.width,
+      zoom: this.state.zoom,
-        editingTextElement: this.state.editingTextElement,
+      offsetLeft: this.state.offsetLeft,
-        newElementId: this.state.newElement?.id,
+      offsetTop: this.state.offsetTop,
-      });
+      scrollX: this.state.scrollX,
+      scrollY: this.state.scrollY,
+      height: this.state.height,
+      width: this.state.width,
+      editingTextElement: this.state.editingTextElement,
+      newElement: this.state.newElement,
+      selectedElements,
+      selectedElementsAreBeingDragged:
+        this.state.selectedElementsAreBeingDragged,
+      frameToHighlight: this.state.frameToHighlight,
+    });
     this.visibleElements = visibleElements;
 
     const allElementsMap = this.scene.getNonDeletedElementsMap();
@@ -2298,7 +2335,7 @@ class App extends React.Component<AppProps, AppState> {
                             elementsMap={elementsMap}
                             allElementsMap={allElementsMap}
                             visibleElements={visibleElements}
-                            sceneNonce={sceneNonce}
+                            canvasNonce={canvasNonce}
                             selectionNonce={
                               this.state.selectionElement?.versionNonce
                             }
@@ -2319,9 +2356,10 @@ class App extends React.Component<AppProps, AppState> {
                               theme: this.state.theme,
                             }}
                           />
-                          {this.state.newElement && (
+                          {newElementCanvasElement && (
                             <NewElementCanvas
                               appState={this.state}
+                              newElement={newElementCanvasElement}
                               scale={window.devicePixelRatio}
                               rc={this.rc}
                               elementsMap={elementsMap}
@@ -2349,7 +2387,7 @@ class App extends React.Component<AppProps, AppState> {
                             visibleElements={visibleElements}
                             allElementsMap={allElementsMap}
                             selectedElements={selectedElements}
-                            sceneNonce={sceneNonce}
+                            canvasNonce={canvasNonce}
                             selectionNonce={
                               this.state.selectionElement?.versionNonce
                             }
@@ -2524,6 +2562,7 @@ class App extends React.Component<AppProps, AppState> {
     const magicFrameChildren = getElementsOverlappingFrame(
       this.scene.getNonDeletedElements(),
       magicFrame,
+      this.scene.getNonDeletedElementsMap(),
     ).filter((el) => !isMagicFrameElement(el));
 
     if (!magicFrameChildren.length) {
@@ -2660,7 +2699,7 @@ class App extends React.Component<AppProps, AppState> {
           locked: false,
         });
 
-        this.scene.insertElement(frame);
+        this.insertNewElement(frame);
 
         for (const child of selectedElements) {
           this.scene.mutateElement(child, { frameId: frame.id });
@@ -3738,6 +3777,7 @@ class App extends React.Component<AppProps, AppState> {
         position:
           this.editorInterface.formFactor === "desktop" ? "cursor" : "center",
         retainSeed: isPlainPaste,
+        preserveFrameChildrenOrder: true,
       });
       return;
     }
@@ -3881,6 +3921,7 @@ class App extends React.Component<AppProps, AppState> {
     position: { clientX: number; clientY: number } | "cursor" | "center";
     retainSeed?: boolean;
     fitToContent?: boolean;
+    preserveFrameChildrenOrder?: boolean;
   }) => {
     const elements = restoreElements(opts.elements, null, {
       deleteInvisibleElements: true,
@@ -3922,6 +3963,7 @@ class App extends React.Component<AppProps, AppState> {
         });
       }),
       randomizeSeed: !opts.retainSeed,
+      preserveFrameChildrenOrder: opts.preserveFrameChildrenOrder,
     });
 
     const prevElements = this.scene.getElementsIncludingDeleted();
@@ -3943,11 +3985,10 @@ class App extends React.Component<AppProps, AppState> {
         duplicatedElements,
         topLayerFrame,
       );
-      addElementsToFrame(
+      nextElements = addElementsToFrame(
         nextElements,
         eligibleElements,
         topLayerFrame,
-        this.state,
       );
     }
 
@@ -4173,7 +4214,7 @@ class App extends React.Component<AppProps, AppState> {
       return;
     }
 
-    this.scene.insertElements(textElements);
+    this.insertNewElements(textElements);
     this.store.scheduleCapture();
     this.setState({
       selectedElementIds: makeNextSelectedElementIds(
@@ -5429,7 +5470,7 @@ class App extends React.Component<AppProps, AppState> {
     if (!event[KEYS.CTRL_OR_CMD]) {
       if (this.flowChartCreator.isCreatingChart) {
         if (this.flowChartCreator.pendingNodes?.length) {
-          this.scene.insertElements(this.flowChartCreator.pendingNodes);
+          this.insertNewElements(this.flowChartCreator.pendingNodes);
         }
 
         const firstNode = this.flowChartCreator.pendingNodes?.[0];
@@ -5527,6 +5568,7 @@ class App extends React.Component<AppProps, AppState> {
         selectedLinearElement: isSelectionLikeTool(nextActiveTool.type)
           ? prevState.selectedLinearElement
           : null,
+        frameToHighlight: null,
       } as const;
 
       if (nextActiveTool.type === "freedraw") {
@@ -6124,6 +6166,12 @@ class App extends React.Component<AppProps, AppState> {
         hitElement = elements[index];
         break;
       } else if (x1 < x && x < x2 && y1 < y && y < y2) {
+        // to allow binding to containers within frames,
+        // ignore frames in hit testing
+        if (isFrameLikeElement(elements[index])) {
+          continue;
+        }
+
         hitElement = elements[index];
         break;
       }
@@ -6213,11 +6261,6 @@ class App extends React.Component<AppProps, AppState> {
       }
     }
 
-    const topLayerFrame = this.getTopLayerFrameAtSceneCoords({
-      x: sceneX,
-      y: sceneY,
-    });
-
     const textCreationGridPoint = this.getTextCreationGridPoint(sceneX, sceneY);
 
     const newTextElementPosition = parentCenterPosition
@@ -6239,6 +6282,20 @@ class App extends React.Component<AppProps, AppState> {
           y: sceneY,
         };
 
+    const topLayerFrame = this.getTopLayerFrameAtSceneCoords({
+      x: newTextElementPosition.x,
+      y: newTextElementPosition.y,
+    });
+
+    // container has higher priority. Only add to frame if container is in the same frame.
+    const frameId =
+      topLayerFrame &&
+      (!shouldBindToContainer ||
+        !container ||
+        container.frameId === topLayerFrame.id)
+        ? topLayerFrame.id
+        : null;
+
     const element =
       existingTextElement ||
       newTextElement({
@@ -6268,7 +6325,7 @@ class App extends React.Component<AppProps, AppState> {
             ? (0 as Radians)
             : container.angle
           : (0 as Radians),
-        frameId: topLayerFrame ? topLayerFrame.id : null,
+        frameId,
       });
 
     if (!existingTextElement && shouldBindToContainer && container) {
@@ -6284,9 +6341,12 @@ class App extends React.Component<AppProps, AppState> {
     if (!existingTextElement) {
       if (container && shouldBindToContainer) {
         const containerIndex = this.scene.getElementIndex(container.id);
-        this.scene.insertElementAtIndex(element, containerIndex + 1);
+        // TODO should use insertNewElement, after we update it to handle
+        // elements with containerId + frameId at the same time (containerId
+        // should take precedence when it comes to z-index)
+        this.scene.insertElementsAtIndex([element], containerIndex + 1);
       } else {
-        this.scene.insertElement(element);
+        this.insertNewElement(element);
       }
     }
 
@@ -6668,19 +6728,161 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
-  private getTopLayerFrameAtSceneCoords = (sceneCoords: {
+  /**
-    x: number;
+   * finds candidate frame under cursor (when dragging frame children/elements
-    y: number;
+   * inside frames)
-  }) => {
+   */
+  private getTopLayerFrameAtSceneCoords = (
+    /**
+     * should be already grid aligned (basically should be what the call site
+     * sets the element's coords to, if applicable)
+     */
+    sceneCoords: {
+      x: number;
+      y: number;
+    },
+    opts?: {
+      /** to exclude selected elements when dragging, etc. */
+      excludeElementIds?: AppState["selectedElementIds"];
+      currentFrameId?: ExcalidrawElement["frameId"];
+    },
+  ) => {
     const elementsMap = this.scene.getNonDeletedElementsMap();
-    const frames = this.scene
+    const framesUnderCursor = this.scene
       .getNonDeletedFramesLikes()
       .filter(
         (frame): frame is ExcalidrawFrameLikeElement =>
           !frame.locked && isCursorInFrame(sceneCoords, frame, elementsMap),
       );
 
-    return frames.length ? frames[frames.length - 1] : null;
+    if (!framesUnderCursor.length) {
+      return null;
+    }
+
+    const topLayerFrame = framesUnderCursor.at(-1)!;
+
+    const hitElement = this.getElementsAtPosition(
+      sceneCoords.x,
+      sceneCoords.y,
+      {
+        includeLockedElements: true,
+      },
+    ).findLast((element) => !opts?.excludeElementIds?.[element.id]);
+
+    if (hitElement) {
+      if (
+        isFrameLikeElement(hitElement) &&
+        // case: we're hitting a locked frame itself (frame's outline
+        // or later its bg once implemented)
+        !hitElement.locked
+      ) {
+        return topLayerFrame;
+      }
+
+      const hitElementIndex = this.scene.getElementIndex(hitElement.id);
+      const topLayerFrameIndex = this.scene.getElementIndex(topLayerFrame.id);
+
+      if (
+        hitElementIndex !== -1 &&
+        topLayerFrameIndex !== -1 &&
+        hitElementIndex <= topLayerFrameIndex
+      ) {
+        return topLayerFrame;
+      }
+
+      // to support a case of dragging a pre-existing frame child underneath
+      // a non-frame element covering the cursor
+      const currentFrame = opts?.currentFrameId
+        ? framesUnderCursor.find((frame) => frame.id === opts.currentFrameId) ??
+          null
+        : null;
+
+      if (currentFrame) {
+        return currentFrame;
+      }
+
+      return hitElement.frameId
+        ? framesUnderCursor.find((frame) => frame.id === hitElement.frameId) ??
+            null
+        : null;
+    }
+
+    return topLayerFrame;
+  };
+
+  private updateFrameToHighlight = (
+    frameToHighlight: AppState["frameToHighlight"],
+  ) => {
+    if (this.state.frameToHighlight !== frameToHighlight) {
+      this.setState({ frameToHighlight });
+    }
+  };
+
+  private maybeUpdateFrameToHighlightOnPointerMove = (
+    sceneCoords: { x: number; y: number },
+    isOverScrollBar: boolean,
+  ) => {
+    // currently this function is being called even during pointerdown so we
+    // need to make sure we don't re-set the state when dragging and similar
+    //
+    // But, we still want to reset on pointermove in case the state is stale
+    // so we updte even for non-eligible tool types
+    if (
+      this.state.newElement ||
+      this.state.multiElement ||
+      this.state.selectionElement ||
+      this.state.selectedElementsAreBeingDragged
+    ) {
+      return;
+    }
+
+    this.updateFrameToHighlight(
+      !isOverScrollBar && isEligibleFrameChildType(this.state.activeTool.type)
+        ? this.getTopLayerFrameAtSceneCoords(sceneCoords)
+        : null,
+    );
+  };
+
+  private insertNewElements = (elements: readonly ExcalidrawElement[]) => {
+    if (!elements.length) {
+      return;
+    }
+
+    const chunkedElements: ExcalidrawElement[][] = [];
+
+    for (const element of elements) {
+      const currentChunk = chunkedElements[chunkedElements.length - 1];
+
+      if (currentChunk?.[0].frameId === element.frameId) {
+        currentChunk.push(element);
+      } else {
+        chunkedElements.push([element]);
+      }
+    }
+
+    for (const chunk of chunkedElements) {
+      const frameId = chunk[0].frameId;
+
+      const insertionIndex = frameId
+        ? getFrameChildrenInsertionIndex(
+            this.scene.getElementsIncludingDeleted(),
+            frameId,
+          )
+        : null;
+      this.scene.insertElementsAtIndex(chunk, insertionIndex);
+    }
+  };
+
+  private insertNewElement = (element: ExcalidrawElement) => {
+    this.insertNewElements([element]);
+
+    const frame = element.frameId
+      ? this.scene.getNonDeletedElement(element.frameId)
+      : null;
+
+    this.updateFrameToHighlight(
+      frame && isFrameLikeElement(frame) ? frame : null,
+    );
   };
 
   private handleCanvasPointerMove = (
@@ -6782,6 +6984,14 @@ class App extends React.Component<AppProps, AppState> {
       }
     }
 
+    this.maybeUpdateFrameToHighlightOnPointerMove(
+      {
+        x: scenePointerX,
+        y: scenePointerY,
+      },
+      isOverScrollBar,
+    );
+
     if (
       !this.state.newElement &&
       isActiveToolNonLinearSnappable(this.state.activeTool.type)
@@ -6920,7 +7130,7 @@ class App extends React.Component<AppProps, AppState> {
               y: scenePointerY,
             },
           });
-          this.setState({ suggestedBinding: null, startBoundElement: null });
+          this.setState({ suggestedBinding: null });
           if (!this.state.activeTool.locked) {
             resetCursor(this.interactiveCanvas);
             this.setState((prevState) => ({
@@ -7239,6 +7449,14 @@ class App extends React.Component<AppProps, AppState> {
           this.interactiveCanvas,
           isTextElement(hitElement) ? CURSOR_TYPE.TEXT : CURSOR_TYPE.CROSSHAIR,
         );
+      } else if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        this.isHittingCommonBoundingBoxOfSelectedElements(
+          scenePointer,
+          selectedElements,
+        )
+      ) {
+        setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);
       } else if (this.state.viewModeEnabled) {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.GRAB);
       } else if (this.state.openDialog?.name === "elementLinkSelector") {
@@ -7556,7 +7774,6 @@ class App extends React.Component<AppProps, AppState> {
         appState: {
           newElement: null,
           editingTextElement: null,
-          startBoundElement: null,
           suggestedBinding: null,
           selectedElementIds: makeNextSelectedElementIds(
             Object.keys(this.state.selectedElementIds)
@@ -7730,17 +7947,24 @@ class App extends React.Component<AppProps, AppState> {
       const hitSelectedElement =
         pointerDownState.hit.element &&
         this.isASelectedElement(pointerDownState.hit.element);
+      const shouldForceLassoReselect =
+        event.altKey &&
+        event[KEYS.CTRL_OR_CMD] &&
+        !pointerDownState.resize.handleType;
+      const shouldStartLassoSelection =
+        shouldForceLassoReselect ||
+        (!pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+          !pointerDownState.resize.handleType &&
+          !hitSelectedElement);
 
-      if (
+      if (shouldStartLassoSelection) {
-        !pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+        if (!this.lassoTrail.hasCurrentTrail) {
-        !pointerDownState.resize.handleType &&
+          this.lassoTrail.startPath(
-        !hitSelectedElement
+            pointerDownState.origin.x,
-      ) {
+            pointerDownState.origin.y,
-        this.lassoTrail.startPath(
+            event.shiftKey,
-          pointerDownState.origin.x,
+          );
-          pointerDownState.origin.y,
+        }
-          event.shiftKey,
-        );
 
         // block dragging after lasso selection on PCs until the next pointer down
         // (on mobile or tablet, we want to allow user to drag immediately)
@@ -8729,12 +8953,14 @@ class App extends React.Component<AppProps, AppState> {
       DEFAULT_COLLISION_THRESHOLD / this.state.zoom.value,
       1,
     );
+    const boundsPadding =
+      (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / this.state.zoom.value;
     const [x1, y1, x2, y2] = getCommonBounds(selectedElements);
     return (
-      point.x > x1 - threshold &&
+      point.x > x1 - boundsPadding - threshold &&
-      point.x < x2 + threshold &&
+      point.x < x2 + boundsPadding + threshold &&
-      point.y > y1 - threshold &&
+      point.y > y1 - boundsPadding - threshold &&
-      point.y < y2 + threshold
+      point.y < y2 + boundsPadding + threshold
     );
   }
 
@@ -8820,7 +9046,7 @@ class App extends React.Component<AppProps, AppState> {
       pressures: simulatePressure ? [] : [event.pressure],
     });
 
-    this.scene.insertElement(element);
+    this.insertNewElement(element);
 
     this.setState((prevState) => {
       const nextSelectedElementIds = {
@@ -8835,18 +9061,8 @@ class App extends React.Component<AppProps, AppState> {
       };
     });
 
-    const boundElement = getHoveredElementForBinding(
-      pointFrom<GlobalPoint>(
-        pointerDownState.origin.x,
-        pointerDownState.origin.y,
-      ),
-      this.scene.getNonDeletedElements(),
-      this.scene.getNonDeletedElementsMap(),
-    );
-
     this.setState({
       newElement: element,
-      startBoundElement: boundElement,
       suggestedBinding: null,
     });
   };
@@ -8887,7 +9103,7 @@ class App extends React.Component<AppProps, AppState> {
       height,
     });
 
-    this.scene.insertElement(element);
+    this.insertNewElement(element);
 
     return element;
   };
@@ -8941,7 +9157,7 @@ class App extends React.Component<AppProps, AppState> {
       link,
     });
 
-    this.scene.insertElement(element);
+    this.insertNewElement(element);
 
     return element;
   };
@@ -9185,7 +9401,7 @@ class App extends React.Component<AppProps, AppState> {
         points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(0, 0)],
       });
 
-      this.scene.insertElement(element);
+      this.insertNewElement(element);
 
       if (isBindingElement(element)) {
         // Do the initial binding so the binding strategy has the initial state
@@ -9343,7 +9559,7 @@ class App extends React.Component<AppProps, AppState> {
         selectionElement: element,
       });
     } else {
-      this.scene.insertElement(element);
+      this.insertNewElement(element);
       this.setState({
         multiElement: null,
         newElement: element,
@@ -9376,7 +9592,7 @@ class App extends React.Component<AppProps, AppState> {
         ? newMagicFrameElement(constructorOpts)
         : newFrameElement(constructorOpts);
 
-    this.scene.insertElement(frame);
+    this.insertNewElement(frame);
 
     this.setState({
       multiElement: null,
@@ -9744,18 +9960,17 @@ class App extends React.Component<AppProps, AppState> {
           return;
         }
 
-        const selectedElementsHasAFrame = selectedElements.find((e) =>
+        const selectedElementsHasAFrame = selectedElements.some((e) =>
           isFrameLikeElement(e),
         );
-        const topLayerFrame = this.getTopLayerFrameAtSceneCoords(pointerCoords);
+        const frameToHighlight = selectedElementsHasAFrame
-        const frameToHighlight =
+          ? null
-          topLayerFrame && !selectedElementsHasAFrame ? topLayerFrame : null;
+          : this.getTopLayerFrameAtSceneCoords(pointerCoords, {
+              currentFrameId: getCommonFrameId(selectedElements),
+              excludeElementIds: this.state.selectedElementIds,
+            });
         // Only update the state if there is a difference
-        if (this.state.frameToHighlight !== frameToHighlight) {
+        this.updateFrameToHighlight(frameToHighlight);
-          flushSync(() => {
-            this.setState({ frameToHighlight });
-          });
-        }
 
         // Marking that click was used for dragging to check
         // if elements should be deselected on pointerup
@@ -10191,20 +10406,38 @@ class App extends React.Component<AppProps, AppState> {
           );
 
           let linearElementEditor = this.state.selectedLinearElement;
-          if (!linearElementEditor) {
+
+          if (
+            !linearElementEditor ||
+            linearElementEditor.elementId !== newElement.id
+          ) {
             linearElementEditor = new LinearElementEditor(
               newElement,
               this.scene.getNonDeletedElementsMap(),
             );
+          }
+
+          const lastClickedPointOutOfBounds =
+            linearElementEditor &&
+            (linearElementEditor.initialState.lastClickedPoint < 0 ||
+              linearElementEditor.initialState.lastClickedPoint >=
+                points.length);
+          if (lastClickedPointOutOfBounds) {
+            console.warn(
+              "Last clicked point is out of bounds. Attempting to fix it.",
+            );
             linearElementEditor = {
               ...linearElementEditor,
-              selectedPointsIndices: [1],
+              selectedPointsIndices: [points.length - 1],
               initialState: {
                 ...linearElementEditor.initialState,
-                lastClickedPoint: 1,
+                prevSelectedPointsIndices: null,
+                lastClickedPoint: points.length - 1,
               },
+              hoverPointIndex: points.length - 1,
             };
           }
+
           this.setState({
             newElement,
             ...LinearElementEditor.handlePointDragging(
@@ -10267,6 +10500,7 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
+                this.state.boxSelectionMode,
               )
             : [];
 
@@ -10698,7 +10932,7 @@ class App extends React.Component<AppProps, AppState> {
               sceneCoords,
             });
           }
-          this.setState({ suggestedBinding: null, startBoundElement: null });
+          this.setState({ suggestedBinding: null });
           if (!activeTool.locked) {
             resetCursor(this.interactiveCanvas);
             this.setState((prevState) => ({
@@ -10719,9 +10953,9 @@ class App extends React.Component<AppProps, AppState> {
               ),
             }));
           } else {
-            this.setState((prevState) => ({
+            this.setState({
               newElement: null,
-            }));
+            });
           }
           // so that the scene gets rendered again to display the newly drawn linear as well
           this.scene.triggerUpdate();
@@ -10783,7 +11017,6 @@ class App extends React.Component<AppProps, AppState> {
             this.scene.getElementsMapIncludingDeleted(),
             elementsInsideFrame,
             newElement,
-            this.state,
           ),
         );
       }
@@ -10843,9 +11076,14 @@ class App extends React.Component<AppProps, AppState> {
           }
         } else {
           // update the relationships between selected elements and frames
-          const topLayerFrame = this.getTopLayerFrameAtSceneCoords(sceneCoords);
-
           const selectedElements = this.scene.getSelectedElements(this.state);
+          const topLayerFrame = this.getTopLayerFrameAtSceneCoords(
+            sceneCoords,
+            {
+              currentFrameId: getCommonFrameId(selectedElements),
+              excludeElementIds: this.state.selectedElementIds,
+            },
+          );
           let nextElements = this.scene.getElementsMapIncludingDeleted();
 
           const updateGroupIdsAfterEditingGroup = (
@@ -10894,10 +11132,8 @@ class App extends React.Component<AppProps, AppState> {
             topLayerFrame &&
             !this.state.selectedElementIds[topLayerFrame.id]
           ) {
-            const elementsToAdd = selectedElements.filter(
+            const elementsToAdd = selectedElements.filter((element) =>
-              (element) =>
+              isElementInFrame(element, nextElements, this.state),
-                element.frameId !== topLayerFrame.id &&
-                isElementInFrame(element, nextElements, this.state),
             );
 
             if (this.state.editingGroupId) {
@@ -10908,7 +11144,6 @@ class App extends React.Component<AppProps, AppState> {
               nextElements,
               elementsToAdd,
               topLayerFrame,
-              this.state,
             );
           } else if (!topLayerFrame) {
             if (this.state.editingGroupId) {
@@ -10970,7 +11205,6 @@ class App extends React.Component<AppProps, AppState> {
               elementsMap,
             ),
             frame,
-            this,
           );
         }
 
@@ -11786,7 +12020,7 @@ class App extends React.Component<AppProps, AppState> {
       sceneY,
       gridPadding,
     );
-    placeholders.forEach((el) => this.scene.insertElement(el));
+    this.insertNewElements(placeholders);
 
     // Create, position, insert and select initialized (replacing placeholders)
     const initialized = await Promise.all(
@@ -11914,6 +12148,7 @@ class App extends React.Component<AppProps, AppState> {
               type: "everything",
               elements: item.elements,
               randomizeSeed: true,
+              preserveFrameChildrenOrder: true,
             }).duplicatedElements,
           }));
 

packages/excalidraw/components/LayerUI.tsx

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

packages/excalidraw/components/LibraryMenuItems.tsx

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

packages/excalidraw/components/RadioGroup.scss

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

packages/excalidraw/components/Stats/Dimension.tsx

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

packages/excalidraw/components/Stats/MultiDimension.tsx

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

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

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

packages/excalidraw/components/canvases/InteractiveCanvas.tsx

@@ -39,7 +39,7 @@ type InteractiveCanvasProps = {
   visibleElements: readonly NonDeletedExcalidrawElement[];
   selectedElements: readonly NonDeletedExcalidrawElement[];
   allElementsMap: NonDeletedSceneElementsMap;
-  sceneNonce: number | undefined;
+  canvasNonce: string;
   selectionNonce: number | undefined;
   scale: number;
   appState: InteractiveCanvasAppState;
@@ -279,10 +279,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.sceneNonce !== nextProps.sceneNonce ||
+    prevProps.canvasNonce !== nextProps.canvasNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if sceneNonce didn't change (e.g. we filter elements out based
+    // even if canvasNonce 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,6 +14,7 @@ import type { RoughCanvas } from "roughjs/bin/canvas";
 
 interface NewElementCanvasProps {
   appState: AppState;
+  newElement: NonNullable<AppState["newElement"]>;
   elementsMap: RenderableElementsMap;
   allElementsMap: NonDeletedSceneElementsMap;
   scale: number;
@@ -31,7 +32,7 @@ const NewElementCanvas = (props: NewElementCanvasProps) => {
       {
         canvas: canvasRef.current,
         scale: props.scale,
-        newElement: props.appState.newElement,
+        newElement: props.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[];
-  sceneNonce: number | undefined;
+  canvasNonce: string;
   selectionNonce: number | undefined;
   scale: number;
   appState: StaticCanvasAppState;
@@ -110,10 +110,10 @@ const areEqual = (
   nextProps: StaticCanvasProps,
 ) => {
   if (
-    prevProps.sceneNonce !== nextProps.sceneNonce ||
+    prevProps.canvasNonce !== nextProps.canvasNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if sceneNonce didn't change (e.g. we filter elements out based
+    // even if canvasNonce 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: 16rem;
+    max-width: 20rem;
     z-index: 1;
 
     &--placement-top {

packages/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.tsx

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

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

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

packages/excalidraw/components/shapes.tsx

@@ -119,15 +119,12 @@ 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(1),
+        ...SHAPES.slice(2),
       ] as const)
     : SHAPES;
 };

packages/excalidraw/css/styles.scss

@@ -814,6 +814,14 @@ 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/data/index.ts

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

packages/excalidraw/data/restore.ts

@@ -96,6 +96,8 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
+const MAX_ARROW_PX = 75_000;
+
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -467,8 +469,8 @@ export const restoreElement = (
         element.endArrowhead === undefined
           ? "arrow"
           : normalizeArrowhead(element.endArrowhead);
-      const x: number | undefined = element.x;
+      const x = element.x as number | undefined;
-      const y: number | undefined = element.y;
+      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)]
@@ -493,8 +495,8 @@ export const restoreElement = (
         startArrowhead,
         endArrowhead,
         points,
-        x,
+        x: x ?? 0,
-        y,
+        y: y ?? 0,
         elbowed: (element as ExcalidrawArrowElement).elbowed,
         ...getSizeFromPoints(points),
       };
@@ -513,12 +515,44 @@ export const restoreElement = (
           })
         : restoreElementWithProperties(element as ExcalidrawArrowElement, base);
 
-      return {
+      const normalizedRestoredElement = {
         ...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
@@ -666,6 +700,7 @@ 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,
@@ -762,7 +797,7 @@ export const restoreElements = <T extends ExcalidrawElement>(
     }
   }
 
-  // NOTE (mtolmacs): Temporary fix for extremely large arrows
+  // NOTE (mtolmacs): Temporary fix for invalid/self-bound elbow arrows
   // Need to iterate again so we have attached text nodes in elementsMap
   return restoredElements.map((element) => {
     if (
@@ -936,6 +971,12 @@ export const restoreAppState = (
         : defaultValue;
   }
 
+  const boxSelectionMode =
+    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
+  if (boxSelectionMode !== undefined) {
+    nextAppState.boxSelectionMode = boxSelectionMode;
+  }
+
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/locales/en.json

@@ -185,6 +185,9 @@
     "shapeSwitch": "Switch shape",
     "preferences": "Preferences",
     "preferences_toolLock": "Tool lock",
+    "boxSelectionMode": "Select on",
+    "boxSelectionContain": "Wrap",
+    "boxSelectionOverlap": "Overlap",
     "arrowBinding": "Arrow binding",
     "midpointSnapping": "Snap to midpoints"
   },

packages/excalidraw/package.json

@@ -95,7 +95,6 @@
     "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,6 +23,94 @@ 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/scene/Renderer.ts

@@ -1,9 +1,15 @@
-import { isElementInViewport } from "@excalidraw/element";
+import {
+  getCommonFrameId,
+  getFrameChildrenInsertionIndex,
+  isElementInViewport,
+} from "@excalidraw/element";
 
-import { memoize, toBrandedType } from "@excalidraw/common";
+import { arrayToMap, memoize, toBrandedType } from "@excalidraw/common";
 
 import type {
   ExcalidrawElement,
+  ExcalidrawFrameLikeElement,
+  NonDeleted,
   NonDeletedElementsMap,
   NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
@@ -16,6 +22,21 @@ 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;
 
@@ -23,9 +44,121 @@ export class Renderer {
     this.scene = scene;
   }
 
-  public getRenderableElements = (() => {
+  private getVisibleCanvasElements({
-    const getVisibleCanvasElements = ({
+    elementsMap,
-      elementsMap,
+    zoom,
+    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,
@@ -33,70 +166,27 @@ 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,
-      newElementId,
+      newElement,
-    }: {
+    }: Omit<
-      elements: readonly NonDeletedExcalidrawElement[];
+      GetRenderableElementsOpts,
-      editingTextElement: AppState["editingTextElement"];
+      | "selectedElements"
-      newElementId: ExcalidrawElement["id"] | undefined;
+      | "selectedElementsAreBeingDragged"
+      | "frameToHighlight"
+    > & {
+      canvasNonce: string;
     }) => {
-      const elementsMap = toBrandedType<RenderableElementsMap>(new Map());
+      const elements = this.scene.getNonDeletedElements();
 
-      for (const element of elements) {
+      const { elementsMap, newElementCanvasElement } =
-        if (newElementId === element.id) {
+        this.getRenderableElementsMap({
-          continue;
+          elements,
-        }
+          editingTextElement,
+          newElement,
+        });
 
-        // we don't want to render text element that's being currently edited
+      const visibleElements = this.getVisibleCanvasElements({
-        // (it's rendered on remote only)
+        elementsMap,
-        if (
-          !editingTextElement ||
-          editingTextElement.type !== "text" ||
-          element.id !== editingTextElement.id
-        ) {
-          elementsMap.set(element.id, element);
-        }
-      }
-      return elementsMap;
-    };
-
-    return memoize(
-      ({
         zoom,
         offsetLeft,
         offsetTop,
@@ -104,52 +194,69 @@ 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();
 
-        const elementsMap = getRenderableElements({
+      return {
-          elements,
+        elementsMap,
-          editingTextElement,
+        visibleElements,
-          newElementId,
+        newElementCanvasElement,
+        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,
         });
 
-        const visibleElements = getVisibleCanvasElements({
+      return {
-          elementsMap,
+        ...ret,
-          zoom,
+        visibleElements: reorderedVisibleElements,
-          offsetLeft,
+      };
-          offsetTop,
+    }
-          scrollX,
-          scrollY,
-          height,
-          width,
-        });
 
-        return { elementsMap, visibleElements };
+    return ret;
-      },
+  };
-    );
-  })();
 
   // 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,7 +157,11 @@ const prepareElementsForRender = ({
   let nextElements: readonly ExcalidrawElement[];
 
   if (exportingFrame) {
-    nextElements = getElementsOverlappingFrame(elements, exportingFrame);
+    nextElements = getElementsOverlappingFrame(
+      elements,
+      exportingFrame,
+      arrayToMap(elements),
+    );
   } else if (frameRendering.enabled && frameRendering.name) {
     nextElements = addFrameLabelsAsTextElements(elements, {
       exportWithDarkMode,

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

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

@@ -13,6 +13,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -646,6 +647,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1207,6 +1209,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1290,7 +1293,6 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1567,6 +1569,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1650,7 +1653,6 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -1929,6 +1931,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2012,7 +2015,6 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2192,6 +2194,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2274,7 +2277,40 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
+  "startBoundElement": {
+    "angle": 0,
+    "backgroundColor": "transparent",
+    "boundElements": [
+      {
+        "id": "id4",
+        "type": "arrow",
+      },
+    ],
+    "customData": undefined,
+    "fillStyle": "solid",
+    "frameId": null,
+    "groupIds": [],
+    "height": 100,
+    "id": "id0",
+    "index": "a0",
+    "isDeleted": false,
+    "link": null,
+    "locked": false,
+    "opacity": 100,
+    "roughness": 1,
+    "roundness": null,
+    "seed": 1,
+    "strokeColor": "#1e1e1e",
+    "strokeStyle": "solid",
+    "strokeWidth": 2,
+    "type": "rectangle",
+    "updated": 1,
+    "version": 3,
+    "versionNonce": 493213705,
+    "width": 100,
+    "x": -100,
+    "y": -50,
+  },
   "stats": {
     "open": false,
     "panels": 3,
@@ -2645,6 +2681,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2728,7 +2765,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2948,6 +2984,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3031,7 +3068,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3267,6 +3303,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3350,7 +3387,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3561,6 +3597,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3644,7 +3681,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -3847,6 +3883,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3930,7 +3967,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4082,6 +4118,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4165,7 +4202,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4339,6 +4375,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4422,7 +4459,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4610,6 +4646,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4693,7 +4730,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -4839,6 +4875,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4922,7 +4959,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5068,6 +5104,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5151,7 +5188,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5315,6 +5351,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5398,7 +5435,6 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5571,6 +5607,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5654,7 +5691,6 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -5829,6 +5865,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5911,7 +5948,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6158,6 +6194,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6240,7 +6277,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6585,6 +6621,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6670,7 +6707,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6959,6 +6995,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7050,7 +7087,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7271,6 +7307,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7563,6 +7600,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7643,7 +7681,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7793,6 +7830,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7873,7 +7911,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8145,6 +8182,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8225,7 +8263,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8497,6 +8534,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8583,7 +8621,6 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8903,6 +8940,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8983,7 +9021,6 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9182,6 +9219,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9264,7 +9302,6 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9446,6 +9483,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9528,7 +9566,6 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9711,6 +9748,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9793,7 +9831,6 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9943,6 +9980,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10026,7 +10064,6 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10240,6 +10277,7 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10557,6 +10595,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10637,7 +10676,6 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10793,6 +10831,7 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10876,7 +10915,6 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11718,6 +11756,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11800,7 +11839,6 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11978,6 +12016,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12058,7 +12097,6 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12213,6 +12251,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12295,7 +12334,6 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12450,6 +12488,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12530,7 +12569,6 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -12841,6 +12879,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12926,7 +12965,6 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13051,6 +13089,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13133,7 +13172,6 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13258,6 +13296,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13344,7 +13383,6 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13559,6 +13597,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13642,7 +13681,6 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -13857,6 +13895,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13940,7 +13979,6 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14102,6 +14140,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14184,7 +14223,6 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14339,6 +14377,7 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14421,7 +14460,6 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14576,6 +14614,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14658,7 +14697,6 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14823,6 +14861,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14905,7 +14944,6 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15154,6 +15192,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15237,7 +15276,6 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15324,6 +15362,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15409,7 +15448,6 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15608,6 +15646,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15691,7 +15730,6 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -15871,6 +15909,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -15954,7 +15993,6 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -16024,6 +16062,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16108,7 +16147,6 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -16306,6 +16344,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -16389,7 +16428,6 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -16468,6 +16506,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -17216,6 +17255,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -17862,6 +17902,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -18508,6 +18549,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -19257,6 +19299,7 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20025,6 +20068,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20110,7 +20154,6 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -20505,6 +20548,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -20592,7 +20636,6 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -21016,6 +21059,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -21098,7 +21142,6 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -21475,6 +21518,7 @@ exports[`history > singleplayer undo/redo > should support linear element creati
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,

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

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

@@ -305,8 +305,88 @@ 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);
     });
   });
 
@@ -379,8 +459,9 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(3);
-      expect(h.elements[1].type).toBe(rect.type);
+      expect(h.elements[0].type).toBe(rect.type);
-      expect(h.elements[1].frameId).toBe(frame.id);
+      expect(h.elements[0].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);
     });
@@ -422,10 +503,11 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(3);
-      expect(h.elements[1].type).toBe(rect.type);
+      expect(h.elements[0].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].type).toBe(rect2.type);
+      expect(h.elements[2].id).toBe(frame.id);
-      expect(h.elements[2].frameId).toBe(frame.id);
     });
   });
 
@@ -473,8 +555,9 @@ describe("pasting & frames", () => {
 
     await waitFor(() => {
       expect(h.elements.length).toBe(4);
-      expect(h.elements[1].type).toBe(rect.type);
+      expect(h.elements[0].type).toBe(rect.type);
-      expect(h.elements[1].frameId).toBe(frame.id);
+      expect(h.elements[0].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/helpers/polyfills.ts

@@ -94,3 +94,42 @@ 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/history.test.tsx

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

packages/excalidraw/tests/regressionTests.test.tsx

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

packages/excalidraw/tests/selection.test.tsx

@@ -1,7 +1,13 @@
 import React from "react";
 import { vi } from "vitest";
 
-import { KEYS, reseed } from "@excalidraw/common";
+import { KEYS, ROUNDNESS, arrayToMap, reseed } from "@excalidraw/common";
+import {
+  getElementBounds,
+  getElementLineSegments,
+  getElementsWithinSelection,
+} from "@excalidraw/element";
+import { pointFrom, pointRotateRads, type LocalPoint } from "@excalidraw/math";
 
 import { SHAPES } from "../components/shapes";
 
@@ -12,6 +18,7 @@ import * as StaticScene from "../renderer/staticScene";
 import { API } from "./helpers/api";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
 import {
+  act,
   render,
   fireEvent,
   mockBoundingClientRect,
@@ -39,6 +46,19 @@ const { h } = window;
 
 const mouse = new Pointer("mouse");
 
+const getOutlineBounds = (element: ReturnType<typeof API.createElement>) => {
+  const sceneElement = API.getElement(element);
+  const elementsMap = h.scene.getNonDeletedElementsMap();
+  const points = getElementLineSegments(sceneElement, elementsMap).flat();
+
+  return [
+    Math.min(...points.map((point) => point[0])),
+    Math.min(...points.map((point) => point[1])),
+    Math.max(...points.map((point) => point[0])),
+    Math.max(...points.map((point) => point[1])),
+  ] as const;
+};
+
 describe("box-selection", () => {
   beforeEach(async () => {
     await render(<Excalidraw />);
@@ -108,6 +128,662 @@ describe("box-selection", () => {
 
     assertSelectedElements([]);
   });
+
+  it("should not select an element when the selection box only partially overlaps it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    mouse.downAt(25, -20);
+    mouse.move(-1000, -1000);
+    mouse.moveTo(75, 70);
+    mouse.up();
+
+    assertSelectedElements([]);
+  });
+});
+
+describe("lasso reselection", () => {
+  beforeEach(async () => {
+    await render(<Excalidraw />);
+  });
+
+  it("should allow ctrl+alt lasso reselection when starting inside the active common bounds", () => {
+    const rectA = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+    const rectB = API.createElement({
+      type: "rectangle",
+      x: 220,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "blue",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rectA, rectB]);
+    mouse.select([rectA, rectB]);
+    act(() => {
+      h.app.setActiveTool({ type: "lasso" });
+    });
+
+    Keyboard.withModifierKeys({ ctrl: true, alt: true }, () => {
+      mouse.downAt(110, 50);
+      mouse.moveTo(50, -20);
+
+      expect(h.app.lassoTrail.hasCurrentTrail).toBe(true);
+
+      mouse.moveTo(-20, 50);
+      mouse.moveTo(50, 120);
+      mouse.moveTo(110, 50);
+      mouse.up();
+    });
+
+    assertSelectedElements([rectA.id]);
+  });
+});
+
+describe("box-selection overlap mode", () => {
+  const boxSelect = (
+    startX: number,
+    startY: number,
+    endX: number,
+    endY: number,
+  ) => {
+    mouse.downAt(startX, startY);
+    mouse.move(-1000, -1000);
+    mouse.moveTo(endX, endY);
+    mouse.up();
+  };
+
+  const boxSelectTopLeftAabbCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneElement, elementsMap);
+
+    boxSelect(x1 + 2, y1 + 2, x1 + 12, y1 + 12);
+  };
+
+  const boxSelectTopRightAabbCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [, y1, x2] = getElementBounds(sceneElement, elementsMap);
+
+    boxSelect(x2 - 12, y1 + 2, x2 - 2, y1 + 12);
+  };
+
+  const boxSelectTopLeftRotatedLocalBoundsCorner = (
+    element: ReturnType<typeof API.createElement>,
+  ) => {
+    const sceneElement = API.getElement(element);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1, x2, y2] = getElementBounds(sceneElement, elementsMap, true);
+    const center = pointFrom((x1 + x2) / 2, (y1 + y2) / 2);
+    const [cornerX, cornerY] = pointRotateRads(
+      pointFrom(x1, y1),
+      center,
+      sceneElement.angle,
+    );
+
+    boxSelect(cornerX - 4, cornerY - 4, cornerX + 4, cornerY + 4);
+  };
+
+  beforeEach(async () => {
+    await render(
+      <Excalidraw
+        initialData={{ appState: { boxSelectionMode: "overlap" } }}
+      />,
+    );
+  });
+
+  it("should select an element when the selection box partially overlaps it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, -20, 75, 70);
+
+    assertSelectedElements([rect1.id]);
+  });
+
+  it("should select the whole group when overlapping one group member", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["A"],
+    });
+    const rect2 = API.createElement({
+      type: "rectangle",
+      x: 100,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["A"],
+    });
+
+    API.setElements([rect1, rect2]);
+
+    boxSelect(25, -20, 75, 70);
+
+    assertSelectedElements([rect1.id, rect2.id]);
+    expect(h.state.selectedGroupIds).toEqual({ A: true });
+  });
+
+  it("should return all group elements when overlapping one group member", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      id: "rect1",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["A"],
+    });
+    const rect2 = API.createElement({
+      type: "rectangle",
+      id: "rect2",
+      x: 100,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["A"],
+    });
+    const rect3 = API.createElement({
+      type: "rectangle",
+      id: "rect3",
+      x: 200,
+      y: 0,
+      width: 50,
+      height: 50,
+    });
+    const selection = API.createElement({
+      type: "rectangle",
+      x: 125,
+      y: -10,
+      width: 10,
+      height: 70,
+    });
+    const elements = [rect1, rect2, rect3];
+
+    expect(
+      getElementsWithinSelection(
+        elements,
+        selection,
+        arrayToMap([...elements, selection]),
+        false,
+        "overlap",
+      ).map((element) => element.id),
+    ).toEqual([rect1.id, rect2.id]);
+  });
+
+  it("should retain nested and interleaved group element order", () => {
+    const outerNested1 = API.createElement({
+      type: "rectangle",
+      id: "outerNested1",
+      x: 0,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["inner", "outer"],
+    });
+    const other1 = API.createElement({
+      type: "rectangle",
+      id: "other1",
+      x: 70,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["other"],
+    });
+    const outerOnly = API.createElement({
+      type: "rectangle",
+      id: "outerOnly",
+      x: 140,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["outer"],
+    });
+    const other2 = API.createElement({
+      type: "rectangle",
+      id: "other2",
+      x: 210,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["other"],
+    });
+    const outerNested2 = API.createElement({
+      type: "rectangle",
+      id: "outerNested2",
+      x: 280,
+      y: 0,
+      width: 50,
+      height: 50,
+      groupIds: ["inner", "outer"],
+    });
+    const selection = API.createElement({
+      type: "rectangle",
+      x: 295,
+      y: -10,
+      width: 10,
+      height: 70,
+    });
+    const elements = [outerNested1, other1, outerOnly, other2, outerNested2];
+
+    expect(
+      getElementsWithinSelection(
+        elements,
+        selection,
+        arrayToMap([...elements, selection]),
+        false,
+        "overlap",
+      ).map((element) => element.id),
+    ).toEqual([outerNested1.id, outerOnly.id, outerNested2.id]);
+  });
+
+  it("should not select a transparent rectangle when the selection box stays inside it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, 25, 75, 75);
+
+    assertSelectedElements([]);
+  });
+
+  it("should select a transparent rectangle when the selection box crosses its outline", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(25, 25, 125, 75);
+
+    assertSelectedElements([rect1.id]);
+  });
+
+  it("should not select a rotated transparent rectangle when the selection box stays inside it", () => {
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect1]);
+
+    boxSelect(40, 40, 60, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should select a rotated rounded rectangle when the selection box contains its outline but not its bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 180,
+      angle: Math.PI / 6,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+      roundness: { type: ROUNDNESS.ADAPTIVE_RADIUS },
+      roughness: 0,
+    });
+
+    API.setElements([rect]);
+
+    const sceneRect = API.getElement(rect);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [boundsX1, boundsY1, boundsX2, boundsY2] = getElementBounds(
+      sceneRect,
+      elementsMap,
+    );
+    const [outlineX1, outlineY1, outlineX2, outlineY2] = getOutlineBounds(rect);
+
+    expect(outlineX1).toBeGreaterThan(boundsX1 - 1);
+    expect(outlineY1).toBeGreaterThan(boundsY1 - 1);
+    expect(outlineX2).toBeLessThan(boundsX2 + 1);
+    expect(outlineY2).toBeLessThan(boundsY2 + 1);
+
+    boxSelect(
+      outlineX1 - (outlineX1 - boundsX1) / 2,
+      outlineY1 - (outlineY1 - boundsY1) / 2,
+      outlineX2 + (boundsX2 - outlineX2) / 2,
+      outlineY2 + (boundsY2 - outlineY2) / 2,
+    );
+
+    assertSelectedElements([rect.id]);
+  });
+
+  it("should not select a filled rotated rectangle when the selection box only overlaps its axis-aligned bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect]);
+
+    boxSelectTopLeftAabbCorner(rect);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled ellipse when the selection box only overlaps its bounds corner", () => {
+    const ellipse = API.createElement({
+      type: "ellipse",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([ellipse]);
+
+    boxSelectTopRightAabbCorner(ellipse);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled diamond when the selection box only overlaps its bounds corner", () => {
+    const diamond = API.createElement({
+      type: "diamond",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([diamond]);
+
+    boxSelectTopRightAabbCorner(diamond);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled rotated ellipse when the selection box only overlaps its axis-aligned bounds", () => {
+    const ellipse = API.createElement({
+      type: "ellipse",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([ellipse]);
+
+    boxSelectTopLeftRotatedLocalBoundsCorner(ellipse);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a filled rotated diamond when the selection box only overlaps its rotated local bounds", () => {
+    const diamond = API.createElement({
+      type: "diamond",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([diamond]);
+
+    boxSelectTopLeftRotatedLocalBoundsCorner(diamond);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select rotated text when the selection box only overlaps its axis-aligned bounds", () => {
+    const text = API.createElement({
+      type: "text",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      text: "test",
+    });
+
+    API.setElements([text]);
+
+    boxSelect(-18, -18, -8, -8);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select rotated image when the selection box only overlaps its axis-aligned bounds", () => {
+    const image = API.createElement({
+      type: "image",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      fileId: "file_A",
+      status: "saved",
+    });
+
+    API.setElements([image]);
+
+    boxSelect(-18, -18, -8, -8);
+
+    assertSelectedElements([]);
+  });
+
+  it("should deselect a selected rotated rectangle when clicking in the empty corner of its axis-aligned bounds", () => {
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([rect]);
+
+    mouse.clickAt(50, 50);
+    assertSelectedElements([rect.id]);
+
+    const sceneRect = API.getElement(rect);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneRect, elementsMap);
+
+    mouse.clickAt(x1 + 2, y1 + 2);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a line when the selection box only overlaps its bounds", () => {
+    const line = API.createElement({
+      type: "line",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(100, 100)],
+    });
+
+    API.setElements([line]);
+
+    boxSelect(20, 50, 30, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not click-select rotated freedraw in the corner of its axis-aligned bounds", () => {
+    const freedraw = API.createElement({
+      type: "freedraw",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      angle: Math.PI / 4,
+      backgroundColor: "transparent",
+      points: [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(100, 0),
+        pointFrom<LocalPoint>(100, 100),
+        pointFrom<LocalPoint>(0, 100),
+        pointFrom<LocalPoint>(0, 0),
+      ],
+    });
+
+    API.setElements([freedraw]);
+
+    const sceneFreedraw = API.getElement(freedraw);
+    const elementsMap = h.scene.getNonDeletedElementsMap();
+    const [x1, y1] = getElementBounds(sceneFreedraw, elementsMap);
+
+    mouse.clickAt(x1 + 2, y1 + 2);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a freedraw when the selection box only overlaps its bounds", () => {
+    const freedraw = API.createElement({
+      type: "freedraw",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      points: [
+        pointFrom<LocalPoint>(0, 0),
+        pointFrom<LocalPoint>(50, 50),
+        pointFrom<LocalPoint>(100, 100),
+      ],
+    });
+
+    API.setElements([freedraw]);
+
+    boxSelect(20, 50, 30, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a transparent framed element when the selection box stays inside its clipped bounds", () => {
+    const frame = API.createElement({
+      type: "frame",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 50,
+      y: 10,
+      width: 100,
+      height: 80,
+      frameId: frame.id,
+      backgroundColor: "transparent",
+      fillStyle: "solid",
+    });
+
+    API.setElements([frame, rect1]);
+
+    boxSelect(60, 20, 90, 60);
+
+    assertSelectedElements([]);
+  });
+
+  it("should not select a framed element when selection only overlaps its clipped-out outline", () => {
+    const frame = API.createElement({
+      type: "frame",
+      x: 100,
+      y: 100,
+      width: 100,
+      height: 100,
+    });
+    const rect1 = API.createElement({
+      type: "rectangle",
+      x: 50,
+      y: 50,
+      width: 200,
+      height: 200,
+      frameId: frame.id,
+      backgroundColor: "red",
+      fillStyle: "solid",
+    });
+
+    API.setElements([frame, rect1]);
+
+    boxSelect(40, 170, 70, 220);
+
+    assertSelectedElements([]);
+  });
 });
 
 describe("inner box-selection", () => {
@@ -183,11 +859,175 @@ describe("inner box-selection", () => {
       mouse.moveTo(rect2.x + rect2.width + 10, rect2.y + rect2.height + 10);
       mouse.up();
 
+      assertSelectedElements([rect1.id]);
+      expect(h.state.selectedGroupIds).toEqual({});
+    });
+
+    Keyboard.withModifierKeys({ ctrl: true }, () => {
+      mouse.downAt(40, 40);
+      mouse.move(-1000, -1000);
+      mouse.moveTo(rect3.x + rect3.width + 10, rect3.y + rect3.height + 10);
+      mouse.up();
+
       assertSelectedElements([rect2.id, rect3.id]);
       expect(h.state.selectedGroupIds).toEqual({ A: true });
     });
   });
 
+  it("does not select a nested outer group until all members are contained", async () => {
+    const innerRect1 = API.createElement({
+      type: "rectangle",
+      x: 50,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["inner", "outer"],
+    });
+    const innerRect2 = API.createElement({
+      type: "rectangle",
+      x: 120,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["inner", "outer"],
+    });
+    const outerRect = API.createElement({
+      type: "rectangle",
+      x: 190,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["outer"],
+    });
+    API.setElements([innerRect1, innerRect2, outerRect]);
+
+    Keyboard.withModifierKeys({ ctrl: true }, () => {
+      mouse.downAt(0, 0);
+      mouse.move(-1000, -1000);
+      mouse.moveTo(
+        innerRect2.x + innerRect2.width + 10,
+        innerRect2.y + innerRect2.height + 10,
+      );
+      mouse.up();
+
+      assertSelectedElements([]);
+      expect(h.state.selectedGroupIds).toEqual({});
+    });
+
+    Keyboard.withModifierKeys({ ctrl: true }, () => {
+      mouse.downAt(0, 0);
+      mouse.move(-1000, -1000);
+      mouse.moveTo(
+        outerRect.x + outerRect.width + 10,
+        outerRect.y + outerRect.height + 10,
+      );
+      mouse.up();
+
+      assertSelectedElements([innerRect1.id, innerRect2.id, outerRect.id]);
+      expect(h.state.selectedGroupIds).toEqual({ outer: true });
+    });
+  });
+
+  it.skip("checks nested containment against the current editing depth", async () => {
+    const innerRect1 = API.createElement({
+      type: "rectangle",
+      x: 50,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["inner", "outer"],
+    });
+    const innerRect2 = API.createElement({
+      type: "rectangle",
+      x: 120,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["inner", "outer"],
+    });
+    const outerRect = API.createElement({
+      type: "rectangle",
+      x: 190,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["outer"],
+    });
+    const selection = API.createElement({
+      type: "rectangle",
+      x: 40,
+      y: 40,
+      width: 140,
+      height: 70,
+    });
+    const elements = [innerRect1, innerRect2, outerRect];
+    const elementsMap = arrayToMap([...elements, selection]);
+
+    expect(
+      getElementsWithinSelection(
+        elements,
+        selection,
+        elementsMap,
+        false,
+        "contain",
+      ).map((element) => element.id),
+    ).toEqual([]);
+
+    expect(
+      getElementsWithinSelection(
+        elements,
+        selection,
+        elementsMap,
+        false,
+        "contain",
+        // "outer", /* editingGroupId - add as param once we implement nested group handling */
+      ).map((element) => element.id),
+    ).toEqual([innerRect1.id, innerRect2.id]);
+  });
+
+  it("ignores grouped bound text when checking box-selection containment", async () => {
+    const container = API.createElement({
+      type: "rectangle",
+      id: "container",
+      x: 50,
+      y: 50,
+      width: 50,
+      height: 50,
+      groupIds: ["A"],
+      boundElements: [{ type: "text", id: "bound-text" }],
+    });
+    const boundText = API.createElement({
+      type: "text",
+      id: "bound-text",
+      x: 50,
+      y: 50,
+      width: 50,
+      height: 20,
+      containerId: container.id,
+      groupIds: ["A"],
+    });
+    const rect = API.createElement({
+      type: "rectangle",
+      x: 150,
+      y: 150,
+      width: 50,
+      height: 50,
+      groupIds: ["A"],
+    });
+    API.setElements([container, boundText, rect]);
+
+    Keyboard.withModifierKeys({ ctrl: true }, () => {
+      mouse.downAt(40, 40);
+      mouse.move(-1000, -1000);
+      mouse.moveTo(rect.x + rect.width + 10, rect.y + rect.height + 10);
+      mouse.up();
+
+      expect(h.state.selectedElementIds[container.id]).toBe(true);
+      expect(h.state.selectedElementIds[rect.id]).toBe(true);
+      expect(h.state.selectedGroupIds).toEqual({ A: true });
+    });
+  });
+
   it("selecting & deselecting grouped elements visually nested inside another", async () => {
     const rect1 = API.createElement({
       type: "rectangle",
@@ -218,7 +1058,7 @@ describe("inner box-selection", () => {
     Keyboard.withModifierKeys({ ctrl: true }, () => {
       mouse.downAt(rect2.x - 20, rect2.y - 20);
       mouse.move(-1000, -1000);
-      mouse.moveTo(rect2.x + rect2.width + 10, rect2.y + rect2.height + 10);
+      mouse.moveTo(rect3.x + rect3.width + 10, rect3.y + rect3.height + 10);
       assertSelectedElements([rect2.id, rect3.id]);
       expect(h.state.selectedGroupIds).toEqual({ A: true });
       mouse.moveTo(rect2.x - 10, rect2.y - 10);

packages/excalidraw/tests/tool.test.tsx

@@ -4,10 +4,12 @@ import { resolvablePromise } from "@excalidraw/common";
 
 import { Excalidraw } from "../index";
 
+import { getToolbarTools } from "../components/shapes";
+
 import { Pointer } from "./helpers/ui";
 import { act, render } from "./test-utils";
 
-import type { ExcalidrawImperativeAPI } from "../types";
+import type { AppClassProperties, ExcalidrawImperativeAPI } from "../types";
 
 describe("setActiveTool()", () => {
   const h = window.h;
@@ -66,3 +68,27 @@ describe("setActiveTool()", () => {
     expect(h.state.activeTool.customType).toBe("comment");
   });
 });
+describe("getToolbarTools()", () => {
+  const getToolValues = (preferredSelectionTool: "selection" | "lasso") =>
+    getToolbarTools({
+      state: {
+        preferredSelectionTool: {
+          type: preferredSelectionTool,
+        },
+      },
+    } as AppClassProperties).map((tool) => tool.value);
+
+  it("does not include lasso when selection is preferred", () => {
+    const toolValues = getToolValues("selection");
+
+    expect(toolValues.filter((value) => value === "selection")).toHaveLength(1);
+    expect(toolValues.filter((value) => value === "lasso")).toHaveLength(0);
+  });
+
+  it("replaces selection with lasso when lasso is preferred", () => {
+    const toolValues = getToolValues("lasso");
+
+    expect(toolValues.filter((value) => value === "lasso")).toHaveLength(1);
+    expect(toolValues.filter((value) => value === "selection")).toHaveLength(0);
+  });
+});

packages/excalidraw/types.ts

@@ -269,6 +269,8 @@ export type ObservedElementsAppState = {
   activeLockedId: AppState["activeLockedId"];
 };
 
+export type BoxSelectionMode = "contain" | "overlap";
+
 export interface AppState {
   contextMenu: {
     items: ContextMenuItems;
@@ -307,11 +309,16 @@ export interface AppState {
    * `bindingPreference` and keyboard modifiers (ctrl/alt)
    */
   isBindingEnabled: boolean;
+  /** user box selection preference; defaults to "contain" when unset */
+  boxSelectionMode: BoxSelectionMode;
   /** user arrow binding preference */
   bindingPreference: "enabled" | "disabled";
   /** user preference whether arrow snap to midpoints while binding */
   isMidpointSnappingEnabled: boolean;
-  startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
+  /**
+   * The bindable element the UI highlights for the user when an arrow is
+   * dragged or otherwise its endpoint being close to said element.
+   */
   suggestedBinding: {
     element: NonDeleted<ExcalidrawBindableElement>;
     midPoint?: GlobalPoint;
@@ -343,8 +350,11 @@ export interface AppState {
     type: "selection" | "lasso";
     initialized: boolean;
   };
+
+  // Pen handling
   penMode: boolean;
   penDetected: boolean;
+
   exportBackground: boolean;
   exportEmbedScene: boolean;
   exportWithDarkMode: boolean;
@@ -468,6 +478,9 @@ export interface AppState {
   // as elements are unlocked, we remove the groupId from the elements
   // and also remove groupId from this map
   lockedMultiSelections: { [groupId: string]: true };
+  // Stores the current bind mode which is detemined at various points during
+  // a drag operation (like pointer position vs bindable element) but needed
+  // globally for calculating the binding strategy
   bindMode: BindMode;
 }
 
@@ -483,10 +496,7 @@ export type SearchMatch = {
   }[];
 };
 
-export type UIAppState = Omit<
+export type UIAppState = Omit<AppState, "cursorButton" | "scrollX" | "scrollY">;
-  AppState,
-  "startBoundElement" | "cursorButton" | "scrollX" | "scrollY"
->;
 
 export type NormalizedZoomValue = number & { _brand: "normalizedZoom" };
 
@@ -866,8 +876,13 @@ export type PointerDownState = Readonly<{
     // Whether selected element(s) were duplicated, might change during the
     // pointer interaction
     hasBeenDuplicated: boolean;
+    // Whether the pointer is hitting the common bounding box of selected
+    // elements, which is useful for discriminating between selecitng
+    // the entire selection vs a specific element
     hasHitCommonBoundingBoxOfSelectedElements: boolean;
   };
+  // This is determined on the initial pointer down event to
+  // set various interaction modalities
   withCmdOrCtrl: boolean;
   drag: {
     // Might change during the pointer interaction
@@ -893,6 +908,7 @@ export type PointerDownState = Readonly<{
     onKeyUp: null | ((event: KeyboardEvent) => void);
   };
   boxSelection: {
+    // If the box selection tool is activated on pointer down
     hasOccurred: boolean;
   };
 }>;

packages/excalidraw/wysiwyg/textWysiwyg.test.tsx

@@ -769,6 +769,63 @@ describe("textWysiwyg", () => {
       ]);
     });
 
+    it("should not add bound text to a frame when its container is not a frame child", async () => {
+      const frame = API.createElement({
+        type: "frame",
+        x: 0,
+        y: 0,
+        width: 200,
+        height: 200,
+      });
+      const rectangle = API.createElement({
+        type: "rectangle",
+        x: 10,
+        y: 20,
+        width: 90,
+        height: 75,
+        backgroundColor: "red",
+      });
+      API.setElements([frame, rectangle]);
+
+      mouse.doubleClickAt(rectangle.x + 10, rectangle.y + 10);
+
+      const text = h.elements[2] as ExcalidrawTextElementWithContainer;
+      expect(text.type).toBe("text");
+      expect(text.containerId).toBe(rectangle.id);
+      expect(text.frameId).toBe(null);
+    });
+
+    it("should bind text to a frame child container when single clicking its center", async () => {
+      const frame = API.createElement({
+        type: "frame",
+        x: 0,
+        y: 0,
+        width: 200,
+        height: 200,
+      });
+      const rectangle = API.createElement({
+        type: "rectangle",
+        x: 10,
+        y: 20,
+        width: 90,
+        height: 75,
+        backgroundColor: "red",
+        frameId: frame.id,
+      });
+      API.setElements([rectangle, frame]);
+
+      UI.clickTool("text");
+      mouse.clickAt(
+        rectangle.x + rectangle.width / 2,
+        rectangle.y + rectangle.height / 2,
+      );
+
+      const text = h.elements[1] as ExcalidrawTextElementWithContainer;
+      expect(text.type).toBe("text");
+      expect(text.containerId).toBe(rectangle.id);
+      expect(text.frameId).toBe(frame.id);
+    });
+
     it("should set the text element angle to same as container angle when binding to rotated container", async () => {
       const rectangle = API.createElement({
         type: "rectangle",

packages/fractional-indexing/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@excalidraw/fractional-indexing",
+  "version": "3.3.0",
+  "description": "Provides functions for generating ordering strings",
+  "type": "module",
+  "types": "./dist/types/fractional-indexing/src/index.d.ts",
+  "main": "./dist/prod/index.js",
+  "module": "./dist/prod/index.js",
+  "engines": {
+    "node": "^14.13.1 || >=16.0.0"
+  },
+  "scripts": {
+    "gen:types": "rimraf types && tsc",
+    "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
+  },
+  "keywords": [
+    "fractional",
+    "indexing",
+    "ordering",
+    "order"
+  ],
+  "homepage": "https://github.com/rocicorp/fractional-indexing#readme",
+  "bugs": "https://github.com/excalidraw/excalidraw/issues",
+  "repository": "https://github.com/excalidraw/excalidraw",
+  "author": "arv@rocicorp.dev",
+  "license": "CC0-1.0",
+  "devDependencies": {
+    "prettier": "^2.6.0",
+    "typescript": "5.9.3"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/fractional-indexing/src/index.d.ts",
+      "development": "./dist/dev/index.js",
+      "production": "./dist/prod/index.js",
+      "default": "./dist/prod/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/*"
+  ]
+}

packages/fractional-indexing/src/index.ts

@@ -0,0 +1,322 @@
+// Vendored from https://www.npmjs.com/package/fractional-indexing
+// License: CC0 (no rights reserved).
+// This is based on https://observablehq.com/@dgreensp/implementing-fractional-indexing
+
+export const BASE_62_DIGITS =
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+// `a` may be empty string, `b` is null or non-empty string.
+// `a < b` lexicographically if `b` is non-null.
+// no trailing zeros allowed.
+// digits is a string such as '0123456789' for base 10.  Digits must be in
+// ascending character code order!
+/**
+ * @param {string} a
+ * @param {string | null | undefined} b
+ * @param {string} digits
+ * @returns {string}
+ */
+function midpoint(
+  a: string,
+  b: string | null | undefined,
+  digits: string,
+): string {
+  const zero = digits[0];
+  if (b != null && a >= b) {
+    throw new Error(`${a} >= ${b}`);
+  }
+  if (a.slice(-1) === zero || (b && b.slice(-1) === zero)) {
+    throw new Error("trailing zero");
+  }
+  if (b) {
+    // remove longest common prefix.  pad `a` with 0s as we
+    // go.  note that we don't need to pad `b`, because it can't
+    // end before `a` while traversing the common prefix.
+    let n = 0;
+    while ((a[n] || zero) === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+    }
+  }
+  // first digits (or lack of digit) are different
+  const digitA = a ? digits.indexOf(a[0]) : 0;
+  const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+  if (digitB - digitA > 1) {
+    const midDigit = Math.round(0.5 * (digitA + digitB));
+    return digits[midDigit];
+  }
+  // first digits are consecutive
+  if (b && b.length > 1) {
+    return b.slice(0, 1);
+  }
+
+  // `b` is null or has length 1 (a single digit).
+  // the first digit of `a` is the previous digit to `b`,
+  // or 9 if `b` is null.
+  // given, for example, midpoint('49', '5'), return
+  // '4' + midpoint('9', null), which will become
+  // '4' + '9' + midpoint('', null), which is '495'
+  return digits[digitA] + midpoint(a.slice(1), null, digits);
+}
+
+/**
+ * @param {string} int
+ * @return {void}
+ */
+
+function validateInteger(int: string): void {
+  if (int.length !== getIntegerLength(int[0])) {
+    throw new Error(`invalid integer part of order key: ${int}`);
+  }
+}
+
+/**
+ * @param {string} head
+ * @return {number}
+ */
+
+function getIntegerLength(head: string): number {
+  if (head >= "a" && head <= "z") {
+    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
+  } else if (head >= "A" && head <= "Z") {
+    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
+  }
+
+  throw new Error(`invalid order key head: ${head}`);
+}
+
+/**
+ * @param {string} key
+ * @return {string}
+ */
+
+function getIntegerPart(key: string): string {
+  const integerPartLength = getIntegerLength(key[0]);
+
+  if (integerPartLength > key.length) {
+    throw new Error(`invalid order key: ${key}`);
+  }
+  return key.slice(0, integerPartLength);
+}
+
+/**
+ * @param {string} key
+ * @param {string} digits
+ * @return {void}
+ */
+export function validateOrderKey(
+  key: string,
+  digits: string = BASE_62_DIGITS,
+): void {
+  const validChars = key.split("").every((char) => digits.includes(char));
+  if (key === `A${digits[0].repeat(26)}` || !validChars) {
+    throw new Error(`invalid order key: ${key}`);
+  }
+  // getIntegerPart will throw if the first character is bad,
+  // or the key is too short.  we'd call it to check these things
+  // even if we didn't need the result
+  const i = getIntegerPart(key);
+  const f = key.slice(i.length);
+  if (f.slice(-1) === digits[0]) {
+    throw new Error(`invalid order key: ${key}`);
+  }
+}
+
+// note that this may return null, as there is a largest integer
+/**
+ * @param {string} x
+ * @param {string} digits
+ * @return {string | null}
+ */
+function incrementInteger(x: string, digits: string): string | null {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let carry = true;
+  for (let i = digs.length - 1; carry && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) + 1;
+    if (d === digits.length) {
+      digs[i] = digits[0];
+    } else {
+      digs[i] = digits[d];
+      carry = false;
+    }
+  }
+  if (carry) {
+    if (head === "Z") {
+      return `a${digits[0]}`;
+    }
+    if (head === "z") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) + 1);
+    if (h > "a") {
+      digs.push(digits[0]);
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  }
+  return head + digs.join("");
+}
+
+// note that this may return null, as there is a smallest integer
+/**
+ * @param {string} x
+ * @param {string} digits
+ * @return {string | null}
+ */
+function decrementInteger(x: string, digits: string): string | null {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let borrow = true;
+  for (let i = digs.length - 1; borrow && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) - 1;
+    if (d === -1) {
+      digs[i] = digits.slice(-1);
+    } else {
+      digs[i] = digits[d];
+      borrow = false;
+    }
+  }
+  if (borrow) {
+    if (head === "a") {
+      return `Z${digits.slice(-1)}`;
+    }
+    if (head === "A") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) - 1);
+    if (h < "Z") {
+      digs.push(digits.slice(-1));
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  }
+  return head + digs.join("");
+}
+
+// `a` is an order key or null (START).
+// `b` is an order key or null (END).
+// `a < b` lexicographically if both are non-null.
+// digits is a string such as '0123456789' for base 10.  Digits must be in
+// ascending character code order!
+/**
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {string=} digits
+ * @return {string}
+ */
+export function generateKeyBetween(
+  a: string | null | undefined,
+  b: string | null | undefined,
+  digits = BASE_62_DIGITS,
+): string {
+  if (a != null) {
+    validateOrderKey(a, digits);
+  }
+  if (b != null) {
+    validateOrderKey(b, digits);
+  }
+  if (a != null && b != null && a >= b) {
+    throw new Error(`${a} >= ${b}`);
+  }
+  if (a == null) {
+    if (b == null) {
+      return `a${digits[0]}`;
+    }
+
+    const ib = getIntegerPart(b);
+    const fb = b.slice(ib.length);
+    if (ib === `A${digits[0].repeat(26)}`) {
+      return ib + midpoint("", fb, digits);
+    }
+    if (ib < b) {
+      return ib;
+    }
+    const res = decrementInteger(ib, digits);
+    if (res == null) {
+      throw new Error("cannot decrement any more");
+    }
+    return res;
+  }
+
+  if (b == null) {
+    const ia = getIntegerPart(a);
+    const fa = a.slice(ia.length);
+    const i = incrementInteger(ia, digits);
+    return i == null ? ia + midpoint(fa, null, digits) : i;
+  }
+
+  const ia = getIntegerPart(a);
+  const fa = a.slice(ia.length);
+  const ib = getIntegerPart(b);
+  const fb = b.slice(ib.length);
+  if (ia === ib) {
+    return ia + midpoint(fa, fb, digits);
+  }
+  const i = incrementInteger(ia, digits);
+  if (i == null) {
+    throw new Error("cannot increment any more");
+  }
+  if (i < b) {
+    return i;
+  }
+  return ia + midpoint(fa, null, digits);
+}
+
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {number} n
+ * @param {string} digits
+ * @return {string[]}
+ */
+export function generateNKeysBetween(
+  a: string | null | undefined,
+  b: string | null | undefined,
+  n: number,
+  digits = BASE_62_DIGITS,
+): string[] {
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [generateKeyBetween(a, b, digits)];
+  }
+  if (b == null) {
+    let c = generateKeyBetween(a, b, digits);
+    const result = [c];
+    for (let i = 0; i < n - 1; i++) {
+      c = generateKeyBetween(c, b, digits);
+      result.push(c);
+    }
+    return result;
+  }
+  if (a == null) {
+    let c = generateKeyBetween(a, b, digits);
+    const result = [c];
+    for (let i = 0; i < n - 1; i++) {
+      c = generateKeyBetween(a, c, digits);
+      result.push(c);
+    }
+    result.reverse();
+    return result;
+  }
+  const mid = Math.floor(n / 2);
+  const c = generateKeyBetween(a, b, digits);
+  return [
+    ...generateNKeysBetween(a, c, mid, digits),
+    c,
+    ...generateNKeysBetween(c, b, n - mid - 1, digits),
+  ];
+}

packages/fractional-indexing/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist/types"
+  },
+  "include": ["src/**/*", "global.d.ts"],
+  "exclude": ["**/*.test.*", "tests", "types", "examples", "dist"]
+}

packages/math/src/constants.ts

@@ -1,5 +1,3 @@
-export const PRECISION = 10e-5;
-
 // Legendre-Gauss abscissae (x values) and weights for n=24
 // Refeerence: https://pomax.github.io/bezierinfo/legendre-gauss.html
 export const LegendreGaussN24TValues = [

packages/math/src/curve.ts

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

packages/tsconfig.base.json

@@ -20,7 +20,9 @@
       "@excalidraw/math": ["./math/src/index.ts"],
       "@excalidraw/math/*": ["./math/src/*"],
       "@excalidraw/utils": ["./utils/src/index.ts"],
-      "@excalidraw/utils/*": ["./utils/src/*"]
+      "@excalidraw/utils/*": ["./utils/src/*"],
+      "@excalidraw/fractional-indexing": ["./fractional-indexing/src/index.ts"],
+      "@excalidraw/fractional-indexing/*": ["./fractional-indexing/src/*"]
     }
   }
 }

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

@@ -13,6 +13,7 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
+  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -97,7 +98,6 @@ exports[`exportToSvg > with default arguments 1`] = `
   "showHyperlinkPopup": false,
   "showWelcomeScreen": false,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,

scripts/buildBase.js

@@ -13,7 +13,12 @@ const getConfig = (outdir) => ({
   alias: {
     "@excalidraw/utils": path.resolve(__dirname, "../packages/utils/src"),
   },
-  external: ["@excalidraw/common", "@excalidraw/element", "@excalidraw/math"],
+  external: [
+    "@excalidraw/common",
+    "@excalidraw/element",
+    "@excalidraw/math",
+    "@excalidraw/fractional-indexing",
+  ],
 });
 
 function buildDev(config) {

scripts/buildPackage.js

@@ -74,7 +74,12 @@ const getConfig = (outdir) => ({
   alias: {
     "@excalidraw/utils": path.resolve(__dirname, "../packages/utils/src"),
   },
-  external: ["@excalidraw/common", "@excalidraw/element", "@excalidraw/math"],
+  external: [
+    "@excalidraw/common",
+    "@excalidraw/element",
+    "@excalidraw/math",
+    "@excalidraw/fractional-indexing",
+  ],
   loader: {
     ".woff2": "file",
   },

scripts/buildUtils.js

@@ -18,6 +18,10 @@ const getConfig = (outdir) => ({
     "@excalidraw/element": path.resolve(__dirname, "../packages/element/src"),
     "@excalidraw/excalidraw": path.resolve(__dirname, "../packages/excalidraw"),
     "@excalidraw/math": path.resolve(__dirname, "../packages/math/src"),
+    "@excalidraw/fractional-indexing": path.resolve(
+      __dirname,
+      "../packages/fractional-indexing/src",
+    ),
     "@excalidraw/utils": path.resolve(__dirname, "../packages/utils/src"),
   },
 });

scripts/release.js

@@ -6,7 +6,13 @@ const { execSync } = require("child_process");
 const updateChangelog = require("./updateChangelog");
 
 // skipping utils for now, as it has independent release process
-const PACKAGES = ["common", "math", "element", "excalidraw"];
+const PACKAGES = [
+  "common",
+  "fractional-indexing",
+  "math",
+  "element",
+  "excalidraw",
+];
 const PACKAGES_DIR = path.resolve(__dirname, "../packages");
 
 /**

scripts/woff2/woff2-vite-plugins.js

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

setupTests.ts

@@ -8,7 +8,13 @@ import { vi } from "vitest";
 import polyfill from "./packages/excalidraw/polyfill";
 import { mockThrottleRAF } from "./packages/excalidraw/tests/helpers/mocks";
 import { yellow } from "./packages/excalidraw/tests/helpers/colorize";
-import { testPolyfills } from "./packages/excalidraw/tests/helpers/polyfills";
+import {
+  PolyfillLocalStorage,
+  testPolyfills,
+} from "./packages/excalidraw/tests/helpers/polyfills";
+
+Object.assign(globalThis, testPolyfills);
+PolyfillLocalStorage();
 
 vi.mock("@excalidraw/common", async (importOriginal) => {
   const module = await importOriginal<typeof import("@excalidraw/common")>();
@@ -22,8 +28,6 @@ vi.mock("@excalidraw/common", async (importOriginal) => {
 // mock for pep.js not working with setPointerCapture()
 HTMLElement.prototype.setPointerCapture = vi.fn();
 
-Object.assign(globalThis, testPolyfills);
-
 require("fake-indexeddb/auto");
 
 polyfill();

tsconfig.json

@@ -25,6 +25,8 @@
       "@excalidraw/excalidraw/*": ["./packages/excalidraw/*"],
       "@excalidraw/element": ["./packages/element/src/index.ts"],
       "@excalidraw/element/*": ["./packages/element/src/*"],
+      "@excalidraw/fractional-indexing": ["./packages/fractional-indexing/src/index.ts"],
+      "@excalidraw/fractional-indexing/*": ["./packages/fractional-indexing/src/*"],
       "@excalidraw/math": ["./packages/math/src/index.ts"],
       "@excalidraw/math/*": ["./packages/math/src/*"],
       "@excalidraw/utils": ["./packages/utils/src/index.ts"],

vitest.config.mts

@@ -45,6 +45,20 @@ export default defineConfig({
         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",
+        ),
+      },
+      {
+        find: /^@excalidraw\/fractional-indexing\/(.*?)/,
+        replacement: path.resolve(
+          __dirname,
+          "./packages/fractional-indexing/src/$1",
+        ),
+      },
     ],
   },
   //@ts-ignore

yarn.lock

@@ -6572,11 +6572,6 @@ fraction.js@^4.2.0:
   resolved "https://registry.yarnpkg.com/fraction.js/-/fraction.js-4.3.7.tgz#06ca0085157e42fda7f9e726e79fefc4068840f7"
   integrity sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==
 
-fractional-indexing@3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/fractional-indexing/-/fractional-indexing-3.2.0.tgz#1193e63d54ff4e0cbe0c79a9ed6cfbab25d91628"
-  integrity sha512-PcOxmqwYCW7O2ovKRU8OoQQj2yqTfEB/yeTYk4gPid6dN5ODRfU1hXd9tTVZzax/0NkO7AxpHykvZnT1aYp/BQ==
-
 fs-constants@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad"
@@ -8525,6 +8520,11 @@ prettier@2.6.2:
   resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.6.2.tgz#e26d71a18a74c3d0f0597f55f01fb6c06c206032"
   integrity sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew==
 
+prettier@^2.6.0:
+  version "2.8.8"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da"
+  integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==
+
 pretty-bytes@^5.3.0:
   version "5.6.0"
   resolved "https://registry.yarnpkg.com/pretty-bytes/-/pretty-bytes-5.6.0.tgz#356256f643804773c82f64723fe78c92c62beaeb"