points cannot be null

Apply fixed delta only if points.length > 1
2025-08-07 21:39:50 +02:00 · 2025-08-07 21:28:30 +02:00
80 changed files with 1465 additions and 5117 deletions
--- a/excalidraw-app/App.tsx
+++ b/excalidraw-app/App.tsx
@ -20,6 +20,7 @@ import {
  APP_NAME,
  EVENT,
  THEME,
  TITLE_TIMEOUT,
  VERSION_TIMEOUT,
  debounce,
  getVersion,
@ -498,6 +499,11 @@ const ExcalidrawWrapper = () => {
      }
    };
    const titleTimeout = setTimeout(
      () => (document.title = APP_NAME),
      TITLE_TIMEOUT,
    );
    const syncData = debounce(() => {
      if (isTestEnv()) {
        return;
@ -588,6 +594,7 @@ const ExcalidrawWrapper = () => {
        visibilityChange,
        false,
      );
      clearTimeout(titleTimeout);
    };
  }, [isCollabDisabled, collabAPI, excalidrawAPI, setLangCode]);
--- a/excalidraw-app/app_constants.ts
+++ b/excalidraw-app/app_constants.ts
@ -8,8 +8,7 @@ export const SYNC_BROWSER_TABS_TIMEOUT = 50;
 export const CURSOR_SYNC_TIMEOUT = 33; // ~30fps
 export const DELETED_ELEMENT_TIMEOUT = 24 * 60 * 60 * 1000; // 1 day
-// should be aligned with MAX_ALLOWED_FILE_BYTES
+export const FILE_UPLOAD_MAX_BYTES = 3 * 1024 * 1024; // 3 MiB
 export const FILE_UPLOAD_MAX_BYTES = 4 * 1024 * 1024; // 4 MiB
 // 1 year (https://stackoverflow.com/a/25201898/927631)
 export const FILE_CACHE_MAX_AGE_SEC = 31536000;
--- a/excalidraw-app/data/firebase.ts
+++ b/excalidraw-app/data/firebase.ts
@ -259,9 +259,7 @@ export const loadFromFirebase = async (
  }
  const storedScene = docSnap.data() as FirebaseStoredScene;
  const elements = getSyncableElements(
-    restoreElements(await decryptElements(storedScene, roomKey), null, {
+    restoreElements(await decryptElements(storedScene, roomKey), null),
      deleteInvisibleElements: true,
    }),
  );
  if (socket) {
--- a/excalidraw-app/data/index.ts
+++ b/excalidraw-app/data/index.ts
@ -258,16 +258,11 @@ export const loadScene = async (
      await importFromBackend(id, privateKey),
      localDataState?.appState,
      localDataState?.elements,
-      {
+      { repairBindings: true, refreshDimensions: false },
        repairBindings: true,
        refreshDimensions: false,
        deleteInvisibleElements: true,
      },
    );
  } else {
    data = restore(localDataState || null, null, null, {
      repairBindings: true,
      deleteInvisibleElements: true,
    });
  }
--- a/excalidraw-app/index.html
+++ b/excalidraw-app/index.html
@ -2,7 +2,9 @@
 <html lang="en">
  <head>
    <meta charset="utf-8" />
-    <title>Excalidraw Whiteboard</title>
+    <title>
      Free, collaborative whiteboard • Hand-drawn look & feel | Excalidraw
    </title>
    <meta
      name="viewport"
      content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover, shrink-to-fit=no"
--- a/excalidraw-app/tests/MobileMenu.test.tsx
+++ b/excalidraw-app/tests/MobileMenu.test.tsx
@ -36,7 +36,7 @@ describe("Test MobileMenu", () => {
        },
        "isTouchScreen": false,
        "viewport": {
-          "isLandscape": true,
+          "isLandscape": false,
          "isMobile": true,
        },
      }
--- a/packages/common/src/constants.ts
+++ b/packages/common/src/constants.ts
@ -18,20 +18,13 @@ export const isChrome = navigator.userAgent.indexOf("Chrome") !== -1;
 export const isSafari =
  !isChrome && navigator.userAgent.indexOf("Safari") !== -1;
 export const isIOS =
-  /iPad|iPhone/i.test(navigator.platform) ||
+  /iPad|iPhone/.test(navigator.platform) ||
  // iPadOS 13+
  (navigator.userAgent.includes("Mac") && "ontouchend" in document);
 // keeping function so it can be mocked in test
 export const isBrave = () =>
  (navigator as any).brave?.isBrave?.name === "isBrave";
 export const isMobile =
  isIOS ||
  /android|webos|ipod|blackberry|iemobile|opera mini/i.test(
    navigator.userAgent,
  ) ||
  /android|ios|ipod|blackberry|windows phone/i.test(navigator.platform);
 export const supportsResizeObserver =
  typeof window !== "undefined" && "ResizeObserver" in window;
@ -129,7 +122,6 @@ export const CLASSES = {
  ZOOM_ACTIONS: "zoom-actions",
  SEARCH_MENU_INPUT_WRAPPER: "layer-ui__search-inputWrapper",
  CONVERT_ELEMENT_TYPE_POPUP: "ConvertElementTypePopup",
  SHAPE_ACTIONS_THEME_SCOPE: "shape-actions-theme-scope",
 };
 export const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
@ -260,17 +252,13 @@ export const IMAGE_MIME_TYPES = {
  jfif: "image/jfif",
 } as const;
