refactor(snaps): restore point markers

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

@@ -6,97 +6,11 @@ on:
       - opened
       - edited
       - synchronize
-      - labeled
-      - unlabeled
 
 jobs:
   semantic:
     runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
     steps:
       - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
-        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

excalidraw-app/data/LocalData.ts

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

excalidraw-app/vite.config.mts

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

package.json

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

packages/element/package.json

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

packages/element/src/Scene.ts

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

packages/element/src/binding.ts

@@ -734,11 +734,12 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
     });
 
   // Handle outside-outside binding to the same element
-  if (
+  if (otherBinding && otherBinding.elementId === hit?.id) {
-    otherBinding &&
+    invariant(
-    otherBinding.elementId === hit?.id &&
+      !opts?.newArrow || appState.selectedLinearElement?.initialState.origin,
-    (!opts?.newArrow || appState.selectedLinearElement?.initialState.origin)
+      "appState.selectedLinearElement.initialState.origin must be defined for new arrows",
-  ) {
+    );
+
     return {
       start: {
         mode: "inside",

packages/element/src/collision.ts

@@ -61,8 +61,6 @@ import { distanceToElement } from "./distance";
 
 import { getBindingGap } from "./binding";
 
-import { hasBackground } from "./comparisons";
-
 import type {
   ElementsMap,
   ExcalidrawArrowElement,
@@ -85,7 +83,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   const isDraggableFromInside =
-    (hasBackground(element.type) && !isTransparent(element.backgroundColor)) ||
+    !isTransparent(element.backgroundColor) ||
     hasBoundTextElement(element) ||
     isIframeLikeElement(element) ||
     isTextElement(element);
@@ -326,10 +324,7 @@ export const getAllHoveredElementAtPoint = (
     ) {
       candidateElements.push(element);
 
-      if (
+      if (!isTransparent(element.backgroundColor)) {
-        hasBackground(element.type) &&
-        !isTransparent(element.backgroundColor)
-      ) {
         break;
       }
     }

packages/element/src/duplicate.ts

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

packages/element/src/embeddable.ts

@@ -130,86 +130,6 @@ 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",
@@ -227,8 +147,6 @@ const ALLOWED_DOMAINS = new Set([
   "giphy.com",
   "reddit.com",
   "forms.microsoft.com",
-  "wikipedia.org",
-  "*.wikipedia.org",
 ]);
 
 const ALLOW_SAME_ORIGIN = new Set([
@@ -360,27 +278,6 @@ 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";
@@ -609,7 +506,6 @@ export const embeddableURLValidator = (
   if (!url) {
     return false;
   }
-
   if (validateEmbeddable != null) {
     if (typeof validateEmbeddable === "function") {
       const ret = validateEmbeddable(url);
@@ -635,5 +531,5 @@ export const embeddableURLValidator = (
     }
   }
 
-  return isGoogleMapsURL(url) || !!matchHostname(url, ALLOWED_DOMAINS);
+  return !!matchHostname(url, ALLOWED_DOMAINS);
 };

packages/element/src/fractionalIndex.ts

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

packages/element/src/frame.ts

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

packages/element/src/linearElementEditor.ts

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

packages/element/src/selection.ts

@@ -129,24 +129,13 @@ export const getElementsWithinSelection = (
   const framesInSelection = excludeElementsInFrames
     ? new Set<NonDeletedExcalidrawElement["id"]>()
     : null;
-  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
+  let elementsInSelection: NonDeletedExcalidrawElement[] = [];
-  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
 
   for (const element of elements) {
     if (shouldIgnoreElementFromSelection(element)) {
       continue;
     }
 
-    // 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);
@@ -220,7 +209,7 @@ export const getElementsWithinSelection = (
       if (framesInSelection && isFrameLikeElement(element)) {
         framesInSelection.add(element.id);
       }
-      elementsInSelection.add(element);
+      elementsInSelection.push(element);
       continue;
     }
 
@@ -230,7 +219,7 @@ export const getElementsWithinSelection = (
       labelAABB &&
       doBoundsIntersect(selectionBounds, labelAABB)
     ) {
-      elementsInSelection.add(element);
+      elementsInSelection.push(element);
       continue;
     }
 
@@ -320,7 +309,7 @@ export const getElementsWithinSelection = (
           framesInSelection.add(element.id);
         }
 
-        elementsInSelection.add(element);
+        elementsInSelection.push(element);
         continue;
       }
     }
@@ -329,41 +318,21 @@ export const getElementsWithinSelection = (
     //    as it is separately handled in App.
   }
 
-  if (framesInSelection) {
+  elementsInSelection = framesInSelection
-    elementsInSelection.forEach((element) => {
+    ? excludeElementsFromFrames(elementsInSelection, framesInSelection)
-      if (element.frameId && framesInSelection.has(element.frameId)) {
+    : elementsInSelection;
-        elementsInSelection.delete(element);
-      }
-    });
-  }
 
-  if (boxSelectionMode === "overlap") {
+  elementsInSelection = elementsInSelection.filter((element) => {
-    Array.from(elementsInSelection).forEach((element) => {
+    const containingFrame = getContainingFrame(element, elementsMap);
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
 
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
+    if (containingFrame) {
-    });
+      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
-  } 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;
+    return true;
+  });
 
-      if (
+  return elementsInSelection;
-        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/typeChecks.ts

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

packages/element/tests/embeddable.test.ts

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

packages/element/tests/frame.test.tsx

@@ -5,15 +5,12 @@ import {
 import { arrayToMap } from "@excalidraw/common";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
-import { Keyboard, Pointer, UI } from "@excalidraw/excalidraw/tests/helpers/ui";
+import { Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";
-import { getTextEditor } from "@excalidraw/excalidraw/tests/queries/dom";
 import {
   getCloneByOrigId,
   render,
 } from "@excalidraw/excalidraw/tests/test-utils";
 
-import { getSelectedElements } from "@excalidraw/excalidraw/scene";
-
 import { elementOverlapsWithFrame } from "../src/frame";
 
 import type {
@@ -154,230 +151,6 @@ describe("adding elements to frames", () => {
     ).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,
   ) => {
@@ -684,329 +457,6 @@ describe("adding elements to frames", () => {
       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/excalidraw/actions/actionDeselect.ts

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

packages/excalidraw/actions/actionFinalize.tsx

@@ -330,7 +330,6 @@ export const actionFinalize = register<FormData>({
         multiElement: null,
         editingTextElement: null,
         suggestedBinding: null,
-        frameToHighlight: null,
         selectedElementIds:
           element &&
           !appState.activeTool.locked &&

packages/excalidraw/actions/actionFrame.ts

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

packages/excalidraw/actions/actionGroup.tsx

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

packages/excalidraw/actions/actionHistory.tsx

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

packages/excalidraw/components/App.tsx

@@ -176,9 +176,7 @@ import {
   isValidTextContainer,
   redrawTextBoundingBox,
   hasBoundingBox,
-  getCommonFrameId,
   getFrameChildren,
-  getFrameChildrenInsertionIndex,
   isCursorInFrame,
   addElementsToFrame,
   replaceAllElementsInFrame,
@@ -261,7 +259,6 @@ import {
   maybeHandleArrowPointlikeDrag,
   getUncroppedWidthAndHeight,
   getActiveTextElement,
-  isEligibleFrameChildType,
 } from "@excalidraw/element";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
@@ -1840,6 +1837,8 @@ class App extends React.Component<AppProps, AppState> {
                         src={
                           src?.type !== "document" ? src?.link ?? "" : undefined
                         }
+                        // https://stackoverflow.com/q/18470015
+                        scrolling="no"
                         referrerPolicy="no-referrer-when-downgrade"
                         title="Excalidraw Embedded Content"
                         allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
@@ -2093,30 +2092,20 @@ class App extends React.Component<AppProps, AppState> {
     const selectedElements = this.scene.getSelectedElements(this.state);
     const { renderTopRightUI, renderTopLeftUI, renderCustomStats } = this.props;
 
-    const {
+    const sceneNonce = this.scene.getSceneNonce();
-      elementsMap,
+    const { elementsMap, visibleElements } =
-      visibleElements,
+      this.renderer.getRenderableElements({
-      canvasNonce,
+        sceneNonce,
-      /**
+        zoom: this.state.zoom,
-       * element to draw on the <NewElementCanvas> for optimization purposes.
+        offsetLeft: this.state.offsetLeft,
-       * Can be null even if this.state.newElement defined
+        offsetTop: this.state.offsetTop,
-       * (e.g. when its zIndex isn't on top) */
+        scrollX: this.state.scrollX,
-      newElementCanvasElement,
+        scrollY: this.state.scrollY,
-    } = this.renderer.getRenderableElements({
+        height: this.state.height,
-      zoom: this.state.zoom,
+        width: this.state.width,
-      offsetLeft: this.state.offsetLeft,
+        editingTextElement: this.state.editingTextElement,
-      offsetTop: this.state.offsetTop,
+        newElementId: this.state.newElement?.id,
-      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();
@@ -2335,7 +2324,7 @@ class App extends React.Component<AppProps, AppState> {
                             elementsMap={elementsMap}
                             allElementsMap={allElementsMap}
                             visibleElements={visibleElements}
-                            canvasNonce={canvasNonce}
+                            sceneNonce={sceneNonce}
                             selectionNonce={
                               this.state.selectionElement?.versionNonce
                             }
@@ -2356,10 +2345,9 @@ class App extends React.Component<AppProps, AppState> {
                               theme: this.state.theme,
                             }}
                           />
-                          {newElementCanvasElement && (
+                          {this.state.newElement && (
                             <NewElementCanvas
                               appState={this.state}
-                              newElement={newElementCanvasElement}
                               scale={window.devicePixelRatio}
                               rc={this.rc}
                               elementsMap={elementsMap}
@@ -2387,7 +2375,7 @@ class App extends React.Component<AppProps, AppState> {
                             visibleElements={visibleElements}
                             allElementsMap={allElementsMap}
                             selectedElements={selectedElements}
-                            canvasNonce={canvasNonce}
+                            sceneNonce={sceneNonce}
                             selectionNonce={
                               this.state.selectionElement?.versionNonce
                             }
@@ -2699,7 +2687,7 @@ class App extends React.Component<AppProps, AppState> {
           locked: false,
         });
 
-        this.insertNewElement(frame);
+        this.scene.insertElement(frame);
 
         for (const child of selectedElements) {
           this.scene.mutateElement(child, { frameId: frame.id });
@@ -3777,7 +3765,6 @@ class App extends React.Component<AppProps, AppState> {
         position:
           this.editorInterface.formFactor === "desktop" ? "cursor" : "center",
         retainSeed: isPlainPaste,
-        preserveFrameChildrenOrder: true,
       });
       return;
     }
@@ -3921,7 +3908,6 @@ 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,
@@ -3963,7 +3949,6 @@ class App extends React.Component<AppProps, AppState> {
         });
       }),
       randomizeSeed: !opts.retainSeed,
-      preserveFrameChildrenOrder: opts.preserveFrameChildrenOrder,
     });
 
     const prevElements = this.scene.getElementsIncludingDeleted();
@@ -3985,10 +3970,11 @@ class App extends React.Component<AppProps, AppState> {
         duplicatedElements,
         topLayerFrame,
       );
-      nextElements = addElementsToFrame(
+      addElementsToFrame(
         nextElements,
         eligibleElements,
         topLayerFrame,
+        this.state,
       );
     }
 
@@ -4214,7 +4200,7 @@ class App extends React.Component<AppProps, AppState> {
       return;
     }
 
-    this.insertNewElements(textElements);
+    this.scene.insertElements(textElements);
     this.store.scheduleCapture();
     this.setState({
       selectedElementIds: makeNextSelectedElementIds(
@@ -5470,7 +5456,7 @@ class App extends React.Component<AppProps, AppState> {
     if (!event[KEYS.CTRL_OR_CMD]) {
       if (this.flowChartCreator.isCreatingChart) {
         if (this.flowChartCreator.pendingNodes?.length) {
-          this.insertNewElements(this.flowChartCreator.pendingNodes);
+          this.scene.insertElements(this.flowChartCreator.pendingNodes);
         }
 
         const firstNode = this.flowChartCreator.pendingNodes?.[0];
@@ -5568,7 +5554,6 @@ class App extends React.Component<AppProps, AppState> {
         selectedLinearElement: isSelectionLikeTool(nextActiveTool.type)
           ? prevState.selectedLinearElement
           : null,
-        frameToHighlight: null,
       } as const;
 
       if (nextActiveTool.type === "freedraw") {
@@ -6166,12 +6151,6 @@ 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;
       }
@@ -6261,6 +6240,11 @@ class App extends React.Component<AppProps, AppState> {
       }
     }
 
+    const topLayerFrame = this.getTopLayerFrameAtSceneCoords({
+      x: sceneX,
+      y: sceneY,
+    });
+
     const textCreationGridPoint = this.getTextCreationGridPoint(sceneX, sceneY);
 
     const newTextElementPosition = parentCenterPosition
@@ -6282,20 +6266,6 @@ 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({
@@ -6325,7 +6295,7 @@ class App extends React.Component<AppProps, AppState> {
             ? (0 as Radians)
             : container.angle
           : (0 as Radians),
-        frameId,
+        frameId: topLayerFrame ? topLayerFrame.id : null,
       });
 
     if (!existingTextElement && shouldBindToContainer && container) {
@@ -6341,12 +6311,9 @@ class App extends React.Component<AppProps, AppState> {
     if (!existingTextElement) {
       if (container && shouldBindToContainer) {
         const containerIndex = this.scene.getElementIndex(container.id);
-        // TODO should use insertNewElement, after we update it to handle
+        this.scene.insertElementAtIndex(element, containerIndex + 1);
-        // 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.insertNewElement(element);
+        this.scene.insertElement(element);
       }
     }
 
@@ -6728,161 +6695,19 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
-  /**
+  private getTopLayerFrameAtSceneCoords = (sceneCoords: {
-   * finds candidate frame under cursor (when dragging frame children/elements
+    x: number;
-   * inside frames)
+    y: number;
-   */
+  }) => {
-  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 framesUnderCursor = this.scene
+    const frames = this.scene
       .getNonDeletedFramesLikes()
       .filter(
         (frame): frame is ExcalidrawFrameLikeElement =>
           !frame.locked && isCursorInFrame(sceneCoords, frame, elementsMap),
       );
 
-    if (!framesUnderCursor.length) {
+    return frames.length ? frames[frames.length - 1] : null;
-      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 = (
@@ -6984,14 +6809,6 @@ class App extends React.Component<AppProps, AppState> {
       }
     }
 
-    this.maybeUpdateFrameToHighlightOnPointerMove(
-      {
-        x: scenePointerX,
-        y: scenePointerY,
-      },
-      isOverScrollBar,
-    );
-
     if (
       !this.state.newElement &&
       isActiveToolNonLinearSnappable(this.state.activeTool.type)
@@ -9046,7 +8863,7 @@ class App extends React.Component<AppProps, AppState> {
       pressures: simulatePressure ? [] : [event.pressure],
     });
 
-    this.insertNewElement(element);
+    this.scene.insertElement(element);
 
     this.setState((prevState) => {
       const nextSelectedElementIds = {
@@ -9103,7 +8920,7 @@ class App extends React.Component<AppProps, AppState> {
       height,
     });
 
-    this.insertNewElement(element);
+    this.scene.insertElement(element);
 
     return element;
   };
@@ -9157,7 +8974,7 @@ class App extends React.Component<AppProps, AppState> {
       link,
     });
 
-    this.insertNewElement(element);
+    this.scene.insertElement(element);
 
     return element;
   };
@@ -9401,7 +9218,7 @@ class App extends React.Component<AppProps, AppState> {
         points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(0, 0)],
       });
 
-      this.insertNewElement(element);
+      this.scene.insertElement(element);
 
       if (isBindingElement(element)) {
         // Do the initial binding so the binding strategy has the initial state
@@ -9559,7 +9376,7 @@ class App extends React.Component<AppProps, AppState> {
         selectionElement: element,
       });
     } else {
-      this.insertNewElement(element);
+      this.scene.insertElement(element);
       this.setState({
         multiElement: null,
         newElement: element,
@@ -9592,7 +9409,7 @@ class App extends React.Component<AppProps, AppState> {
         ? newMagicFrameElement(constructorOpts)
         : newFrameElement(constructorOpts);
 
-    this.insertNewElement(frame);
+    this.scene.insertElement(frame);
 
     this.setState({
       multiElement: null,
@@ -9960,17 +9777,18 @@ class App extends React.Component<AppProps, AppState> {
           return;
         }
 
-        const selectedElementsHasAFrame = selectedElements.some((e) =>
+        const selectedElementsHasAFrame = selectedElements.find((e) =>
           isFrameLikeElement(e),
         );
-        const frameToHighlight = selectedElementsHasAFrame
+        const topLayerFrame = this.getTopLayerFrameAtSceneCoords(pointerCoords);
-          ? null
+        const frameToHighlight =
-          : this.getTopLayerFrameAtSceneCoords(pointerCoords, {
+          topLayerFrame && !selectedElementsHasAFrame ? topLayerFrame : null;
-              currentFrameId: getCommonFrameId(selectedElements),
-              excludeElementIds: this.state.selectedElementIds,
-            });
         // Only update the state if there is a difference
-        this.updateFrameToHighlight(frameToHighlight);
+        if (this.state.frameToHighlight !== frameToHighlight) {
+          flushSync(() => {
+            this.setState({ frameToHighlight });
+          });
+        }
 
         // Marking that click was used for dragging to check
         // if elements should be deselected on pointerup
@@ -10406,38 +10224,20 @@ 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: [points.length - 1],
+              selectedPointsIndices: [1],
               initialState: {
                 ...linearElementEditor.initialState,
-                prevSelectedPointsIndices: null,
+                lastClickedPoint: 1,
-                lastClickedPoint: points.length - 1,
               },
-              hoverPointIndex: points.length - 1,
             };
           }
-
           this.setState({
             newElement,
             ...LinearElementEditor.handlePointDragging(
@@ -11017,6 +10817,7 @@ class App extends React.Component<AppProps, AppState> {
             this.scene.getElementsMapIncludingDeleted(),
             elementsInsideFrame,
             newElement,
+            this.state,
           ),
         );
       }
@@ -11076,14 +10877,9 @@ 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 = (
@@ -11132,8 +10928,10 @@ class App extends React.Component<AppProps, AppState> {
             topLayerFrame &&
             !this.state.selectedElementIds[topLayerFrame.id]
           ) {
-            const elementsToAdd = selectedElements.filter((element) =>
+            const elementsToAdd = selectedElements.filter(
-              isElementInFrame(element, nextElements, this.state),
+              (element) =>
+                element.frameId !== topLayerFrame.id &&
+                isElementInFrame(element, nextElements, this.state),
             );
 
             if (this.state.editingGroupId) {
@@ -11144,6 +10942,7 @@ class App extends React.Component<AppProps, AppState> {
               nextElements,
               elementsToAdd,
               topLayerFrame,
+              this.state,
             );
           } else if (!topLayerFrame) {
             if (this.state.editingGroupId) {
@@ -11205,6 +11004,7 @@ class App extends React.Component<AppProps, AppState> {
               elementsMap,
             ),
             frame,
+            this,
           );
         }
 
@@ -12020,7 +11820,7 @@ class App extends React.Component<AppProps, AppState> {
       sceneY,
       gridPadding,
     );
-    this.insertNewElements(placeholders);
+    placeholders.forEach((el) => this.scene.insertElement(el));
 
     // Create, position, insert and select initialized (replacing placeholders)
     const initialized = await Promise.all(
@@ -12148,7 +11948,6 @@ class App extends React.Component<AppProps, AppState> {
               type: "everything",
               elements: item.elements,
               randomizeSeed: true,
-              preserveFrameChildrenOrder: true,
             }).duplicatedElements,
           }));
 

packages/excalidraw/components/LibraryMenuItems.tsx

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

packages/excalidraw/components/Stats/Dimension.tsx

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

packages/excalidraw/components/Stats/MultiDimension.tsx

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

packages/excalidraw/components/canvases/InteractiveCanvas.tsx

@@ -39,7 +39,7 @@ type InteractiveCanvasProps = {
   visibleElements: readonly NonDeletedExcalidrawElement[];
   selectedElements: readonly NonDeletedExcalidrawElement[];
   allElementsMap: NonDeletedSceneElementsMap;
-  canvasNonce: string;
+  sceneNonce: number | undefined;
   selectionNonce: number | undefined;
   scale: number;
   appState: InteractiveCanvasAppState;
@@ -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.canvasNonce !== nextProps.canvasNonce ||
+    prevProps.sceneNonce !== nextProps.sceneNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if canvasNonce didn't change (e.g. we filter elements out based
+    // even if sceneNonce didn't change (e.g. we filter elements out based
     // on appState)
     prevProps.elementsMap !== nextProps.elementsMap ||
     prevProps.visibleElements !== nextProps.visibleElements ||

packages/excalidraw/components/canvases/NewElementCanvas.tsx

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

packages/excalidraw/components/canvases/StaticCanvas.tsx

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

packages/excalidraw/components/shapes.tsx

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

packages/excalidraw/package.json

@@ -95,6 +95,7 @@
     "clsx": "1.1.1",
     "cross-env": "7.0.3",
     "es6-promise-pool": "2.5.0",
+    "fractional-indexing": "3.2.0",
     "fuzzy": "0.1.3",
     "image-blob-reduce": "3.0.1",
     "jotai": "2.11.0",

packages/excalidraw/polyfill.ts

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

packages/excalidraw/renderer/renderSnaps.ts

@@ -19,8 +19,6 @@ export const renderSnaps = (
   }
 
   // in dark mode, we need to adjust the color to account for color inversion.
-  // Don't change if zen mode, because we draw only crosses, we want the
-  // colors to be more visible
   const snapColor =
     appState.theme === THEME.LIGHT || appState.zenModeEnabled
       ? SNAP_COLOR_LIGHT

packages/excalidraw/scene/Renderer.ts

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

packages/excalidraw/snapping.ts

@@ -39,6 +39,14 @@ import type {
 } from "./types";
 
 const SNAP_DISTANCE = 8;
+// Keep snap candidates with effectively identical offsets together. This needs
+// to be wider than the 6-decimal rounding quantum to absorb JS floating-point
+// noise around values like 4 and 4.000001.
+const SNAP_OFFSET_TOLERANCE = 0.00001;
+// Point snaps can come from both nearby and distant references within snap
+// distance. If their visual distances have a large break, prefer the nearest
+// cluster before comparing offsets.
+const SNAP_REFERENCE_CLUSTER_BREAK_DISTANCE = 200;
 
 // do not comput more gaps per axis than this limit
 // TODO increase or remove once we optimize
@@ -49,16 +57,51 @@ export const getSnapDistance = (zoomValue: number) => {
   return SNAP_DISTANCE / zoomValue;
 };
 
+/**
+ * Keeps the cluster threshold visually stable across zoom levels.
+ */
+const getSnapReferenceClusterBreakDistance = (zoomValue: number) => {
+  return SNAP_REFERENCE_CLUSTER_BREAK_DISTANCE / zoomValue;
+};
+
 type Vector2D = {
   x: number;
   y: number;
 };
 
 type PointPair = [GlobalPoint, GlobalPoint];
+type SnapPointType = "outer" | "center";
+type SnapSourceId = string;
+
+const SELECTION_SNAP_SOURCE_ID = "selection";
+
+// Snap source ids let us filter redundant snaplines only within one
+// selection-to-reference relationship, without mixing separate reference groups.
+// For example, "selection->rectA" may collapse to its outermost snaplines,
+// while "selection->rectB" still keeps its own independent snaplines.
+type SnapPoint = {
+  point: GlobalPoint;
+  type: SnapPointType;
+  snapSourceId: SnapSourceId;
+};
+
+const outerSnapPoint = (
+  point: GlobalPoint,
+  snapSourceId = SELECTION_SNAP_SOURCE_ID,
+): SnapPoint => ({
+  point,
+  type: "outer",
+  snapSourceId,
+});
 
 export type PointSnap = {
   type: "point";
   points: PointPair;
+  pointTypes: [SnapPointType, SnapPointType];
+  snapSourceIds: [SnapSourceId, SnapSourceId];
+  // Distance along the rendered snapline, used to group visually nearby
+  // references before choosing which point snaps should win.
+  visualDistance: number;
   offset: number;
 };
 
@@ -120,14 +163,14 @@ export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
 // -----------------------------------------------------------------------------
 
 export class SnapCache {
-  private static referenceSnapPoints: GlobalPoint[] | null = null;
+  private static referenceSnapPoints: SnapPoint[] | null = null;
 
   private static visibleGaps: {
     verticalGaps: Gap[];
     horizontalGaps: Gap[];
   } | null = null;
 
-  public static setReferenceSnapPoints = (snapPoints: GlobalPoint[] | null) => {
+  public static setReferenceSnapPoints = (snapPoints: SnapPoint[] | null) => {
     SnapCache.referenceSnapPoints = snapPoints;
   };
 
@@ -195,6 +238,17 @@ export const areRoughlyEqual = (a: number, b: number, precision = 0.01) => {
   return Math.abs(a - b) <= precision;
 };
 
+/**
+ * Keeps nearly identical snap offsets in the same winner set. This prevents
+ * snapline flicker when rounded geometry differs by a tiny floating-point tail.
+ */
+const isWithinSnapOffset = (offset: number, minOffset: number) => {
+  return (
+    Math.abs(offset) <= minOffset ||
+    areRoughlyEqual(Math.abs(offset), minOffset, SNAP_OFFSET_TOLERANCE)
+  );
+};
+
 export const getElementsCorners = (
   elements: ExcalidrawElement[],
   elementsMap: ElementsMap,
@@ -312,18 +366,81 @@ export const getElementsCorners = (
   return result.map((p) => pointFrom(round(p[0]), round(p[1])));
 };
 
+const getElementsSnapPoints = (
+  elements: ExcalidrawElement[],
+  elementsMap: ElementsMap,
+  options: Parameters<typeof getElementsCorners>[2] = {},
+  snapSourceId = SELECTION_SNAP_SOURCE_ID,
+): SnapPoint[] => {
+  const points = getElementsCorners(elements, elementsMap, options);
+  // getElementsCorners() appends the center point last unless omitCenter is set.
+  const hasCenterPoint = !options.omitCenter && points.length > 0;
+
+  return points.map((point, index) => ({
+    point,
+    type: hasCenterPoint && index === points.length - 1 ? "center" : "outer",
+    snapSourceId,
+  }));
+};
+
+/**
+ * Builds a stable identity for one snap reference group. Sorting keeps grouped
+ * elements represented by the same snap source id regardless of element order.
+ */
+const getSnapSourceId = (elements: ExcalidrawElement[]) => {
+  return elements
+    .map((element) => element.id)
+    .sort()
+    .join(",");
+};
+
+/**
+ * Finds frames that the current selection already belongs to. Their children
+ * are still valid snap references; children of unrelated frames are not.
+ */
+const getSelectedFrameIdsForSnapping = (
+  selectedElements: readonly ExcalidrawElement[],
+) => {
+  const selectedFrameIds = new Set<ExcalidrawElement["id"]>();
+
+  for (const element of selectedElements) {
+    if (element.frameId) {
+      selectedFrameIds.add(element.frameId);
+    }
+  }
+
+  return selectedFrameIds;
+};
+
+/**
+ * Frame children are only snap references when the dragged selection is inside
+ * the same frame. This avoids snapping external elements to internals of a
+ * framed diagram.
+ */
+const canUseElementAsSnapReference = (
+  element: NonDeletedExcalidrawElement,
+  selectedFrameIds: Set<ExcalidrawElement["id"]>,
+) => {
+  return !element.frameId || selectedFrameIds.has(element.frameId);
+};
+
 const getReferenceElements = (
   elements: readonly NonDeletedExcalidrawElement[],
   selectedElements: NonDeletedExcalidrawElement[],
   appState: AppState,
   elementsMap: ElementsMap,
-) =>
+) => {
-  getVisibleAndNonSelectedElements(
+  const selectedFrameIds = getSelectedFrameIdsForSnapping(selectedElements);
+
+  return getVisibleAndNonSelectedElements(
     elements,
     selectedElements,
     appState,
     elementsMap,
-  );
+  ).filter((element) => {
+    return canUseElementAsSnapReference(element, selectedFrameIds);
+  });
+};
 
 export const getVisibleGaps = (
   elements: readonly NonDeletedExcalidrawElement[],
@@ -482,7 +599,10 @@ const getGapSnaps = (
       const centerOffset = round(gapMidX - centerX);
       const gapIsLargerThanSelection = gap.length > maxX - minX;
 
-      if (gapIsLargerThanSelection && Math.abs(centerOffset) <= minOffset.x) {
+      if (
+        gapIsLargerThanSelection &&
+        isWithinSnapOffset(centerOffset, minOffset.x)
+      ) {
         if (Math.abs(centerOffset) < minOffset.x) {
           nearestSnapsX.length = 0;
         }
@@ -504,7 +624,7 @@ const getGapSnaps = (
       const distanceToEndElementX = minX - endMaxX;
       const sideOffsetRight = round(gap.length - distanceToEndElementX);
 
-      if (Math.abs(sideOffsetRight) <= minOffset.x) {
+      if (isWithinSnapOffset(sideOffsetRight, minOffset.x)) {
         if (Math.abs(sideOffsetRight) < minOffset.x) {
           nearestSnapsX.length = 0;
         }
@@ -525,7 +645,7 @@ const getGapSnaps = (
       const distanceToStartElementX = startMinX - maxX;
       const sideOffsetLeft = round(distanceToStartElementX - gap.length);
 
-      if (Math.abs(sideOffsetLeft) <= minOffset.x) {
+      if (isWithinSnapOffset(sideOffsetLeft, minOffset.x)) {
         if (Math.abs(sideOffsetLeft) < minOffset.x) {
           nearestSnapsX.length = 0;
         }
@@ -551,7 +671,10 @@ const getGapSnaps = (
       const centerOffset = round(gapMidY - centerY);
       const gapIsLargerThanSelection = gap.length > maxY - minY;
 
-      if (gapIsLargerThanSelection && Math.abs(centerOffset) <= minOffset.y) {
+      if (
+        gapIsLargerThanSelection &&
+        isWithinSnapOffset(centerOffset, minOffset.y)
+      ) {
         if (Math.abs(centerOffset) < minOffset.y) {
           nearestSnapsY.length = 0;
         }
@@ -573,7 +696,7 @@ const getGapSnaps = (
       const distanceToStartElementY = startMinY - maxY;
       const sideOffsetTop = round(distanceToStartElementY - gap.length);
 
-      if (Math.abs(sideOffsetTop) <= minOffset.y) {
+      if (isWithinSnapOffset(sideOffsetTop, minOffset.y)) {
         if (Math.abs(sideOffsetTop) < minOffset.y) {
           nearestSnapsY.length = 0;
         }
@@ -594,7 +717,7 @@ const getGapSnaps = (
       const distanceToEndElementY = round(minY - endMaxY);
       const sideOffsetBottom = gap.length - distanceToEndElementY;
 
-      if (Math.abs(sideOffsetBottom) <= minOffset.y) {
+      if (isWithinSnapOffset(sideOffsetBottom, minOffset.y)) {
         if (Math.abs(sideOffsetBottom) < minOffset.y) {
           nearestSnapsY.length = 0;
         }
@@ -613,6 +736,102 @@ const getGapSnaps = (
   }
 };
 
+/**
+ * Narrows point snaps to the nearest visual cluster, then keeps the best offset
+ * inside that cluster. If all references look continuous, this preserves the
+ * old smallest-offset behavior.
+ */
+const filterPointSnapsToNearestCluster = (
+  snaps: Snaps,
+  clusterBreakDistance: number,
+) => {
+  const pointSnaps = snaps.filter(
+    (snap): snap is PointSnap => snap.type === "point",
+  );
+
+  if (pointSnaps.length < 2) {
+    return;
+  }
+
+  const snapsByOffset = new Map<number, PointSnap[]>();
+
+  for (const snap of pointSnaps) {
+    const offset = round(snap.offset);
+    const offsetSnaps = snapsByOffset.get(offset) ?? [];
+    offsetSnaps.push(snap);
+    snapsByOffset.set(offset, offsetSnaps);
+  }
+
+  const keptPointSnaps = new Set<PointSnap>();
+  const offsetGroups = Array.from(snapsByOffset.entries()).map(
+    ([offset, offsetSnaps]) => ({
+      offset,
+      snaps: offsetSnaps,
+      visualDistance: Math.min(
+        ...offsetSnaps.map((snap) => snap.visualDistance),
+      ),
+    }),
+  );
+  const sortedOffsetGroups = offsetGroups
+    .slice()
+    .sort((a, b) => a.visualDistance - b.visualDistance);
+  let keepOffsetGroupsUntil = sortedOffsetGroups.length;
+
+  // Prefer a nearby reference cluster before comparing offset. If there is no
+  // clear distance break, this keeps all offsets and falls back to the old
+  // smallest-offset behavior.
+  for (let i = 1; i < sortedOffsetGroups.length; i++) {
+    const distanceGap =
+      sortedOffsetGroups[i].visualDistance -
+      sortedOffsetGroups[i - 1].visualDistance;
+
+    if (distanceGap > clusterBreakDistance) {
+      keepOffsetGroupsUntil = i;
+      break;
+    }
+  }
+
+  const nearestOffsetGroups = sortedOffsetGroups.slice(
+    0,
+    keepOffsetGroupsUntil,
+  );
+  const minOffset = Math.min(
+    ...nearestOffsetGroups.map(({ offset }) => Math.abs(offset)),
+  );
+  const selectedOffsets = nearestOffsetGroups
+    .filter(({ offset }) =>
+      areRoughlyEqual(Math.abs(offset), minOffset, SNAP_OFFSET_TOLERANCE),
+    )
+    .map(({ offset }) => offset);
+
+  for (const offsetSnaps of snapsByOffset.values()) {
+    if (
+      !selectedOffsets.some((offset) =>
+        areRoughlyEqual(
+          round(offsetSnaps[0].offset),
+          offset,
+          SNAP_OFFSET_TOLERANCE,
+        ),
+      )
+    ) {
+      continue;
+    }
+
+    offsetSnaps.forEach((snap) => keptPointSnaps.add(snap));
+  }
+
+  let writeIndex = 0;
+
+  for (const snap of snaps) {
+    if (snap.type !== "point" || keptPointSnaps.has(snap)) {
+      snaps[writeIndex] = snap;
+      writeIndex++;
+    }
+  }
+
+  snaps.length = writeIndex;
+};
+
 export const getReferenceSnapPoints = (
   elements: readonly NonDeletedExcalidrawElement[],
   selectedElements: ExcalidrawElement[],
@@ -630,12 +849,24 @@ export const getReferenceSnapPoints = (
       (elementsGroup) =>
         !(elementsGroup.length === 1 && isBoundToContainer(elementsGroup[0])),
     )
-    .flatMap((elementGroup) => getElementsCorners(elementGroup, elementsMap));
+    .flatMap((elementGroup) =>
+      getElementsSnapPoints(
+        elementGroup,
+        elementsMap,
+        {},
+        getSnapSourceId(elementGroup),
+      ),
+    );
 };
 
+/**
+ * Collects point snaps within snap distance. Unlike gap snaps, point snaps first
+ * go through visual-cluster filtering so a nearby reference can beat a slightly
+ * better offset from a far-away reference.
+ */
 const getPointSnaps = (
   selectedElements: ExcalidrawElement[],
-  selectionSnapPoints: GlobalPoint[],
+  selectionSnapPoints: SnapPoint[],
   app: AppClassProperties,
   event: KeyboardModifiersObject,
   nearestSnapsX: Snaps,
@@ -654,39 +885,62 @@ const getPointSnaps = (
   if (referenceSnapPoints) {
     for (const thisSnapPoint of selectionSnapPoints) {
       for (const otherSnapPoint of referenceSnapPoints) {
-        const offsetX = otherSnapPoint[0] - thisSnapPoint[0];
+        const offsetX = otherSnapPoint.point[0] - thisSnapPoint.point[0];
-        const offsetY = otherSnapPoint[1] - thisSnapPoint[1];
+        const offsetY = otherSnapPoint.point[1] - thisSnapPoint.point[1];
-
-        if (Math.abs(offsetX) <= minOffset.x) {
-          if (Math.abs(offsetX) < minOffset.x) {
-            nearestSnapsX.length = 0;
-          }
 
+        if (isWithinSnapOffset(offsetX, minOffset.x)) {
           nearestSnapsX.push({
             type: "point",
-            points: [thisSnapPoint, otherSnapPoint],
+            points: [thisSnapPoint.point, otherSnapPoint.point],
+            pointTypes: [thisSnapPoint.type, otherSnapPoint.type],
+            snapSourceIds: [
+              thisSnapPoint.snapSourceId,
+              otherSnapPoint.snapSourceId,
+            ],
+            visualDistance: Math.abs(
+              otherSnapPoint.point[1] - thisSnapPoint.point[1],
+            ),
             offset: offsetX,
           });
-
-          minOffset.x = Math.abs(offsetX);
         }
 
-        if (Math.abs(offsetY) <= minOffset.y) {
+        if (isWithinSnapOffset(offsetY, minOffset.y)) {
-          if (Math.abs(offsetY) < minOffset.y) {
-            nearestSnapsY.length = 0;
-          }
-
           nearestSnapsY.push({
             type: "point",
-            points: [thisSnapPoint, otherSnapPoint],
+            points: [thisSnapPoint.point, otherSnapPoint.point],
+            pointTypes: [thisSnapPoint.type, otherSnapPoint.type],
+            snapSourceIds: [
+              thisSnapPoint.snapSourceId,
+              otherSnapPoint.snapSourceId,
+            ],
+            visualDistance: Math.abs(
+              otherSnapPoint.point[0] - thisSnapPoint.point[0],
+            ),
             offset: offsetY,
           });
-
-          minOffset.y = Math.abs(offsetY);
         }
       }
     }
   }
+
+  const clusterBreakDistance = getSnapReferenceClusterBreakDistance(
+    app.state.zoom.value,
+  );
+
+  filterPointSnapsToNearestCluster(nearestSnapsX, clusterBreakDistance);
+  filterPointSnapsToNearestCluster(nearestSnapsY, clusterBreakDistance);
+
+  if (nearestSnapsX.length > 0) {
+    minOffset.x = Math.min(
+      ...nearestSnapsX.map((snap) => Math.abs(snap.offset)),
+    );
+  }
+
+  if (nearestSnapsY.length > 0) {
+    minOffset.y = Math.min(
+      ...nearestSnapsY.map((snap) => Math.abs(snap.offset)),
+    );
+  }
 };
 
 export const snapDraggedElements = (
@@ -720,7 +974,7 @@ export const snapDraggedElements = (
     y: snapDistance,
   };
 
-  const selectionPoints = getElementsCorners(selectedElements, elementsMap, {
+  const selectionPoints = getElementsSnapPoints(selectedElements, elementsMap, {
     dragOffset,
   });
 
@@ -770,7 +1024,7 @@ export const snapDraggedElements = (
 
   getPointSnaps(
     selectedElements,
-    getElementsCorners(selectedElements, elementsMap, {
+    getElementsSnapPoints(selectedElements, elementsMap, {
       dragOffset: newDragOffset,
     }),
     app,
@@ -825,12 +1079,185 @@ const dedupePoints = (points: GlobalPoint[]): GlobalPoint[] => {
   return Array.from(map.values());
 };
 
+// Point snaplines are collected from every winning point snap first. Multiple
+// snap source pairs can collapse to the same rendered line, so candidates keep
+// source-pair metadata until redundant center and inner outer lines are removed.
+type PointSnapLineSourcePair = {
+  snapSourcePairKey: string;
+  pointType: SnapPointType;
+};
+
+type PointSnapLineCandidate = PointSnapLine & {
+  sourcePairs: PointSnapLineSourcePair[];
+};
+
+type PointSnapLineBucket = {
+  points: GlobalPoint[];
+  sourcePairs: PointSnapLineSourcePair[];
+};
+
+type OuterSnapLineCoordinateRange = {
+  count: number;
+  min: number;
+  max: number;
+};
+
+/**
+ * Describes which snap source pair produced a rendered point snapline, so later
+ * filtering can reason about redundancy without mixing unrelated references.
+ * Only center-to-center snaps count as center snaplines; a center-to-outer snap
+ * still explains an outer edge or midpoint alignment.
+ */
+const getPointSnapLineSourcePair = (
+  snap: PointSnap,
+): PointSnapLineSourcePair => {
+  return {
+    snapSourcePairKey: snap.snapSourceIds.join("->"),
+    pointType: snap.pointTypes.every((pointType) => pointType === "center")
+      ? "center"
+      : "outer",
+  };
+};
+
+/**
+ * Builds each snap source pair's outer coordinate range. Center snaplines use
+ * this range to decide whether the surrounding outer lines already explain
+ * them, and outer snaplines use it to keep only the two extremes.
+ */
+const getOuterCoordinateRangesBySnapSourcePairKey = (
+  snapLines: PointSnapLineCandidate[],
+  getCoordinate: (snapLine: PointSnapLine) => number,
+) => {
+  const ranges = new Map<string, OuterSnapLineCoordinateRange>();
+
+  for (const snapLine of snapLines) {
+    const coordinate = getCoordinate(snapLine);
+
+    for (const sourcePair of snapLine.sourcePairs) {
+      if (sourcePair.pointType === "center") {
+        continue;
+      }
+
+      const range = ranges.get(sourcePair.snapSourcePairKey);
+
+      ranges.set(sourcePair.snapSourcePairKey, {
+        count: (range?.count ?? 0) + 1,
+        min: range ? Math.min(range.min, coordinate) : coordinate,
+        max: range ? Math.max(range.max, coordinate) : coordinate,
+      });
+    }
+  }
+
+  return ranges;
+};
+
+/**
+ * A center snapline is redundant when outer snaplines from the same snap source
+ * pair exist on both sides, because the outer lines already imply center
+ * alignment.
+ */
+const isRedundantCenterSnapLine = (
+  coordinate: number,
+  outerCoordinateRange?: OuterSnapLineCoordinateRange,
+) => {
+  if (!outerCoordinateRange) {
+    return false;
+  }
+
+  return (
+    outerCoordinateRange.min < coordinate &&
+    outerCoordinateRange.max > coordinate
+  );
+};
+
+/**
+ * When more than two outer snaplines come from the same snap source pair, the
+ * inner ones are redundant; the two extremes communicate the same shape
+ * alignment.
+ */
+const isRedundantOuterSnapLine = (
+  coordinate: number,
+  outerCoordinateRange?: OuterSnapLineCoordinateRange,
+) => {
+  if (!outerCoordinateRange || outerCoordinateRange.count <= 2) {
+    return false;
+  }
+
+  return (
+    coordinate !== outerCoordinateRange.min &&
+    coordinate !== outerCoordinateRange.max
+  );
+};
+
+/**
+ * Keeps a visual snapline if at least one snap source pair represented by the
+ * line still needs it. This matters when multiple snap source pairs collapse to
+ * the same rendered coordinate.
+ */
+const isPointSnapLineNeededBySourcePair = (
+  sourcePair: PointSnapLineSourcePair,
+  coordinate: number,
+  outerCoordinateRangesBySnapSourcePairKey: Map<
+    string,
+    OuterSnapLineCoordinateRange
+  >,
+) => {
+  const outerCoordinateRange = outerCoordinateRangesBySnapSourcePairKey.get(
+    sourcePair.snapSourcePairKey,
+  );
+
+  if (sourcePair.pointType === "center") {
+    return !isRedundantCenterSnapLine(coordinate, outerCoordinateRange);
+  }
+
+  return !isRedundantOuterSnapLine(coordinate, outerCoordinateRange);
+};
+
+/**
+ * Removes point snaplines that are visually redundant, while preserving any line
+ * that is still needed by at least one snap source pair represented on that
+ * line.
+ */
+const filterRedundantPointSnapLines = (
+  snapLines: PointSnapLineCandidate[],
+  getCoordinate: (snapLine: PointSnapLine) => number,
+): PointSnapLine[] => {
+  if (snapLines.length < 3) {
+    return snapLines.map(({ sourcePairs, ...snapLine }) => snapLine);
+  }
+
+  // Track outer-line ranges per snap source pair. The same visual snapline can
+  // be produced by multiple snap source pairs, so a line is removed only when
+  // every pair represented by that line considers it redundant.
+  const outerCoordinateRangesBySnapSourcePairKey =
+    getOuterCoordinateRangesBySnapSourcePairKey(snapLines, getCoordinate);
+
+  return snapLines
+    .filter((snapLine) => {
+      const coordinate = getCoordinate(snapLine);
+
+      return snapLine.sourcePairs.some((sourcePair) =>
+        isPointSnapLineNeededBySourcePair(
+          sourcePair,
+          coordinate,
+          outerCoordinateRangesBySnapSourcePairKey,
+        ),
+      );
+    })
+    .map(({ sourcePairs, ...snapLine }) => snapLine);
+};
+
+/**
+ * Merges point snaps that render on the same x/y coordinate, attaches their
+ * snap source pair metadata, then removes redundant center and inner outer
+ * lines.
+ */
 const createPointSnapLines = (
   nearestSnapsX: Snaps,
   nearestSnapsY: Snaps,
 ): PointSnapLine[] => {
-  const snapsX = {} as { [key: string]: GlobalPoint[] };
+  const snapsX = {} as { [key: string]: PointSnapLineBucket };
-  const snapsY = {} as { [key: string]: GlobalPoint[] };
+  const snapsY = {} as { [key: string]: PointSnapLineBucket };
 
   if (nearestSnapsX.length > 0) {
     for (const snap of nearestSnapsX) {
@@ -838,13 +1265,14 @@ const createPointSnapLines = (
         // key = thisPoint.x
         const key = round(snap.points[0][0]);
         if (!snapsX[key]) {
-          snapsX[key] = [];
+          snapsX[key] = { points: [], sourcePairs: [] };
         }
-        snapsX[key].push(
+        snapsX[key].points.push(
           ...snap.points.map((p) =>
             pointFrom<GlobalPoint>(round(p[0]), round(p[1])),
           ),
         );
+        snapsX[key].sourcePairs.push(getPointSnapLineSourcePair(snap));
       }
     }
   }
@@ -855,44 +1283,55 @@ const createPointSnapLines = (
         // key = thisPoint.y
         const key = round(snap.points[0][1]);
         if (!snapsY[key]) {
-          snapsY[key] = [];
+          snapsY[key] = { points: [], sourcePairs: [] };
         }
-        snapsY[key].push(
+        snapsY[key].points.push(
           ...snap.points.map((p) =>
             pointFrom<GlobalPoint>(round(p[0]), round(p[1])),
           ),
         );
+        snapsY[key].sourcePairs.push(getPointSnapLineSourcePair(snap));
       }
     }
   }
 
-  return Object.entries(snapsX)
+  const snapLinesX = Object.entries(snapsX).map(([key, snap]) => {
-    .map(([key, points]) => {
+    return {
-      return {
+      type: "points",
-        type: "points",
+      points: dedupePoints(
-        points: dedupePoints(
+        snap.points
-          points
+          .map((p) => {
-            .map((p) => {
+            return pointFrom<GlobalPoint>(Number(key), p[1]);
-              return pointFrom<GlobalPoint>(Number(key), p[1]);
+          })
-            })
+          .sort((a, b) => a[1] - b[1]),
-            .sort((a, b) => a[1] - b[1]),
+      ),
-        ),
+      sourcePairs: snap.sourcePairs,
-      } as PointSnapLine;
+    } as PointSnapLineCandidate;
-    })
+  });
-    .concat(
+
-      Object.entries(snapsY).map(([key, points]) => {
+  const snapLinesY = Object.entries(snapsY).map(([key, snap]) => {
-        return {
+    return {
-          type: "points",
+      type: "points",
-          points: dedupePoints(
+      points: dedupePoints(
-            points
+        snap.points
-              .map((p) => {
+          .map((p) => {
-                return pointFrom<GlobalPoint>(p[0], Number(key));
+            return pointFrom<GlobalPoint>(p[0], Number(key));
-              })
+          })
-              .sort((a, b) => a[0] - b[0]),
+          .sort((a, b) => a[0] - b[0]),
-          ),
+      ),
-        } as PointSnapLine;
+      sourcePairs: snap.sourcePairs,
-      }),
+    } as PointSnapLineCandidate;
-    );
+  });
+
+  return filterRedundantPointSnapLines(
+    snapLinesX,
+    (snapLine) => snapLine.points[0][0],
+  ).concat(
+    filterRedundantPointSnapLines(
+      snapLinesY,
+      (snapLine) => snapLine.points[0][1],
+    ),
+  );
 };
 
 const dedupeGapSnapLines = (gapSnapLines: GapSnapLine[]) => {
@@ -917,10 +1356,13 @@ const createGapSnapLines = (
   dragOffset: Vector2D,
   gapSnaps: GapSnap[],
 ): GapSnapLine[] => {
+  // Use the same rounded bounds as getGapSnaps(). Otherwise a gap snap can be
+  // accepted during snapping but skipped here because the raw bounds miss the
+  // reference gap overlap by a tiny floating-point delta.
   const [minX, minY, maxX, maxY] = getDraggedElementsBounds(
     selectedElements,
     dragOffset,
-  );
+  ).map((bound) => round(bound));
 
   const gapSnapLines: GapSnapLine[] = [];
 
@@ -1143,40 +1585,52 @@ export const snapResizingElements = (
     }
   }
 
-  const selectionSnapPoints: GlobalPoint[] = [];
+  const selectionSnapPoints: SnapPoint[] = [];
 
   if (transformHandle) {
     switch (transformHandle) {
       case "e": {
-        selectionSnapPoints.push(pointFrom(maxX, minY), pointFrom(maxX, maxY));
+        selectionSnapPoints.push(
+          outerSnapPoint(pointFrom(maxX, minY)),
+          outerSnapPoint(pointFrom(maxX, maxY)),
+        );
         break;
       }
       case "w": {
-        selectionSnapPoints.push(pointFrom(minX, minY), pointFrom(minX, maxY));
+        selectionSnapPoints.push(
+          outerSnapPoint(pointFrom(minX, minY)),
+          outerSnapPoint(pointFrom(minX, maxY)),
+        );
         break;
       }
       case "n": {
-        selectionSnapPoints.push(pointFrom(minX, minY), pointFrom(maxX, minY));
+        selectionSnapPoints.push(
+          outerSnapPoint(pointFrom(minX, minY)),
+          outerSnapPoint(pointFrom(maxX, minY)),
+        );
         break;
       }
       case "s": {
-        selectionSnapPoints.push(pointFrom(minX, maxY), pointFrom(maxX, maxY));
+        selectionSnapPoints.push(
+          outerSnapPoint(pointFrom(minX, maxY)),
+          outerSnapPoint(pointFrom(maxX, maxY)),
+        );
         break;
       }
       case "ne": {
-        selectionSnapPoints.push(pointFrom(maxX, minY));
+        selectionSnapPoints.push(outerSnapPoint(pointFrom(maxX, minY)));
         break;
       }
       case "nw": {
-        selectionSnapPoints.push(pointFrom(minX, minY));
+        selectionSnapPoints.push(outerSnapPoint(pointFrom(minX, minY)));
         break;
       }
       case "se": {
-        selectionSnapPoints.push(pointFrom(maxX, maxY));
+        selectionSnapPoints.push(outerSnapPoint(pointFrom(maxX, maxY)));
         break;
       }
       case "sw": {
-        selectionSnapPoints.push(pointFrom(minX, maxY));
+        selectionSnapPoints.push(outerSnapPoint(pointFrom(minX, maxY)));
         break;
       }
     }
@@ -1218,11 +1672,11 @@ export const snapResizingElements = (
     round(bound),
   );
 
-  const corners: GlobalPoint[] = [
+  const corners: SnapPoint[] = [
-    pointFrom(x1, y1),
+    outerSnapPoint(pointFrom(x1, y1)),
-    pointFrom(x1, y2),
+    outerSnapPoint(pointFrom(x1, y2)),
-    pointFrom(x2, y1),
+    outerSnapPoint(pointFrom(x2, y1)),
-    pointFrom(x2, y2),
+    outerSnapPoint(pointFrom(x2, y2)),
   ];
 
   getPointSnaps(
@@ -1258,8 +1712,8 @@ export const snapNewElement = (
     };
   }
 
-  const selectionSnapPoints: GlobalPoint[] = [
+  const selectionSnapPoints: SnapPoint[] = [
-    pointFrom(origin.x + dragOffset.x, origin.y + dragOffset.y),
+    outerSnapPoint(pointFrom(origin.x + dragOffset.x, origin.y + dragOffset.y)),
   ];
 
   const snapDistance = getSnapDistance(app.state.zoom.value);
@@ -1292,7 +1746,7 @@ export const snapNewElement = (
   nearestSnapsX.length = 0;
   nearestSnapsY.length = 0;
 
-  const corners = getElementsCorners([newElement], elementsMap, {
+  const corners = getElementsSnapPoints([newElement], elementsMap, {
     boundingBoxCorners: true,
     omitCenter: true,
   });

packages/excalidraw/tests/clipboard.test.tsx

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

packages/excalidraw/tests/helpers/polyfills.ts

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

packages/excalidraw/tests/selection.test.tsx

@@ -1,12 +1,8 @@
 import React from "react";
 import { vi } from "vitest";
 
-import { KEYS, ROUNDNESS, arrayToMap, reseed } from "@excalidraw/common";
+import { KEYS, ROUNDNESS, reseed } from "@excalidraw/common";
-import {
+import { getElementBounds, getElementLineSegments } from "@excalidraw/element";
-  getElementBounds,
-  getElementLineSegments,
-  getElementsWithinSelection,
-} from "@excalidraw/element";
 import { pointFrom, pointRotateRads, type LocalPoint } from "@excalidraw/math";
 
 import { SHAPES } from "../components/shapes";
@@ -273,145 +269,6 @@ describe("box-selection overlap mode", () => {
     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",
@@ -859,175 +716,11 @@ 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",
@@ -1058,7 +751,7 @@ describe("inner box-selection", () => {
     Keyboard.withModifierKeys({ ctrl: true }, () => {
       mouse.downAt(rect2.x - 20, rect2.y - 20);
       mouse.move(-1000, -1000);
-      mouse.moveTo(rect3.x + rect3.width + 10, rect3.y + rect3.height + 10);
+      mouse.moveTo(rect2.x + rect2.width + 10, rect2.y + rect2.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/snapping.test.ts

@@ -0,0 +1,833 @@
+import { arrayToMap } from "@excalidraw/common";
+import {
+  pointFrom,
+  rangeInclusive,
+  type GlobalPoint,
+  type Radians,
+} from "@excalidraw/math";
+
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+
+import { getDefaultAppState } from "../appState";
+import {
+  getElementsCorners,
+  getVisibleGaps,
+  getReferenceSnapPoints,
+  SnapCache,
+  snapDraggedElements,
+} from "../snapping";
+
+import { API } from "./helpers/api";
+
+import type {
+  AppClassProperties,
+  AppState,
+  NormalizedZoomValue,
+} from "../types";
+
+type ReferenceSnapPoints = NonNullable<
+  ReturnType<typeof SnapCache.getReferenceSnapPoints>
+>;
+
+const NO_MODIFIER_KEYS = {
+  altKey: false,
+  ctrlKey: false,
+  metaKey: false,
+  shiftKey: false,
+};
+
+const createSnappingApp = (appState: Partial<AppState> = {}) =>
+  ({
+    props: {},
+    state: {
+      ...getDefaultAppState(),
+      objectsSnapModeEnabled: true,
+      width: 1000,
+      height: 1000,
+      offsetLeft: 0,
+      offsetTop: 0,
+      ...appState,
+    },
+  } as AppClassProperties);
+
+const getHorizontalPointSnapLineCoordinates = (
+  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
+) => {
+  return snapLines
+    .filter((snapLine) => snapLine.type === "points")
+    .filter((snapLine) => {
+      const [firstPoint, lastPoint] = snapLine.points;
+
+      return firstPoint[1] === lastPoint[1];
+    })
+    .map((snapLine) => {
+      return snapLine.points[0][1];
+    })
+    .sort((a, b) => a - b);
+};
+
+const getVerticalPointSnapLineCoordinates = (
+  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
+) => {
+  return snapLines
+    .filter((snapLine) => snapLine.type === "points")
+    .filter((snapLine) => {
+      const [firstPoint, lastPoint] = snapLine.points;
+
+      return firstPoint[0] === lastPoint[0];
+    })
+    .map((snapLine) => {
+      return snapLine.points[0][0];
+    })
+    .sort((a, b) => a - b);
+};
+
+const getHorizontalPointSnapLineMaxX = (
+  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
+) => {
+  const horizontalSnapLine = snapLines
+    .filter((snapLine) => snapLine.type === "points")
+    .find((snapLine) => {
+      const [firstPoint, lastPoint] = snapLine.points;
+
+      return firstPoint[1] === lastPoint[1];
+    });
+
+  if (!horizontalSnapLine) {
+    return null;
+  }
+
+  return horizontalSnapLine.points[horizontalSnapLine.points.length - 1][0];
+};
+
+const getHorizontalPointSnapLineXRange = (
+  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
+) => {
+  const horizontalSnapLine = snapLines
+    .filter((snapLine) => snapLine.type === "points")
+    .find((snapLine) => {
+      const [firstPoint, lastPoint] = snapLine.points;
+
+      return firstPoint[1] === lastPoint[1];
+    });
+
+  if (!horizontalSnapLine) {
+    return null;
+  }
+
+  return [
+    horizontalSnapLine.points[0][0],
+    horizontalSnapLine.points[horizontalSnapLine.points.length - 1][0],
+  ] as const;
+};
+
+const getHorizontalGapSnapLines = (
+  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
+) => {
+  return snapLines.filter(
+    (snapLine) =>
+      snapLine.type === "gap" && snapLine.direction === "horizontal",
+  );
+};
+
+const getVerticalGapSnapLines = (
+  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
+) => {
+  return snapLines.filter(
+    (snapLine) => snapLine.type === "gap" && snapLine.direction === "vertical",
+  );
+};
+
+const getPointKeys = (points: ReturnType<typeof getElementsCorners>) => {
+  return points.map((point) => point.join(","));
+};
+
+const getReferenceSnapPointKeys = (
+  elements: ExcalidrawElement[],
+  selectedElements: ExcalidrawElement[],
+  app: AppClassProperties,
+) => {
+  return new Set(
+    getReferenceSnapPoints(
+      elements,
+      selectedElements,
+      app.state,
+      arrayToMap(elements),
+    ).map((snapPoint) => snapPoint.point.join(",")),
+  );
+};
+
+const primeReferenceSnapPoints = (
+  elements: ExcalidrawElement[],
+  selectedElements: ExcalidrawElement[],
+) => {
+  const selectedElementIds = new Set(
+    selectedElements.map((element) => element.id),
+  );
+  const elementsMap = arrayToMap(elements);
+
+  SnapCache.setReferenceSnapPoints(
+    elements
+      .filter((element) => !selectedElementIds.has(element.id))
+      .flatMap((element) => {
+        const corners = getElementsCorners([element], elementsMap);
+
+        return corners.map((point, index) => ({
+          point,
+          type: index === corners.length - 1 ? "center" : "outer",
+          snapSourceId: element.id,
+        }));
+      }) as Parameters<typeof SnapCache.setReferenceSnapPoints>[0],
+  );
+};
+
+describe("snapping", () => {
+  afterEach(() => {
+    SnapCache.destroy();
+  });
+
+  it("does not use frame children as references when snapping outside elements", () => {
+    const frame = API.createElement({
+      type: "frame",
+      id: "frame",
+      x: 0,
+      y: 0,
+      width: 300,
+      height: 300,
+    });
+    const frameChild = API.createElement({
+      type: "rectangle",
+      id: "frameChild",
+      x: 37,
+      y: 53,
+      width: 71,
+      height: 83,
+      frameId: frame.id,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 400,
+      y: 50,
+      width: 100,
+      height: 100,
+    });
+    const elements = [frame, frameChild, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    const referenceSnapPointKeys = getReferenceSnapPointKeys(
+      elements,
+      [selected],
+      app,
+    );
+    const frameChildPointKeys = getPointKeys(
+      getElementsCorners([frameChild], arrayToMap(elements)),
+    );
+
+    expect(
+      frameChildPointKeys.some((pointKey) =>
+        referenceSnapPointKeys.has(pointKey),
+      ),
+    ).toBe(false);
+  });
+
+  it("uses frame siblings as references when snapping elements in the same frame", () => {
+    const frame = API.createElement({
+      type: "frame",
+      id: "frame",
+      x: 0,
+      y: 0,
+      width: 300,
+      height: 300,
+    });
+    const sibling = API.createElement({
+      type: "rectangle",
+      id: "sibling",
+      x: 37,
+      y: 53,
+      width: 71,
+      height: 83,
+      frameId: frame.id,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 150,
+      y: 50,
+      width: 100,
+      height: 100,
+      frameId: frame.id,
+    });
+    const elements = [frame, sibling, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    const referenceSnapPointKeys = getReferenceSnapPointKeys(
+      elements,
+      [selected],
+      app,
+    );
+    const siblingPointKeys = getPointKeys(
+      getElementsCorners([sibling], arrayToMap(elements)),
+    );
+
+    expect(
+      siblingPointKeys.some((pointKey) => referenceSnapPointKeys.has(pointKey)),
+    ).toBe(true);
+  });
+
+  it("does not use frame children as references when snapping the frame itself", () => {
+    const frame = API.createElement({
+      type: "frame",
+      id: "frame",
+      x: 0,
+      y: 0,
+      width: 300,
+      height: 300,
+    });
+    const frameChild = API.createElement({
+      type: "rectangle",
+      id: "frameChild",
+      x: 37,
+      y: 53,
+      width: 71,
+      height: 83,
+      frameId: frame.id,
+    });
+    const elements = [frame, frameChild];
+    const app = createSnappingApp({
+      selectedElementIds: { [frame.id]: true },
+    });
+
+    const referenceSnapPointKeys = getReferenceSnapPointKeys(
+      elements,
+      [frame],
+      app,
+    );
+    const frameChildPointKeys = getPointKeys(
+      getElementsCorners([frameChild], arrayToMap(elements)),
+    );
+
+    expect(
+      frameChildPointKeys.some((pointKey) =>
+        referenceSnapPointKeys.has(pointKey),
+      ),
+    ).toBe(false);
+  });
+
+  it("does not use frame children as visible gap references when snapping outside elements", () => {
+    const frame = API.createElement({
+      type: "frame",
+      id: "frame",
+      x: 0,
+      y: 0,
+      width: 500,
+      height: 300,
+    });
+    const frameChildA = API.createElement({
+      type: "rectangle",
+      id: "frameChildA",
+      x: 50,
+      y: 50,
+      width: 100,
+      height: 100,
+      frameId: frame.id,
+    });
+    const frameChildB = API.createElement({
+      type: "rectangle",
+      id: "frameChildB",
+      x: 250,
+      y: 50,
+      width: 100,
+      height: 100,
+      frameId: frame.id,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 700,
+      y: 50,
+      width: 100,
+      height: 100,
+    });
+    const elements = [frame, frameChildA, frameChildB, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    const visibleGaps = getVisibleGaps(
+      elements,
+      [selected],
+      app.state,
+      arrayToMap(elements),
+    );
+
+    expect(visibleGaps.horizontalGaps).toHaveLength(0);
+    expect(visibleGaps.verticalGaps).toHaveLength(0);
+  });
+
+  it("filters center and inner outer point snaplines for the same reference", () => {
+    const angle = 0.68 as Radians;
+    const reference = API.createElement({
+      type: "rectangle",
+      id: "reference",
+      x: 0,
+      y: 0,
+      width: 140,
+      height: 140,
+      angle,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 200,
+      y: 0,
+      width: 140,
+      height: 140,
+      angle,
+    });
+    const elements = [reference, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    primeReferenceSnapPoints(elements, [selected]);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toHaveLength(2);
+  });
+
+  it("keeps a snapline that is redundant for one reference but needed for another", () => {
+    const angle = 0.68 as Radians;
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 200,
+      y: 0,
+      width: 140,
+      height: 140,
+      angle,
+    });
+    const elements = [selected];
+    const elementsMap = arrayToMap(elements);
+    const selectedSnapPoints = getElementsCorners([selected], elementsMap);
+    const outerSnapPoints = selectedSnapPoints.slice(0, -1);
+    const centerSnapPoint = selectedSnapPoints[selectedSnapPoints.length - 1];
+    const innerOuterSnapPoint = [...outerSnapPoints].sort(
+      (a, b) => a[1] - b[1],
+    )[1];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    const referenceSnapPoints: ReferenceSnapPoints = [
+      ...outerSnapPoints.map((point) => ({
+        point: pointFrom<GlobalPoint>(point[0] - 200, point[1]),
+        type: "outer" as const,
+        snapSourceId: "referenceA",
+      })),
+      {
+        point: pointFrom<GlobalPoint>(
+          centerSnapPoint[0] - 200,
+          centerSnapPoint[1],
+        ),
+        type: "center" as const,
+        snapSourceId: "referenceA",
+      },
+      {
+        point: pointFrom<GlobalPoint>(
+          innerOuterSnapPoint[0] - 300,
+          innerOuterSnapPoint[1],
+        ),
+        type: "outer" as const,
+        snapSourceId: "referenceB",
+      },
+    ];
+
+    SnapCache.setReferenceSnapPoints(referenceSnapPoints);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      elementsMap,
+    );
+
+    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toHaveLength(3);
+  });
+
+  it("keeps a center snapline when no outer snaplines imply it", () => {
+    const reference = API.createElement({
+      type: "rectangle",
+      id: "reference",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 200,
+      y: 25,
+      width: 50,
+      height: 50,
+    });
+    const elements = [reference, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    primeReferenceSnapPoints(elements, [selected]);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toEqual([50]);
+  });
+
+  it("filters center snaplines when matching outer offsets differ by rounding precision", () => {
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 2532.227563984471,
+      y: -1553.9657067952232,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const reference = API.createElement({
+      type: "rectangle",
+      id: "reference",
+      x: 2532.2275640966914,
+      y: -1299.4323092037737,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const elements = [reference, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    primeReferenceSnapPoints(elements, [selected]);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getVerticalPointSnapLineCoordinates(snapLines)).toEqual([
+      2532.227564, 2672.329126,
+    ]);
+  });
+
+  it("keeps outer snaplines stable while dragging a snapped element through rounding-equivalent offsets", () => {
+    const referenceMiddle = API.createElement({
+      type: "rectangle",
+      id: "referenceMiddle",
+      x: 2532.22756398447,
+      y: -1553.9657067952237,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const referenceAbove = API.createElement({
+      type: "rectangle",
+      id: "referenceAbove",
+      x: 2532.2275637826165,
+      y: -1779.7363232531268,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 2532.227563096691,
+      y: -1328.1950902037736,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const elements = [referenceAbove, referenceMiddle, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    primeReferenceSnapPoints(elements, [selected]);
+
+    for (const dragOffsetX of [-4, -1, -0.1, 0, 0.1, 1, 4]) {
+      const { snapLines } = snapDraggedElements(
+        elements,
+        { x: dragOffsetX, y: 0 },
+        app,
+        NO_MODIFIER_KEYS,
+        arrayToMap(elements),
+      );
+      const coordinates = getVerticalPointSnapLineCoordinates(snapLines);
+
+      expect(coordinates).toHaveLength(2);
+      expect(coordinates[1] - coordinates[0]).toBeCloseTo(selected.width, 5);
+    }
+  });
+
+  it("keeps same-offset point snaps even across distant references", () => {
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+    });
+    const elements = [selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    SnapCache.setReferenceSnapPoints([
+      {
+        point: pointFrom<GlobalPoint>(220, 50),
+        type: "center",
+        snapSourceId: "near",
+      },
+      {
+        point: pointFrom<GlobalPoint>(900, 50),
+        type: "center",
+        snapSourceId: "far",
+      },
+    ]);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(900);
+  });
+
+  it("prefers a nearby point snap over a slightly better far offset", () => {
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+    });
+    const elements = [selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    SnapCache.setReferenceSnapPoints([
+      {
+        point: pointFrom<GlobalPoint>(220, 54),
+        type: "center",
+        snapSourceId: "near",
+      },
+      {
+        point: pointFrom<GlobalPoint>(900, 50),
+        type: "center",
+        snapSourceId: "far",
+      },
+    ]);
+
+    const { snapOffset, snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(snapOffset.y).toBe(4);
+    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(220);
+  });
+
+  it("keeps same-offset point snaps when references form a continuous cluster", () => {
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100,
+    });
+    const elements = [selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    SnapCache.setReferenceSnapPoints([
+      {
+        point: pointFrom<GlobalPoint>(200, 50),
+        type: "center",
+        snapSourceId: "referenceA",
+      },
+      {
+        point: pointFrom<GlobalPoint>(350, 50),
+        type: "center",
+        snapSourceId: "referenceB",
+      },
+      {
+        point: pointFrom<GlobalPoint>(500, 50),
+        type: "center",
+        snapSourceId: "referenceC",
+      },
+    ]);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(500);
+  });
+
+  it("keeps same-source same-offset point snaps across zoom-scaled cluster breaks", () => {
+    const reference = API.createElement({
+      type: "rectangle",
+      id: "reference",
+      x: 0,
+      y: 0,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 338.608871112217,
+      y: 0,
+      width: 140.1015625,
+      height: 140.1015625,
+    });
+    const elements = [reference, selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+      zoom: { value: 1.5 as NormalizedZoomValue },
+    });
+
+    primeReferenceSnapPoints(elements, [selected]);
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    const range = getHorizontalPointSnapLineXRange(snapLines);
+
+    expect(range).not.toBe(null);
+    expect(range![0]).toBeCloseTo(reference.x, 6);
+    expect(range![1]).toBeCloseTo(selected.x + selected.width, 6);
+  });
+
+  it("renders gap snaplines when rounded bounds touch the reference gap overlap", () => {
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 0,
+      y: 0.0000004,
+      width: 100,
+      height: 100,
+    });
+    const elements = [selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    SnapCache.setVisibleGaps({
+      horizontalGaps: [
+        {
+          startBounds: [200, -100, 300, 0],
+          endBounds: [400, -100, 500, 0],
+          startSide: [pointFrom(300, -100), pointFrom(300, 0)],
+          endSide: [pointFrom(400, -100), pointFrom(400, 0)],
+          overlap: rangeInclusive(-100, 0),
+          length: 100,
+        },
+      ],
+      verticalGaps: [],
+    });
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getHorizontalGapSnapLines(snapLines)).toHaveLength(2);
+  });
+
+  it("renders gap snaplines when the winning gap offset only differs by rounding precision", () => {
+    const selected = API.createElement({
+      type: "rectangle",
+      id: "selected",
+      x: 0,
+      y: 399.999999,
+      width: 100,
+      height: 100,
+    });
+    const elements = [selected];
+    const app = createSnappingApp({
+      selectedElementIds: { [selected.id]: true },
+    });
+
+    SnapCache.setReferenceSnapPoints([
+      {
+        point: pointFrom<GlobalPoint>(0, 399.999999),
+        type: "outer",
+        snapSourceId: "reference",
+      },
+    ]);
+    SnapCache.setVisibleGaps({
+      horizontalGaps: [],
+      verticalGaps: [
+        {
+          startBounds: [0, 100, 100, 200],
+          endBounds: [0, 250, 100, 350],
+          startSide: [pointFrom(0, 200), pointFrom(100, 200)],
+          endSide: [pointFrom(0, 250), pointFrom(100, 250)],
+          overlap: rangeInclusive(0, 100),
+          length: 50,
+        },
+      ],
+    });
+
+    const { snapLines } = snapDraggedElements(
+      elements,
+      { x: 0, y: 0 },
+      app,
+      NO_MODIFIER_KEYS,
+      arrayToMap(elements),
+    );
+
+    expect(getVerticalGapSnapLines(snapLines)).toHaveLength(2);
+  });
+});

packages/excalidraw/tests/tool.test.tsx

@@ -4,12 +4,10 @@ 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 { AppClassProperties, ExcalidrawImperativeAPI } from "../types";
+import type { ExcalidrawImperativeAPI } from "../types";
 
 describe("setActiveTool()", () => {
   const h = window.h;
@@ -68,27 +66,3 @@ 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/wysiwyg/textWysiwyg.test.tsx

@@ -769,63 +769,6 @@ 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

@@ -1,45 +0,0 @@
-{
-  "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

@@ -1,322 +0,0 @@
-// 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

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

packages/tsconfig.base.json

@@ -20,9 +20,7 @@
       "@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/*"]
     }
   }
 }

scripts/buildBase.js

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

scripts/buildPackage.js

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

scripts/buildUtils.js

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

setupTests.ts

@@ -8,13 +8,7 @@ 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 {
+import { testPolyfills } from "./packages/excalidraw/tests/helpers/polyfills";
-  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")>();
@@ -28,6 +22,8 @@ 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,8 +25,6 @@
       "@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,20 +45,6 @@ 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,6 +6572,11 @@ 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"
@@ -8520,11 +8525,6 @@ 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"