-export const STRING_MIME_TYPES = {
+export const MIME_TYPES = {
  text: "text/plain",
  html: "text/html",
  json: "application/json",
  // excalidraw data
  excalidraw: "application/vnd.excalidraw+json",
  excalidrawlib: "application/vnd.excalidrawlib+json",
 } as const;
 export const MIME_TYPES = {
  ...STRING_MIME_TYPES,
  // image-encoded excalidraw data
  "excalidraw.svg": "image/svg+xml",
  "excalidraw.png": "image/png",
@ -347,17 +335,10 @@ export const DEFAULT_UI_OPTIONS: AppProps["UIOptions"] = {
 // breakpoints
 // -----------------------------------------------------------------------------
-
+// md screen
-// mobile: up to 699px
+export const MQ_MAX_WIDTH_PORTRAIT = 730;
-export const MQ_MAX_MOBILE = 599;
+export const MQ_MAX_WIDTH_LANDSCAPE = 1000;
-
+export const MQ_MAX_HEIGHT_LANDSCAPE = 500;
 // tablets
 export const MQ_MIN_TABLET = MQ_MAX_MOBILE + 1; // lower bound (excludes phones)
 export const MQ_MAX_TABLET = 1400; // upper bound (excludes laptops/desktops)
 // desktop/laptop
 export const MQ_MIN_WIDTH_DESKTOP = 1440;
 // sidebar
 export const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
 // -----------------------------------------------------------------------------
@ -534,5 +515,3 @@ export enum UserIdleState {
 * the start and end points)
 */
 export const LINE_POLYGON_POINT_MERGE_DISTANCE = 20;
 export const DOUBLE_TAP_POSITION_THRESHOLD = 35;
--- a/packages/common/src/utils.ts
+++ b/packages/common/src/utils.ts
@ -21,8 +21,6 @@ import {
  FONT_FAMILY,
  getFontFamilyFallbacks,
  isDarwin,
  isAndroid,
  isIOS,
  WINDOWS_EMOJI_FALLBACK_FONT,
 } from "./constants";
@ -1280,59 +1278,3 @@ export const reduceToCommonValue = <T, R = T>(
  return commonValue;
 };
 export const isMobileOrTablet = (): boolean => {
  const ua = navigator.userAgent || "";
  const platform = navigator.platform || "";
  const uaData = (navigator as any).userAgentData as
    | { mobile?: boolean; platform?: string }
    | undefined;
  // --- 1) chromium: prefer ua client hints -------------------------------
  if (uaData) {
    const plat = (uaData.platform || "").toLowerCase();
    const isDesktopOS =
      plat === "windows" ||
      plat === "macos" ||
      plat === "linux" ||
      plat === "chrome os";
    if (uaData.mobile === true) {
      return true;
    }
    if (uaData.mobile === false && plat === "android") {
      const looksTouchTablet =
        matchMedia?.("(hover: none)").matches &&
        matchMedia?.("(pointer: coarse)").matches;
      return looksTouchTablet;
    }
    if (isDesktopOS) {
      return false;
    }
  }
  // --- 2) ios (includes ipad) --------------------------------------------
  if (isIOS) {
    return true;
  }
  // --- 3) android legacy ua fallback -------------------------------------
  if (isAndroid) {
    const isAndroidPhone = /Mobile/i.test(ua);
    const isAndroidTablet = !isAndroidPhone;
    if (isAndroidPhone || isAndroidTablet) {
      const looksTouchTablet =
        matchMedia?.("(hover: none)").matches &&
        matchMedia?.("(pointer: coarse)").matches;
      return looksTouchTablet;
    }
  }
  // --- 4) last resort desktop exclusion ----------------------------------
  const looksDesktopPlatform =
    /Win|Linux|CrOS|Mac/.test(platform) ||
    /Windows NT|X11|CrOS|Macintosh/.test(ua);
  if (looksDesktopPlatform) {
    return false;
  }
  return false;
 };
--- a/packages/element/src/Scene.ts
+++ b/packages/element/src/Scene.ts
@ -164,14 +164,9 @@ export class Scene {
    return this.frames;
  }
-  constructor(
+  constructor(elements: ElementsMapOrArray | null = null) {
    elements: ElementsMapOrArray | null = null,
    options?: {
      skipValidation?: true;
    },
  ) {
    if (elements) {
-      this.replaceAllElements(elements, options);
+      this.replaceAllElements(elements);
    }
  }
@ -268,19 +263,12 @@ export class Scene {
    return didChange;
  }
-  replaceAllElements(
+  replaceAllElements(nextElements: ElementsMapOrArray) {
    nextElements: ElementsMapOrArray,
    options?: {
      skipValidation?: true;
    },
  ) {
    // we do trust the insertion order on the map, though maybe we shouldn't and should prefer order defined by fractional indices
    const _nextElements = toArray(nextElements);
    const nextFrameLikes: ExcalidrawFrameLikeElement[] = [];
    if (!options?.skipValidation) {
    validateIndicesThrottled(_nextElements);
    }
    this.elements = syncInvalidIndices(_nextElements);
    this.elementsMap.clear();
--- a/packages/element/src/bounds.ts
+++ b/packages/element/src/bounds.ts
@ -1126,9 +1126,7 @@ export interface BoundingBox {
 }
 export const getCommonBoundingBox = (
-  elements:
+  elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[],
    | readonly ExcalidrawElement[]
    | readonly NonDeleted<ExcalidrawElement>[],
 ): BoundingBox => {
  const [minX, minY, maxX, maxY] = getCommonBounds(elements);
  return {
--- a/packages/element/src/delta.ts
+++ b/packages/element/src/delta.ts
@ -2,6 +2,7 @@ import {
  arrayToMap,
  arrayToObject,
  assertNever,
  invariant,
  isDevEnv,
  isShallowEqual,
  isTestEnv,
@ -55,10 +56,10 @@ import { getNonDeletedGroupIds } from "./groups";
 import { orderByFractionalIndex, syncMovedIndices } from "./fractionalIndex";
 import { StoreSnapshot } from "./store";
 import { Scene } from "./Scene";
 import { StoreSnapshot } from "./store";
 import type { BindableProp, BindingProp } from "./binding";
 import type { ElementUpdate } from "./mutateElement";
@ -153,14 +154,10 @@ export class Delta<T> {
  /**
   * Merges two deltas into a new one.
   */
-  public static merge<T>(
+  public static merge<T>(delta1: Delta<T>, delta2: Delta<T>) {
    delta1: Delta<T>,
    delta2: Delta<T>,
    delta3: Delta<T> = Delta.empty(),
  ) {
    return Delta.create(
-      { ...delta1.deleted, ...delta2.deleted, ...delta3.deleted },
+      { ...delta1.deleted, ...delta2.deleted },
-      { ...delta1.inserted, ...delta2.inserted, ...delta3.inserted },
+      { ...delta1.inserted, ...delta2.inserted },
    );
  }
@ -170,7 +167,7 @@ export class Delta<T> {
  public static mergeObjects<T extends { [key: string]: unknown }>(
    prev: T,
    added: T,
-    removed: T = {} as T,
+    removed: T,
  ) {
    const cloned = { ...prev };
@ -524,10 +521,6 @@ export interface DeltaContainer<T> {
 export class AppStateDelta implements DeltaContainer<AppState> {
  private constructor(public delta: Delta<ObservedAppState>) {}
  public static create(delta: Delta<ObservedAppState>): AppStateDelta {
    return new AppStateDelta(delta);
  }
  public static calculate<T extends ObservedAppState>(
    prevAppState: T,
    nextAppState: T,
@ -558,74 +551,7 @@ export class AppStateDelta implements DeltaContainer<AppState> {
  }
  public squash(delta: AppStateDelta): this {
-    if (delta.isEmpty()) {
+    this.delta = Delta.merge(this.delta, delta.delta);
      return this;
    }
    const mergedDeletedSelectedElementIds = Delta.mergeObjects(
      this.delta.deleted.selectedElementIds ?? {},
      delta.delta.deleted.selectedElementIds ?? {},
    );
    const mergedInsertedSelectedElementIds = Delta.mergeObjects(
      this.delta.inserted.selectedElementIds ?? {},
      delta.delta.inserted.selectedElementIds ?? {},
    );
    const mergedDeletedSelectedGroupIds = Delta.mergeObjects(
      this.delta.deleted.selectedGroupIds ?? {},
      delta.delta.deleted.selectedGroupIds ?? {},
    );
    const mergedInsertedSelectedGroupIds = Delta.mergeObjects(
      this.delta.inserted.selectedGroupIds ?? {},
      delta.delta.inserted.selectedGroupIds ?? {},
    );
    const mergedDeletedLockedMultiSelections = Delta.mergeObjects(
      this.delta.deleted.lockedMultiSelections ?? {},
      delta.delta.deleted.lockedMultiSelections ?? {},
    );
    const mergedInsertedLockedMultiSelections = Delta.mergeObjects(
      this.delta.inserted.lockedMultiSelections ?? {},
      delta.delta.inserted.lockedMultiSelections ?? {},
    );
    const mergedInserted: Partial<ObservedAppState> = {};
    const mergedDeleted: Partial<ObservedAppState> = {};
    if (
      Object.keys(mergedDeletedSelectedElementIds).length ||
      Object.keys(mergedInsertedSelectedElementIds).length
    ) {
      mergedDeleted.selectedElementIds = mergedDeletedSelectedElementIds;
      mergedInserted.selectedElementIds = mergedInsertedSelectedElementIds;
    }
    if (
      Object.keys(mergedDeletedSelectedGroupIds).length ||
      Object.keys(mergedInsertedSelectedGroupIds).length
    ) {
      mergedDeleted.selectedGroupIds = mergedDeletedSelectedGroupIds;
      mergedInserted.selectedGroupIds = mergedInsertedSelectedGroupIds;
    }
    if (
      Object.keys(mergedDeletedLockedMultiSelections).length ||
      Object.keys(mergedInsertedLockedMultiSelections).length
    ) {
      mergedDeleted.lockedMultiSelections = mergedDeletedLockedMultiSelections;
      mergedInserted.lockedMultiSelections =
        mergedInsertedLockedMultiSelections;
    }
    this.delta = Delta.merge(
      this.delta,
      delta.delta,
      Delta.create(mergedDeleted, mergedInserted),
    );
    return this;
  }
@ -635,59 +561,70 @@ export class AppStateDelta implements DeltaContainer<AppState> {
  ): [AppState, boolean] {
    try {
      const {
-        selectedElementIds: deletedSelectedElementIds = {},
+        selectedElementIds: removedSelectedElementIds = {},
-        selectedGroupIds: deletedSelectedGroupIds = {},
+        selectedGroupIds: removedSelectedGroupIds = {},
        lockedMultiSelections: deletedLockedMultiSelections = {},
      } = this.delta.deleted;
      const {
-        selectedElementIds: insertedSelectedElementIds = {},
+        selectedElementIds: addedSelectedElementIds = {},
-        selectedGroupIds: insertedSelectedGroupIds = {},
+        selectedGroupIds: addedSelectedGroupIds = {},
-        lockedMultiSelections: insertedLockedMultiSelections = {},
+        selectedLinearElementId,
-        selectedLinearElement: insertedSelectedLinearElement,
+        selectedLinearElementIsEditing,
        ...directlyApplicablePartial
      } = this.delta.inserted;
      const mergedSelectedElementIds = Delta.mergeObjects(
        appState.selectedElementIds,
-        insertedSelectedElementIds,
+        addedSelectedElementIds,
-        deletedSelectedElementIds,
+        removedSelectedElementIds,
      );
      const mergedSelectedGroupIds = Delta.mergeObjects(
        appState.selectedGroupIds,
-        insertedSelectedGroupIds,
+        addedSelectedGroupIds,
-        deletedSelectedGroupIds,
+        removedSelectedGroupIds,
      );
-      const mergedLockedMultiSelections = Delta.mergeObjects(
+      let selectedLinearElement = appState.selectedLinearElement;
        appState.lockedMultiSelections,
        insertedLockedMultiSelections,
        deletedLockedMultiSelections,
      );
-      const selectedLinearElement =
+      if (selectedLinearElementId === null) {
-        insertedSelectedLinearElement &&
+        // Unselect linear element (visible change)
-        nextElements.has(insertedSelectedLinearElement.elementId)
+        selectedLinearElement = null;
-          ? new LinearElementEditor(
+      } else if (
        selectedLinearElementId &&
        nextElements.has(selectedLinearElementId)
      ) {
        selectedLinearElement = new LinearElementEditor(
          nextElements.get(
-                insertedSelectedLinearElement.elementId,
+            selectedLinearElementId,
          ) as NonDeleted<ExcalidrawLinearElement>,
          nextElements,
-              insertedSelectedLinearElement.isEditing,
+          selectedLinearElementIsEditing === true, // Can be unknown which is defaulted to false
-            )
+        );
-          : null;
+      }
      if (
        // Value being 'null' is equivaluent to unknown in this case because it only gets set
        // to null when 'selectedLinearElementId' is set to null
        selectedLinearElementIsEditing != null
      ) {
        invariant(
          selectedLinearElement,
          `selectedLinearElement is null when selectedLinearElementIsEditing is set to ${selectedLinearElementIsEditing}`,
        );
        selectedLinearElement = {
          ...selectedLinearElement,
          isEditing: selectedLinearElementIsEditing,
        };
      }
      const nextAppState = {
        ...appState,
        ...directlyApplicablePartial,
        selectedElementIds: mergedSelectedElementIds,
        selectedGroupIds: mergedSelectedGroupIds,
-        lockedMultiSelections: mergedLockedMultiSelections,
+        selectedLinearElement,
        selectedLinearElement:
          typeof insertedSelectedLinearElement !== "undefined"
            ? selectedLinearElement
            : appState.selectedLinearElement,
      };
      const constainsVisibleChanges = this.filterInvisibleChanges(
@ -816,48 +753,58 @@ export class AppStateDelta implements DeltaContainer<AppState> {
            }
            break;
-          case "selectedLinearElement":
+          case "selectedLinearElementId": {
-            const nextLinearElement = nextAppState[key];
+            const appStateKey = AppStateDelta.convertToAppStateKey(key);
            const linearElement = nextAppState[appStateKey];
-            if (!nextLinearElement) {
+            if (!linearElement) {
              // previously there was a linear element (assuming visible), now there is none
              visibleDifferenceFlag.value = true;
            } else {
-              const element = nextElements.get(nextLinearElement.elementId);
+              const element = nextElements.get(linearElement.elementId);
              if (element && !element.isDeleted) {
                // previously there wasn't a linear element, now there is one which is visible
                visibleDifferenceFlag.value = true;
              } else {
                // there was assigned a linear element now, but it's deleted
-                nextAppState[key] = null;
+                nextAppState[appStateKey] = null;
              }
            }
            break;
-          case "lockedMultiSelections":
+          }
          case "selectedLinearElementIsEditing": {
            // Changes in editing state are always visible
            const prevIsEditing =
              prevAppState.selectedLinearElement?.isEditing ?? false;
            const nextIsEditing =
              nextAppState.selectedLinearElement?.isEditing ?? false;
            if (prevIsEditing !== nextIsEditing) {
              visibleDifferenceFlag.value = true;
            }
            break;
          }
          case "lockedMultiSelections": {
            const prevLockedUnits = prevAppState[key] || {};
            const nextLockedUnits = nextAppState[key] || {};
            // TODO: this seems wrong, we are already doing this comparison generically above,
            // hence instead we should check whether elements are actually visible,
            // so that once these changes are applied they actually result in a visible change to the user
            if (!isShallowEqual(prevLockedUnits, nextLockedUnits)) {
              visibleDifferenceFlag.value = true;
            }
            break;
-          case "activeLockedId":
+          }
          case "activeLockedId": {
            const prevHitLockedId = prevAppState[key] || null;
            const nextHitLockedId = nextAppState[key] || null;
            // TODO: this seems wrong, we are already doing this comparison generically above,
            // hence instead we should check whether elements are actually visible,
            // so that once these changes are applied they actually result in a visible change to the user
            if (prevHitLockedId !== nextHitLockedId) {
              visibleDifferenceFlag.value = true;
            }
            break;
-          default:
+          }
          default: {
            assertNever(
              key,
              `Unknown ObservedElementsAppState's key "${key}"`,
@ -866,10 +813,20 @@ export class AppStateDelta implements DeltaContainer<AppState> {
          }
        }
      }
    }
    return visibleDifferenceFlag.value;
  }
  private static convertToAppStateKey(
    key: keyof Pick<ObservedElementsAppState, "selectedLinearElementId">,
  ): keyof Pick<AppState, "selectedLinearElement"> {
    switch (key) {
      case "selectedLinearElementId":
        return "selectedLinearElement";
    }
  }
  private static filterSelectedElements(
    selectedElementIds: AppState["selectedElementIds"],
    elements: SceneElementsMap,
@ -934,7 +891,8 @@ export class AppStateDelta implements DeltaContainer<AppState> {
      editingGroupId,
      selectedGroupIds,
      selectedElementIds,
-      selectedLinearElement,
+      selectedLinearElementId,
      selectedLinearElementIsEditing,
      croppingElementId,
      lockedMultiSelections,
      activeLockedId,
@ -988,6 +946,12 @@ export class AppStateDelta implements DeltaContainer<AppState> {
        "lockedMultiSelections",
        (prevValue) => (prevValue ?? {}) as ValueOf<T["lockedMultiSelections"]>,
      );
      Delta.diffObjects(
        deleted,
        inserted,
        "activeLockedId",
        (prevValue) => (prevValue ?? null) as ValueOf<T["activeLockedId"]>,
      );
    } catch (e) {
      // if postprocessing fails it does not make sense to bubble up, but let's make sure we know about it
      console.error(`Couldn't postprocess appstate change deltas.`);
@ -1016,13 +980,12 @@ type ElementPartial<TElement extends ExcalidrawElement = ExcalidrawElement> =
  Omit<Partial<Ordered<TElement>>, "id" | "updated" | "seed">;
 export type ApplyToOptions = {
-  excludedProperties?: Set<keyof ElementPartial>;
+  excludedProperties: Set<keyof ElementPartial>;
 };
 type ApplyToFlags = {
  containsVisibleDifference: boolean;
  containsZindexDifference: boolean;
  applyDirection: "forward" | "backward" | undefined;
 };
 /**
@ -1111,27 +1074,18 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    inserted,
  }: Delta<ElementPartial>) =>
    !!(
      deleted.version &&
      inserted.version &&
      // versions are required integers
      (
      Number.isInteger(deleted.version) &&
      Number.isInteger(inserted.version) &&
      // versions should be positive, zero included
-        deleted.version! >= 0 &&
+      deleted.version >= 0 &&
-        inserted.version! >= 0 &&
+      inserted.version >= 0 &&
      // versions should never be the same
      deleted.version !== inserted.version
      )
    );
  private static satisfiesUniqueInvariants = (
    elementsDelta: ElementsDelta,
    id: string,
  ) => {
    const { added, removed, updated } = elementsDelta;
    // it's required that there is only one unique delta type per element
    return [added[id], removed[id], updated[id]].filter(Boolean).length === 1;
  };
  private static validate(
    elementsDelta: ElementsDelta,
    type: "added" | "removed" | "updated",
@ -1140,7 +1094,6 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    for (const [id, delta] of Object.entries(elementsDelta[type])) {
      if (
        !this.satisfiesCommmonInvariants(delta) ||
        !this.satisfiesUniqueInvariants(elementsDelta, id) ||
        !satifiesSpecialInvariants(delta)
      ) {
        console.error(
@ -1177,7 +1130,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
      const nextElement = nextElements.get(prevElement.id);
      if (!nextElement) {
-        const deleted = { ...prevElement } as ElementPartial;
+        const deleted = { ...prevElement, isDeleted: false } as ElementPartial;
        const inserted = {
          isDeleted: true,
@ -1191,11 +1144,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
          ElementsDelta.stripIrrelevantProps,
        );
        if (!prevElement.isDeleted) {
        removed[prevElement.id] = delta;
        } else {
          updated[prevElement.id] = delta;
        }
      }
    }
@ -1211,6 +1160,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        const inserted = {
          ...nextElement,
          isDeleted: false,
        } as ElementPartial;
        const delta = Delta.create(
@ -1219,12 +1169,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
          ElementsDelta.stripIrrelevantProps,
        );
        // ignore updates which would "delete" already deleted element
        if (!nextElement.isDeleted) {
        added[nextElement.id] = delta;
        } else {
          updated[nextElement.id] = delta;
        }
        continue;
      }
@ -1253,9 +1198,12 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
          continue;
        }
        // making sure there are at least some changes
        if (!Delta.isEmpty(delta)) {
          updated[nextElement.id] = delta;
        }
      }
    }
    return ElementsDelta.create(added, removed, updated);
  }
@ -1388,7 +1336,9 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  public applyTo(
    elements: SceneElementsMap,
    snapshot: StoreSnapshot["elements"] = StoreSnapshot.empty().elements,
-    options?: ApplyToOptions,
+    options: ApplyToOptions = {
      excludedProperties: new Set(),
    },
  ): [SceneElementsMap, boolean] {
    let nextElements = new Map(elements) as SceneElementsMap;
    let changedElements: Map<string, OrderedExcalidrawElement>;
@ -1396,28 +1346,22 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    const flags: ApplyToFlags = {
      containsVisibleDifference: false,
      containsZindexDifference: false,
      applyDirection: undefined,
    };
    // mimic a transaction by applying deltas into `nextElements` (always new instance, no mutation)
    try {
      const applyDeltas = ElementsDelta.createApplier(
        elements,
        nextElements,
        snapshot,
        flags,
        options,
        flags,
      );
      const addedElements = applyDeltas(this.added);
      const removedElements = applyDeltas(this.removed);
      const updatedElements = applyDeltas(this.updated);
-      const affectedElements = this.resolveConflicts(
+      const affectedElements = this.resolveConflicts(elements, nextElements);
        elements,
        nextElements,
        flags.applyDirection,
      );
      // TODO: #7348 validate elements semantically and syntactically the changed elements, in case they would result data integrity issues
      changedElements = new Map([
@ -1441,15 +1385,22 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    }
    try {
-      // the following reorder performs mutations, but only on new instances of changed elements,
+      // the following reorder performs also mutations, but only on new instances of changed elements
-      // unless something goes really bad and it fallbacks to fixing all invalid indices
+      // (unless something goes really bad and it fallbacks to fixing all invalid indices)
      nextElements = ElementsDelta.reorderElements(
        nextElements,
        changedElements,
        flags,
      );
-      ElementsDelta.redrawElements(nextElements, changedElements);
+      // we don't have an up-to-date scene, as we can be just in the middle of applying history entry
      // we also don't have a scene on the server
      // so we are creating a temp scene just to query and mutate elements
      const tempScene = new Scene(nextElements);
      ElementsDelta.redrawTextBoundingBoxes(tempScene, changedElements);
      // Need ordered nextElements to avoid z-index binding issues
      ElementsDelta.redrawBoundArrows(tempScene, changedElements);
    } catch (e) {
      console.error(
        `Couldn't mutate elements after applying elements change`,
@ -1465,112 +1416,47 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  }
  public squash(delta: ElementsDelta): this {
    if (delta.isEmpty()) {
      return this;
    }
    const { added, removed, updated } = delta;
    const mergeBoundElements = (
      prevDelta: Delta<ElementPartial>,
      nextDelta: Delta<ElementPartial>,
    ) => {
      const mergedDeletedBoundElements =
        Delta.mergeArrays(
          prevDelta.deleted.boundElements ?? [],
          nextDelta.deleted.boundElements ?? [],
          undefined,
          (x) => x.id,
        ) ?? [];
      const mergedInsertedBoundElements =
        Delta.mergeArrays(
          prevDelta.inserted.boundElements ?? [],
          nextDelta.inserted.boundElements ?? [],
          undefined,
          (x) => x.id,
        ) ?? [];
      if (
        !mergedDeletedBoundElements.length &&
        !mergedInsertedBoundElements.length
      ) {
        return;
      }
      return Delta.create(
        {
          boundElements: mergedDeletedBoundElements,
        },
        {
          boundElements: mergedInsertedBoundElements,
        },
      );
    };
    for (const [id, nextDelta] of Object.entries(added)) {
-      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
+      const prevDelta = this.added[id];
      if (!prevDelta) {
        this.added[id] = nextDelta;
      } else {
-        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        this.added[id] = Delta.merge(prevDelta, nextDelta);
        delete this.removed[id];
        delete this.updated[id];
        this.added[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
      }
    }
    for (const [id, nextDelta] of Object.entries(removed)) {
-      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
+      const prevDelta = this.removed[id];
      if (!prevDelta) {
        this.removed[id] = nextDelta;
      } else {
-        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        this.removed[id] = Delta.merge(prevDelta, nextDelta);
        delete this.added[id];
        delete this.updated[id];
        this.removed[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
      }
    }
    for (const [id, nextDelta] of Object.entries(updated)) {
-      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
+      const prevDelta = this.updated[id];
      if (!prevDelta) {
        this.updated[id] = nextDelta;
      } else {
-        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        this.updated[id] = Delta.merge(prevDelta, nextDelta);
        const updatedDelta = Delta.merge(prevDelta, nextDelta, mergedDelta);
        if (prevDelta === this.added[id]) {
          this.added[id] = updatedDelta;
        } else if (prevDelta === this.removed[id]) {
          this.removed[id] = updatedDelta;
        } else {
          this.updated[id] = updatedDelta;
      }
    }
    }
    if (isTestEnv() || isDevEnv()) {
      ElementsDelta.validate(this, "added", ElementsDelta.satisfiesAddition);
      ElementsDelta.validate(this, "removed", ElementsDelta.satisfiesRemoval);
      ElementsDelta.validate(this, "updated", ElementsDelta.satisfiesUpdate);
    }
    return this;
  }
  private static createApplier =
    (
      prevElements: SceneElementsMap,
      nextElements: SceneElementsMap,
      snapshot: StoreSnapshot["elements"],
      options: ApplyToOptions,
      flags: ApplyToFlags,
      options?: ApplyToOptions,
    ) =>
    (deltas: Record<string, Delta<ElementPartial>>) => {
      const getElement = ElementsDelta.createGetter(
@ -1583,26 +1469,15 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        const element = getElement(id, delta.inserted);
        if (element) {
-          const nextElement = ElementsDelta.applyDelta(
+          const newElement = ElementsDelta.applyDelta(
            element,
            delta,
            flags,
            options,
            flags,
          );
-          nextElements.set(nextElement.id, nextElement);
+          nextElements.set(newElement.id, newElement);
-          acc.set(nextElement.id, nextElement);
+          acc.set(newElement.id, newElement);
          if (!flags.applyDirection) {
            const prevElement = prevElements.get(id);
            if (prevElement) {
              flags.applyDirection =
                prevElement.version > nextElement.version
                  ? "backward"
                  : "forward";
            }
          }
        }
        return acc;
@ -1647,8 +1522,8 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  private static applyDelta(
    element: OrderedExcalidrawElement,
    delta: Delta<ElementPartial>,
    options: ApplyToOptions,
    flags: ApplyToFlags,
    options?: ApplyToOptions,
  ) {
    const directlyApplicablePartial: Mutable<ElementPartial> = {};
@ -1662,7 +1537,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        continue;
      }
-      if (options?.excludedProperties?.has(key)) {
+      if (options.excludedProperties.has(key)) {
        continue;
      }
@ -1702,7 +1577,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        delta.deleted.index !== delta.inserted.index;
    }
-    return newElementWith(element, directlyApplicablePartial, true);
+    return newElementWith(element, directlyApplicablePartial);
  }
  /**
@ -1742,7 +1617,6 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  private resolveConflicts(
    prevElements: SceneElementsMap,
    nextElements: SceneElementsMap,
    applyDirection: "forward" | "backward" = "forward",
  ) {
    const nextAffectedElements = new Map<string, OrderedExcalidrawElement>();
    const updater = (
@ -1754,36 +1628,21 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        return;
      }
      const prevElement = prevElements.get(element.id);
      const nextVersion =
        applyDirection === "forward"
          ? nextElement.version + 1
          : nextElement.version - 1;
      const elementUpdates = updates as ElementUpdate<OrderedExcalidrawElement>;
      let affectedElement: OrderedExcalidrawElement;
-      if (prevElement === nextElement) {
+      if (prevElements.get(element.id) === nextElement) {
        // create the new element instance in case we didn't modify the element yet
        // so that we won't end up in an incosistent state in case we would fail in the middle of mutations
        affectedElement = newElementWith(
          nextElement,
-          {
+          updates as ElementUpdate<OrderedExcalidrawElement>,
            ...elementUpdates,
            version: nextVersion,
          },
          true,
        );
      } else {
-        affectedElement = mutateElement(nextElement, nextElements, {
+        affectedElement = mutateElement(
-          ...elementUpdates,
+          nextElement,
-          // don't modify the version further, if it's already different
+          nextElements,
-          version:
+          updates as ElementUpdate<OrderedExcalidrawElement>,
-            prevElement?.version !== nextElement.version
+        );
              ? nextElement.version
              : nextVersion,
        });
      }
      nextAffectedElements.set(affectedElement.id, affectedElement);
@ -1888,31 +1747,6 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    BindableElement.rebindAffected(nextElements, nextElement(), updater);
  }
  public static redrawElements(
    nextElements: SceneElementsMap,
    changedElements: Map<string, OrderedExcalidrawElement>,
  ) {
    try {
      // we don't have an up-to-date scene, as we can be just in the middle of applying history entry
      // we also don't have a scene on the server
      // so we are creating a temp scene just to query and mutate elements
      const tempScene = new Scene(nextElements, { skipValidation: true });
      ElementsDelta.redrawTextBoundingBoxes(tempScene, changedElements);
      // needs ordered nextElements to avoid z-index binding issues
      ElementsDelta.redrawBoundArrows(tempScene, changedElements);
    } catch (e) {
      console.error(`Couldn't redraw elements`, e);
      if (isTestEnv() || isDevEnv()) {
        throw e;
      }
    } finally {
      return nextElements;
    }
  }
  private static redrawTextBoundingBoxes(
    scene: Scene,
    changed: Map<string, OrderedExcalidrawElement>,
@ -1967,7 +1801,6 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  ) {
    for (const element of changed.values()) {
      if (!element.isDeleted && isBindableElement(element)) {
        // TODO: with precise bindings this is quite expensive, so consider optimisation so it's only triggered when the arrow does not intersect (imprecise) element bounds
        updateBoundElements(element, scene, {
          changedElements: changed,
        });
--- a/packages/element/src/elbowArrow.ts
+++ b/packages/element/src/elbowArrow.ts
@ -359,12 +359,6 @@ const handleSegmentRelease = (
    null,
  );
  if (!restoredPoints || restoredPoints.length < 2) {
    throw new Error(
      "Property 'points' is required in the update returned by normalizeArrowElementUpdate()",
    );
  }
  const nextPoints: GlobalPoint[] = [];
  // First part of the arrow are the old points
@ -712,7 +706,7 @@ const handleEndpointDrag = (
  endGlobalPoint: GlobalPoint,
  hoveredStartElement: ExcalidrawBindableElement | null,
  hoveredEndElement: ExcalidrawBindableElement | null,
-): ElementUpdate<ExcalidrawElbowArrowElement> => {
+) => {
  let startIsSpecial = arrow.startIsSpecial ?? null;
  let endIsSpecial = arrow.endIsSpecial ?? null;
  const globalUpdatedPoints = updatedPoints.map((p, i) =>
@ -747,15 +741,8 @@ const handleEndpointDrag = (
  // Calculate the moving second point connection and add the start point
  {
-    const secondPoint = globalUpdatedPoints.at(startIsSpecial ? 2 : 1);
+    const secondPoint = globalUpdatedPoints[startIsSpecial ? 2 : 1];
-    const thirdPoint = globalUpdatedPoints.at(startIsSpecial ? 3 : 2);
+    const thirdPoint = globalUpdatedPoints[startIsSpecial ? 3 : 2];
    if (!secondPoint || !thirdPoint) {
      throw new Error(
        `Second and third points must exist when handling endpoint drag (${startIsSpecial})`,
      );
    }
    const startIsHorizontal = headingIsHorizontal(startHeading);
    const secondIsHorizontal = headingIsHorizontal(
      vectorToHeading(vectorFromPoint(secondPoint, thirdPoint)),
@ -814,19 +801,10 @@ const handleEndpointDrag = (
  // Calculate the moving second to last point connection
  {
-    const secondToLastPoint = globalUpdatedPoints.at(
+    const secondToLastPoint =
-      globalUpdatedPoints.length - (endIsSpecial ? 3 : 2),
+      globalUpdatedPoints[globalUpdatedPoints.length - (endIsSpecial ? 3 : 2)];
-    );
+    const thirdToLastPoint =
-    const thirdToLastPoint = globalUpdatedPoints.at(
+      globalUpdatedPoints[globalUpdatedPoints.length - (endIsSpecial ? 4 : 3)];
      globalUpdatedPoints.length - (endIsSpecial ? 4 : 3),
    );
    if (!secondToLastPoint || !thirdToLastPoint) {
      throw new Error(
        `Second and third to last points must exist when handling endpoint drag (${endIsSpecial})`,
      );
    }
    const endIsHorizontal = headingIsHorizontal(endHeading);
    const secondIsHorizontal = headingForPointIsHorizontal(
      thirdToLastPoint,
@ -2093,7 +2071,16 @@ const normalizeArrowElementUpdate = (
  nextFixedSegments: readonly FixedSegment[] | null,
  startIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"],
  endIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"],
-): ElementUpdate<ExcalidrawElbowArrowElement> => {
+): {
  points: LocalPoint[];
  x: number;
  y: number;
  width: number;
  height: number;
  fixedSegments: readonly FixedSegment[] | null;
  startIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"];
  endIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"];
 } => {
  const offsetX = global[0][0];
  const offsetY = global[0][1];
  let points = global.map((p) =>
--- a/packages/element/src/index.ts
+++ b/packages/element/src/index.ts
@ -97,7 +97,6 @@ export * from "./image";
 export * from "./linearElementEditor";
 export * from "./mutateElement";
 export * from "./newElement";
 export * from "./positionElementsOnGrid";
 export * from "./renderElement";
 export * from "./resizeElements";
 export * from "./resizeTest";
--- a/packages/element/src/positionElementsOnGrid.ts
+++ b/packages/element/src/positionElementsOnGrid.ts
@ -1,112 +0,0 @@
 import { getCommonBounds } from "./bounds";
 import { type ElementUpdate, newElementWith } from "./mutateElement";
 import type { ExcalidrawElement } from "./types";
 // TODO rewrite (mostly vibe-coded)
 export const positionElementsOnGrid = <TElement extends ExcalidrawElement>(
  elements: TElement[] | TElement[][],
  centerX: number,
  centerY: number,
  padding = 50,
 ): TElement[] => {
  // Ensure there are elements to position
  if (!elements || elements.length === 0) {
    return [];
  }
  const res: TElement[] = [];
  // Normalize input to work with atomic units (groups of elements)
  // If elements is a flat array, treat each element as its own atomic unit
  const atomicUnits: TElement[][] = Array.isArray(elements[0])
    ? (elements as TElement[][])
    : (elements as TElement[]).map((element) => [element]);
  // Determine the number of columns for atomic units
  // A common approach for a "grid-like" layout without specific column constraints
  // is to aim for a roughly square arrangement.
  const numUnits = atomicUnits.length;
  const numColumns = Math.max(1, Math.ceil(Math.sqrt(numUnits)));
  // Group atomic units into rows based on the calculated number of columns
  const rows: TElement[][][] = [];
  for (let i = 0; i < numUnits; i += numColumns) {
    rows.push(atomicUnits.slice(i, i + numColumns));
  }
  // Calculate properties for each row (total width, max height)
  // and the total actual height of all row content.
  let totalGridActualHeight = 0; // Sum of max heights of rows, without inter-row padding
  const rowProperties = rows.map((rowUnits) => {
    let rowWidth = 0;
    let maxUnitHeightInRow = 0;
    const unitBounds = rowUnits.map((unit) => {
      const [minX, minY, maxX, maxY] = getCommonBounds(unit);
      return {
        elements: unit,
        bounds: [minX, minY, maxX, maxY] as const,
        width: maxX - minX,
        height: maxY - minY,
      };
    });
    unitBounds.forEach((unitBound, index) => {
      rowWidth += unitBound.width;
      // Add padding between units in the same row, but not after the last one
      if (index < unitBounds.length - 1) {
        rowWidth += padding;
      }
      if (unitBound.height > maxUnitHeightInRow) {
        maxUnitHeightInRow = unitBound.height;
      }
    });
    totalGridActualHeight += maxUnitHeightInRow;
    return {
      unitBounds,
      width: rowWidth,
      maxHeight: maxUnitHeightInRow,
    };
  });
  // Calculate the total height of the grid including padding between rows
  const totalGridHeightWithPadding =
    totalGridActualHeight + Math.max(0, rows.length - 1) * padding;
  // Calculate the starting Y position to center the entire grid vertically around centerY
  let currentY = centerY - totalGridHeightWithPadding / 2;
  // Position atomic units row by row
  rowProperties.forEach((rowProp) => {
    const { unitBounds, width: rowWidth, maxHeight: rowMaxHeight } = rowProp;
    // Calculate the starting X for the current row to center it horizontally around centerX
    let currentX = centerX - rowWidth / 2;
    unitBounds.forEach((unitBound) => {
      // Calculate the offset needed to position this atomic unit
      const [originalMinX, originalMinY] = unitBound.bounds;
      const offsetX = currentX - originalMinX;
      const offsetY = currentY - originalMinY;
      // Apply the offset to all elements in this atomic unit
      unitBound.elements.forEach((element) => {
        res.push(
          newElementWith(element, {
            x: element.x + offsetX,
            y: element.y + offsetY,
          } as ElementUpdate<TElement>),
        );
      });
      // Move X for the next unit in the row
      currentX += unitBound.width + padding;
    });
    // Move Y to the starting position for the next row
    // This accounts for the tallest unit in the current row and the inter-row padding
    currentY += rowMaxHeight + padding;
  });
  return res;
 };
--- a/packages/element/src/renderElement.ts
+++ b/packages/element/src/renderElement.ts
@ -1,14 +1,7 @@
 import rough from "roughjs/bin/rough";
 import { getStroke } from "perfect-freehand";
-import {
+import { isRightAngleRads } from "@excalidraw/math";
  type GlobalPoint,
  isRightAngleRads,
  lineSegment,
  pointFrom,
  pointRotateRads,
  type Radians,
 } from "@excalidraw/math";
 import {
  BOUND_TEXT_PADDING,
@ -21,7 +14,6 @@ import {
  getFontString,
  isRTL,
  getVerticalOffset,
  invariant,
 } from "@excalidraw/common";
 import type {
@ -40,7 +32,7 @@ import type {
  InteractiveCanvasRenderConfig,
 } from "@excalidraw/excalidraw/scene/types";
-import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
+import { getElementAbsoluteCoords } from "./bounds";
 import { getUncroppedImageElement } from "./cropElement";
 import { LinearElementEditor } from "./linearElementEditor";
 import {
@ -1047,66 +1039,6 @@ export function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement) {
 }
 export function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement) {
  return getSvgPathFromStroke(getFreedrawOutlinePoints(element));
 }
 export function getFreedrawOutlineAsSegments(
  element: ExcalidrawFreeDrawElement,
  points: [number, number][],
  elementsMap: ElementsMap,
 ) {
  const bounds = getElementBounds(
    {
      ...element,
      angle: 0 as Radians,
    },
    elementsMap,
  );
  const center = pointFrom<GlobalPoint>(
    (bounds[0] + bounds[2]) / 2,
    (bounds[1] + bounds[3]) / 2,
  );
  invariant(points.length >= 2, "Freepath outline must have at least 2 points");
  return points.slice(2).reduce(
    (acc, curr) => {
      acc.push(
        lineSegment<GlobalPoint>(
          acc[acc.length - 1][1],
          pointRotateRads(
            pointFrom<GlobalPoint>(curr[0] + element.x, curr[1] + element.y),
            center,
            element.angle,
          ),
        ),
      );
      return acc;
    },
    [
      lineSegment<GlobalPoint>(
        pointRotateRads(
          pointFrom<GlobalPoint>(
            points[0][0] + element.x,
            points[0][1] + element.y,
          ),
          center,
          element.angle,
        ),
        pointRotateRads(
          pointFrom<GlobalPoint>(
            points[1][0] + element.x,
            points[1][1] + element.y,
          ),
          center,
          element.angle,
        ),
      ),
    ],
  );
 }
 export function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement) {
  // If input points are empty (should they ever be?) return a dot
  const inputPoints = element.simulatePressure
    ? element.points
@ -1125,7 +1057,7 @@ export function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement) {
    last: !!element.lastCommittedPoint, // LastCommittedPoint is added on pointerup
  };
-  return getStroke(inputPoints as number[][], options) as [number, number][];
+  return getSvgPathFromStroke(getStroke(inputPoints as number[][], options));
 }
 function med(A: number[], B: number[]) {
--- a/packages/element/src/resizeElements.ts
+++ b/packages/element/src/resizeElements.ts
@ -35,7 +35,6 @@ import {
  getContainerElement,
  handleBindTextResize,
  getBoundTextMaxWidth,
  computeBoundTextPosition,
 } from "./textElement";
 import {
  getMinTextElementWidth,
@ -226,16 +225,7 @@ const rotateSingleElement = (
      scene.getElement<ExcalidrawTextElementWithContainer>(boundTextElementId);
    if (textElement && !isArrowElement(element)) {
-      const { x, y } = computeBoundTextPosition(
+      scene.mutateElement(textElement, { angle });
        element,
        textElement,
        scene.getNonDeletedElementsMap(),
      );
      scene.mutateElement(textElement, {
        angle,
        x,
        y,
      });
    }
  }
 };
@ -426,15 +416,9 @@ const rotateMultipleElements = (
      const boundText = getBoundTextElement(element, elementsMap);
      if (boundText && !isArrowElement(element)) {
        const { x, y } = computeBoundTextPosition(
          element,
          boundText,
          elementsMap,
        );
        scene.mutateElement(boundText, {
-          x,
+          x: boundText.x + (rotatedCX - cx),
-          y,
+          y: boundText.y + (rotatedCY - cy),
          angle: normalizeRadians((centerAngle + origAngle) as Radians),
        });
      }
--- a/packages/element/src/store.ts
+++ b/packages/element/src/store.ts
@ -552,26 +552,10 @@ export class StoreDelta {
  public static load({
    id,
    elements: { added, removed, updated },
    appState: { delta: appStateDelta },
  }: DTO<StoreDelta>) {
    const elements = ElementsDelta.create(added, removed, updated);
    const appState = AppStateDelta.create(appStateDelta);
-    return new this(id, elements, appState);
+    return new this(id, elements, AppStateDelta.empty());
  }
  /**
   * Squash the passed deltas into the aggregated delta instance.
   */
  public static squash(...deltas: StoreDelta[]) {
    const aggregatedDelta = StoreDelta.empty();
    for (const delta of deltas) {
      aggregatedDelta.elements.squash(delta.elements);
      aggregatedDelta.appState.squash(delta.appState);
    }
    return aggregatedDelta;
  }
  /**
@ -588,7 +572,9 @@ export class StoreDelta {
    delta: StoreDelta,
    elements: SceneElementsMap,
    appState: AppState,
-    options?: ApplyToOptions,
+    options: ApplyToOptions = {
      excludedProperties: new Set(),
    },
  ): [SceneElementsMap, AppState, boolean] {
    const [nextElements, elementsContainVisibleChange] = delta.elements.applyTo(
      elements,
@ -627,10 +613,6 @@ export class StoreDelta {
    );
  }
  public static empty() {
    return StoreDelta.create(ElementsDelta.empty(), AppStateDelta.empty());
  }
  public isEmpty() {
    return this.elements.isEmpty() && this.appState.isEmpty();
  }
@ -996,7 +978,8 @@ const getDefaultObservedAppState = (): ObservedAppState => {
    viewBackgroundColor: COLOR_PALETTE.white,
    selectedElementIds: {},
    selectedGroupIds: {},
-    selectedLinearElement: null,
+    selectedLinearElementId: null,
    selectedLinearElementIsEditing: null,
    croppingElementId: null,
    activeLockedId: null,
    lockedMultiSelections: {},
@ -1015,12 +998,14 @@ export const getObservedAppState = (
    croppingElementId: appState.croppingElementId,
    activeLockedId: appState.activeLockedId,
    lockedMultiSelections: appState.lockedMultiSelections,
-    selectedLinearElement: appState.selectedLinearElement
+    selectedLinearElementId:
-      ? {
+      (appState as AppState).selectedLinearElement?.elementId ??
-          elementId: appState.selectedLinearElement.elementId,
+      (appState as ObservedAppState).selectedLinearElementId ??
-          isEditing: !!appState.selectedLinearElement.isEditing,
+      null,
-        }
+    selectedLinearElementIsEditing:
-      : null,
+      (appState as AppState).selectedLinearElement?.isEditing ??
      (appState as ObservedAppState).selectedLinearElementIsEditing ??
      null,
  };
  Reflect.defineProperty(observedAppState, hiddenObservedAppStateProp, {
--- a/packages/element/src/textElement.ts
+++ b/packages/element/src/textElement.ts
@ -10,12 +10,12 @@ import {
  invariant,
 } from "@excalidraw/common";
 import { pointFrom, pointRotateRads, type Radians } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExtractSetType } from "@excalidraw/common/utility-types";
 import type { Radians } from "@excalidraw/math";
 import {
  resetOriginalContainerCache,
  updateOriginalContainerCache,
@ -254,26 +254,6 @@ export const computeBoundTextPosition = (
    x =
      containerCoords.x + (maxContainerWidth / 2 - boundTextElement.width / 2);
  }
  const angle = (container.angle ?? 0) as Radians;
  if (angle !== 0) {
    const contentCenter = pointFrom(
      containerCoords.x + maxContainerWidth / 2,
      containerCoords.y + maxContainerHeight / 2,
    );
    const textCenter = pointFrom(
      x + boundTextElement.width / 2,
      y + boundTextElement.height / 2,
    );
    const [rx, ry] = pointRotateRads(textCenter, contentCenter, angle);
    return {
      x: rx - boundTextElement.width / 2,
      y: ry - boundTextElement.height / 2,
    };
  }
  return { x, y };
 };
--- a/packages/element/tests/delta.test.tsx
+++ b/packages/element/tests/delta.test.tsx
@ -1,345 +1,13 @@
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 import type { ObservedAppState } from "@excalidraw/excalidraw/types";
 import type { LinearElementEditor } from "@excalidraw/element";
 import type { SceneElementsMap } from "@excalidraw/element/types";
-import { AppStateDelta, Delta, ElementsDelta } from "../src/delta";
+import { AppStateDelta } from "../src/delta";
 describe("ElementsDelta", () => {
  describe("elements delta calculation", () => {
    it("should not throw when element gets removed but was already deleted", () => {
      const element = API.createElement({
        type: "rectangle",
        x: 100,
        y: 100,
        isDeleted: true,
      });
      const prevElements = new Map([[element.id, element]]);
      const nextElements = new Map();
      expect(() =>
        ElementsDelta.calculate(prevElements, nextElements),
      ).not.toThrow();
    });
    it("should not throw when adding element as already deleted", () => {
      const element = API.createElement({
        type: "rectangle",
        x: 100,
        y: 100,
        isDeleted: true,
      });
      const prevElements = new Map();
      const nextElements = new Map([[element.id, element]]);
      expect(() =>
        ElementsDelta.calculate(prevElements, nextElements),
      ).not.toThrow();
    });
    it("should create updated delta even when there is only version and versionNonce change", () => {
      const baseElement = API.createElement({
        type: "rectangle",
        x: 100,
        y: 100,
        strokeColor: "#000000",
        backgroundColor: "#ffffff",
      });
      const modifiedElement = {
        ...baseElement,
        version: baseElement.version + 1,
        versionNonce: baseElement.versionNonce + 1,
      };
      // Create maps for the delta calculation
      const prevElements = new Map([[baseElement.id, baseElement]]);
      const nextElements = new Map([[modifiedElement.id, modifiedElement]]);
      // Calculate the delta
      const delta = ElementsDelta.calculate(
        prevElements as SceneElementsMap,
        nextElements as SceneElementsMap,
      );
      expect(delta).toEqual(
        ElementsDelta.create(
          {},
          {},
          {
            [baseElement.id]: Delta.create(
              {
                version: baseElement.version,
                versionNonce: baseElement.versionNonce,
              },
              {
                version: baseElement.version + 1,
                versionNonce: baseElement.versionNonce + 1,
              },
            ),
          },
        ),
      );
    });
  });
  describe("squash", () => {
    it("should not squash when second delta is empty", () => {
      const updatedDelta = Delta.create(
        { x: 100, version: 1, versionNonce: 1 },
        { x: 200, version: 2, versionNonce: 2 },
      );
      const elementsDelta1 = ElementsDelta.create(
        {},
        {},
        { id1: updatedDelta },
      );
      const elementsDelta2 = ElementsDelta.empty();
      const elementsDelta = elementsDelta1.squash(elementsDelta2);
      expect(elementsDelta.isEmpty()).toBeFalsy();
      expect(elementsDelta).toBe(elementsDelta1);
      expect(elementsDelta.updated.id1).toBe(updatedDelta);
    });
    it("should squash mutually exclusive delta types", () => {
      const addedDelta = Delta.create(
        { x: 100, version: 1, versionNonce: 1, isDeleted: true },
        { x: 200, version: 2, versionNonce: 2, isDeleted: false },
      );
      const removedDelta = Delta.create(
        { x: 100, version: 1, versionNonce: 1, isDeleted: false },
        { x: 200, version: 2, versionNonce: 2, isDeleted: true },
      );
      const updatedDelta = Delta.create(
        { x: 100, version: 1, versionNonce: 1 },
        { x: 200, version: 2, versionNonce: 2 },
      );
      const elementsDelta1 = ElementsDelta.create(
        { id1: addedDelta },
        { id2: removedDelta },
        {},
      );
      const elementsDelta2 = ElementsDelta.create(
        {},
        {},
        { id3: updatedDelta },
      );
      const elementsDelta = elementsDelta1.squash(elementsDelta2);
      expect(elementsDelta.isEmpty()).toBeFalsy();
      expect(elementsDelta).toBe(elementsDelta1);
      expect(elementsDelta.added.id1).toBe(addedDelta);
      expect(elementsDelta.removed.id2).toBe(removedDelta);
      expect(elementsDelta.updated.id3).toBe(updatedDelta);
    });
    it("should squash the same delta types", () => {
      const elementsDelta1 = ElementsDelta.create(
        {
          id1: Delta.create(
            { x: 100, version: 1, versionNonce: 1, isDeleted: true },
            { x: 200, version: 2, versionNonce: 2, isDeleted: false },
          ),
        },
        {
          id2: Delta.create(
            { x: 100, version: 1, versionNonce: 1, isDeleted: false },
            { x: 200, version: 2, versionNonce: 2, isDeleted: true },
          ),
        },
        {
          id3: Delta.create(
            { x: 100, version: 1, versionNonce: 1 },
            { x: 200, version: 2, versionNonce: 2 },
          ),
        },
      );
      const elementsDelta2 = ElementsDelta.create(
        {
          id1: Delta.create(
            { y: 100, version: 2, versionNonce: 2, isDeleted: true },
            { y: 200, version: 3, versionNonce: 3, isDeleted: false },
          ),
        },
        {
          id2: Delta.create(
            { y: 100, version: 2, versionNonce: 2, isDeleted: false },
            { y: 200, version: 3, versionNonce: 3, isDeleted: true },
          ),
        },
        {
          id3: Delta.create(
            { y: 100, version: 2, versionNonce: 2 },
            { y: 200, version: 3, versionNonce: 3 },
          ),
        },
      );
      const elementsDelta = elementsDelta1.squash(elementsDelta2);
      expect(elementsDelta.isEmpty()).toBeFalsy();
      expect(elementsDelta).toBe(elementsDelta1);
      expect(elementsDelta.added.id1).toEqual(
        Delta.create(
          { x: 100, y: 100, version: 2, versionNonce: 2, isDeleted: true },
          { x: 200, y: 200, version: 3, versionNonce: 3, isDeleted: false },
        ),
      );
      expect(elementsDelta.removed.id2).toEqual(
        Delta.create(
          { x: 100, y: 100, version: 2, versionNonce: 2, isDeleted: false },
          { x: 200, y: 200, version: 3, versionNonce: 3, isDeleted: true },
        ),
      );
      expect(elementsDelta.updated.id3).toEqual(
        Delta.create(
          { x: 100, y: 100, version: 2, versionNonce: 2 },
          { x: 200, y: 200, version: 3, versionNonce: 3 },
        ),
      );
    });
    it("should squash different delta types ", () => {
      // id1: added   -> updated => added
      // id2: removed -> added   => added
      // id3: updated -> removed => removed
      const elementsDelta1 = ElementsDelta.create(
        {
          id1: Delta.create(
            { x: 100, version: 1, versionNonce: 1, isDeleted: true },
            { x: 101, version: 2, versionNonce: 2, isDeleted: false },
          ),
        },
        {
          id2: Delta.create(
            { x: 200, version: 1, versionNonce: 1, isDeleted: false },
            { x: 201, version: 2, versionNonce: 2, isDeleted: true },
          ),
        },
        {
          id3: Delta.create(
            { x: 300, version: 1, versionNonce: 1 },
            { x: 301, version: 2, versionNonce: 2 },
          ),
        },
      );
      const elementsDelta2 = ElementsDelta.create(
        {
          id2: Delta.create(
            { y: 200, version: 2, versionNonce: 2, isDeleted: true },
            { y: 201, version: 3, versionNonce: 3, isDeleted: false },
          ),
        },
        {
          id3: Delta.create(
            { y: 300, version: 2, versionNonce: 2, isDeleted: false },
            { y: 301, version: 3, versionNonce: 3, isDeleted: true },
          ),
        },
        {
          id1: Delta.create(
            { y: 100, version: 2, versionNonce: 2 },
            { y: 101, version: 3, versionNonce: 3 },
          ),
        },
      );
      const elementsDelta = elementsDelta1.squash(elementsDelta2);
      expect(elementsDelta.isEmpty()).toBeFalsy();
      expect(elementsDelta).toBe(elementsDelta1);
      expect(elementsDelta.added).toEqual({
        id1: Delta.create(
          { x: 100, y: 100, version: 2, versionNonce: 2, isDeleted: true },
          { x: 101, y: 101, version: 3, versionNonce: 3, isDeleted: false },
        ),
        id2: Delta.create(
          { x: 200, y: 200, version: 2, versionNonce: 2, isDeleted: true },
          { x: 201, y: 201, version: 3, versionNonce: 3, isDeleted: false },
        ),
      });
      expect(elementsDelta.removed).toEqual({
        id3: Delta.create(
          { x: 300, y: 300, version: 2, versionNonce: 2, isDeleted: false },
          { x: 301, y: 301, version: 3, versionNonce: 3, isDeleted: true },
        ),
      });
      expect(elementsDelta.updated).toEqual({});
    });
    it("should squash bound elements", () => {
      const elementsDelta1 = ElementsDelta.create(
        {},
        {},
        {
          id1: Delta.create(
            {
              version: 1,
              versionNonce: 1,
              boundElements: [{ id: "t1", type: "text" }],
            },
            {
              version: 2,
              versionNonce: 2,
              boundElements: [{ id: "t2", type: "text" }],
            },
          ),
        },
      );
      const elementsDelta2 = ElementsDelta.create(
        {},
        {},
        {
          id1: Delta.create(
            {
              version: 2,
              versionNonce: 2,
              boundElements: [{ id: "a1", type: "arrow" }],
            },
            {
              version: 3,
              versionNonce: 3,
              boundElements: [{ id: "a2", type: "arrow" }],
            },
          ),
        },
      );
      const elementsDelta = elementsDelta1.squash(elementsDelta2);
      expect(elementsDelta.updated.id1.deleted.boundElements).toEqual([
        { id: "t1", type: "text" },
        { id: "a1", type: "arrow" },
      ]);
      expect(elementsDelta.updated.id1.inserted.boundElements).toEqual([
        { id: "t2", type: "text" },
        { id: "a2", type: "arrow" },
      ]);
    });
  });
 });
 describe("AppStateDelta", () => {
  describe("ensure stable delta properties order", () => {
    it("should maintain stable order for root properties", () => {
      const name = "untitled scene";
-      const selectedLinearElement = {
+      const selectedLinearElementId = "id1" as LinearElementEditor["elementId"];
        elementId: "id1" as LinearElementEditor["elementId"],
        isEditing: false,
      };
      const commonAppState = {
        viewBackgroundColor: "#ffffff",
@ -356,23 +24,23 @@ describe("AppStateDelta", () => {
      const prevAppState1: ObservedAppState = {
        ...commonAppState,
        name: "",
-        selectedLinearElement: null,
+        selectedLinearElementId: null,
      };
      const nextAppState1: ObservedAppState = {
        ...commonAppState,
        name,
-        selectedLinearElement,
+        selectedLinearElementId,
      };
      const prevAppState2: ObservedAppState = {
-        selectedLinearElement: null,
+        selectedLinearElementId: null,
        name: "",
        ...commonAppState,
      };
      const nextAppState2: ObservedAppState = {
-        selectedLinearElement,
+        selectedLinearElementId,
        name,
        ...commonAppState,
      };
@ -390,7 +58,9 @@ describe("AppStateDelta", () => {
        selectedGroupIds: {},
        editingGroupId: null,
        croppingElementId: null,
-        selectedLinearElement: null,
+        selectedLinearElementId: null,
        selectedLinearElementIsEditing: null,
        editingLinearElementId: null,
        activeLockedId: null,
        lockedMultiSelections: {},
      };
@ -436,7 +106,9 @@ describe("AppStateDelta", () => {
        selectedElementIds: {},
        editingGroupId: null,
        croppingElementId: null,
-        selectedLinearElement: null,
+        selectedLinearElementId: null,
        selectedLinearElementIsEditing: null,
        editingLinearElementId: null,
        activeLockedId: null,
        lockedMultiSelections: {},
      };
@ -477,97 +149,4 @@ describe("AppStateDelta", () => {
      expect(JSON.stringify(delta1)).toBe(JSON.stringify(delta2));
    });
  });
  describe("squash", () => {
    it("should not squash when second delta is empty", () => {
      const delta = Delta.create(
        { name: "untitled scene" },
        { name: "titled scene" },
      );
      const appStateDelta1 = AppStateDelta.create(delta);
      const appStateDelta2 = AppStateDelta.empty();
      const appStateDelta = appStateDelta1.squash(appStateDelta2);
      expect(appStateDelta.isEmpty()).toBeFalsy();
      expect(appStateDelta).toBe(appStateDelta1);
      expect(appStateDelta.delta).toBe(delta);
    });
    it("should squash exclusive properties", () => {
      const delta1 = Delta.create(
        { name: "untitled scene" },
        { name: "titled scene" },
      );
      const delta2 = Delta.create(
        { viewBackgroundColor: "#ffffff" },
        { viewBackgroundColor: "#000000" },
      );
      const appStateDelta1 = AppStateDelta.create(delta1);
      const appStateDelta2 = AppStateDelta.create(delta2);
      const appStateDelta = appStateDelta1.squash(appStateDelta2);
      expect(appStateDelta.isEmpty()).toBeFalsy();
      expect(appStateDelta).toBe(appStateDelta1);
      expect(appStateDelta.delta).toEqual(
        Delta.create(
          { name: "untitled scene", viewBackgroundColor: "#ffffff" },
          { name: "titled scene", viewBackgroundColor: "#000000" },
        ),
      );
    });
    it("should squash selectedElementIds, selectedGroupIds and lockedMultiSelections", () => {
      const delta1 = Delta.create<Partial<ObservedAppState>>(
        {
          name: "untitled scene",
          selectedElementIds: { id1: true },
          selectedGroupIds: {},
          lockedMultiSelections: { g1: true },
        },
        {
          name: "titled scene",
          selectedElementIds: { id2: true },
          selectedGroupIds: { g1: true },
          lockedMultiSelections: {},
        },
      );
      const delta2 = Delta.create<Partial<ObservedAppState>>(
        {
          selectedElementIds: { id3: true },
          selectedGroupIds: { g1: true },
          lockedMultiSelections: {},
        },
        {
          selectedElementIds: { id2: true },
          selectedGroupIds: { g2: true, g3: true },
          lockedMultiSelections: { g3: true },
        },
      );
      const appStateDelta1 = AppStateDelta.create(delta1);
      const appStateDelta2 = AppStateDelta.create(delta2);
      const appStateDelta = appStateDelta1.squash(appStateDelta2);
      expect(appStateDelta.isEmpty()).toBeFalsy();
      expect(appStateDelta).toBe(appStateDelta1);
      expect(appStateDelta.delta).toEqual(
        Delta.create<Partial<ObservedAppState>>(
          {
            name: "untitled scene",
            selectedElementIds: { id1: true, id3: true },
            selectedGroupIds: { g1: true },
            lockedMultiSelections: { g1: true },
          },
          {
            name: "titled scene",
            selectedElementIds: { id2: true },
            selectedGroupIds: { g1: true, g2: true, g3: true },
            lockedMultiSelections: { g3: true },
          },
        ),
      );
    });
  });
 });
--- a/packages/element/tests/textElement.test.ts
+++ b/packages/element/tests/textElement.test.ts
@ -1,14 +1,13 @@
 import { getLineHeight } from "@excalidraw/common";
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
-import { FONT_FAMILY, TEXT_ALIGN, VERTICAL_ALIGN } from "@excalidraw/common";
+import { FONT_FAMILY } from "@excalidraw/common";
 import {
  computeContainerDimensionForBoundText,
  getContainerCoords,
  getBoundTextMaxWidth,
  getBoundTextMaxHeight,
  computeBoundTextPosition,
 } from "../src/textElement";
 import { detectLineHeight, getLineHeightInPx } from "../src/textMeasurements";
@ -208,172 +207,3 @@ describe("Test getDefaultLineHeight", () => {
    expect(getLineHeight(FONT_FAMILY.Cascadia)).toBe(1.2);
  });
 });
 describe("Test computeBoundTextPosition", () => {
  const createMockElementsMap = () => new Map();
  // Helper function to create rectangle test case with 90-degree rotation
  const createRotatedRectangleTestCase = (
    textAlign: string,
    verticalAlign: string,
  ) => {
    const container = API.createElement({
      type: "rectangle",
      x: 100,
      y: 100,
      width: 200,
      height: 100,
      angle: (Math.PI / 2) as any, // 90 degrees
    });
    const boundTextElement = API.createElement({
      type: "text",
      width: 80,
      height: 40,
      text: "hello darkness my old friend",
      textAlign: textAlign as any,
      verticalAlign: verticalAlign as any,
      containerId: container.id,
    }) as ExcalidrawTextElementWithContainer;
    const elementsMap = createMockElementsMap();
    return { container, boundTextElement, elementsMap };
  };
  describe("90-degree rotation with all alignment combinations", () => {
    // Test all 9 combinations of horizontal (left, center, right) and vertical (top, middle, bottom) alignment
    it("should position text with LEFT + TOP alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.LEFT, VERTICAL_ALIGN.TOP);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(185, 1);
      expect(result.y).toBeCloseTo(75, 1);
    });
    it("should position text with LEFT + MIDDLE alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.LEFT, VERTICAL_ALIGN.MIDDLE);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(160, 1);
      expect(result.y).toBeCloseTo(75, 1);
    });
    it("should position text with LEFT + BOTTOM alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.LEFT, VERTICAL_ALIGN.BOTTOM);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(135, 1);
      expect(result.y).toBeCloseTo(75, 1);
    });
    it("should position text with CENTER + TOP alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.CENTER, VERTICAL_ALIGN.TOP);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(185, 1);
      expect(result.y).toBeCloseTo(130, 1);
    });
    it("should position text with CENTER + MIDDLE alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(
          TEXT_ALIGN.CENTER,
          VERTICAL_ALIGN.MIDDLE,
        );
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(160, 1);
      expect(result.y).toBeCloseTo(130, 1);
    });
    it("should position text with CENTER + BOTTOM alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(
          TEXT_ALIGN.CENTER,
          VERTICAL_ALIGN.BOTTOM,
        );
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(135, 1);
      expect(result.y).toBeCloseTo(130, 1);
    });
    it("should position text with RIGHT + TOP alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.RIGHT, VERTICAL_ALIGN.TOP);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(185, 1);
      expect(result.y).toBeCloseTo(185, 1);
    });
    it("should position text with RIGHT + MIDDLE alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.RIGHT, VERTICAL_ALIGN.MIDDLE);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(160, 1);
      expect(result.y).toBeCloseTo(185, 1);
    });
    it("should position text with RIGHT + BOTTOM alignment at 90-degree rotation", () => {
      const { container, boundTextElement, elementsMap } =
        createRotatedRectangleTestCase(TEXT_ALIGN.RIGHT, VERTICAL_ALIGN.BOTTOM);
      const result = computeBoundTextPosition(
        container,
        boundTextElement,
        elementsMap,
      );
      expect(result.x).toBeCloseTo(135, 1);
      expect(result.y).toBeCloseTo(185, 1);
    });
  });
 });
--- a/packages/excalidraw/actions/actionCanvas.tsx
+++ b/packages/excalidraw/actions/actionCanvas.tsx
@ -69,7 +69,7 @@ export const actionChangeViewBackgroundColor = register({
        : CaptureUpdateAction.EVENTUALLY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, appProps, data }) => {
+  PanelComponent: ({ elements, appState, updateData, appProps }) => {
    // FIXME move me to src/components/mainMenu/DefaultItems.tsx
    return (
      <ColorPicker
@ -83,7 +83,6 @@ export const actionChangeViewBackgroundColor = register({
        elements={elements}
        appState={appState}
        updateData={updateData}
        compactMode={appState.stylesPanelMode === "compact"}
      />
    );
  },
@ -122,7 +121,7 @@ export const actionClearCanvas = register({
        pasteDialog: appState.pasteDialog,
        activeTool:
          appState.activeTool.type === "image"
-            ? { ...appState.activeTool, type: app.defaultSelectionTool }
+            ? { ...appState.activeTool, type: "selection" }
            : appState.activeTool,
      },
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
@ -495,13 +494,13 @@ export const actionToggleEraserTool = register({
  name: "toggleEraserTool",
  label: "toolBar.eraser",
  trackEvent: { category: "toolbar" },
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    let activeTool: AppState["activeTool"];
    if (isEraserActive(appState)) {
      activeTool = updateActiveTool(appState, {
        ...(appState.activeTool.lastActiveTool || {
-          type: app.defaultSelectionTool,
+          type: "selection",
        }),
        lastActiveToolBeforeEraser: null,
      });
@ -531,9 +530,6 @@ export const actionToggleLassoTool = register({
  label: "toolBar.lasso",
  icon: LassoIcon,
  trackEvent: { category: "toolbar" },
  predicate: (elements, appState, props, app) => {
    return app.defaultSelectionTool !== "lasso";
  },
  perform: (elements, appState, _, app) => {
    let activeTool: AppState["activeTool"];
--- a/packages/excalidraw/actions/actionDeleteSelected.tsx
+++ b/packages/excalidraw/actions/actionDeleteSelected.tsx
@ -298,9 +298,7 @@ export const actionDeleteSelected = register({
      elements: nextElements,
      appState: {
        ...nextAppState,
-        activeTool: updateActiveTool(appState, {
+        activeTool: updateActiveTool(appState, { type: "selection" }),
          type: app.defaultSelectionTool,
        }),
        multiElement: null,
        activeEmbeddable: null,
        selectedLinearElement: null,
--- a/packages/excalidraw/actions/actionFinalize.tsx
+++ b/packages/excalidraw/actions/actionFinalize.tsx
@ -5,11 +5,7 @@ import {
  bindOrUnbindLinearElement,
  isBindingEnabled,
 } from "@excalidraw/element/binding";
-import {
+import { isValidPolygon, LinearElementEditor } from "@excalidraw/element";
  isValidPolygon,
  LinearElementEditor,
  newElementWith,
 } from "@excalidraw/element";
 import {
  isBindingElement,
@ -82,14 +78,7 @@ export const actionFinalize = register({
        let newElements = elements;
        if (element && isInvisiblySmallElement(element)) {
          // TODO: #7348 in theory this gets recorded by the store, so the invisible elements could be restored by the undo/redo, which might be not what we would want
-          newElements = newElements.map((el) => {
+          newElements = newElements.filter((el) => el.id !== element!.id);
            if (el.id === element.id) {
              return newElementWith(el, {
                isDeleted: true,
              });
            }
            return el;
          });
        }
        return {
          elements: newElements,
@ -128,12 +117,7 @@ export const actionFinalize = register({
        return {
          elements:
            element.points.length < 2 || isInvisiblySmallElement(element)
-              ? elements.map((el) => {
+              ? elements.filter((el) => el.id !== element.id)
                  if (el.id === element.id) {
                    return newElementWith(el, { isDeleted: true });
                  }
                  return el;
                })
              : undefined,
          appState: {
            ...appState,
@ -188,12 +172,7 @@ export const actionFinalize = register({
      if (element && isInvisiblySmallElement(element)) {
        // TODO: #7348 in theory this gets recorded by the store, so the invisible elements could be restored by the undo/redo, which might be not what we would want
-        newElements = newElements.map((el) => {
+        newElements = newElements.filter((el) => el.id !== element!.id);
          if (el.id === element?.id) {
            return newElementWith(el, { isDeleted: true });
          }
          return el;
        });
      }
      if (isLinearElement(element) || isFreeDrawElement(element)) {
@ -261,13 +240,13 @@ export const actionFinalize = register({
    if (appState.activeTool.type === "eraser") {
      activeTool = updateActiveTool(appState, {
        ...(appState.activeTool.lastActiveTool || {
-          type: app.defaultSelectionTool,
+          type: "selection",
        }),
        lastActiveToolBeforeEraser: null,
      });
    } else {
      activeTool = updateActiveTool(appState, {
-        type: app.defaultSelectionTool,
+        type: "selection",
      });
    }
--- a/packages/excalidraw/actions/actionLinearEditor.tsx
+++ b/packages/excalidraw/actions/actionLinearEditor.tsx
@ -88,10 +88,6 @@ export const actionToggleLinearEditor = register({
      selectedElementIds: appState.selectedElementIds,
    })[0] as ExcalidrawLinearElement;
    if (!selectedElement) {
      return null;
    }
    const label = t(
      selectedElement.type === "arrow"
        ? "labels.lineEditor.editArrow"
--- a/packages/excalidraw/actions/actionProperties.tsx
+++ b/packages/excalidraw/actions/actionProperties.tsx
@ -137,11 +137,6 @@ import {
  isSomeElementSelected,
 } from "../scene";
 import {
  withCaretPositionPreservation,
  restoreCaretPosition,
 } from "../hooks/useTextEditorFocus";
 import { register } from "./register";
 import type { AppClassProperties, AppState, Primitive } from "../types";
@ -326,11 +321,9 @@ export const actionChangeStrokeColor = register({
        : CaptureUpdateAction.EVENTUALLY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => (
+  PanelComponent: ({ elements, appState, updateData, app }) => (
    <>
      {appState.stylesPanelMode === "full" && (
      <h3 aria-hidden="true">{t("labels.stroke")}</h3>
      )}
      <ColorPicker
        topPicks={DEFAULT_ELEMENT_STROKE_PICKS}
        palette={DEFAULT_ELEMENT_STROKE_COLOR_PALETTE}
@ -348,7 +341,6 @@ export const actionChangeStrokeColor = register({
        elements={elements}
        appState={appState}
        updateData={updateData}
        compactMode={appState.stylesPanelMode === "compact"}
      />
    </>
  ),
@ -406,11 +398,9 @@ export const actionChangeBackgroundColor = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => (
+  PanelComponent: ({ elements, appState, updateData, app }) => (
    <>
      {appState.stylesPanelMode === "full" && (
      <h3 aria-hidden="true">{t("labels.background")}</h3>
      )}
      <ColorPicker
        topPicks={DEFAULT_ELEMENT_BACKGROUND_PICKS}
        palette={DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE}
@ -428,7 +418,6 @@ export const actionChangeBackgroundColor = register({
        elements={elements}
        appState={appState}
        updateData={updateData}
        compactMode={appState.stylesPanelMode === "compact"}
      />
    </>
  ),
@ -529,11 +518,9 @@ export const actionChangeStrokeWidth = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => (
+  PanelComponent: ({ elements, appState, updateData, app }) => (
    <fieldset>
      {appState.stylesPanelMode === "full" && (
      <legend>{t("labels.strokeWidth")}</legend>
      )}
      <div className="buttonList">
        <RadioSelection
          group="stroke-width"
@ -588,11 +575,9 @@ export const actionChangeSloppiness = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => (
+  PanelComponent: ({ elements, appState, updateData, app }) => (
    <fieldset>
      {appState.stylesPanelMode === "full" && (
      <legend>{t("labels.sloppiness")}</legend>
      )}
      <div className="buttonList">
        <RadioSelection
          group="sloppiness"
@ -643,11 +628,9 @@ export const actionChangeStrokeStyle = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => (
+  PanelComponent: ({ elements, appState, updateData, app }) => (
    <fieldset>
      {appState.stylesPanelMode === "full" && (
      <legend>{t("labels.strokeStyle")}</legend>
      )}
      <div className="buttonList">
        <RadioSelection
          group="strokeStyle"
@ -714,7 +697,7 @@ export const actionChangeFontSize = register({
  perform: (elements, appState, value, app) => {
    return changeFontSize(elements, appState, app, () => value, value);
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => (
+  PanelComponent: ({ elements, appState, updateData, app }) => (
    <fieldset>
      <legend>{t("labels.fontSize")}</legend>
      <div className="buttonList">
@ -773,14 +756,7 @@ export const actionChangeFontSize = register({
                ? null
                : appState.currentItemFontSize || DEFAULT_FONT_SIZE,
          )}
-          onChange={(value) => {
+          onChange={(value) => updateData(value)}
            withCaretPositionPreservation(
              () => updateData(value),
              appState.stylesPanelMode === "compact",
              !!appState.editingTextElement,
              data?.onPreventClose,
            );
          }}
        />
      </div>
    </fieldset>
@ -1040,7 +1016,7 @@ export const actionChangeFontFamily = register({
    return result;
  },
-  PanelComponent: ({ elements, appState, app, updateData, data }) => {
+  PanelComponent: ({ elements, appState, app, updateData }) => {
    const cachedElementsRef = useRef<ElementsMap>(new Map());
    const prevSelectedFontFamilyRef = useRef<number | null>(null);
    // relying on state batching as multiple `FontPicker` handlers could be called in rapid succession and we want to combine them
@ -1118,28 +1094,20 @@ export const actionChangeFontFamily = register({
    return (
      <fieldset>
        {appState.stylesPanelMode === "full" && (
        <legend>{t("labels.fontFamily")}</legend>
        )}
        <FontPicker
          isOpened={appState.openPopup === "fontFamily"}
          selectedFontFamily={selectedFontFamily}
          hoveredFontFamily={appState.currentHoveredFontFamily}
          compactMode={appState.stylesPanelMode === "compact"}
          onSelect={(fontFamily) => {
            withCaretPositionPreservation(
              () => {
            setBatchedData({
              openPopup: null,
              currentHoveredFontFamily: null,
              currentItemFontFamily: fontFamily,
            });
            // defensive clear so immediate close won't abuse the cached elements
            cachedElementsRef.current.clear();
              },
              appState.stylesPanelMode === "compact",
              !!appState.editingTextElement,
            );
          }}
          onHover={(fontFamily) => {
            setBatchedData({
@ -1196,28 +1164,25 @@ export const actionChangeFontFamily = register({
              }
              setBatchedData({
                ...batchedData,
                openPopup: "fontFamily",
              });
            } else {
-              const fontFamilyData = {
+              // close, use the cache and clear it afterwards
              const data = {
                openPopup: null,
                currentHoveredFontFamily: null,
                cachedElements: new Map(cachedElementsRef.current),
                resetAll: true,
              } as ChangeFontFamilyData;
-              setBatchedData({
+              if (isUnmounted.current) {
-                ...fontFamilyData,
+                // in case the component was unmounted by the parent, trigger the update directly
-              });
+                updateData({ ...batchedData, ...data });
-              cachedElementsRef.current.clear();
+              } else {
-
+                setBatchedData(data);
              // Refocus text editor when font picker closes if we were editing text
              if (
                appState.stylesPanelMode === "compact" &&
                appState.editingTextElement
              ) {
                restoreCaretPosition(null); // Just refocus without saved position
              }
              cachedElementsRef.current.clear();
            }
          }}
        />
@ -1260,9 +1225,8 @@ export const actionChangeTextAlign = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => {
+  PanelComponent: ({ elements, appState, updateData, app }) => {
    const elementsMap = app.scene.getNonDeletedElementsMap();
    return (
      <fieldset>
        <legend>{t("labels.textAlign")}</legend>
@ -1311,14 +1275,7 @@ export const actionChangeTextAlign = register({
              (hasSelection) =>
                hasSelection ? null : appState.currentItemTextAlign,
            )}
-            onChange={(value) => {
+            onChange={(value) => updateData(value)}
              withCaretPositionPreservation(
                () => updateData(value),
                appState.stylesPanelMode === "compact",
                !!appState.editingTextElement,
                data?.onPreventClose,
              );
            }}
          />
        </div>
      </fieldset>
@ -1360,7 +1317,7 @@ export const actionChangeVerticalAlign = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app, data }) => {
+  PanelComponent: ({ elements, appState, updateData, app }) => {
    return (
      <fieldset>
        <div className="buttonList">
@ -1410,14 +1367,7 @@ export const actionChangeVerticalAlign = register({
                ) !== null,
              (hasSelection) => (hasSelection ? null : VERTICAL_ALIGN.MIDDLE),
            )}
-            onChange={(value) => {
+            onChange={(value) => updateData(value)}
              withCaretPositionPreservation(
                () => updateData(value),
                appState.stylesPanelMode === "compact",
                !!appState.editingTextElement,
                data?.onPreventClose,
              );
            }}
          />
        </div>
      </fieldset>
@ -1666,25 +1616,6 @@ export const actionChangeArrowhead = register({
  },
 });
 export const actionChangeArrowProperties = register({
  name: "changeArrowProperties",
  label: "Change arrow properties",
  trackEvent: false,
  perform: (elements, appState, value, app) => {
    // This action doesn't perform any changes directly
    // It's just a container for the arrow type and arrowhead actions
    return false;
  },
  PanelComponent: ({ elements, appState, updateData, app, renderAction }) => {
    return (
      <div className="selected-shape-actions">
        {renderAction("changeArrowType")}
        {renderAction("changeArrowhead")}
      </div>
    );
  },
 });
 export const actionChangeArrowType = register({
  name: "changeArrowType",
  label: "Change arrow types",
--- a/packages/excalidraw/actions/index.ts
+++ b/packages/excalidraw/actions/index.ts
@ -18,7 +18,6 @@ export {
  actionChangeFontFamily,
  actionChangeTextAlign,
  actionChangeVerticalAlign,
  actionChangeArrowProperties,
 } from "./actionProperties";
 export {
--- a/packages/excalidraw/actions/types.ts
+++ b/packages/excalidraw/actions/types.ts
@ -69,7 +69,6 @@ export type ActionName =
  | "changeStrokeStyle"
  | "changeArrowhead"
  | "changeArrowType"
  | "changeArrowProperties"
  | "changeOpacity"
  | "changeFontSize"
  | "toggleCanvasMenu"
--- a/packages/excalidraw/appState.ts
+++ b/packages/excalidraw/appState.ts
@ -123,7 +123,6 @@ export const getDefaultAppState = (): Omit<
    searchMatches: null,
    lockedMultiSelections: {},
    activeLockedId: null,
    stylesPanelMode: "full",
  };
 };
@ -248,7 +247,6 @@ const APP_STATE_STORAGE_CONF = (<
  searchMatches: { browser: false, export: false, server: false },
  lockedMultiSelections: { browser: true, export: true, server: true },
  activeLockedId: { browser: false, export: false, server: false },
  stylesPanelMode: { browser: true, export: false, server: false },
 });
 const _clearAppStateForStorage = <
--- a/packages/excalidraw/clipboard.test.ts
+++ b/packages/excalidraw/clipboard.test.ts
@ -1,7 +1,6 @@
 import {
  createPasteEvent,
  parseClipboard,
  parseDataTransferEvent,
  serializeAsClipboardJSON,
 } from "./clipboard";
 import { API } from "./tests/helpers/api";
@ -14,9 +13,7 @@ describe("parseClipboard()", () => {
    text = "123";
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({ types: { "text/plain": text } }),
      ),
    );
    expect(clipboardData.text).toBe(text);
@ -24,9 +21,7 @@ describe("parseClipboard()", () => {
    text = "[123]";
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({ types: { "text/plain": text } }),
      ),
    );
    expect(clipboardData.text).toBe(text);
@ -34,9 +29,7 @@ describe("parseClipboard()", () => {
    text = JSON.stringify({ val: 42 });
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({ types: { "text/plain": text } }),
      ),
    );
    expect(clipboardData.text).toBe(text);
  });
@ -46,13 +39,11 @@ describe("parseClipboard()", () => {
    const json = serializeAsClipboardJSON({ elements: [rect], files: null });
    const clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/plain": json,
        },
      }),
      ),
    );
    expect(clipboardData.elements).toEqual([rect]);
  });
@ -65,25 +56,21 @@ describe("parseClipboard()", () => {
    // -------------------------------------------------------------------------
    json = serializeAsClipboardJSON({ elements: [rect], files: null });
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": json,
        },
      }),
      ),
    );
    expect(clipboardData.elements).toEqual([rect]);
    // -------------------------------------------------------------------------
    json = serializeAsClipboardJSON({ elements: [rect], files: null });
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": `<div> ${json}</div>`,
        },
      }),
      ),
    );
    expect(clipboardData.elements).toEqual([rect]);
    // -------------------------------------------------------------------------
@ -93,13 +80,11 @@ describe("parseClipboard()", () => {
    let clipboardData;
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": `<img src="https://example.com/image.png" />`,
        },
      }),
      ),
    );
    expect(clipboardData.mixedContent).toEqual([
      {
@ -109,13 +94,11 @@ describe("parseClipboard()", () => {
    ]);
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": `<div><img src="https://example.com/image.png" /></div><a><img src="https://example.com/image2.png" /></a>`,
        },
      }),
      ),
    );
    expect(clipboardData.mixedContent).toEqual([
      {
@ -131,13 +114,11 @@ describe("parseClipboard()", () => {
  it("should parse text content alongside <image> `src` urls out of text/html", async () => {
    const clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": `<a href="https://example.com">hello </a><div><img src="https://example.com/image.png" /></div><b>my friend!</b>`,
        },
      }),
      ),
    );
    expect(clipboardData.mixedContent).toEqual([
      {
@ -160,7 +141,6 @@ describe("parseClipboard()", () => {
    let clipboardData;
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/plain": `a	b
@ -169,7 +149,6 @@ describe("parseClipboard()", () => {
        7	10`,
        },
      }),
      ),
    );
    expect(clipboardData.spreadsheet).toEqual({
      title: "b",
@ -178,7 +157,6 @@ describe("parseClipboard()", () => {
    });
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": `a	b
@ -187,7 +165,6 @@ describe("parseClipboard()", () => {
        7	10`,
        },
      }),
      ),
    );
    expect(clipboardData.spreadsheet).toEqual({
      title: "b",
@ -196,7 +173,6 @@ describe("parseClipboard()", () => {
    });
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
      await parseDataTransferEvent(
      createPasteEvent({
        types: {
          "text/html": `<html>
@ -210,7 +186,6 @@ describe("parseClipboard()", () => {
        7	10`,
        },
      }),
      ),
    );
    expect(clipboardData.spreadsheet).toEqual({
      title: "b",
--- a/packages/excalidraw/clipboard.ts
+++ b/packages/excalidraw/clipboard.ts
@ -5,7 +5,6 @@ import {
  arrayToMap,
  isMemberOf,
  isPromiseLike,
  EVENT,
 } from "@excalidraw/common";
 import { mutateElement } from "@excalidraw/element";
@ -17,26 +16,15 @@ import {
 import { getContainingFrame } from "@excalidraw/element";
 import type { ValueOf } from "@excalidraw/common/utility-types";
 import type { IMAGE_MIME_TYPES, STRING_MIME_TYPES } from "@excalidraw/common";
 import type {
  ExcalidrawElement,
  NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
 import { ExcalidrawError } from "./errors";
-import {
+import { createFile, isSupportedImageFileType } from "./data/blob";
  createFile,
  getFileHandle,
  isSupportedImageFileType,
  normalizeFile,
 } from "./data/blob";
 import { tryParseSpreadsheet, VALID_SPREADSHEET } from "./charts";
 import type { FileSystemHandle } from "./data/filesystem";
 import type { Spreadsheet } from "./charts";
 import type { BinaryFiles } from "./types";
@ -104,7 +92,7 @@ export const createPasteEvent = ({
    console.warn("createPasteEvent: no types or files provided");
  }
-  const event = new ClipboardEvent(EVENT.PASTE, {
+  const event = new ClipboardEvent("paste", {
    clipboardData: new DataTransfer(),
  });
@ -113,11 +101,10 @@ export const createPasteEvent = ({
      if (typeof value !== "string") {
        files = files || [];
        files.push(value);
        event.clipboardData?.items.add(value);
        continue;
      }
      try {
-        event.clipboardData?.items.add(value, type);
+        event.clipboardData?.setData(type, value);
        if (event.clipboardData?.getData(type) !== value) {
          throw new Error(`Failed to set "${type}" as clipboardData item`);
        }
@ -242,10 +229,14 @@ function parseHTMLTree(el: ChildNode) {
  return result;
 }
-const maybeParseHTMLDataItem = (
+const maybeParseHTMLPaste = (
-  dataItem: ParsedDataTransferItemType<typeof MIME_TYPES["html"]>,
+  event: ClipboardEvent,
 ): { type: "mixedContent"; value: PastedMixedContent } | null => {
-  const html = dataItem.value;
+  const html = event.clipboardData?.getData(MIME_TYPES.html);
  if (!html) {
    return null;
  }
  try {
    const doc = new DOMParser().parseFromString(html, MIME_TYPES.html);
@ -341,21 +332,18 @@ export const readSystemClipboard = async () => {
 * Parses "paste" ClipboardEvent.
 */
 const parseClipboardEventTextData = async (
-  dataList: ParsedDataTranferList,
+  event: ClipboardEvent,
  isPlainPaste = false,
 ): Promise<ParsedClipboardEventTextData> => {
  try {
-    const htmlItem = dataList.findByType(MIME_TYPES.html);
+    const mixedContent = !isPlainPaste && event && maybeParseHTMLPaste(event);
    const mixedContent =
      !isPlainPaste && htmlItem && maybeParseHTMLDataItem(htmlItem);
    if (mixedContent) {
      if (mixedContent.value.every((item) => item.type === "text")) {
        return {
          type: "text",
          value:
-            dataList.getData(MIME_TYPES.text) ??
+            event.clipboardData?.getData(MIME_TYPES.text) ||
            mixedContent.value
              .map((item) => item.value)
              .join("\n")
@ -366,155 +354,23 @@ const parseClipboardEventTextData = async (
      return mixedContent;
    }
-    return {
+    const text = event.clipboardData?.getData(MIME_TYPES.text);
-      type: "text",
+
-      value: (dataList.getData(MIME_TYPES.text) || "").trim(),
+    return { type: "text", value: (text || "").trim() };
    };
  } catch {
    return { type: "text", value: "" };
  }
 };
 type AllowedParsedDataTransferItem =
  | {
      type: ValueOf<typeof IMAGE_MIME_TYPES>;
      kind: "file";
      file: File;
      fileHandle: FileSystemHandle | null;
    }
  | { type: ValueOf<typeof STRING_MIME_TYPES>; kind: "string"; value: string };
 type ParsedDataTransferItem =
  | {
      type: string;
      kind: "file";
      file: File;
      fileHandle: FileSystemHandle | null;
    }
  | { type: string; kind: "string"; value: string };
 type ParsedDataTransferItemType<
  T extends AllowedParsedDataTransferItem["type"],
 > = AllowedParsedDataTransferItem & { type: T };
 export type ParsedDataTransferFile = Extract<
  AllowedParsedDataTransferItem,
  { kind: "file" }
 >;
 type ParsedDataTranferList = ParsedDataTransferItem[] & {
  /**
   * Only allows filtering by known `string` data types, since `file`
   * types can have multiple items of the same type (e.g. multiple image files)
   * unlike `string` data transfer items.
   */
  findByType: typeof findDataTransferItemType;
  /**
   * Only allows filtering by known `string` data types, since `file`
   * types can have multiple items of the same type (e.g. multiple image files)
   * unlike `string` data transfer items.
   */
  getData: typeof getDataTransferItemData;
  getFiles: typeof getDataTransferFiles;
 };
 const findDataTransferItemType = function <
  T extends ValueOf<typeof STRING_MIME_TYPES>,
 >(this: ParsedDataTranferList, type: T): ParsedDataTransferItemType<T> | null {
  return (
    this.find(
      (item): item is ParsedDataTransferItemType<T> => item.type === type,
    ) || null
  );
 };
 const getDataTransferItemData = function <
  T extends ValueOf<typeof STRING_MIME_TYPES>,
 >(
  this: ParsedDataTranferList,
  type: T,
 ):
  | ParsedDataTransferItemType<ValueOf<typeof STRING_MIME_TYPES>>["value"]
  | null {
  const item = this.find(
    (
      item,
    ): item is ParsedDataTransferItemType<ValueOf<typeof STRING_MIME_TYPES>> =>
      item.type === type,
  );
  return item?.value ?? null;
 };
 const getDataTransferFiles = function (
  this: ParsedDataTranferList,
 ): ParsedDataTransferFile[] {
  return this.filter(
    (item): item is ParsedDataTransferFile => item.kind === "file",
  );
 };
 export const parseDataTransferEvent = async (
  event: ClipboardEvent | DragEvent | React.DragEvent<HTMLDivElement>,
 ): Promise<ParsedDataTranferList> => {
  let items: DataTransferItemList | undefined = undefined;
  if (isClipboardEvent(event)) {
    items = event.clipboardData?.items;
  } else {
    const dragEvent = event;
    items = dragEvent.dataTransfer?.items;
  }
  const dataItems = (
    await Promise.all(
      Array.from(items || []).map(
        async (item): Promise<ParsedDataTransferItem | null> => {
          if (item.kind === "file") {
            const file = item.getAsFile();
            if (file) {
              const fileHandle = await getFileHandle(item);
              return {
                type: file.type,
                kind: "file",
                file: await normalizeFile(file),
                fileHandle,
              };
            }
          } else if (item.kind === "string") {
            const { type } = item;
            let value: string;
            if ("clipboardData" in event && event.clipboardData) {
              value = event.clipboardData?.getData(type);
            } else {
              value = await new Promise<string>((resolve) => {
                item.getAsString((str) => resolve(str));
              });
            }
            return { type, kind: "string", value };
          }
          return null;
        },
      ),
    )
  ).filter((data): data is ParsedDataTransferItem => data != null);
  return Object.assign(dataItems, {
    findByType: findDataTransferItemType,
    getData: getDataTransferItemData,
    getFiles: getDataTransferFiles,
  });
 };
 /**
 * Attempts to parse clipboard event.
 */
 export const parseClipboard = async (
-  dataList: ParsedDataTranferList,
+  event: ClipboardEvent,
  isPlainPaste = false,
 ): Promise<ClipboardData> => {
  const parsedEventData = await parseClipboardEventTextData(
-    dataList,
+    event,
    isPlainPaste,
  );
@ -663,14 +519,3 @@ const copyTextViaExecCommand = (text: string | null) => {
  return success;
 };
 export const isClipboardEvent = (
  event: React.SyntheticEvent | Event,
 ): event is ClipboardEvent => {
  /** not using instanceof ClipboardEvent due to tests (jsdom) */
  return (
    event.type === EVENT.PASTE ||
    event.type === EVENT.COPY ||
    event.type === EVENT.CUT
  );
 };
--- a/packages/excalidraw/components/Actions.scss
+++ b/packages/excalidraw/components/Actions.scss
@ -91,120 +91,3 @@
    }
  }
 }
 .compact-shape-actions {
  display: flex;
  flex-direction: column;
  gap: 0.5rem;
  max-height: calc(100vh - 200px);
  overflow-y: auto;
  padding: 0.5rem;
  .compact-action-item {
    position: relative;
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 2.5rem;
    --default-button-size: 2rem;
    .compact-action-button {
      width: 2rem;
      height: 2rem;
      border: none;
      border-radius: var(--border-radius-lg);
      background: transparent;
      color: var(--color-on-surface);
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: all 0.2s ease;
      svg {
        width: 1rem;
        height: 1rem;
        flex: 0 0 auto;
      }
      &:hover {
        background: var(--button-hover-bg, var(--island-bg-color));
        border-color: var(
          --button-hover-border,
          var(--button-border, var(--default-border-color))
        );
      }
      &:active {
        background: var(--button-active-bg, var(--island-bg-color));
        border-color: var(--button-active-border, var(--color-primary-darkest));
      }
    }
    .compact-popover-content {
      .popover-section {
        margin-bottom: 1rem;
        &:last-child {
          margin-bottom: 0;
        }
        .popover-section-title {
          font-size: 0.75rem;
          font-weight: 600;
          color: var(--color-text-secondary);
          margin-bottom: 0.5rem;
          text-transform: uppercase;
          letter-spacing: 0.5px;
        }
        .buttonList {
          display: flex;
          flex-wrap: wrap;
          gap: 0.25rem;
        }
      }
    }
  }
 }
 .compact-shape-actions-island {
  width: fit-content;
  overflow-x: hidden;
 }
 .compact-popover-content {
  .popover-section {
    margin-bottom: 1rem;
    &:last-child {
      margin-bottom: 0;
    }
    .popover-section-title {
      font-size: 0.75rem;
      font-weight: 600;
      color: var(--color-text-secondary);
      margin-bottom: 0.5rem;
      text-transform: uppercase;
      letter-spacing: 0.5px;
    }
    .buttonList {
      display: flex;
      flex-wrap: wrap;
      gap: 0.25rem;
    }
  }
 }
 .shape-actions-theme-scope {
  --button-border: transparent;
  --button-bg: var(--color-surface-mid);
 }
 :root.theme--dark .shape-actions-theme-scope {
  --button-hover-bg: #363541;
  --button-bg: var(--color-surface-high);
 }
--- a/packages/excalidraw/components/Actions.tsx
+++ b/packages/excalidraw/components/Actions.tsx
@ -1,6 +1,5 @@
 import clsx from "clsx";
 import { useState } from "react";
 import * as Popover from "@radix-ui/react-popover";
 import {
  CLASSES,
@ -20,7 +19,6 @@ import {
  isImageElement,
  isLinearElement,
  isTextElement,
  isArrowElement,
 } from "@excalidraw/element";
 import { hasStrokeColor, toolIsArrow } from "@excalidraw/element";
@ -48,20 +46,15 @@ import {
  hasStrokeWidth,
 } from "../scene";
-import { getFormValue } from "../actions/actionProperties";
+import { SHAPES } from "./shapes";
 import { useTextEditorFocus } from "../hooks/useTextEditorFocus";
 import { getToolbarTools } from "./shapes";
 import "./Actions.scss";
-import { useDevice, useExcalidrawContainer } from "./App";
+import { useDevice } from "./App";
 import Stack from "./Stack";
 import { ToolButton } from "./ToolButton";
 import { Tooltip } from "./Tooltip";
 import DropdownMenu from "./dropdownMenu/DropdownMenu";
 import { PropertiesPopover } from "./PropertiesPopover";
 import {
  EmbedIcon,
  extraToolsIcon,
@ -70,29 +63,11 @@ import {
  laserPointerToolIcon,
  MagicIcon,
  LassoIcon,
  sharpArrowIcon,
  roundArrowIcon,
  elbowArrowIcon,
  TextSizeIcon,
  adjustmentsIcon,
  DotsHorizontalIcon,
 } from "./icons";
-import type {
+import type { AppClassProperties, AppProps, UIAppState, Zoom } from "../types";
  AppClassProperties,
  AppProps,
  UIAppState,
  Zoom,
  AppState,
 } from "../types";
 import type { ActionManager } from "../actions/manager";
 // Common CSS class combinations
 const PROPERTIES_CLASSES = clsx([
  CLASSES.SHAPE_ACTIONS_THEME_SCOPE,
  "properties-content",
 ]);
 export const canChangeStrokeColor = (
  appState: UIAppState,
  targetElements: ExcalidrawElement[],
@ -305,437 +280,6 @@ export const SelectedShapeActions = ({
  );
 };
 export const CompactShapeActions = ({
  appState,
  elementsMap,
  renderAction,
  app,
  setAppState,
 }: {
  appState: UIAppState;
  elementsMap: NonDeletedElementsMap | NonDeletedSceneElementsMap;
  renderAction: ActionManager["renderAction"];
  app: AppClassProperties;
  setAppState: React.Component<any, AppState>["setState"];
 }) => {
  const targetElements = getTargetElements(elementsMap, appState);
  const { saveCaretPosition, restoreCaretPosition } = useTextEditorFocus();
  const { container } = useExcalidrawContainer();
  const isEditingTextOrNewElement = Boolean(
    appState.editingTextElement || appState.newElement,
  );
  const showFillIcons =
    (hasBackground(appState.activeTool.type) &&
      !isTransparent(appState.currentItemBackgroundColor)) ||
    targetElements.some(
      (element) =>
        hasBackground(element.type) && !isTransparent(element.backgroundColor),
    );
  const showLinkIcon = targetElements.length === 1;
  const showLineEditorAction =
    !appState.selectedLinearElement?.isEditing &&
    targetElements.length === 1 &&
    isLinearElement(targetElements[0]) &&
    !isElbowArrow(targetElements[0]);
  const showCropEditorAction =
    !appState.croppingElementId &&
    targetElements.length === 1 &&
    isImageElement(targetElements[0]);
  const showAlignActions = alignActionsPredicate(appState, app);
  let isSingleElementBoundContainer = false;
  if (
    targetElements.length === 2 &&
    (hasBoundTextElement(targetElements[0]) ||
      hasBoundTextElement(targetElements[1]))
  ) {
    isSingleElementBoundContainer = true;
  }
  const isRTL = document.documentElement.getAttribute("dir") === "rtl";
  return (
    <div className="compact-shape-actions">
      {/* Stroke Color */}
      {canChangeStrokeColor(appState, targetElements) && (
        <div className={clsx("compact-action-item")}>
          {renderAction("changeStrokeColor")}
        </div>
      )}
      {/* Background Color */}
      {canChangeBackgroundColor(appState, targetElements) && (
        <div className="compact-action-item">
          {renderAction("changeBackgroundColor")}
        </div>
      )}
      {/* Combined Properties (Fill, Stroke, Opacity) */}
      {(showFillIcons ||
        hasStrokeWidth(appState.activeTool.type) ||
        targetElements.some((element) => hasStrokeWidth(element.type)) ||
        hasStrokeStyle(appState.activeTool.type) ||
        targetElements.some((element) => hasStrokeStyle(element.type)) ||
        canChangeRoundness(appState.activeTool.type) ||
        targetElements.some((element) => canChangeRoundness(element.type))) && (
        <div className="compact-action-item">
          <Popover.Root
            open={appState.openPopup === "compactStrokeStyles"}
            onOpenChange={(open) => {
              if (open) {
                setAppState({ openPopup: "compactStrokeStyles" });
              } else {
                setAppState({ openPopup: null });
              }
            }}
          >
            <Popover.Trigger asChild>
              <button
                type="button"
                className="compact-action-button properties-trigger"
                title={t("labels.stroke")}
                onClick={(e) => {
                  e.preventDefault();
                  e.stopPropagation();
                  setAppState({
                    openPopup:
                      appState.openPopup === "compactStrokeStyles"
                        ? null
                        : "compactStrokeStyles",
                  });
                }}
              >
                {adjustmentsIcon}
              </button>
            </Popover.Trigger>
            {appState.openPopup === "compactStrokeStyles" && (
              <PropertiesPopover
                className={PROPERTIES_CLASSES}
                container={container}
                style={{ maxWidth: "13rem" }}
                onClose={() => {}}
              >
                <div className="selected-shape-actions">
                  {showFillIcons && renderAction("changeFillStyle")}
                  {(hasStrokeWidth(appState.activeTool.type) ||
                    targetElements.some((element) =>
                      hasStrokeWidth(element.type),
                    )) &&
                    renderAction("changeStrokeWidth")}
                  {(hasStrokeStyle(appState.activeTool.type) ||
                    targetElements.some((element) =>
                      hasStrokeStyle(element.type),
                    )) && (
                    <>
                      {renderAction("changeStrokeStyle")}
                      {renderAction("changeSloppiness")}
                    </>
                  )}
                  {(canChangeRoundness(appState.activeTool.type) ||
                    targetElements.some((element) =>
                      canChangeRoundness(element.type),
                    )) &&
                    renderAction("changeRoundness")}
                  {renderAction("changeOpacity")}
                </div>
              </PropertiesPopover>
            )}
          </Popover.Root>
        </div>
      )}
      {/* Combined Arrow Properties */}
      {(toolIsArrow(appState.activeTool.type) ||
        targetElements.some((element) => toolIsArrow(element.type))) && (
        <div className="compact-action-item">
          <Popover.Root
            open={appState.openPopup === "compactArrowProperties"}
            onOpenChange={(open) => {
              if (open) {
                setAppState({ openPopup: "compactArrowProperties" });
              } else {
                setAppState({ openPopup: null });
              }
            }}
          >
            <Popover.Trigger asChild>
              <button
                type="button"
                className="compact-action-button properties-trigger"
                title={t("labels.arrowtypes")}
                onClick={(e) => {
                  e.preventDefault();
                  e.stopPropagation();
                  setAppState({
                    openPopup:
                      appState.openPopup === "compactArrowProperties"
                        ? null
                        : "compactArrowProperties",
                  });
                }}
              >
                {(() => {
                  // Show an icon based on the current arrow type
                  const arrowType = getFormValue(
                    targetElements,
                    app,
                    (element) => {
                      if (isArrowElement(element)) {
                        return element.elbowed
                          ? "elbow"
                          : element.roundness
                          ? "round"
                          : "sharp";
                      }
                      return null;
                    },
                    (element) => isArrowElement(element),
                    (hasSelection) =>
                      hasSelection ? null : appState.currentItemArrowType,
                  );
                  if (arrowType === "elbow") {
                    return elbowArrowIcon;
                  }
                  if (arrowType === "round") {
                    return roundArrowIcon;
                  }
                  return sharpArrowIcon;
                })()}
              </button>
            </Popover.Trigger>
            {appState.openPopup === "compactArrowProperties" && (
              <PropertiesPopover
                container={container}
                className="properties-content"
                style={{ maxWidth: "13rem" }}
                onClose={() => {}}
              >
                {renderAction("changeArrowProperties")}
              </PropertiesPopover>
            )}
          </Popover.Root>
        </div>
      )}
      {/* Linear Editor */}
      {showLineEditorAction && (
        <div className="compact-action-item">
          {renderAction("toggleLinearEditor")}
        </div>
      )}
      {/* Text Properties */}
      {(appState.activeTool.type === "text" ||
        targetElements.some(isTextElement)) && (
        <>
          <div className="compact-action-item">
            {renderAction("changeFontFamily")}
          </div>
          <div className="compact-action-item">
            <Popover.Root
              open={appState.openPopup === "compactTextProperties"}
              onOpenChange={(open) => {
                if (open) {
                  if (appState.editingTextElement) {
                    saveCaretPosition();
                  }
                  setAppState({ openPopup: "compactTextProperties" });
                } else {
                  setAppState({ openPopup: null });
                  if (appState.editingTextElement) {
                    restoreCaretPosition();
                  }
                }
              }}
            >
              <Popover.Trigger asChild>
                <button
                  type="button"
                  className="compact-action-button properties-trigger"
                  title={t("labels.textAlign")}
                  onClick={(e) => {
                    e.preventDefault();
                    e.stopPropagation();
                    if (appState.openPopup === "compactTextProperties") {
                      setAppState({ openPopup: null });
                    } else {
                      if (appState.editingTextElement) {
                        saveCaretPosition();
                      }
                      setAppState({ openPopup: "compactTextProperties" });
                    }
                  }}
                >
                  {TextSizeIcon}
                </button>
              </Popover.Trigger>
              {appState.openPopup === "compactTextProperties" && (
                <PropertiesPopover
                  className={PROPERTIES_CLASSES}
                  container={container}
                  style={{ maxWidth: "13rem" }}
                  // Improve focus handling for text editing scenarios
                  preventAutoFocusOnTouch={!!appState.editingTextElement}
                  onClose={() => {
                    // Refocus text editor when popover closes with caret restoration
                    if (appState.editingTextElement) {
                      restoreCaretPosition();
                    }
                  }}
                >
                  <div className="selected-shape-actions">
                    {(appState.activeTool.type === "text" ||
                      targetElements.some(isTextElement)) &&
                      renderAction("changeFontSize")}
                    {(appState.activeTool.type === "text" ||
                      suppportsHorizontalAlign(targetElements, elementsMap)) &&
                      renderAction("changeTextAlign")}
                    {shouldAllowVerticalAlign(targetElements, elementsMap) &&
                      renderAction("changeVerticalAlign")}
                  </div>
                </PropertiesPopover>
              )}
            </Popover.Root>
          </div>
        </>
      )}
      {/* Dedicated Copy Button */}
      {!isEditingTextOrNewElement && targetElements.length > 0 && (
        <div className="compact-action-item">
          {renderAction("duplicateSelection")}
        </div>
      )}
      {/* Dedicated Delete Button */}
      {!isEditingTextOrNewElement && targetElements.length > 0 && (
        <div className="compact-action-item">
          {renderAction("deleteSelectedElements")}
        </div>
      )}
      {/* Combined Other Actions */}
      {!isEditingTextOrNewElement && targetElements.length > 0 && (
        <div className="compact-action-item">
          <Popover.Root
            open={appState.openPopup === "compactOtherProperties"}
            onOpenChange={(open) => {
              if (open) {
                setAppState({ openPopup: "compactOtherProperties" });
              } else {
                setAppState({ openPopup: null });
              }
            }}
          >
            <Popover.Trigger asChild>
              <button
                type="button"
                className="compact-action-button properties-trigger"
                title={t("labels.actions")}
                onClick={(e) => {
                  e.preventDefault();
                  e.stopPropagation();
                  setAppState({
                    openPopup:
                      appState.openPopup === "compactOtherProperties"
                        ? null
                        : "compactOtherProperties",
                  });
                }}
              >
                {DotsHorizontalIcon}
              </button>
            </Popover.Trigger>
            {appState.openPopup === "compactOtherProperties" && (
              <PropertiesPopover
                className={PROPERTIES_CLASSES}
                container={container}
                style={{
                  maxWidth: "12rem",
                  // center the popover content
                  justifyContent: "center",
                  alignItems: "center",
                }}
                onClose={() => {}}
              >
                <div className="selected-shape-actions">
                  <fieldset>
                    <legend>{t("labels.layers")}</legend>
                    <div className="buttonList">
                      {renderAction("sendToBack")}
                      {renderAction("sendBackward")}
                      {renderAction("bringForward")}
                      {renderAction("bringToFront")}
                    </div>
                  </fieldset>
                  {showAlignActions && !isSingleElementBoundContainer && (
                    <fieldset>
                      <legend>{t("labels.align")}</legend>
                      <div className="buttonList">
                        {isRTL ? (
                          <>
                            {renderAction("alignRight")}
                            {renderAction("alignHorizontallyCentered")}
                            {renderAction("alignLeft")}
                          </>
                        ) : (
                          <>
                            {renderAction("alignLeft")}
                            {renderAction("alignHorizontallyCentered")}
                            {renderAction("alignRight")}
                          </>
                        )}
                        {targetElements.length > 2 &&
                          renderAction("distributeHorizontally")}
                        {/* breaks the row ˇˇ */}
                        <div style={{ flexBasis: "100%", height: 0 }} />
                        <div
                          style={{
                            display: "flex",
                            flexWrap: "wrap",
                            gap: ".5rem",
                            marginTop: "-0.5rem",
                          }}
                        >
                          {renderAction("alignTop")}
                          {renderAction("alignVerticallyCentered")}
                          {renderAction("alignBottom")}
                          {targetElements.length > 2 &&
                            renderAction("distributeVertically")}
                        </div>
                      </div>
                    </fieldset>
                  )}
                  <fieldset>
                    <legend>{t("labels.actions")}</legend>
                    <div className="buttonList">
                      {renderAction("group")}
                      {renderAction("ungroup")}
                      {showLinkIcon && renderAction("hyperlink")}
                      {showCropEditorAction && renderAction("cropEditor")}
                    </div>
                  </fieldset>
                </div>
              </PropertiesPopover>
            )}
          </Popover.Root>
        </div>
      )}
    </div>
  );
 };
 export const ShapesSwitcher = ({
  activeTool,
  appState,
@ -751,8 +295,7 @@ export const ShapesSwitcher = ({
  const frameToolSelected = activeTool.type === "frame";
  const laserToolSelected = activeTool.type === "laser";
-  const lassoToolSelected =
+  const lassoToolSelected = activeTool.type === "lasso";
    activeTool.type === "lasso" && app.defaultSelectionTool !== "lasso";
  const embeddableToolSelected = activeTool.type === "embeddable";
@ -760,14 +303,10 @@ export const ShapesSwitcher = ({
  return (
    <>
-      {getToolbarTools(app).map(
+      {SHAPES.map(({ value, icon, key, numericKey, fillable }, index) => {
        ({ value, icon, key, numericKey, fillable }, index) => {
        if (
          UIOptions.tools?.[
-              value as Extract<
+            value as Extract<typeof value, keyof AppProps["UIOptions"]["tools"]>
                typeof value,
                keyof AppProps["UIOptions"]["tools"]
              >
          ] === false
        ) {
          return null;
@ -820,8 +359,7 @@ export const ShapesSwitcher = ({
            }}
          />
        );
-        },
+      })}
      )}
      <div className="App-toolbar__divider" />
      <DropdownMenu open={isExtraToolsMenuOpen}>
@ -880,7 +418,6 @@ export const ShapesSwitcher = ({
          >
            {t("toolBar.laser")}
          </DropdownMenu.Item>
          {app.defaultSelectionTool !== "lasso" && (
          <DropdownMenu.Item
            onSelect={() => app.setActiveTool({ type: "lasso" })}
            icon={LassoIcon}
@ -889,7 +426,6 @@ export const ShapesSwitcher = ({
          >
            {t("toolBar.lasso")}
          </DropdownMenu.Item>
          )}
          <div style={{ margin: "6px 0", fontSize: 14, fontWeight: 600 }}>
            Generate
          </div>
--- a/packages/excalidraw/components/App.tsx
+++ b/packages/excalidraw/components/App.tsx
--- a/packages/excalidraw/components/ColorPicker/ColorPicker.scss
+++ b/packages/excalidraw/components/ColorPicker/ColorPicker.scss
@ -22,12 +22,6 @@
    @include isMobile {
      max-width: 11rem;
    }
    &.color-picker-container--no-top-picks {
      display: flex;
      justify-content: center;
      grid-template-columns: unset;
    }
  }
  .color-picker__top-picks {
@ -86,16 +80,6 @@
      }
    }
    .color-picker__button-background {
      display: flex;
      align-items: center;
      justify-content: center;
      svg {
        width: 100%;
        height: 100%;
      }
    }
    &.active {
      .color-picker__button-outline {
        position: absolute;
--- a/packages/excalidraw/components/ColorPicker/ColorPicker.tsx
+++ b/packages/excalidraw/components/ColorPicker/ColorPicker.tsx
@ -1,6 +1,6 @@
 import * as Popover from "@radix-ui/react-popover";
 import clsx from "clsx";
-import { useRef, useEffect } from "react";
+import { useRef } from "react";
 import {
  COLOR_OUTLINE_CONTRAST_THRESHOLD,
@ -18,12 +18,7 @@ import { useExcalidrawContainer } from "../App";
 import { ButtonSeparator } from "../ButtonSeparator";
 import { activeEyeDropperAtom } from "../EyeDropper";
 import { PropertiesPopover } from "../PropertiesPopover";
-import { backgroundIcon, slashIcon, strokeIcon } from "../icons";
+import { slashIcon } from "../icons";
 import {
  saveCaretPosition,
  restoreCaretPosition,
  temporarilyDisableTextEditorBlur,
 } from "../../hooks/useTextEditorFocus";
 import { ColorInput } from "./ColorInput";
 import { Picker } from "./Picker";
@ -72,7 +67,6 @@ interface ColorPickerProps {
  palette?: ColorPaletteCustom | null;
  topPicks?: ColorTuple;
  updateData: (formData?: any) => void;
  compactMode?: boolean;
 }
 const ColorPickerPopupContent = ({
@ -83,8 +77,6 @@ const ColorPickerPopupContent = ({
  elements,
  palette = COLOR_PALETTE,
  updateData,
  getOpenPopup,
  appState,
 }: Pick<
  ColorPickerProps,
  | "type"
@ -94,10 +86,7 @@ const ColorPickerPopupContent = ({
  | "elements"
  | "palette"
  | "updateData"
-  | "appState"
+>) => {
 > & {
  getOpenPopup: () => AppState["openPopup"];
 }) => {
  const { container } = useExcalidrawContainer();
  const [, setActiveColorPickerSection] = useAtom(activeColorPickerSectionAtom);
@ -128,8 +117,6 @@ const ColorPickerPopupContent = ({
    <PropertiesPopover
      container={container}
      style={{ maxWidth: "13rem" }}
      // Improve focus handling for text editing scenarios
      preventAutoFocusOnTouch={!!appState.editingTextElement}
      onFocusOutside={(event) => {
        // refocus due to eye dropper
        focusPickerContent();
@ -144,23 +131,8 @@ const ColorPickerPopupContent = ({
        }
      }}
      onClose={() => {
        // only clear if we're still the active popup (avoid racing with switch)
        if (getOpenPopup() === type) {
        updateData({ openPopup: null });
        }
        setActiveColorPickerSection(null);
        // Refocus text editor when popover closes if we were editing text
        if (appState.editingTextElement) {
          setTimeout(() => {
            const textEditor = document.querySelector(
              ".excalidraw-wysiwyg",
            ) as HTMLTextAreaElement;
            if (textEditor) {
              textEditor.focus();
            }
          }, 0);
        }
      }}
    >
      {palette ? (
@ -169,17 +141,7 @@ const ColorPickerPopupContent = ({
          palette={palette}
          color={color}
          onChange={(changedColor) => {
            // Save caret position before color change if editing text
            const savedSelection = appState.editingTextElement
              ? saveCaretPosition()
              : null;
            onChange(changedColor);
            // Restore caret position after color change if editing text
            if (appState.editingTextElement && savedSelection) {
              restoreCaretPosition(savedSelection);
            }
          }}
          onEyeDropperToggle={(force) => {
            setEyeDropperState((state) => {
@ -206,7 +168,6 @@ const ColorPickerPopupContent = ({
            if (eyeDropperState) {
              setEyeDropperState(null);
            } else {
              // close explicitly on Escape
              updateData({ openPopup: null });
            }
          }}
@ -227,32 +188,11 @@ const ColorPickerTrigger = ({
  label,
  color,
  type,
  compactMode = false,
  mode = "background",
  onToggle,
  editingTextElement,
 }: {
  color: string | null;
  label: string;
  type: ColorPickerType;
  compactMode?: boolean;
  mode?: "background" | "stroke";
  onToggle: () => void;
  editingTextElement?: boolean;
 }) => {
  const handleClick = (e: React.MouseEvent) => {
    // use pointerdown so we run before outside-close logic
    e.preventDefault();
    e.stopPropagation();
    // If editing text, temporarily disable the wysiwyg blur event
    if (editingTextElement) {
      temporarilyDisableTextEditorBlur();
    }
    onToggle();
  };
  return (
    <Popover.Trigger
      type="button"
@ -268,37 +208,8 @@ const ColorPickerTrigger = ({
          ? t("labels.showStroke")
          : t("labels.showBackground")
      }
      data-openpopup={type}
      onClick={handleClick}
    >
      <div className="color-picker__button-outline">{!color && slashIcon}</div>
      {compactMode && color && (
        <div className="color-picker__button-background">
          {mode === "background" ? (
            <span
              style={{
                color:
                  color && isColorDark(color, COLOR_OUTLINE_CONTRAST_THRESHOLD)
                    ? "#fff"
                    : "#111",
              }}
            >
              {backgroundIcon}
            </span>
          ) : (
            <span
              style={{
                color:
                  color && isColorDark(color, COLOR_OUTLINE_CONTRAST_THRESHOLD)
                    ? "#fff"
                    : "#111",
              }}
            >
              {strokeIcon}
            </span>
          )}
        </div>
      )}
    </Popover.Trigger>
  );
 };
@ -313,59 +224,25 @@ export const ColorPicker = ({
  topPicks,
  updateData,
  appState,
  compactMode = false,
 }: ColorPickerProps) => {
  const openRef = useRef(appState.openPopup);
  useEffect(() => {
    openRef.current = appState.openPopup;
  }, [appState.openPopup]);
  return (
    <div>
-      <div
+      <div role="dialog" aria-modal="true" className="color-picker-container">
        role="dialog"
        aria-modal="true"
        className={clsx("color-picker-container", {
          "color-picker-container--no-top-picks": compactMode,
        })}
      >
        {!compactMode && (
        <TopPicks
          activeColor={color}
          onChange={onChange}
          type={type}
          topPicks={topPicks}
        />
-        )}
+        <ButtonSeparator />
        {!compactMode && <ButtonSeparator />}
        <Popover.Root
          open={appState.openPopup === type}
          onOpenChange={(open) => {
-            if (open) {
+            updateData({ openPopup: open ? type : null });
              updateData({ openPopup: type });
            }
          }}
        >
          {/* serves as an active color indicator as well */}
-          <ColorPickerTrigger
+          <ColorPickerTrigger color={color} label={label} type={type} />
            color={color}
            label={label}
            type={type}
            compactMode={compactMode}
            mode={type === "elementStroke" ? "stroke" : "background"}
            editingTextElement={!!appState.editingTextElement}
            onToggle={() => {
              // atomic switch: if another popup is open, close it first, then open this one next tick
              if (appState.openPopup === type) {
                // toggle off on same trigger
                updateData({ openPopup: null });
              } else if (appState.openPopup) {
                updateData({ openPopup: type });
              } else {
                // open this one
                updateData({ openPopup: type });
              }
            }}
          />
          {/* popup content */}
          {appState.openPopup === type && (
            <ColorPickerPopupContent
@ -376,8 +253,6 @@ export const ColorPicker = ({
              elements={elements}
              palette={palette}
              updateData={updateData}
              getOpenPopup={() => openRef.current}
              appState={appState}
            />
          )}
        </Popover.Root>
--- a/packages/excalidraw/components/FontPicker/FontPicker.scss
+++ b/packages/excalidraw/components/FontPicker/FontPicker.scss
@ -11,10 +11,5 @@
        2rem + 4 * var(--default-button-size)
      ); // 4 gaps + 4 buttons
    }
    &--compact {
      display: block;
      grid-template-columns: none;
    }
  }
 }
--- a/packages/excalidraw/components/FontPicker/FontPicker.tsx
+++ b/packages/excalidraw/components/FontPicker/FontPicker.tsx
@ -1,5 +1,4 @@
 import * as Popover from "@radix-ui/react-popover";
 import clsx from "clsx";
 import React, { useCallback, useMemo } from "react";
 import { FONT_FAMILY } from "@excalidraw/common";
@ -59,7 +58,6 @@ interface FontPickerProps {
  onHover: (fontFamily: FontFamilyValues) => void;
  onLeave: () => void;
  onPopupChange: (open: boolean) => void;
  compactMode?: boolean;
 }
 export const FontPicker = React.memo(
@ -71,7 +69,6 @@ export const FontPicker = React.memo(
    onHover,
    onLeave,
    onPopupChange,
    compactMode = false,
  }: FontPickerProps) => {
    const defaultFonts = useMemo(() => DEFAULT_FONTS, []);
    const onSelectCallback = useCallback(
@ -84,14 +81,7 @@ export const FontPicker = React.memo(
    );
    return (
-      <div
+      <div role="dialog" aria-modal="true" className="FontPicker__container">
        role="dialog"
        aria-modal="true"
        className={clsx("FontPicker__container", {
          "FontPicker__container--compact": compactMode,
        })}
      >
        {!compactMode && (
        <div className="buttonList">
          <RadioSelection<FontFamilyValues | false>
            type="button"
@ -100,13 +90,9 @@ export const FontPicker = React.memo(
            onClick={onSelectCallback}
          />
        </div>
-        )}
+        <ButtonSeparator />
        {!compactMode && <ButtonSeparator />}
        <Popover.Root open={isOpened} onOpenChange={onPopupChange}>
-          <FontPickerTrigger
+          <FontPickerTrigger selectedFontFamily={selectedFontFamily} />
            selectedFontFamily={selectedFontFamily}
            isOpened={isOpened}
          />
          {isOpened && (
            <FontPickerList
              selectedFontFamily={selectedFontFamily}
--- a/packages/excalidraw/components/FontPicker/FontPickerList.tsx
+++ b/packages/excalidraw/components/FontPicker/FontPickerList.tsx
@ -90,8 +90,7 @@ export const FontPickerList = React.memo(
    onClose,
  }: FontPickerListProps) => {
    const { container } = useExcalidrawContainer();
-    const app = useApp();
+    const { fonts } = useApp();
    const { fonts } = app;
    const { showDeprecatedFonts } = useAppProps();
    const [searchTerm, setSearchTerm] = useState("");
@ -188,42 +187,6 @@ export const FontPickerList = React.memo(
      onLeave,
    ]);
    // Create a wrapped onSelect function that preserves caret position
    const wrappedOnSelect = useCallback(
      (fontFamily: FontFamilyValues) => {
        // Save caret position before font selection if editing text
        let savedSelection: { start: number; end: number } | null = null;
        if (app.state.editingTextElement) {
          const textEditor = document.querySelector(
            ".excalidraw-wysiwyg",
          ) as HTMLTextAreaElement;
          if (textEditor) {
            savedSelection = {
              start: textEditor.selectionStart,
              end: textEditor.selectionEnd,
            };
          }
        }
        onSelect(fontFamily);
        // Restore caret position after font selection if editing text
        if (app.state.editingTextElement && savedSelection) {
          setTimeout(() => {
            const textEditor = document.querySelector(
              ".excalidraw-wysiwyg",
            ) as HTMLTextAreaElement;
            if (textEditor && savedSelection) {
              textEditor.focus();
              textEditor.selectionStart = savedSelection.start;
              textEditor.selectionEnd = savedSelection.end;
            }
          }, 0);
        }
      },
      [onSelect, app.state.editingTextElement],
    );
    const onKeyDown = useCallback<KeyboardEventHandler<HTMLDivElement>>(
      (event) => {
        const handled = fontPickerKeyHandler({
@ -231,7 +194,7 @@ export const FontPickerList = React.memo(
          inputRef,
          hoveredFont,
          filteredFonts,
-          onSelect: wrappedOnSelect,
+          onSelect,
          onHover,
          onClose,
        });
@ -241,7 +204,7 @@ export const FontPickerList = React.memo(
          event.stopPropagation();
        }
      },
-      [hoveredFont, filteredFonts, wrappedOnSelect, onHover, onClose],
+      [hoveredFont, filteredFonts, onSelect, onHover, onClose],
    );
    useEffect(() => {
@ -277,7 +240,7 @@ export const FontPickerList = React.memo(
        // allow to tab between search and selected font
        tabIndex={font.value === selectedFontFamily ? 0 : -1}
        onClick={(e) => {
-          wrappedOnSelect(Number(e.currentTarget.value));
+          onSelect(Number(e.currentTarget.value));
        }}
        onMouseMove={() => {
          if (hoveredFont?.value !== font.value) {
@ -319,24 +282,9 @@ export const FontPickerList = React.memo(
        className="properties-content"
        container={container}
        style={{ width: "15rem" }}
-        onClose={() => {
+        onClose={onClose}
          onClose();
          // Refocus text editor when font picker closes if we were editing text
          if (app.state.editingTextElement) {
            setTimeout(() => {
              const textEditor = document.querySelector(
                ".excalidraw-wysiwyg",
              ) as HTMLTextAreaElement;
              if (textEditor) {
                textEditor.focus();
              }
            }, 0);
          }
        }}
        onPointerLeave={onLeave}
        onKeyDown={onKeyDown}
        preventAutoFocusOnTouch={!!app.state.editingTextElement}
      >
        <QuickSearch
          ref={inputRef}
--- a/packages/excalidraw/components/FontPicker/FontPickerTrigger.tsx
+++ b/packages/excalidraw/components/FontPicker/FontPickerTrigger.tsx
@ -1,4 +1,5 @@
 import * as Popover from "@radix-ui/react-popover";
 import { useMemo } from "react";
 import type { FontFamilyValues } from "@excalidraw/element/types";
@ -6,38 +7,33 @@ import { t } from "../../i18n";
 import { ButtonIcon } from "../ButtonIcon";
 import { TextIcon } from "../icons";
-import { useExcalidrawSetAppState } from "../App";
+import { isDefaultFont } from "./FontPicker";
 interface FontPickerTriggerProps {
  selectedFontFamily: FontFamilyValues | null;
  isOpened?: boolean;
 }
 export const FontPickerTrigger = ({
  selectedFontFamily,
  isOpened = false,
 }: FontPickerTriggerProps) => {
-  const setAppState = useExcalidrawSetAppState();
+  const isTriggerActive = useMemo(
    () => Boolean(selectedFontFamily && !isDefaultFont(selectedFontFamily)),
    [selectedFontFamily],
  );
  return (
    <Popover.Trigger asChild>
-      <div data-openpopup="fontFamily" className="properties-trigger">
+      {/* Empty div as trigger so it's stretched 100% due to different button sizes */}
      <div>
        <ButtonIcon
          standalone
          icon={TextIcon}
          title={t("labels.showFonts")}
          className="properties-trigger"
          testId={"font-family-show-fonts"}
-          active={isOpened}
+          active={isTriggerActive}
-          onClick={() => {
+          // no-op
-            setAppState((appState) => ({
+          onClick={() => {}}
              openPopup:
                appState.openPopup === "fontFamily" ? null : appState.openPopup,
            }));
          }}
          style={{
            border: "none",
          }}
        />
      </div>
    </Popover.Trigger>
--- a/packages/excalidraw/components/LayerUI.scss
+++ b/packages/excalidraw/components/LayerUI.scss
@ -24,10 +24,6 @@
      gap: 0.75rem;
      pointer-events: none !important;
      &--compact {
        gap: 0.5rem;
      }
      & > * {
        pointer-events: var(--ui-pointerEvents);
      }
--- a/packages/excalidraw/components/LayerUI.tsx
+++ b/packages/excalidraw/components/LayerUI.tsx
@ -4,7 +4,6 @@ import React from "react";
 import {
  CLASSES,
  DEFAULT_SIDEBAR,
  MQ_MIN_WIDTH_DESKTOP,
  TOOL_TYPE,
  arrayToMap,
  capitalizeString,
@ -29,11 +28,7 @@ import { useAtom, useAtomValue } from "../editor-jotai";
 import { t } from "../i18n";
 import { calculateScrollCenter } from "../scene";
-import {
+import { SelectedShapeActions, ShapesSwitcher } from "./Actions";
  SelectedShapeActions,
  ShapesSwitcher,
  CompactShapeActions,
 } from "./Actions";
 import { LoadingMessage } from "./LoadingMessage";
 import { LockButton } from "./LockButton";
 import { MobileMenu } from "./MobileMenu";
@ -162,25 +157,6 @@ const LayerUI = ({
  const device = useDevice();
  const tunnels = useInitializeTunnels();
  const spacing =
    appState.stylesPanelMode === "compact"
      ? {
          menuTopGap: 4,
          toolbarColGap: 4,
          toolbarRowGap: 1,
          toolbarInnerRowGap: 0.5,
          islandPadding: 1,
          collabMarginLeft: 8,
        }
      : {
          menuTopGap: 6,
          toolbarColGap: 4,
          toolbarRowGap: 1,
          toolbarInnerRowGap: 1,
          islandPadding: 1,
          collabMarginLeft: 8,
        };
  const TunnelsJotaiProvider = tunnels.tunnelsJotai.Provider;
  const [eyeDropperState, setEyeDropperState] = useAtom(activeEyeDropperAtom);
@ -233,35 +209,13 @@ const LayerUI = ({
    </div>
  );
-  const renderSelectedShapeActions = () => {
+  const renderSelectedShapeActions = () => (
    const isCompactMode = appState.stylesPanelMode === "compact";
    return (
    <Section
      heading="selectedShapeActions"
      className={clsx("selected-shape-actions zen-mode-transition", {
        "transition-left": appState.zenModeEnabled,
      })}
    >
        {isCompactMode ? (
          <Island
            className={clsx("compact-shape-actions-island")}
            padding={0}
            style={{
              // we want to make sure this doesn't overflow so subtracting the
              // approximate height of hamburgerMenu + footer
              maxHeight: `${appState.height - 166}px`,
            }}
          >
            <CompactShapeActions
              appState={appState}
              elementsMap={app.scene.getNonDeletedElementsMap()}
              renderAction={actionManager.renderAction}
              app={app}
              setAppState={setAppState}
            />
          </Island>
        ) : (
      <Island
        className={CLASSES.SHAPE_ACTIONS_MENU}
        padding={2}
@ -278,10 +232,8 @@ const LayerUI = ({
          app={app}
        />
      </Island>
        )}
    </Section>
  );
  };
  const renderFixedSideContainer = () => {
    const shouldRenderSelectedShapeActions = showSelectedShapeActions(
@ -298,19 +250,9 @@ const LayerUI = ({
    return (
      <FixedSideContainer side="top">
        <div className="App-menu App-menu_top">
-          <Stack.Col
+          <Stack.Col gap={6} className={clsx("App-menu_top__left")}>
            gap={spacing.menuTopGap}
            className={clsx("App-menu_top__left")}
          >
            {renderCanvasActions()}
            <div
              className={clsx("selected-shape-actions-container", {
                "selected-shape-actions-container--compact":
                  appState.stylesPanelMode === "compact",
              })}
            >
            {shouldRenderSelectedShapeActions && renderSelectedShapeActions()}
            </div>
          </Stack.Col>
          {!appState.viewModeEnabled &&
            appState.openDialog?.name !== "elementLinkSelector" && (
@ -320,19 +262,17 @@ const LayerUI = ({
                    {renderWelcomeScreen && (
                      <tunnels.WelcomeScreenToolbarHintTunnel.Out />
                    )}
-                    <Stack.Col gap={spacing.toolbarColGap} align="start">
+                    <Stack.Col gap={4} align="start">
                      <Stack.Row
-                        gap={spacing.toolbarRowGap}
+                        gap={1}
                        className={clsx("App-toolbar-container", {
                          "zen-mode": appState.zenModeEnabled,
                        })}
                      >
                        <Island
-                          padding={spacing.islandPadding}
+                          padding={1}
                          className={clsx("App-toolbar", {
                            "zen-mode": appState.zenModeEnabled,
                            "App-toolbar--compact":
                              appState.stylesPanelMode === "compact",
                          })}
                        >
                          <HintViewer
@ -342,7 +282,7 @@ const LayerUI = ({
                            app={app}
                          />
                          {heading}
-                          <Stack.Row gap={spacing.toolbarInnerRowGap}>
+                          <Stack.Row gap={1}>
                            <PenModeButton
                              zenModeEnabled={appState.zenModeEnabled}
                              checked={appState.penMode}
@ -376,7 +316,7 @@ const LayerUI = ({
                        {isCollaborating && (
                          <Island
                            style={{
-                              marginLeft: spacing.collabMarginLeft,
+                              marginLeft: 8,
                              alignSelf: "center",
                              height: "fit-content",
                            }}
@ -404,8 +344,6 @@ const LayerUI = ({
              "layer-ui__wrapper__top-right zen-mode-transition",
              {
                "transition-right": appState.zenModeEnabled,
                "layer-ui__wrapper__top-right--compact":
                  appState.stylesPanelMode === "compact",
              },
            )}
          >
@ -480,9 +418,7 @@ const LayerUI = ({
        }}
        tab={DEFAULT_SIDEBAR.defaultTab}
      >
-        {appState.stylesPanelMode === "full" &&
+        {t("toolBar.library")}
          appState.width >= MQ_MIN_WIDTH_DESKTOP &&
          t("toolBar.library")}
      </DefaultSidebar.Trigger>
      <DefaultOverwriteConfirmDialog />
      {appState.openDialog?.name === "ttd" && <TTDDialog __fallback />}
--- a/packages/excalidraw/components/PropertiesPopover.tsx
+++ b/packages/excalidraw/components/PropertiesPopover.tsx
@ -17,7 +17,6 @@ interface PropertiesPopoverProps {
  onPointerLeave?: React.PointerEventHandler<HTMLDivElement>;
  onFocusOutside?: Popover.PopoverContentProps["onFocusOutside"];
  onPointerDownOutside?: Popover.PopoverContentProps["onPointerDownOutside"];
  preventAutoFocusOnTouch?: boolean;
 }
 export const PropertiesPopover = React.forwardRef<
@ -35,7 +34,6 @@ export const PropertiesPopover = React.forwardRef<
      onFocusOutside,
      onPointerLeave,
      onPointerDownOutside,
      preventAutoFocusOnTouch = false,
    },
    ref,
  ) => {
@ -66,12 +64,6 @@ export const PropertiesPopover = React.forwardRef<
          onKeyDown={onKeyDown}
          onFocusOutside={onFocusOutside}
          onPointerDownOutside={onPointerDownOutside}
          onOpenAutoFocus={(e) => {
            // prevent auto-focus on touch devices to avoid keyboard popup
            if (preventAutoFocusOnTouch && device.isTouchScreen) {
              e.preventDefault();
            }
          }}
          onCloseAutoFocus={(e) => {
            e.stopPropagation();
            // prevents focusing the trigger
--- a/packages/excalidraw/components/Toolbar.scss
+++ b/packages/excalidraw/components/Toolbar.scss
@ -10,16 +10,6 @@
      }
    }
    &--compact {
      .ToolIcon__keybinding {
        display: none;
      }
      .App-toolbar__divider {
        margin: 0;
      }
    }
    &__divider {
      width: 1px;
      height: 1.5rem;
--- a/packages/excalidraw/components/icons.tsx
+++ b/packages/excalidraw/components/icons.tsx
@ -118,17 +118,6 @@ export const DotsIcon = createIcon(
  tablerIconProps,
 );
 // tabler-icons: dots-horizontal (horizontal equivalent of dots-vertical)
 export const DotsHorizontalIcon = createIcon(
  <g strokeWidth="1.5">
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M5 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0" />
    <path d="M12 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0" />
    <path d="M19 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0" />
  </g>,
  tablerIconProps,
 );
 // tabler-icons: pinned
 export const PinIcon = createIcon(
  <svg strokeWidth="1.5">
@ -407,19 +396,6 @@ export const TextIcon = createIcon(
  tablerIconProps,
 );
 export const TextSizeIcon = createIcon(
  <g stroke="currentColor" strokeWidth="1.5">
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M3 7v-2h13v2" />
    <path d="M10 5v14" />
    <path d="M12 19h-4" />
    <path d="M15 13v-1h6v1" />
    <path d="M18 12v7" />
    <path d="M17 19h2" />
  </g>,
  tablerIconProps,
 );
 // modified tabler-icons: photo
 export const ImageIcon = createIcon(
  <g strokeWidth="1.25">
@ -2293,48 +2269,3 @@ export const elementLinkIcon = createIcon(
  </g>,
  tablerIconProps,
 );
 export const resizeIcon = createIcon(
  <g strokeWidth={1.5}>
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M4 11v8a1 1 0 0 0 1 1h8m-9 -14v-1a1 1 0 0 1 1 -1h1m5 0h2m5 0h1a1 1 0 0 1 1 1v1m0 5v2m0 5v1a1 1 0 0 1 -1 1h-1" />
    <path d="M4 12h7a1 1 0 0 1 1 1v7" />
  </g>,
  tablerIconProps,
 );
 export const adjustmentsIcon = createIcon(
  <g strokeWidth={1.5}>
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M14 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
    <path d="M4 6l8 0" />
    <path d="M16 6l4 0" />
    <path d="M8 12m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
    <path d="M4 12l2 0" />
    <path d="M10 12l10 0" />
    <path d="M17 18m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
    <path d="M4 18l11 0" />
    <path d="M19 18l1 0" />
  </g>,
  tablerIconProps,
 );
 export const backgroundIcon = createIcon(
  <g strokeWidth={1}>
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M6 10l4 -4" />
    <path d="M6 14l8 -8" />
    <path d="M6 18l12 -12" />
    <path d="M10 18l8 -8" />
    <path d="M14 18l4 -4" />
  </g>,
  tablerIconProps,
 );
 export const strokeIcon = createIcon(
  <g strokeWidth={1}>
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <rect x="6" y="6" width="12" height="12" fill="none" />
  </g>,
  tablerIconProps,
 );
--- a/packages/excalidraw/components/live-collaboration/LiveCollaborationTrigger.tsx
+++ b/packages/excalidraw/components/live-collaboration/LiveCollaborationTrigger.tsx
@ -1,7 +1,5 @@
 import clsx from "clsx";
 import { isMobileOrTablet, MQ_MIN_WIDTH_DESKTOP } from "@excalidraw/common";
 import { t } from "../../i18n";
 import { Button } from "../Button";
 import { share } from "../icons";
@ -19,8 +17,7 @@ const LiveCollaborationTrigger = ({
 } & React.ButtonHTMLAttributes<HTMLButtonElement>) => {
  const appState = useUIAppState();
-  const showIconOnly =
+  const showIconOnly = appState.width < 830;
    isMobileOrTablet() || appState.width < MQ_MIN_WIDTH_DESKTOP;
  return (
    <Button
--- a/packages/excalidraw/components/shapes.tsx
+++ b/packages/excalidraw/components/shapes.tsx
@ -13,8 +13,6 @@ import {
  EraserIcon,
 } from "./icons";
 import type { AppClassProperties } from "../types";
 export const SHAPES = [
  {
    icon: SelectionIcon,
@ -88,23 +86,8 @@ export const SHAPES = [
  },
 ] as const;
-export const getToolbarTools = (app: AppClassProperties) => {
+export const findShapeByKey = (key: string) => {
-  return app.defaultSelectionTool === "lasso"
+  const shape = SHAPES.find((shape, index) => {
    ? ([
        {
          value: "lasso",
          icon: SelectionIcon,
          key: KEYS.V,
          numericKey: KEYS["1"],
          fillable: true,
        },
        ...SHAPES.slice(1),
      ] as const)
    : SHAPES;
 };
 export const findShapeByKey = (key: string, app: AppClassProperties) => {
  const shape = getToolbarTools(app).find((shape, index) => {
    return (
      (shape.numericKey != null && key === shape.numericKey.toString()) ||
      (shape.key &&
--- a/packages/excalidraw/css/styles.scss
+++ b/packages/excalidraw/css/styles.scss
@ -317,7 +317,7 @@ body.excalidraw-cursor-resize * {
  .App-menu_top {
    grid-template-columns: 1fr 2fr 1fr;
-    grid-gap: 1rem;
+    grid-gap: 2rem;
    align-items: flex-start;
    cursor: default;
    pointer-events: none !important;
@ -336,14 +336,6 @@ body.excalidraw-cursor-resize * {
    justify-self: flex-start;
  }
  .selected-shape-actions-container {
    width: fit-content;
    &--compact {
      min-width: 48px;
    }
  }
  .App-menu_top > *:last-child {
    justify-self: flex-end;
  }
--- a/packages/excalidraw/data/blob.ts
+++ b/packages/excalidraw/data/blob.ts
@ -96,8 +96,6 @@ export const getMimeType = (blob: Blob | string): string => {
    return MIME_TYPES.jpg;
  } else if (/\.svg$/.test(name)) {
    return MIME_TYPES.svg;
  } else if (/\.excalidrawlib$/.test(name)) {
    return MIME_TYPES.excalidrawlib;
  }
  return "";
 };
@ -172,11 +170,7 @@ export const loadSceneOrLibraryFromBlob = async (
          },
          localAppState,
          localElements,
-          {
+          { repairBindings: true, refreshDimensions: false },
            repairBindings: true,
            refreshDimensions: false,
            deleteInvisibleElements: true,
          },
        ),
      };
    } else if (isValidLibrary(data)) {
@ -391,18 +385,23 @@ export const ImageURLToFile = async (
  throw new Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
 };
 export const getFileFromEvent = async (
  event: React.DragEvent<HTMLDivElement>,
 ) => {
  const file = event.dataTransfer.files.item(0);
  const fileHandle = await getFileHandle(event);
  return { file: file ? await normalizeFile(file) : null, fileHandle };
 };
 export const getFileHandle = async (
-  event: DragEvent | React.DragEvent | DataTransferItem,
+  event: React.DragEvent<HTMLDivElement>,
 ): Promise<FileSystemHandle | null> => {
  if (nativeFileSystemSupported) {
    try {
-      const dataTransferItem =
+      const item = event.dataTransfer.items[0];
        event instanceof DataTransferItem
          ? event
          : (event as DragEvent).dataTransfer?.items?.[0];
      const handle: FileSystemHandle | null =
-        (await (dataTransferItem as any).getAsFileSystemHandle()) || null;
+        (await (item as any).getAsFileSystemHandle()) || null;
      return handle;
    } catch (error: any) {
--- a/packages/excalidraw/data/reconcile.ts
+++ b/packages/excalidraw/data/reconcile.ts
@ -20,7 +20,7 @@ export type ReconciledExcalidrawElement = OrderedExcalidrawElement &
 export type RemoteExcalidrawElement = OrderedExcalidrawElement &
  MakeBrand<"RemoteExcalidrawElement">;
-export const shouldDiscardRemoteElement = (
+const shouldDiscardRemoteElement = (
  localAppState: AppState,
  local: OrderedExcalidrawElement | undefined,
  remote: RemoteExcalidrawElement,
@ -30,7 +30,7 @@ export const shouldDiscardRemoteElement = (
    // local element is being edited
    (local.id === localAppState.editingTextElement?.id ||
      local.id === localAppState.resizingElement?.id ||
-      local.id === localAppState.newElement?.id ||
+      local.id === localAppState.newElement?.id || // TODO: Is this still valid? As newElement is selection element, which is never part of the elements array
      // local element is newer
      local.version > remote.version ||
      // resolve conflicting edits deterministically by taking the one with
--- a/packages/excalidraw/data/restore.ts
+++ b/packages/excalidraw/data/restore.ts
@ -241,9 +241,8 @@ const restoreElementWithProperties = <
  return ret;
 };
-export const restoreElement = (
+const restoreElement = (
  element: Exclude<ExcalidrawElement, ExcalidrawSelectionElement>,
  opts?: { deleteInvisibleElements?: boolean },
 ): typeof element | null => {
  element = { ...element };
@ -291,8 +290,7 @@ export const restoreElement = (
      // if empty text, mark as deleted. We keep in array
      // for data integrity purposes (collab etc.)
-      if (opts?.deleteInvisibleElements && !text && !element.isDeleted) {
+      if (!text && !element.isDeleted) {
        // TODO: we should not do this since it breaks sync / versioning when we exchange / apply just deltas and restore the elements (deletion isn't recorded)
        element = { ...element, originalText: text, isDeleted: true };
        element = bumpVersion(element);
      }
@ -387,10 +385,7 @@ export const restoreElement = (
            elbowed: true,
            startBinding: repairBinding(element, element.startBinding),
            endBinding: repairBinding(element, element.endBinding),
-            fixedSegments:
+            fixedSegments: element.fixedSegments,
              element.fixedSegments?.length && base.points.length >= 4
                ? element.fixedSegments
                : null,
            startIsSpecial: element.startIsSpecial,
            endIsSpecial: element.endIsSpecial,
          })
@ -528,13 +523,7 @@ export const restoreElements = (
  elements: ImportedDataState["elements"],
  /** NOTE doesn't serve for reconciliation */
  localElements: readonly ExcalidrawElement[] | null | undefined,
-  opts?:
+  opts?: { refreshDimensions?: boolean; repairBindings?: boolean } | undefined,
    | {
        refreshDimensions?: boolean;
        repairBindings?: boolean;
        deleteInvisibleElements?: boolean;
      }
    | undefined,
 ): OrderedExcalidrawElement[] => {
  // used to detect duplicate top-level element ids
  const existingIds = new Set<string>();
@ -543,30 +532,16 @@ export const restoreElements = (
    (elements || []).reduce((elements, element) => {
      // filtering out selection, which is legacy, no longer kept in elements,
      // and causing issues if retained
-      if (element.type === "selection") {
+      if (element.type !== "selection" && !isInvisiblySmallElement(element)) {
-        return elements;
+        let migratedElement: ExcalidrawElement | null = restoreElement(element);
      }
      let migratedElement: ExcalidrawElement | null = restoreElement(element, {
        deleteInvisibleElements: opts?.deleteInvisibleElements,
      });
        if (migratedElement) {
          const localElement = localElementsMap?.get(element.id);
-
+          if (localElement && localElement.version > migratedElement.version) {
-        const shouldMarkAsDeleted =
+            migratedElement = bumpVersion(
-          opts?.deleteInvisibleElements && isInvisiblySmallElement(element);
+              migratedElement,
-
+              localElement.version,
-        if (
+            );
          shouldMarkAsDeleted ||
          (localElement && localElement.version > migratedElement.version)
        ) {
          migratedElement = bumpVersion(migratedElement, localElement?.version);
          }
        if (shouldMarkAsDeleted) {
          migratedElement = { ...migratedElement, isDeleted: true };
        }
          if (existingIds.has(migratedElement.id)) {
            migratedElement = { ...migratedElement, id: randomId() };
          }
@ -574,7 +549,7 @@ export const restoreElements = (
          elements.push(migratedElement);
        }
-
+      }
      return elements;
    }, [] as ExcalidrawElement[]),
  );
@ -815,11 +790,7 @@ export const restore = (
   */
  localAppState: Partial<AppState> | null | undefined,
  localElements: readonly ExcalidrawElement[] | null | undefined,
-  elementsConfig?: {
+  elementsConfig?: { refreshDimensions?: boolean; repairBindings?: boolean },
    refreshDimensions?: boolean;
    repairBindings?: boolean;
    deleteInvisibleElements?: boolean;
  },
 ): RestoredDataState => {
  return {
    elements: restoreElements(data?.elements, localElements, elementsConfig),
--- a/packages/excalidraw/eraser/index.ts
+++ b/packages/excalidraw/eraser/index.ts
@ -1,26 +1,11 @@
 import { arrayToMap, easeOut, THEME } from "@excalidraw/common";
 import {
  computeBoundTextPosition,
  distanceToElement,
  doBoundsIntersect,
  getBoundTextElement,
  getElementBounds,
  getFreedrawOutlineAsSegments,
  getFreedrawOutlinePoints,
  intersectElementWithLineSegment,
  isArrowElement,
  isFreeDrawElement,
  isLineElement,
  isPointInElement,
 } from "@excalidraw/element";
-import {
+import { lineSegment, pointFrom } from "@excalidraw/math";
  lineSegment,
  lineSegmentsDistance,
  pointFrom,
  polygon,
  polygonIncludesPointNonZero,
 } from "@excalidraw/math";
 import { getElementsInGroup } from "@excalidraw/element";
@ -28,8 +13,6 @@ import { shouldTestInside } from "@excalidraw/element";
 import { hasBoundTextElement, isBoundToContainer } from "@excalidraw/element";
 import { getBoundTextElementId } from "@excalidraw/element";
 import type { Bounds } from "@excalidraw/element";
 import type { GlobalPoint, LineSegment } from "@excalidraw/math/types";
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
@ -113,7 +96,6 @@ export class EraserTrail extends AnimatedTrail {
          pathSegment,
          element,
          candidateElementsMap,
          this.app.state.zoom.value,
        );
        if (intersects) {
@ -149,7 +131,6 @@ export class EraserTrail extends AnimatedTrail {
          pathSegment,
          element,
          candidateElementsMap,
          this.app.state.zoom.value,
        );
        if (intersects) {
@ -199,33 +180,8 @@ const eraserTest = (
  pathSegment: LineSegment<GlobalPoint>,
  element: ExcalidrawElement,
  elementsMap: ElementsMap,
  zoom: number,
 ): boolean => {
  const lastPoint = pathSegment[1];
  // PERF: Do a quick bounds intersection test first because it's cheap
  const threshold = isFreeDrawElement(element) ? 15 : element.strokeWidth / 2;
  const segmentBounds = [
    Math.min(pathSegment[0][0], pathSegment[1][0]) - threshold,
    Math.min(pathSegment[0][1], pathSegment[1][1]) - threshold,
    Math.max(pathSegment[0][0], pathSegment[1][0]) + threshold,
    Math.max(pathSegment[0][1], pathSegment[1][1]) + threshold,
  ] as Bounds;
  const origElementBounds = getElementBounds(element, elementsMap);
  const elementBounds: Bounds = [
    origElementBounds[0] - threshold,
    origElementBounds[1] - threshold,
    origElementBounds[2] + threshold,
    origElementBounds[3] + threshold,
  ];
  if (!doBoundsIntersect(segmentBounds, elementBounds)) {
    return false;
  }
  // There are shapes where the inner area should trigger erasing
  // even though the eraser path segment doesn't intersect with or
  // get close to the shape's stroke
  if (
    shouldTestInside(element) &&
    isPointInElement(lastPoint, element, elementsMap)
@ -233,50 +189,6 @@ const eraserTest = (
    return true;
  }
  // Freedraw elements are tested for erasure by measuring the distance
  // of the eraser path and the freedraw shape outline lines to a tolerance
  // which offers a good visual precision at various zoom levels
  if (isFreeDrawElement(element)) {
    const outlinePoints = getFreedrawOutlinePoints(element);
    const strokeSegments = getFreedrawOutlineAsSegments(
      element,
      outlinePoints,
      elementsMap,
    );
    const tolerance = Math.max(2.25, 5 / zoom); // NOTE: Visually fine-tuned approximation
    for (const seg of strokeSegments) {
      if (lineSegmentsDistance(seg, pathSegment) <= tolerance) {
        return true;
      }
    }
    const poly = polygon(
      ...(outlinePoints.map(([x, y]) =>
        pointFrom<GlobalPoint>(element.x + x, element.y + y),
      ) as GlobalPoint[]),
    );
    // PERF: Check only one point of the eraser segment. If the eraser segment
    // start is inside the closed freedraw shape, the other point is either also
    // inside or the eraser segment will intersect the shape outline anyway
    if (polygonIncludesPointNonZero(pathSegment[0], poly)) {
      return true;
    }
    return false;
  } else if (
    isArrowElement(element) ||
    (isLineElement(element) && !element.polygon)
  ) {
    const tolerance = Math.max(
      element.strokeWidth,
      (element.strokeWidth * 2) / zoom,
    );
    return distanceToElement(element, elementsMap, lastPoint) <= tolerance;
  }
  const boundTextElement = getBoundTextElement(element, elementsMap);
  return (
--- a/packages/excalidraw/history.ts
+++ b/packages/excalidraw/history.ts
@ -175,7 +175,7 @@ export class History {
      let nextAppState = appState;
      let containsVisibleChange = false;
-      // iterate through the history entries in case they result in no visible changes
+      // iterate through the history entries in case ;they result in no visible changes
      while (historyDelta) {
        try {
          [nextElements, nextAppState, containsVisibleChange] =
--- a/packages/excalidraw/hooks/useTextEditorFocus.ts
+++ b/packages/excalidraw/hooks/useTextEditorFocus.ts
@ -1,112 +0,0 @@
 import { useState, useCallback } from "react";
 // Utility type for caret position
 export type CaretPosition = {
  start: number;
  end: number;
 };
 // Utility function to get text editor element
 const getTextEditor = (): HTMLTextAreaElement | null => {
  return document.querySelector(".excalidraw-wysiwyg") as HTMLTextAreaElement;
 };
 // Utility functions for caret position management
 export const saveCaretPosition = (): CaretPosition | null => {
  const textEditor = getTextEditor();
  if (textEditor) {
    return {
      start: textEditor.selectionStart,
      end: textEditor.selectionEnd,
    };
  }
  return null;
 };
 export const restoreCaretPosition = (position: CaretPosition | null): void => {
  setTimeout(() => {
    const textEditor = getTextEditor();
    if (textEditor) {
      textEditor.focus();
      if (position) {
        textEditor.selectionStart = position.start;
        textEditor.selectionEnd = position.end;
      }
    }
  }, 0);
 };
 export const withCaretPositionPreservation = (
  callback: () => void,
  isCompactMode: boolean,
  isEditingText: boolean,
  onPreventClose?: () => void,
 ): void => {
  // Prevent popover from closing in compact mode
  if (isCompactMode && onPreventClose) {
    onPreventClose();
  }
  // Save caret position if editing text
  const savedPosition =
    isCompactMode && isEditingText ? saveCaretPosition() : null;
  // Execute the callback
  callback();
  // Restore caret position if needed
  if (isCompactMode && isEditingText) {
    restoreCaretPosition(savedPosition);
  }
 };
 // Hook for managing text editor caret position with state
 export const useTextEditorFocus = () => {
  const [savedCaretPosition, setSavedCaretPosition] =
    useState<CaretPosition | null>(null);
  const saveCaretPositionToState = useCallback(() => {
    const position = saveCaretPosition();
    setSavedCaretPosition(position);
  }, []);
  const restoreCaretPositionFromState = useCallback(() => {
    setTimeout(() => {
      const textEditor = getTextEditor();
      if (textEditor) {
        textEditor.focus();
        if (savedCaretPosition) {
          textEditor.selectionStart = savedCaretPosition.start;
          textEditor.selectionEnd = savedCaretPosition.end;
          setSavedCaretPosition(null);
        }
      }
    }, 0);
  }, [savedCaretPosition]);
  const clearSavedPosition = useCallback(() => {
    setSavedCaretPosition(null);
  }, []);
  return {
    saveCaretPosition: saveCaretPositionToState,
    restoreCaretPosition: restoreCaretPositionFromState,
    clearSavedPosition,
    hasSavedPosition: !!savedCaretPosition,
  };
 };
 // Utility function to temporarily disable text editor blur
 export const temporarilyDisableTextEditorBlur = (
  duration: number = 100,
 ): void => {
  const textEditor = getTextEditor();
  if (textEditor) {
    const originalOnBlur = textEditor.onblur;
    textEditor.onblur = null;
    setTimeout(() => {
      textEditor.onblur = originalOnBlur;
    }, duration);
  }
 };
--- a/packages/excalidraw/index.tsx
+++ b/packages/excalidraw/index.tsx
@ -229,7 +229,6 @@ export { defaultLang, useI18n, languages } from "./i18n";
 export {
  restore,
  restoreAppState,
  restoreElement,
  restoreElements,
  restoreLibraryItems,
 } from "./data/restore";
--- a/packages/excalidraw/package.json
+++ b/packages/excalidraw/package.json
@ -83,7 +83,7 @@
    "@excalidraw/element": "0.18.0",
    "@excalidraw/math": "0.18.0",
    "@excalidraw/laser-pointer": "1.3.1",
-    "@excalidraw/mermaid-to-excalidraw": "1.1.3",
+    "@excalidraw/mermaid-to-excalidraw": "1.1.2",
    "@excalidraw/random-username": "1.1.0",
    "@radix-ui/react-popover": "1.1.6",
    "@radix-ui/react-tabs": "1.1.3",
--- a/packages/excalidraw/snapping.ts
+++ b/packages/excalidraw/snapping.ts
@ -169,14 +169,8 @@ export const isSnappingEnabled = ({
  selectedElements: NonDeletedExcalidrawElement[];
 }) => {
  if (event) {
    // Allow snapping for lasso tool when dragging selected elements
    // but not during lasso selection phase
    const isLassoDragging =
      app.state.activeTool.type === "lasso" &&
      app.state.selectedElementsAreBeingDragged;
    return (
-      (app.state.activeTool.type !== "lasso" || isLassoDragging) &&
+      app.state.activeTool.type !== "lasso" &&
      ((app.state.objectsSnapModeEnabled && !event[KEYS.CTRL_OR_CMD]) ||
        (!app.state.objectsSnapModeEnabled &&
          event[KEYS.CTRL_OR_CMD] &&
--- a/packages/excalidraw/tests/snapshots/contextmenu.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/contextmenu.test.tsx.snap
@ -981,7 +981,6 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1173,7 +1172,6 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": {
@ -1386,7 +1384,6 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1716,7 +1713,6 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2046,7 +2042,6 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": {
@ -2257,7 +2252,6 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2499,7 +2493,6 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2801,7 +2794,6 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3167,7 +3159,6 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": {
@ -3659,7 +3650,6 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3692,14 +3682,14 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
  "opacity": 100,
  "roughness": 1,
  "roundness": null,
-  "seed": 400692809,
+  "seed": 1116226695,
  "strokeColor": "#1e1e1e",
  "strokeStyle": "solid",
  "strokeWidth": 2,
  "type": "rectangle",
  "updated": 1,
  "version": 4,
-  "versionNonce": 81784553,
+  "versionNonce": 23633383,
  "width": 20,
  "x": 20,
  "y": 30,
@ -3724,14 +3714,14 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
  "opacity": 100,
  "roughness": 1,
  "roundness": null,
-  "seed": 449462985,
+  "seed": 1278240551,
  "strokeColor": "#1e1e1e",
  "strokeStyle": "solid",
  "strokeWidth": 2,
  "type": "rectangle",
  "updated": 1,
  "version": 3,
-  "versionNonce": 1150084233,
+  "versionNonce": 401146281,
  "width": 20,
  "x": -10,
  "y": 0,
@ -3981,7 +3971,6 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4306,7 +4295,6 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5590,7 +5578,6 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -6808,7 +6795,6 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7738,7 +7724,6 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8736,7 +8721,6 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9729,7 +9713,6 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
--- a/packages/excalidraw/tests/snapshots/excalidraw.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/excalidraw.test.tsx.snap
@ -688,7 +688,6 @@ exports[`<Excalidraw/> > Test UIOptions prop > Test canvasActions > should rende
              aria-haspopup="dialog"
              aria-label="Canvas background"
              class="color-picker__button active-color properties-trigger has-outline"
              data-openpopup="canvasBackground"
              data-state="closed"
              style="--swatch-color: #ffffff;"
              title="Show background color picker"
--- a/packages/excalidraw/tests/snapshots/history.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/history.test.tsx.snap
--- a/packages/excalidraw/tests/snapshots/regressionTests.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/regressionTests.test.tsx.snap
@ -108,7 +108,6 @@ exports[`given element A and group of elements B and given both are selected whe
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -535,7 +534,6 @@ exports[`given element A and group of elements B and given both are selected whe
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -941,7 +939,6 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1506,7 +1503,6 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1717,7 +1713,6 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2097,7 +2092,6 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2339,7 +2333,6 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2520,7 +2513,6 @@ exports[`regression tests > can drag element that covers another element, while
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2842,7 +2834,6 @@ exports[`regression tests > change the properties of a shape > [end of test] app
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3098,7 +3089,6 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3338,7 +3328,6 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3573,7 +3562,6 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3831,7 +3819,6 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4143,7 +4130,6 @@ exports[`regression tests > deleting last but one element in editing group shoul
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4605,7 +4591,6 @@ exports[`regression tests > deselects group of selected elements on pointer down
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4859,7 +4844,6 @@ exports[`regression tests > deselects group of selected elements on pointer up w
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5161,7 +5145,6 @@ exports[`regression tests > deselects selected element on pointer down when poin
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5340,7 +5323,6 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5539,7 +5521,6 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5935,7 +5916,6 @@ exports[`regression tests > drags selected elements from point inside common bou
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -6225,7 +6205,6 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -6415,16 +6394,15 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id9": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id9",
-            "elementId": "id9",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
          "selectedElementIds": {
            "id6": true,
          },
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -6492,19 +6470,13 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id12": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id12",
            "elementId": "id12",
            "isEditing": false,
          },
        },
        "inserted": {
          "selectedElementIds": {
            "id9": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id9",
            "elementId": "id9",
            "isEditing": false,
          },
        },
      },
    },
@ -6570,16 +6542,15 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id15": true,
          },
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
        "inserted": {
          "selectedElementIds": {
            "id12": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id12",
-            "elementId": "id12",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
      },
    },
@ -6706,13 +6677,12 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id15",
-            "elementId": "id15",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -6730,16 +6700,15 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id22": true,
          },
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
        "inserted": {
          "selectedElementIds": {
            "id15": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id15",
-            "elementId": "id15",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
      },
    },
@ -6864,13 +6833,12 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id22",
-            "elementId": "id22",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -6905,13 +6873,12 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
        "inserted": {
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id22",
-            "elementId": "id22",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
      },
    },
@ -7085,7 +7052,6 @@ exports[`regression tests > given a group of selected elements with an element t
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7418,7 +7384,6 @@ exports[`regression tests > given a selected element A and a not selected elemen
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7695,7 +7660,6 @@ exports[`regression tests > given selected element A with lower z-index than uns
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7929,7 +7893,6 @@ exports[`regression tests > given selected element A with lower z-index than uns
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8166,7 +8129,6 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8345,7 +8307,6 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8524,7 +8485,6 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8730,7 +8690,6 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8760,14 +8719,13 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] undo stack
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id0",
-            "elementId": "id0",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -8959,7 +8917,6 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8989,14 +8946,13 @@ exports[`regression tests > key 6 selects line tool > [end of test] undo stack 1
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id0",
-            "elementId": "id0",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -9157,7 +9113,6 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9381,7 +9336,6 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9411,14 +9365,13 @@ exports[`regression tests > key a selects arrow tool > [end of test] undo stack
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id0",
-            "elementId": "id0",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -9583,7 +9536,6 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9789,7 +9741,6 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9819,14 +9770,13 @@ exports[`regression tests > key l selects line tool > [end of test] undo stack 1
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id0",
-            "elementId": "id0",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
      },
    },
@ -9989,7 +9939,6 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -10166,7 +10115,6 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -10363,7 +10311,6 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -10550,7 +10497,6 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11074,7 +11020,6 @@ exports[`regression tests > noop interaction after undo shouldn't create history
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11349,7 +11294,6 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11473,7 +11417,6 @@ exports[`regression tests > shift click on selected element should deselect it o
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11676,7 +11619,6 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11996,7 +11938,6 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -12428,7 +12369,6 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -13058,7 +12998,6 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -13184,7 +13123,6 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -13843,7 +13781,6 @@ exports[`regression tests > switches from group of selected elements to another
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14180,7 +14117,6 @@ exports[`regression tests > switches selected element on pointer down > [end of
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14411,7 +14347,6 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14535,7 +14470,6 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14560,13 +14494,12 @@ exports[`regression tests > undo/redo drawing an element > [end of test] redo st
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElement": null,
+          "selectedLinearElementId": null,
          "selectedLinearElementIsEditing": null,
        },
        "inserted": {
-          "selectedLinearElement": {
+          "selectedLinearElementId": "id6",
-            "elementId": "id6",
+          "selectedLinearElementIsEditing": false,
            "isEditing": false,
          },
        },
      },
    },
@ -14924,7 +14857,6 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -15049,7 +14981,6 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
--- a/packages/excalidraw/tests/appState.test.tsx
+++ b/packages/excalidraw/tests/appState.test.tsx
@ -35,10 +35,8 @@ describe("appState", () => {
      expect(h.state.viewBackgroundColor).toBe("#F00");
    });
-    await API.drop([
+    await API.drop(
-      {
+      new Blob(
        kind: "file",
        file: new Blob(
        [
          JSON.stringify({
            type: EXPORT_DATA_TYPES.excalidraw,
@ -50,8 +48,7 @@ describe("appState", () => {
        ],
        { type: MIME_TYPES.json },
      ),
-      },
+    );
    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([expect.objectContaining({ id: "A" })]);
--- a/packages/excalidraw/tests/data/restore.test.ts
+++ b/packages/excalidraw/tests/data/restore.test.ts
@ -60,11 +60,7 @@ describe("restoreElements", () => {
    const rectElement = API.createElement({ type: "rectangle" });
    mockSizeHelper.mockImplementation(() => true);
-    expect(
+    expect(restore.restoreElements([rectElement], null).length).toBe(0);
      restore.restoreElements([rectElement], null, {
        deleteInvisibleElements: true,
      }),
    ).toEqual([expect.objectContaining({ isDeleted: true })]);
  });
  it("should restore text element correctly passing value for each attribute", () => {
@ -89,23 +85,6 @@ describe("restoreElements", () => {
    });
  });
  it("should not delete empty text element when opts.deleteInvisibleElements is not defined", () => {
    const textElement = API.createElement({
      type: "text",
      text: "",
      isDeleted: false,
    });
    const restoredElements = restore.restoreElements([textElement], null);
    expect(restoredElements).toEqual([
      expect.objectContaining({
        id: textElement.id,
        isDeleted: false,
      }),
    ]);
  });
  it("should restore text element correctly with unknown font family, null text and undefined alignment", () => {
    const textElement: any = API.createElement({
      type: "text",
@ -118,9 +97,10 @@ describe("restoreElements", () => {
    textElement.font = "10 unknown";
    expect(textElement.isDeleted).toBe(false);
-    const restoredText = restore.restoreElements([textElement], null, {
+    const restoredText = restore.restoreElements(
-      deleteInvisibleElements: true,
+      [textElement],
-    })[0] as ExcalidrawTextElement;
+      null,
    )[0] as ExcalidrawTextElement;
    expect(restoredText.isDeleted).toBe(true);
    expect(restoredText).toMatchSnapshot({
      seed: expect.any(Number),
@ -197,16 +177,13 @@ describe("restoreElements", () => {
      y: 0,
    });
-    const restoredElements = restore.restoreElements([arrowElement], null, {
+    const restoredElements = restore.restoreElements([arrowElement], null);
      deleteInvisibleElements: true,
    });
    const restoredArrow = restoredElements[0] as
      | ExcalidrawArrowElement
      | undefined;
-    expect(restoredArrow).not.toBeUndefined();
+    expect(restoredArrow).toBeUndefined();
    expect(restoredArrow?.isDeleted).toBe(true);
  });
  it("should keep 'imperceptibly' small freedraw/line elements", () => {
@ -871,7 +848,6 @@ describe("repairing bindings", () => {
    let restoredElements = restore.restoreElements(
      [container, invisibleBoundElement, boundElement],
      null,
      { deleteInvisibleElements: true },
    );
    expect(restoredElements).toEqual([
@ -879,11 +855,6 @@ describe("repairing bindings", () => {
        id: container.id,
        boundElements: [obsoleteBinding, invisibleBinding, nonExistentBinding],
      }),
      expect.objectContaining({
        id: invisibleBoundElement.id,
        containerId: container.id,
        isDeleted: true,
      }),
      expect.objectContaining({
        id: boundElement.id,
        containerId: container.id,
@ -893,7 +864,7 @@ describe("repairing bindings", () => {
    restoredElements = restore.restoreElements(
      [container, invisibleBoundElement, boundElement],
      null,
-      { repairBindings: true, deleteInvisibleElements: true },
+      { repairBindings: true },
    );
    expect(restoredElements).toEqual([
@ -901,11 +872,6 @@ describe("repairing bindings", () => {
        id: container.id,
        boundElements: [],
      }),
      expect.objectContaining({
        id: invisibleBoundElement.id,
        containerId: container.id,
        isDeleted: true,
      }),
      expect.objectContaining({
        id: boundElement.id,
        containerId: container.id,
--- a/packages/excalidraw/tests/dragCreate.test.tsx
+++ b/packages/excalidraw/tests/dragCreate.test.tsx
@ -315,12 +315,7 @@ describe("Test dragCreate", () => {
      );
      expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`5`);
      expect(h.state.selectionElement).toBeNull();
-      expect(h.elements).toEqual([
+      expect(h.elements.length).toEqual(0);
        expect.objectContaining({
          type: "arrow",
          isDeleted: true,
        }),
      ]);
    });
    it("line", async () => {
@ -349,12 +344,7 @@ describe("Test dragCreate", () => {
      );
      expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`5`);
      expect(h.state.selectionElement).toBeNull();
-      expect(h.elements).toEqual([
+      expect(h.elements.length).toEqual(0);
        expect.objectContaining({
          type: "line",
          isDeleted: true,
        }),
      ]);
    });
  });
 });
--- a/packages/excalidraw/tests/export.test.tsx
+++ b/packages/excalidraw/tests/export.test.tsx
@ -57,7 +57,7 @@ describe("export", () => {
      blob: pngBlob,
      metadata: serializeAsJSON(testElements, h.state, {}, "local"),
    });
-    await API.drop([{ kind: "file", file: pngBlobEmbedded }]);
+    await API.drop(pngBlobEmbedded);
    await waitFor(() => {
      expect(h.elements).toEqual([
@ -94,12 +94,7 @@ describe("export", () => {
  });
  it("import embedded png (legacy v1)", async () => {
-    await API.drop([
+    await API.drop(await API.loadFile("./fixtures/test_embedded_v1.png"));
      {
        kind: "file",
        file: await API.loadFile("./fixtures/test_embedded_v1.png"),
      },
    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "test" }),
@ -108,12 +103,7 @@ describe("export", () => {
  });
  it("import embedded png (v2)", async () => {
-    await API.drop([
+    await API.drop(await API.loadFile("./fixtures/smiley_embedded_v2.png"));
      {
        kind: "file",
        file: await API.loadFile("./fixtures/smiley_embedded_v2.png"),
      },
    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "😀" }),
@ -122,12 +112,7 @@ describe("export", () => {
  });
  it("import embedded svg (legacy v1)", async () => {
-    await API.drop([
+    await API.drop(await API.loadFile("./fixtures/test_embedded_v1.svg"));
      {
        kind: "file",
        file: await API.loadFile("./fixtures/test_embedded_v1.svg"),
      },
    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "test" }),
@ -136,12 +121,7 @@ describe("export", () => {
  });
  it("import embedded svg (v2)", async () => {
-    await API.drop([
+    await API.drop(await API.loadFile("./fixtures/smiley_embedded_v2.svg"));
      {
        kind: "file",
        file: await API.loadFile("./fixtures/smiley_embedded_v2.svg"),
      },
    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "😀" }),
--- a/packages/excalidraw/tests/fixtures/constants.ts
+++ b/packages/excalidraw/tests/fixtures/constants.ts
@ -1,9 +0,0 @@
 export const DEER_IMAGE_DIMENSIONS = {
  width: 318,
  height: 335,
 };
 export const SMILEY_IMAGE_DIMENSIONS = {
  width: 56,
  height: 77,
 };
--- a/packages/excalidraw/tests/flip.test.tsx
+++ b/packages/excalidraw/tests/flip.test.tsx
@ -25,7 +25,6 @@ import { Excalidraw } from "../index";
 // Importing to spy on it and mock the implementation (mocking does not work with simple vi.mock for some reason)
 import * as blobModule from "../data/blob";
 import { SMILEY_IMAGE_DIMENSIONS } from "./fixtures/constants";
 import { API } from "./helpers/api";
 import { UI, Pointer, Keyboard } from "./helpers/ui";
 import {
@ -745,6 +744,11 @@ describe("freedraw", () => {
 //image
 //TODO: currently there is no test for pixel colors at flipped positions.
 describe("image", () => {
  const smileyImageDimensions = {
    width: 56,
    height: 77,
  };
  beforeEach(() => {
    // it's necessary to specify the height in order to calculate natural dimensions of the image
    h.state.height = 1000;
@ -752,8 +756,8 @@ describe("image", () => {
  beforeAll(() => {
    mockHTMLImageElement(
-      SMILEY_IMAGE_DIMENSIONS.width,
+      smileyImageDimensions.width,
-      SMILEY_IMAGE_DIMENSIONS.height,
+      smileyImageDimensions.height,
    );
  });
--- a/packages/excalidraw/tests/helpers/api.ts
+++ b/packages/excalidraw/tests/helpers/api.ts
@ -478,43 +478,33 @@ export class API {
    });
  };
-  static drop = async (items: ({kind: "string", value: string, type: string} | {kind: "file", file: File | Blob, type?: string })[]) => {
+  static drop = async (blob: Blob) => {
    const fileDropEvent = createEvent.drop(GlobalTestState.interactiveCanvas);
    const text = await new Promise<string>((resolve, reject) => {
      try {
        const reader = new FileReader();
        reader.onload = () => {
          resolve(reader.result as string);
        };
        reader.readAsText(blob);
      } catch (error: any) {
        reject(error);
      }
    });
-    const dataTransferFileItems = items.filter(i => i.kind === "file") as {kind: "file", file: File | Blob, type: string }[];
+    const files = [blob] as File[] & { item: (index: number) => File };
    const files = dataTransferFileItems.map(item => item.file) as File[] & { item: (index: number) => File };
    // https://developer.mozilla.org/en-US/docs/Web/API/FileList/item
    files.item = (index: number) => files[index];
    Object.defineProperty(fileDropEvent, "dataTransfer", {
      value: {
        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/files
        files,
        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/items
        items: items.map((item, idx) => {
          if (item.kind === "string")  {
            return {
              kind: "string",
              type: item.type,
              // https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/getAsString
              getAsString: (cb: (text: string) => any) => cb(item.value),
            };
          }
          return {
            kind: "file",
            type: item.type || item.file.type,
            // https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/getAsFile
            getAsFile: () => item.file,
          };
        }),
        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/getData
        getData: (type: string) => {
-          return items.find((item) => item.type === "string" && item.type === type) || "";
+          if (type === blob.type || type === "text") {
            return text;
          }
          return "";
        },
-        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/types
+        types: [blob.type],
        types: Array.from(new Set(items.map((item) => item.kind === "file" ? "Files" : item.type))),
      },
    });
    Object.defineProperty(fileDropEvent, "clientX", {
--- a/packages/excalidraw/tests/helpers/constants.ts
+++ b/packages/excalidraw/tests/helpers/constants.ts
@ -1,6 +0,0 @@
 export const INITIALIZED_IMAGE_PROPS = {
  type: "image",
  fileId: expect.any(String),
  x: expect.toBeNonNaNNumber(),
  y: expect.toBeNonNaNNumber(),
 };
--- a/packages/excalidraw/tests/helpers/mocks.ts
+++ b/packages/excalidraw/tests/helpers/mocks.ts
@ -58,35 +58,3 @@ export const mockHTMLImageElement = (
    },
  );
 };
 // Mocks for multiple HTMLImageElements (dimensions are assigned in the order of image initialization)
 export const mockMultipleHTMLImageElements = (
  sizes: (readonly [number, number])[],
 ) => {
  const _sizes = [...sizes];
  vi.stubGlobal(
    "Image",
    class extends Image {
      constructor() {
        super();
        const size = _sizes.shift();
        if (!size) {
          throw new Error("Insufficient sizes");
        }
        Object.defineProperty(this, "naturalWidth", {
          value: size[0],
        });
        Object.defineProperty(this, "naturalHeight", {
          value: size[1],
        });
        queueMicrotask(() => {
          this.onload?.({} as Event);
        });
      }
    },
  );
 };
--- a/packages/excalidraw/tests/helpers/polyfills.ts
+++ b/packages/excalidraw/tests/helpers/polyfills.ts
@ -47,43 +47,42 @@ class DataTransferItem {
  }
 }
-class DataTransferItemList extends Array<DataTransferItem> {
+class DataTransferList {
  items: DataTransferItem[] = [];
  add(data: string | File, type: string = ""): void {
    if (typeof data === "string") {
-      this.push(new DataTransferItem("string", type, data));
+      this.items.push(new DataTransferItem("string", type, data));
    } else if (data instanceof File) {
-      this.push(new DataTransferItem("file", type, data));
+      this.items.push(new DataTransferItem("file", type, data));
    }
  }
  clear(): void {
-    this.clear();
+    this.items = [];
  }
 }
 class DataTransfer {
-  public items: DataTransferItemList = new DataTransferItemList();
+  public items: DataTransferList = new DataTransferList();
  private _types: Record<string, string> = {};
  get files() {
-    return this.items
+    return this.items.items
      .filter((item) => item.kind === "file")
      .map((item) => item.getAsFile()!);
  }
  add(data: string | File, type: string = ""): void {
    if (typeof data === "string") {
    this.items.add(data, type);
    } else {
      this.items.add(data);
    }
  }
  setData(type: string, value: string) {
-    this.items.add(value, type);
+    this._types[type] = value;
  }
  getData(type: string) {
-    return this.items.find((item) => item.type === type)?.data || "";
+    return this._types[type] || "";
  }
 }
--- a/packages/excalidraw/tests/history.test.tsx
+++ b/packages/excalidraw/tests/history.test.tsx
@ -20,7 +20,6 @@ import {
  DEFAULT_ELEMENT_BACKGROUND_COLOR_INDEX,
  DEFAULT_ELEMENT_STROKE_COLOR_INDEX,
  reseed,
  randomId,
 } from "@excalidraw/common";
 import "@excalidraw/utils/test-utils";
@ -59,13 +58,9 @@ import { createPasteEvent } from "../clipboard";
 import * as blobModule from "../data/blob";
 import {
  DEER_IMAGE_DIMENSIONS,
  SMILEY_IMAGE_DIMENSIONS,
 } from "./fixtures/constants";
 import { API } from "./helpers/api";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
-import { INITIALIZED_IMAGE_PROPS } from "./helpers/constants";
+import { mockHTMLImageElement } from "./helpers/mocks";
 import {
  GlobalTestState,
  act,
@ -76,7 +71,6 @@ import {
  checkpointHistory,
  unmountComponent,
 } from "./test-utils";
 import { setupImageTest as _setupImageTest } from "./image.test";
 import type { AppState } from "../types";
@ -129,9 +123,7 @@ describe("history", () => {
    const generateIdSpy = vi.spyOn(blobModule, "generateIdFromFile");
    const resizeFileSpy = vi.spyOn(blobModule, "resizeImageFile");
-    generateIdSpy.mockImplementation(() =>
+    generateIdSpy.mockImplementation(() => Promise.resolve("fileId" as FileId));
      Promise.resolve(randomId() as FileId),
    );
    resizeFileSpy.mockImplementation((file: File) => Promise.resolve(file));
    Object.assign(document, {
@ -568,10 +560,8 @@ describe("history", () => {
        expect(h.elements).toEqual([expect.objectContaining({ id: "A" })]),
      );
-      await API.drop([
+      await API.drop(
-        {
+        new Blob(
          kind: "file",
          file: new Blob(
          [
            JSON.stringify({
              type: EXPORT_DATA_TYPES.excalidraw,
@ -584,8 +574,7 @@ describe("history", () => {
          ],
          { type: MIME_TYPES.json },
        ),
-        },
+      );
      ]);
      await waitFor(() => expect(API.getUndoStack().length).toBe(1));
      expect(h.state.viewBackgroundColor).toBe("#000");
@ -623,141 +612,201 @@ describe("history", () => {
      ]);
    });
    it("should create new history entry on image drag&drop", async () => {
      await render(<Excalidraw handleKeyboardGlobally={true} />);
      // it's necessary to specify the height in order to calculate natural dimensions of the image
      h.state.height = 1000;
      const deerImageDimensions = {
        width: 318,
        height: 335,
      };
      mockHTMLImageElement(
        deerImageDimensions.width,
        deerImageDimensions.height,
      );
      await API.drop(await API.loadFile("./fixtures/deer.png"));
      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
        expect(API.getRedoStack().length).toBe(0);
        expect(h.elements).toEqual([
          expect.objectContaining({
            type: "image",
            fileId: expect.any(String),
            x: expect.toBeNonNaNNumber(),
            y: expect.toBeNonNaNNumber(),
            ...deerImageDimensions,
          }),
        ]);
        // need to check that delta actually contains initialized image element (with fileId & natural dimensions)
        expect(
          Object.values(h.history.undoStack[0].elements.removed)[0].deleted,
        ).toEqual(
          expect.objectContaining({
            type: "image",
            fileId: expect.any(String),
            x: expect.toBeNonNaNNumber(),
            y: expect.toBeNonNaNNumber(),
            ...deerImageDimensions,
          }),
        );
      });
      Keyboard.undo();
      expect(API.getUndoStack().length).toBe(0);
      expect(API.getRedoStack().length).toBe(1);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "image",
          fileId: expect.any(String),
          x: expect.toBeNonNaNNumber(),
          y: expect.toBeNonNaNNumber(),
          isDeleted: true,
          ...deerImageDimensions,
        }),
      ]);
      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(1);
      expect(API.getRedoStack().length).toBe(0);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "image",
          fileId: expect.any(String),
          x: expect.toBeNonNaNNumber(),
          y: expect.toBeNonNaNNumber(),
          isDeleted: false,
          ...deerImageDimensions,
        }),
      ]);
    });
    it("should create new history entry on embeddable link drag&drop", async () => {
      await render(<Excalidraw handleKeyboardGlobally={true} />);
      const link = "https://www.youtube.com/watch?v=gkGMXY0wekg";
      await API.drop([
        {
          kind: "string",
          value: link,
          type: MIME_TYPES.text,
        },
      ]);
      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
        expect(API.getRedoStack().length).toBe(0);
        expect(h.elements).toEqual([
          expect.objectContaining({
            type: "embeddable",
            link,
          }),
        ]);
      });
      Keyboard.undo();
      expect(API.getUndoStack().length).toBe(0);
      expect(API.getRedoStack().length).toBe(1);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "embeddable",
          link,
          isDeleted: true,
        }),
      ]);
      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(1);
      expect(API.getRedoStack().length).toBe(0);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "embeddable",
          link,
          isDeleted: false,
        }),
      ]);
    });
    const setupImageTest = () =>
      _setupImageTest([DEER_IMAGE_DIMENSIONS, SMILEY_IMAGE_DIMENSIONS]);
    const assertImageTest = async () => {
      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
        expect(API.getRedoStack().length).toBe(0);
        // need to check that delta actually contains initialized image elements (with fileId & natural dimensions)
        expect(
          Object.values(h.history.undoStack[0].elements.removed).map(
            (val) => val.deleted,
          ),
        ).toEqual([
          expect.objectContaining({
            ...INITIALIZED_IMAGE_PROPS,
            ...DEER_IMAGE_DIMENSIONS,
          }),
          expect.objectContaining({
            ...INITIALIZED_IMAGE_PROPS,
            ...SMILEY_IMAGE_DIMENSIONS,
          }),
        ]);
      });
      Keyboard.undo();
      expect(API.getUndoStack().length).toBe(0);
      expect(API.getRedoStack().length).toBe(1);
      expect(h.elements).toEqual([
        expect.objectContaining({
          ...INITIALIZED_IMAGE_PROPS,
          isDeleted: true,
          ...DEER_IMAGE_DIMENSIONS,
        }),
        expect.objectContaining({
          ...INITIALIZED_IMAGE_PROPS,
          isDeleted: true,
          ...SMILEY_IMAGE_DIMENSIONS,
        }),
      ]);
      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(1);
      expect(API.getRedoStack().length).toBe(0);
      expect(h.elements).toEqual([
        expect.objectContaining({
          ...INITIALIZED_IMAGE_PROPS,
          isDeleted: false,
          ...DEER_IMAGE_DIMENSIONS,
        }),
        expect.objectContaining({
          ...INITIALIZED_IMAGE_PROPS,
          isDeleted: false,
          ...SMILEY_IMAGE_DIMENSIONS,
        }),
      ]);
    };
    it("should create new history entry on image drag&drop", async () => {
      await setupImageTest();
      await API.drop(
-        (
+        new Blob([link], {
-          await Promise.all([
+          type: MIME_TYPES.text,
-            API.loadFile("./fixtures/deer.png"),
+        }),
            API.loadFile("./fixtures/smiley.png"),
          ])
        ).map((file) => ({
          kind: "file",
          file,
        })),
      );
-      await assertImageTest();
+      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
        expect(API.getRedoStack().length).toBe(0);
        expect(h.elements).toEqual([
          expect.objectContaining({
            type: "embeddable",
            link,
          }),
        ]);
      });
      Keyboard.undo();
      expect(API.getUndoStack().length).toBe(0);
      expect(API.getRedoStack().length).toBe(1);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "embeddable",
          link,
          isDeleted: true,
        }),
      ]);
      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(1);
      expect(API.getRedoStack().length).toBe(0);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "embeddable",
          link,
          isDeleted: false,
        }),
      ]);
    });
    it("should create new history entry on image paste", async () => {
-      await setupImageTest();
+      await render(
        <Excalidraw autoFocus={true} handleKeyboardGlobally={true} />,
      );
      // it's necessary to specify the height in order to calculate natural dimensions of the image
      h.state.height = 1000;
      const smileyImageDimensions = {
        width: 56,
        height: 77,
      };
      mockHTMLImageElement(
        smileyImageDimensions.width,
        smileyImageDimensions.height,
      );
      document.dispatchEvent(
        createPasteEvent({
-          files: await Promise.all([
+          files: [await API.loadFile("./fixtures/smiley_embedded_v2.png")],
            API.loadFile("./fixtures/deer.png"),
            API.loadFile("./fixtures/smiley.png"),
          ]),
        }),
      );
-      await assertImageTest();
+      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
        expect(API.getRedoStack().length).toBe(0);
        expect(h.elements).toEqual([
          expect.objectContaining({
            type: "image",
            fileId: expect.any(String),
            x: expect.toBeNonNaNNumber(),
            y: expect.toBeNonNaNNumber(),
            ...smileyImageDimensions,
          }),
        ]);
        // need to check that delta actually contains initialized image element (with fileId & natural dimensions)
        expect(
          Object.values(h.history.undoStack[0].elements.removed)[0].deleted,
        ).toEqual(
          expect.objectContaining({
            type: "image",
            fileId: expect.any(String),
            x: expect.toBeNonNaNNumber(),
            y: expect.toBeNonNaNNumber(),
            ...smileyImageDimensions,
          }),
        );
      });
      Keyboard.undo();
      expect(API.getUndoStack().length).toBe(0);
      expect(API.getRedoStack().length).toBe(1);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "image",
          fileId: expect.any(String),
          x: expect.toBeNonNaNNumber(),
          y: expect.toBeNonNaNNumber(),
          isDeleted: true,
          ...smileyImageDimensions,
        }),
      ]);
      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(1);
      expect(API.getRedoStack().length).toBe(0);
      expect(h.elements).toEqual([
        expect.objectContaining({
          type: "image",
          fileId: expect.any(String),
          x: expect.toBeNonNaNNumber(),
          y: expect.toBeNonNaNNumber(),
          isDeleted: false,
          ...smileyImageDimensions,
        }),
      ]);
    });
    it("should create new history entry on embeddable link paste", async () => {
@ -2994,14 +3043,15 @@ describe("history", () => {
      });
      Keyboard.undo();
-      expect(API.getUndoStack().length).toBe(0);
+      expect(API.getUndoStack().length).toBe(3);
-      expect(API.getRedoStack().length).toBe(4);
+      expect(API.getRedoStack().length).toBe(1);
-      expect(h.state.selectedLinearElement).toBeNull();
+      expect(h.state.selectedLinearElement).not.toBeNull();
      expect(h.state.selectedLinearElement?.isEditing).toBe(true);
      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(4);
      expect(API.getRedoStack().length).toBe(0);
-      expect(h.state.selectedLinearElement).toBeNull();
+      expect(h.state.selectedLinearElement).not.toBeNull();
      expect(h.state.selectedLinearElement?.isEditing ?? false).toBe(false);
    });
@ -4006,7 +4056,7 @@ describe("history", () => {
            expect.objectContaining({
              id: container.id,
              boundElements: [{ id: remoteText.id, type: "text" }],
-              isDeleted: false,
+              isDeleted: false, // isDeleted got remotely updated to false
            }),
            expect.objectContaining({
              id: text.id,
@ -4015,6 +4065,7 @@ describe("history", () => {
            }),
            expect.objectContaining({
              id: remoteText.id,
              // unbound
              containerId: container.id,
              isDeleted: false,
            }),
@ -4305,8 +4356,8 @@ describe("history", () => {
          expect.objectContaining({
            ...textProps,
            // text element got redrawn!
-            x: 241.295259647664,
+            x: 205,
-            y: 247.59240920619527,
+            y: 205,
            angle: 90,
            id: text.id,
            containerId: container.id,
@ -4349,8 +4400,8 @@ describe("history", () => {
          }),
          expect.objectContaining({
            ...textProps,
-            x: 241.295259647664,
+            x: 205,
-            y: 247.59240920619527,
+            y: 205,
            angle: 90,
            id: text.id,
            containerId: container.id,
--- a/packages/excalidraw/tests/image.test.tsx
+++ b/packages/excalidraw/tests/image.test.tsx
@ -1,115 +0,0 @@
 import { randomId, reseed } from "@excalidraw/common";
 import type { FileId } from "@excalidraw/element/types";
 import * as blobModule from "../data/blob";
 import * as filesystemModule from "../data/filesystem";
 import { Excalidraw } from "../index";
 import { createPasteEvent } from "../clipboard";
 import { API } from "./helpers/api";
 import { mockMultipleHTMLImageElements } from "./helpers/mocks";
 import { UI } from "./helpers/ui";
 import { GlobalTestState, render, waitFor } from "./test-utils";
 import {
  DEER_IMAGE_DIMENSIONS,
  SMILEY_IMAGE_DIMENSIONS,
 } from "./fixtures/constants";
 import { INITIALIZED_IMAGE_PROPS } from "./helpers/constants";
 const { h } = window;
 export const setupImageTest = async (
  sizes: { width: number; height: number }[],
 ) => {
  await render(<Excalidraw autoFocus={true} handleKeyboardGlobally={true} />);
  h.state.height = 1000;
  mockMultipleHTMLImageElements(sizes.map((size) => [size.width, size.height]));
 };
 describe("image insertion", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    vi.unstubAllGlobals();
    reseed(7);
    const generateIdSpy = vi.spyOn(blobModule, "generateIdFromFile");
    const resizeFileSpy = vi.spyOn(blobModule, "resizeImageFile");
    generateIdSpy.mockImplementation(() =>
      Promise.resolve(randomId() as FileId),
    );
    resizeFileSpy.mockImplementation((file: File) => Promise.resolve(file));
    Object.assign(document, {
      elementFromPoint: () => GlobalTestState.canvas,
    });
  });
  const setup = () =>
    setupImageTest([DEER_IMAGE_DIMENSIONS, SMILEY_IMAGE_DIMENSIONS]);
  const assert = async () => {
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({
          ...INITIALIZED_IMAGE_PROPS,
          ...DEER_IMAGE_DIMENSIONS,
        }),
        expect.objectContaining({
          ...INITIALIZED_IMAGE_PROPS,
          ...SMILEY_IMAGE_DIMENSIONS,
        }),
      ]);
    });
    // Not placed on top of each other
    const dimensionsSet = new Set(h.elements.map((el) => `${el.x}-${el.y}`));
    expect(dimensionsSet.size).toEqual(h.elements.length);
  };
  it("should eventually initialize all dropped images", async () => {
    await setup();
    const files = await Promise.all([
      API.loadFile("./fixtures/deer.png"),
      API.loadFile("./fixtures/smiley.png"),
    ]);
    await API.drop(files.map((file) => ({ kind: "file", file })));
    await assert();
  });
  it("should eventually initialize all pasted images", async () => {
    await setup();
    document.dispatchEvent(
      createPasteEvent({
        files: await Promise.all([
          API.loadFile("./fixtures/deer.png"),
          API.loadFile("./fixtures/smiley.png"),
        ]),
      }),
    );
    await assert();
  });
  it("should eventually initialize all images added through image tool", async () => {
    await setup();
    const fileOpenSpy = vi.spyOn(filesystemModule, "fileOpen");
    fileOpenSpy.mockImplementation(
      async () =>
        await Promise.all([
          API.loadFile("./fixtures/deer.png"),
          API.loadFile("./fixtures/smiley.png"),
        ]),
    );
    UI.clickTool("image");
    await assert();
  });
 });
--- a/packages/excalidraw/tests/library.test.tsx
+++ b/packages/excalidraw/tests/library.test.tsx
@ -56,13 +56,9 @@ describe("library", () => {
  it("import library via drag&drop", async () => {
    expect(await h.app.library.getLatestLibrary()).toEqual([]);
-    await API.drop([
+    await API.drop(
-      {
+      await API.loadFile("./fixtures/fixture_library.excalidrawlib"),
-        kind: "file",
+    );
        type: MIME_TYPES.excalidrawlib,
        file: await API.loadFile("./fixtures/fixture_library.excalidrawlib"),
      },
    ]);
    await waitFor(async () => {
      expect(await h.app.library.getLatestLibrary()).toEqual([
        {
@ -79,13 +75,11 @@ describe("library", () => {
  it("drop library item onto canvas", async () => {
    expect(h.elements).toEqual([]);
    const libraryItems = parseLibraryJSON(await libraryJSONPromise);
-    await API.drop([
+    await API.drop(
-      {
+      new Blob([serializeLibraryAsJSON(libraryItems)], {
        kind: "string",
        value: serializeLibraryAsJSON(libraryItems),
        type: MIME_TYPES.excalidrawlib,
-      },
+      }),
-    ]);
+    );
    await waitFor(() => {
      expect(h.elements).toEqual([expect.objectContaining({ [ORIG_ID]: "A" })]);
    });
@ -117,10 +111,10 @@ describe("library", () => {
      },
    });
-    await API.drop([
+    await API.drop(
-      {
+      new Blob(
-        kind: "string",
+        [
-        value: serializeLibraryAsJSON([
+          serializeLibraryAsJSON([
            {
              id: "item1",
              status: "published",
@ -128,9 +122,12 @@ describe("library", () => {
              created: 1,
            },
          ]),
        ],
        {
          type: MIME_TYPES.excalidrawlib,
        },
-    ]);
+      ),
    );
    await waitFor(() => {
      expect(h.elements).toEqual(
@ -173,13 +170,11 @@ describe("library", () => {
      created: 1,
    };
-    await API.drop([
+    await API.drop(
-      {
+      new Blob([serializeLibraryAsJSON([item1, item1])], {
        kind: "string",
        value: serializeLibraryAsJSON([item1, item1]),
        type: MIME_TYPES.excalidrawlib,
-      },
+      }),
-    ]);
+    );
    await waitFor(() => {
      expect(h.elements).toEqual([
@ -198,13 +193,11 @@ describe("library", () => {
    UI.clickTool("rectangle");
    expect(h.elements).toEqual([]);
    const libraryItems = parseLibraryJSON(await libraryJSONPromise);
-    await API.drop([
+    await API.drop(
-      {
+      new Blob([serializeLibraryAsJSON(libraryItems)], {
        kind: "string",
        value: serializeLibraryAsJSON(libraryItems),
        type: MIME_TYPES.excalidrawlib,
-      },
+      }),
-    ]);
+    );
    await waitFor(() => {
      expect(h.elements).toEqual([expect.objectContaining({ [ORIG_ID]: "A" })]);
    });
--- a/packages/excalidraw/types.ts
+++ b/packages/excalidraw/types.ts
@ -248,10 +248,8 @@ export type ObservedElementsAppState = {
  editingGroupId: AppState["editingGroupId"];
  selectedElementIds: AppState["selectedElementIds"];
  selectedGroupIds: AppState["selectedGroupIds"];
-  selectedLinearElement: {
+  selectedLinearElementId: LinearElementEditor["elementId"] | null;
-    elementId: LinearElementEditor["elementId"];
+  selectedLinearElementIsEditing: boolean | null;
    isEditing: boolean;
  } | null;
  croppingElementId: AppState["croppingElementId"];
  lockedMultiSelections: AppState["lockedMultiSelections"];
  activeLockedId: AppState["activeLockedId"];
@ -352,10 +350,6 @@ export interface AppState {
    | "elementBackground"
    | "elementStroke"
    | "fontFamily"
    | "compactTextProperties"
    | "compactStrokeStyles"
    | "compactOtherProperties"
    | "compactArrowProperties"
    | null;
  openSidebar: { name: SidebarName; tab?: SidebarTabName } | null;
  openDialog:
@ -446,9 +440,6 @@ export interface AppState {
  // as elements are unlocked, we remove the groupId from the elements
  // and also remove groupId from this map
  lockedMultiSelections: { [groupId: string]: true };
  /** properties sidebar mode - determines whether to show compact or complete sidebar */
  stylesPanelMode: "compact" | "full";
 }
 export type SearchMatch = {
@ -738,8 +729,6 @@ export type AppClassProperties = {
  onPointerUpEmitter: App["onPointerUpEmitter"];
  updateEditorAtom: App["updateEditorAtom"];
  defaultSelectionTool: "selection" | "lasso";
 };
 export type PointerDownState = Readonly<{
@ -789,10 +778,6 @@ export type PointerDownState = Readonly<{
    // by default same as PointerDownState.origin. On alt-duplication, reset
    // to current pointer position at time of duplication.
    origin: { x: number; y: number };
    // Whether to block drag after lasso selection
    // this is meant to be used to block dragging after lasso selection on PCs
    // until the next pointer down
    blockDragging: boolean;
  };
  // We need to have these in the state so that we can unsubscribe them
  eventListeners: {
@ -814,7 +799,6 @@ export type UnsubscribeCallback = () => void;
 export interface ExcalidrawImperativeAPI {
  updateScene: InstanceType<typeof App>["updateScene"];
  applyDeltas: InstanceType<typeof App>["applyDeltas"];
  mutateElement: InstanceType<typeof App>["mutateElement"];
  updateLibrary: InstanceType<typeof Library>["updateLibrary"];
  resetScene: InstanceType<typeof App>["resetScene"];
--- a/packages/excalidraw/wysiwyg/textWysiwyg.test.tsx
+++ b/packages/excalidraw/wysiwyg/textWysiwyg.test.tsx
@ -704,7 +704,7 @@ describe("textWysiwyg", () => {
        rectangle.x + rectangle.width / 2,
        rectangle.y + rectangle.height / 2,
      );
-      expect(h.elements.length).toBe(3);
+      expect(h.elements.length).toBe(2);
      text = h.elements[1] as ExcalidrawTextElementWithContainer;
      expect(text.type).toBe("text");
@ -1198,11 +1198,7 @@ describe("textWysiwyg", () => {
      updateTextEditor(editor, "   ");
      Keyboard.exitTextEditor(editor);
      expect(rectangle.boundElements).toStrictEqual([]);
-      expect(h.elements[1]).toEqual(
+      expect(h.elements[1]).toBeUndefined();
        expect.objectContaining({
          isDeleted: true,
        }),
      );
    });
    it("should restore original container height and clear cache once text is unbind", async () => {
--- a/packages/excalidraw/wysiwyg/textWysiwyg.tsx
+++ b/packages/excalidraw/wysiwyg/textWysiwyg.tsx
@ -7,7 +7,6 @@ import {
  getFontString,
  getFontFamilyString,
  isTestEnv,
  MIME_TYPES,
 } from "@excalidraw/common";
 import {
@ -46,7 +45,7 @@ import type {
 import { actionSaveToActiveFile } from "../actions";
-import { parseDataTransferEvent } from "../clipboard";
+import { parseClipboard } from "../clipboard";
 import {
  actionDecreaseFontSize,
  actionIncreaseFontSize,
@ -216,12 +215,11 @@ export const textWysiwyg = ({
          );
          app.scene.mutateElement(container, { height: targetContainerHeight });
        } else {
-          const { x, y } = computeBoundTextPosition(
+          const { y } = computeBoundTextPosition(
            container,
            updatedTextElement as ExcalidrawTextElementWithContainer,
            elementsMap,
          );
          coordX = x;
          coordY = y;
        }
      }
@ -333,14 +331,12 @@ export const textWysiwyg = ({
  if (onChange) {
    editable.onpaste = async (event) => {
-      const textItem = (await parseDataTransferEvent(event)).findByType(
+      const clipboardData = await parseClipboard(event, true);
-        MIME_TYPES.text,
+      if (!clipboardData.text) {
      );
      if (!textItem) {
        return;
      }
-      const text = normalizeText(textItem.value);
+      const data = normalizeText(clipboardData.text);
-      if (!text) {
+      if (!data) {
        return;
      }
      const container = getContainerElement(
@ -358,7 +354,7 @@ export const textWysiwyg = ({
          app.scene.getNonDeletedElementsMap(),
        );
        const wrappedText = wrapText(
-          `${editable.value}${text}`,
+          `${editable.value}${data}`,
          font,
          getBoundTextMaxWidth(container, boundTextElement),
        );
@ -542,7 +538,6 @@ export const textWysiwyg = ({
    if (isDestroyed) {
      return;
    }
    isDestroyed = true;
    // cleanup must be run before onSubmit otherwise when app blurs the wysiwyg
    // it'd get stuck in an infinite loop of blur→onSubmit after we re-focus the
@ -626,24 +621,14 @@ export const textWysiwyg = ({
    const isPropertiesTrigger =
      target instanceof HTMLElement &&
      target.classList.contains("properties-trigger");
    const isPropertiesContent =
      (target instanceof HTMLElement || target instanceof SVGElement) &&
      !!(target as Element).closest(".properties-content");
    const inShapeActionsMenu =
      (target instanceof HTMLElement || target instanceof SVGElement) &&
      (!!(target as Element).closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) ||
        !!(target as Element).closest(".compact-shape-actions-island"));
    setTimeout(() => {
      // If we interacted within shape actions menu or its popovers/triggers,
      // keep submit disabled and don't steal focus back to textarea.
      if (inShapeActionsMenu || isPropertiesTrigger || isPropertiesContent) {
        return;
      }
      // Otherwise, re-enable submit on blur and refocus the editor.
      editable.onblur = handleSubmit;
      // case: clicking on the same property → no change → no update → no focus
      if (!isPropertiesTrigger) {
        editable.focus();
      }
    });
  };
@ -666,7 +651,6 @@ export const textWysiwyg = ({
        event.preventDefault();
        app.handleCanvasPanUsingWheelOrSpaceDrag(event);
      }
      temporarilyDisableSubmit();
      return;
    }
@ -674,20 +658,15 @@ export const textWysiwyg = ({
    const isPropertiesTrigger =
      target instanceof HTMLElement &&
      target.classList.contains("properties-trigger");
    const isPropertiesContent =
      (target instanceof HTMLElement || target instanceof SVGElement) &&
      !!(target as Element).closest(".properties-content");
    if (
      ((event.target instanceof HTMLElement ||
        event.target instanceof SVGElement) &&
-        (event.target.closest(
+        event.target.closest(
          `.${CLASSES.SHAPE_ACTIONS_MENU}, .${CLASSES.ZOOM_ACTIONS}`,
-        ) ||
+        ) &&
          event.target.closest(".compact-shape-actions-island")) &&
        !isWritableElement(event.target)) ||
-      isPropertiesTrigger ||
+      isPropertiesTrigger
      isPropertiesContent
    ) {
      temporarilyDisableSubmit();
    } else if (
--- a/packages/math/src/segment.ts
+++ b/packages/math/src/segment.ts
@ -177,19 +177,3 @@ export function lineSegmentIntersectionPoints<
  return candidate;
 }
 export function lineSegmentsDistance<Point extends GlobalPoint | LocalPoint>(
  s1: LineSegment<Point>,
  s2: LineSegment<Point>,
 ): number {
  if (lineSegmentIntersectionPoints(s1, s2)) {
    return 0;
  }
  return Math.min(
    distanceToLineSegment(s1[0], s2),
    distanceToLineSegment(s1[1], s2),
    distanceToLineSegment(s2[0], s1),
    distanceToLineSegment(s2[1], s1),
  );
 }
--- a/packages/utils/src/export.ts
+++ b/packages/utils/src/export.ts
@ -49,7 +49,6 @@ export const exportToCanvas = ({
    { elements, appState },
    null,
    null,
    { deleteInvisibleElements: true },
  );
  const { exportBackground, viewBackgroundColor } = restoredAppState;
  return _exportToCanvas(
@ -180,7 +179,6 @@ export const exportToSvg = async ({
    { elements, appState },
    null,
    null,
    { deleteInvisibleElements: true },
  );
  const exportAppState = {
--- a/packages/utils/tests/snapshots/export.test.ts.snap
+++ b/packages/utils/tests/snapshots/export.test.ts.snap
@ -100,7 +100,6 @@ exports[`exportToSvg > with default arguments 1`] = `
    "open": false,
    "panels": 3,
  },
  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
--- a/yarn.lock
+++ b/yarn.lock
@ -1452,15 +1452,14 @@
  resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
  integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==
-"@excalidraw/mermaid-to-excalidraw@1.1.3":
+"@excalidraw/mermaid-to-excalidraw@1.1.2":
-  version "1.1.3"
+  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-1.1.3.tgz#3204642c99f3d49c2ad41108217a5d493ef7fd09"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-1.1.2.tgz#74d9507971976a7d3d960a1b2e8fb49a9f1f0d22"
-  integrity sha512-/50GUWlGotc+FCMX7nM1P1kWm9vNd3fuq38v7upBp9IHqlw6Zmfyj79eG/0vz1heifuYrSW9yzzv0q9jVALzxg==
+  integrity sha512-hAFv/TTIsOdoy0dL5v+oBd297SQ+Z88gZ5u99fCIFuEMHfQuPgLhU/ztKhFSTs7fISwVo6fizny/5oQRR3d4tQ==
  dependencies:
    "@excalidraw/markdown-to-text" "0.1.2"
-    mermaid "10.9.4"
+    mermaid "10.9.3"
    nanoid "4.0.2"
    react-split "^2.0.14"
 "@excalidraw/prettier-config@1.0.2":
  version "1.0.2"
@ -7058,10 +7057,10 @@ merge2@^1.3.0, merge2@^1.4.1:
  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-mermaid@10.9.4:
+mermaid@10.9.3:
-  version "10.9.4"
+  version "10.9.3"
-  resolved "https://registry.yarnpkg.com/mermaid/-/mermaid-10.9.4.tgz#985fd4b6d73ae795b87f0b32f620a56d3d6bf1f8"
+  resolved "https://registry.yarnpkg.com/mermaid/-/mermaid-10.9.3.tgz#90bc6f15c33dbe5d9507fed31592cc0d88fee9f7"
-  integrity sha512-VIG2B0R9ydvkS+wShA8sXqkzfpYglM2Qwj7VyUeqzNVqSGPoP/tcaUr3ub4ESykv8eqQJn3p99bHNvYdg3gCHQ==
+  integrity sha512-V80X1isSEvAewIL3xhmz/rVmc27CVljcsbWxkxlWJWY/1kQa4XOABqpDl2qQLGKzpKm6WbTfUEKImBlUfFYArw==
  dependencies:
    "@braintree/sanitize-url" "^6.0.1"
    "@types/d3-scale" "^4.0.3"
@ -7964,7 +7963,7 @@ progress@2.0.3, progress@^2.0.0:
  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
  integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
-prop-types@^15.5.7, prop-types@^15.8.1:
+prop-types@^15.8.1:
  version "15.8.1"
  resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz#67d87bf1a694f48435cf332c24af10214a3140b5"
  integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
@ -8109,14 +8108,6 @@ react-remove-scroll@^2.6.3:
    use-callback-ref "^1.3.3"
    use-sidecar "^1.1.3"
 react-split@^2.0.14:
  version "2.0.14"
  resolved "https://registry.yarnpkg.com/react-split/-/react-split-2.0.14.tgz#ef198259bf43264d605f792fb3384f15f5b34432"
  integrity sha512-bKWydgMgaKTg/2JGQnaJPg51T6dmumTWZppFgEbbY0Fbme0F5TuatAScCLaqommbGQQf/ZT1zaejuPDriscISA==
  dependencies:
    prop-types "^15.5.7"
    split.js "^1.6.0"
 react-style-singleton@^2.2.2, react-style-singleton@^2.2.3:
  version "2.2.3"
  resolved "https://registry.yarnpkg.com/react-style-singleton/-/react-style-singleton-2.2.3.tgz#4265608be69a4d70cfe3047f2c6c88b2c3ace388"
@ -8756,11 +8747,6 @@ sourcemap-codec@^1.4.8:
  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
 split.js@^1.6.0:
  version "1.6.5"
  resolved "https://registry.yarnpkg.com/split.js/-/split.js-1.6.5.tgz#f7f61da1044c9984cb42947df4de4fadb5a3f300"
  integrity sha512-mPTnGCiS/RiuTNsVhCm9De9cCAUsrNFFviRbADdKiiV+Kk8HKp/0fWu7Kr8pi3/yBmsqLFHuXGT9UUZ+CNLwFw==
 sprintf-js@~1.0.2:
  version "1.0.3"
  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
Author	SHA1	Message	Date
zsviczian	a17090f455	points cannot be null	2025-08-07 21:39:50 +02:00
zsviczian	2df323a5c3	Apply fixed delta only if points.length > 1	2025-08-07 21:28:30 +02:00