refactor

fix: to support wrapping with autoResize and given dimensions
2025-12-31 14:53:20 +11:00 · 2025-12-29 17:35:00 +11:00
192 changed files with 2556 additions and 8634 deletions
@@ -12,7 +12,7 @@ VITE_APP_WS_SERVER_URL=http://localhost:3002
 VITE_APP_PLUS_LP=https://plus.excalidraw.com
 VITE_APP_PLUS_APP=http://localhost:3000

-VITE_APP_AI_BACKEND=http://localhost:3016
+VITE_APP_AI_BACKEND=http://localhost:3015

 VITE_APP_FIREBASE_CONFIG='{"apiKey":"AIzaSyCMkxA60XIW8KbqMYL7edC4qT5l4qHX2h8","authDomain":"excalidraw-oss-dev.firebaseapp.com","projectId":"excalidraw-oss-dev","storageBucket":"excalidraw-oss-dev.appspot.com","messagingSenderId":"664559512677","appId":"1:664559512677:web:a385181f2928d328a7aa8c"}'

@@ -27,7 +27,7 @@ VITE_APP_ENABLE_TRACKING=true
 FAST_REFRESH=false

 # The port the run the dev server
-VITE_APP_PORT=3001
+VITE_APP_PORT=3000

 #Debug flags

@@ -28,7 +28,7 @@ jobs:
          export SENTRY_RELEASE=$(sentry-cli releases propose-version)
          sentry-cli releases new $SENTRY_RELEASE --project $SENTRY_PROJECT
          sentry-cli releases set-commits --auto $SENTRY_RELEASE
-          sentry-cli sourcemaps upload --release $SENTRY_RELEASE --no-rewrite ./build/static/js/ --url-prefix "~/static/js"
+          sentry-cli releases files $SENTRY_RELEASE upload-sourcemaps --no-rewrite ./build/static/js/ --url-prefix "~/static/js"
          sentry-cli releases finalize $SENTRY_RELEASE
          sentry-cli releases deploys $SENTRY_RELEASE new -e production
        env:
@@ -14,7 +14,7 @@ jobs:
      - name: "Install Node"
        uses: actions/setup-node@v2
        with:
-          node-version: "20.x"
+          node-version: "18.x"
      - name: "Install Deps"
        run: yarn install
      - name: "Test Coverage"
@@ -9,10 +9,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - name: Setup Node.js
+      - name: Setup Node.js 18.x
        uses: actions/setup-node@v4
        with:
-          node-version: 20.x
+          node-version: 18.x
      - name: Install and test
        run: |
          yarn install
@@ -48,11 +48,7 @@ import {
  youtubeIcon,
 } from "@excalidraw/excalidraw/components/icons";
 import { isElementLink } from "@excalidraw/element";
-import {
-  bumpElementVersions,
-  restoreAppState,
-  restoreElements,
-} from "@excalidraw/excalidraw/data/restore";
+import { restore, restoreAppState } from "@excalidraw/excalidraw/data/restore";
 import { newElementWith } from "@excalidraw/element";
 import { isInitializedImageElement } from "@excalidraw/element";
 import clsx from "clsx";
@@ -109,8 +105,8 @@ import { TopErrorBoundary } from "./components/TopErrorBoundary";
 import {
  exportToBackend,
  getCollaborationLinkData,
-  importFromBackend,
  isCollaborationLink,
+  loadScene,
 } from "./data";

 import { updateStaleImageStatuses } from "./data/FileManager";
@@ -228,20 +224,9 @@ const initializeScene = async (opts: {

  const localDataState = importFromLocalStorage();

-  let scene: Omit<
-    RestoredDataState,
-    // we're not storing files in the scene database/localStorage, and instead
-    // fetch them async from a different store
-    "files"
-  > & {
+  let scene: RestoredDataState & {
    scrollToContent?: boolean;
-  } = {
-    elements: restoreElements(localDataState?.elements, null, {
-      repairBindings: true,
-      deleteInvisibleElements: true,
-    }),
-    appState: restoreAppState(localDataState?.appState, null),
-  };
+  } = await loadScene(null, null, localDataState);

  let roomLinkData = getCollaborationLinkData(window.location.href);
  const isExternalScene = !!(id || jsonBackendMatch || roomLinkData);
@@ -255,26 +240,11 @@ const initializeScene = async (opts: {
      (await openConfirmModal(shareableLinkConfirmDialog))
    ) {
      if (jsonBackendMatch) {
-        const imported = await importFromBackend(
+        scene = await loadScene(
          jsonBackendMatch[1],
          jsonBackendMatch[2],
+          localDataState,
        );
-
-        scene = {
-          elements: bumpElementVersions(
-            restoreElements(imported.elements, null, {
-              repairBindings: true,
-              deleteInvisibleElements: true,
-            }),
-            localDataState?.elements,
-          ),
-          appState: restoreAppState(
-            imported.appState,
-            // local appState when importing from backend to ensure we restore
-            // localStorage user settings which we do not persist on server.
-            localDataState?.appState,
-          ),
-        };
      }
      scene.scrollToContent = true;
      if (!roomLinkData) {
@@ -526,10 +496,8 @@ const ExcalidrawWrapper = () => {
          loadImages(data);
          if (data.scene) {
            excalidrawAPI.updateScene({
-              elements: restoreElements(data.scene.elements, null, {
-                repairBindings: true,
-              }),
-              appState: restoreAppState(data.scene.appState, null),
+              ...data.scene,
+              ...restore(data.scene, null, null, { repairBindings: true }),
              captureUpdate: CaptureUpdateAction.IMMEDIATELY,
            });
          }
@@ -46,7 +46,6 @@ export const STORAGE_KEYS = {
  VERSION_FILES: "version-files",

  IDB_LIBRARY: "excalidraw-library",
-  IDB_TTD_CHATS: "excalidraw-ttd-chats",

  // do not use apart from migrations
  __LEGACY_LOCAL_STORAGE_LIBRARY: "excalidraw-library",
@@ -6,7 +6,7 @@ import {
  reconcileElements,
 } from "@excalidraw/excalidraw";
 import { ErrorDialog } from "@excalidraw/excalidraw/components/ErrorDialog";
-import { APP_NAME, cloneJSON, EVENT, toBrandedType } from "@excalidraw/common";
+import { APP_NAME, EVENT } from "@excalidraw/common";
 import {
  IDLE_THRESHOLD,
  ACTIVE_THRESHOLD,
@@ -29,8 +29,6 @@ import { withBatchedUpdates } from "@excalidraw/excalidraw/reactUtils";
 import throttle from "lodash.throttle";
 import { PureComponent } from "react";

-import { bumpElementVersions } from "@excalidraw/excalidraw/data/restore";
-
 import type {
  ReconciledExcalidrawElement,
  RemoteExcalidrawElement,
@@ -313,7 +311,6 @@ class Collab extends PureComponent<CollabProps, CollabState> {
  saveCollabRoomToFirebase = async (
    syncableElements: readonly SyncableExcalidrawElement[],
  ) => {
-    syncableElements = cloneJSON(syncableElements);
    try {
      const storedElements = await saveToFirebase(
        this.portal,
@@ -582,9 +579,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
          case WS_SUBTYPES.INIT: {
            if (!this.portal.socketInitialized) {
              this.initializeRoom({ fetchScene: false });
-              const remoteElements = toBrandedType<
-                readonly RemoteExcalidrawElement[]
-              >(decryptedData.payload.elements);
+              const remoteElements = decryptedData.payload.elements;
              const reconciledElements =
                this._reconcileElements(remoteElements);
              this.handleRemoteSceneUpdate(reconciledElements);
@@ -598,11 +593,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
          }
          case WS_SUBTYPES.UPDATE:
            this.handleRemoteSceneUpdate(
-              this._reconcileElements(
-                toBrandedType<readonly RemoteExcalidrawElement[]>(
-                  decryptedData.payload.elements,
-                ),
-              ),
+              this._reconcileElements(decryptedData.payload.elements),
            );
            break;
          case WS_SUBTYPES.MOUSE_LOCATION: {
@@ -751,26 +742,18 @@ class Collab extends PureComponent<CollabProps, CollabState> {
  };

  private _reconcileElements = (
-    remoteElements: readonly RemoteExcalidrawElement[],
+    remoteElements: readonly ExcalidrawElement[],
  ): ReconciledExcalidrawElement[] => {
+    const localElements = this.getSceneElementsIncludingDeleted();
    const appState = this.excalidrawAPI.getAppState();
-
-    const existingElements = this.getSceneElementsIncludingDeleted();
-
-    // NOTE ideally we restore _after_ reconciliation but we can't do that
-    // as we'd regenerate even elements such as appState.newElement which would
-    // break the state
-    remoteElements = restoreElements(remoteElements, existingElements);
-
-    let reconciledElements = reconcileElements(
-      existingElements,
+    const restoredRemoteElements = restoreElements(
      remoteElements,
-      appState,
+      this.excalidrawAPI.getSceneElementsMapIncludingDeleted(),
    );
-
-    reconciledElements = bumpElementVersions(
-      reconciledElements,
-      existingElements,
+    const reconciledElements = reconcileElements(
+      localElements,
+      restoredRemoteElements as RemoteExcalidrawElement[],
+      appState,
    );

    // Avoid broadcasting to the rest of the collaborators the scene
@@ -4,15 +4,12 @@ import {
  getTextFromElements,
  MIME_TYPES,
  TTDDialog,
-  TTDStreamFetch,
 } from "@excalidraw/excalidraw";
 import { getDataURL } from "@excalidraw/excalidraw/data/blob";
 import { safelyParseJSON } from "@excalidraw/common";

 import type { ExcalidrawImperativeAPI } from "@excalidraw/excalidraw/types";

-import { TTDIndexedDBAdapter } from "../data/TTDStorage";
-
 export const AIComponents = ({
  excalidrawAPI,
 }: {
@@ -102,23 +99,61 @@ export const AIComponents = ({
      />

      <TTDDialog
-        onTextSubmit={async (props) => {
-          const { onChunk, onStreamCreated, signal, messages } = props;
+        onTextSubmit={async (input) => {
+          try {
+            const response = await fetch(
+              `${
+                import.meta.env.VITE_APP_AI_BACKEND
+              }/v1/ai/text-to-diagram/generate`,
+              {
+                method: "POST",
+                headers: {
+                  Accept: "application/json",
+                  "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ prompt: input }),
+              },
+            );

-          const result = await TTDStreamFetch({
-            url: `${
-              import.meta.env.VITE_APP_AI_BACKEND
-            }/v1/ai/text-to-diagram/chat-streaming`,
-            messages,
-            onChunk,
-            onStreamCreated,
-            extractRateLimits: true,
-            signal,
-          });
+            const rateLimit = response.headers.has("X-Ratelimit-Limit")
+              ? parseInt(response.headers.get("X-Ratelimit-Limit") || "0", 10)
+              : undefined;

-          return result;
+            const rateLimitRemaining = response.headers.has(
+              "X-Ratelimit-Remaining",
+            )
+              ? parseInt(
+                  response.headers.get("X-Ratelimit-Remaining") || "0",
+                  10,
+                )
+              : undefined;
+
+            const json = await response.json();
+
+            if (!response.ok) {
+              if (response.status === 429) {
+                return {
+                  rateLimit,
+                  rateLimitRemaining,
+                  error: new Error(
+                    "Too many requests today, please try again tomorrow!",
+                  ),
+                };
+              }
+
+              throw new Error(json.message || "Generation failed...");
+            }
+
+            const generatedResponse = json.generatedResponse;
+            if (!generatedResponse) {
+              throw new Error("Generation failed...");
+            }
+
+            return { generatedResponse, rateLimit, rateLimitRemaining };
+          } catch (err: any) {
+            throw new Error("Request failed");
+          }
        }}
-        persistenceAdapter={TTDIndexedDBAdapter}
      />
    </>
  );
@@ -27,10 +27,7 @@ import { isCurve } from "@excalidraw/math/curve";
 import React from "react";

 import type { Curve } from "@excalidraw/math";
-import type {
-  DebugElement,
-  DebugPolygon,
-} from "@excalidraw/element/visualdebug";
+import type { DebugElement } from "@excalidraw/common";
 import type {
  ElementsMap,
  ExcalidrawArrowElement,
@@ -78,44 +75,6 @@ const renderCubicBezier = (
  context.restore();
 };

-const renderPolygon = (
-  context: CanvasRenderingContext2D,
-  zoom: number,
-  polygon: DebugPolygon,
-  color: string,
-) => {
-  const { points, fill, close } = polygon;
-
-  if (points.length < 2) {
-    return;
-  }
-
-  context.save();
-  context.beginPath();
-  context.moveTo(points[0][0] * zoom, points[0][1] * zoom);
-  for (let i = 1; i < points.length; i += 1) {
-    context.lineTo(points[i][0] * zoom, points[i][1] * zoom);
-  }
-  if (close !== false) {
-    context.closePath();
-  }
-
-  if (fill) {
-    context.save();
-    context.globalAlpha = 0.15;
-    context.fillStyle = color;
-    context.fill();
-    context.restore();
-  }
-
-  context.strokeStyle = color;
-  context.stroke();
-  context.restore();
-};
-
-const isDebugPolygon = (data: DebugElement["data"]): data is DebugPolygon =>
-  (data as DebugPolygon).type === "polygon";
-
 const renderOrigin = (context: CanvasRenderingContext2D, zoom: number) => {
  context.strokeStyle = "#888";
  context.save();
@@ -321,9 +280,6 @@ const render = (
          el.color,
        );
        break;
-      case isDebugPolygon(el.data):
-        renderPolygon(context, appState.zoom.value, el.data, el.color);
-        break;
      default:
        throw new Error(`Unknown element type ${JSON.stringify(el)}`);
    }
@@ -0,0 +1,46 @@
+import { THEME } from "@excalidraw/common";
+import oc from "open-color";
+import React from "react";
+
+import type { Theme } from "@excalidraw/element/types";
+
+// https://github.com/tholman/github-corners
+export const GitHubCorner = React.memo(
+  ({ theme, dir }: { theme: Theme; dir: string }) => (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width="40"
+      height="40"
+      viewBox="0 0 250 250"
+      className="rtl-mirror"
+      style={{
+        marginTop: "calc(var(--space-factor) * -1)",
+        [dir === "rtl" ? "marginLeft" : "marginRight"]:
+          "calc(var(--space-factor) * -1)",
+      }}
+    >
+      <a
+        href="https://github.com/excalidraw/excalidraw"
+        target="_blank"
+        rel="noopener noreferrer"
+        aria-label="GitHub repository"
+      >
+        <path
+          d="M0 0l115 115h15l12 27 108 108V0z"
+          fill={theme === THEME.LIGHT ? oc.gray[6] : oc.gray[7]}
+        />
+        <path
+          className="octo-arm"
+          d="M128 109c-15-9-9-19-9-19 3-7 2-11 2-11-1-7 3-2 3-2 4 5 2 11 2 11-3 10 5 15 9 16"
+          style={{ transformOrigin: "130px 106px" }}
+          fill={theme === THEME.LIGHT ? oc.white : "var(--default-bg-color)"}
+        />
+        <path
+          className="octo-body"
+          d="M115 115s4 2 5 0l14-14c3-2 6-3 8-3-8-11-15-24 2-41 5-5 10-7 16-7 1-2 3-7 12-11 0 0 5 3 7 16 4 2 8 5 12 9s7 8 9 12c14 3 17 7 17 7-4 8-9 11-11 11 0 6-2 11-7 16-16 16-30 10-41 2 0 3-1 7-5 11l-12 11c-1 1 1 5 1 5z"
+          fill={theme === THEME.LIGHT ? oc.white : "var(--default-bg-color)"}
+        />
+      </a>
+    </svg>
+  ),
+);
@@ -1,51 +0,0 @@
-import { createStore, get, set } from "idb-keyval";
-
-import type { SavedChats } from "@excalidraw/excalidraw/components/TTDDialog/types";
-
-import { STORAGE_KEYS } from "../app_constants";
-
-/**
- * IndexedDB adapter for TTD chat storage.
- * Implements TTDPersistenceAdapter interface.
- */
-export class TTDIndexedDBAdapter {
-  /** IndexedDB database name */
-  private static idb_name = STORAGE_KEYS.IDB_TTD_CHATS;
-  /** Store key for chat data */
-  private static key = "ttdChats";
-
-  private static store = createStore(
-    `${TTDIndexedDBAdapter.idb_name}-db`,
-    `${TTDIndexedDBAdapter.idb_name}-store`,
-  );
-
-  /**
-   * Load saved chats from IndexedDB.
-   * @returns Promise resolving to saved chats array (empty if none found)
-   */
-  static async loadChats(): Promise<SavedChats> {
-    try {
-      const data = await get<SavedChats>(
-        TTDIndexedDBAdapter.key,
-        TTDIndexedDBAdapter.store,
-      );
-      return data || [];
-    } catch (error) {
-      console.warn("Failed to load TTD chats from IndexedDB:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Save chats to IndexedDB.
-   * @param chats - The chats array to persist
-   */
-  static async saveChats(chats: SavedChats): Promise<void> {
-    try {
-      await set(TTDIndexedDBAdapter.key, chats, TTDIndexedDBAdapter.store);
-    } catch (error) {
-      console.warn("Failed to save TTD chats to IndexedDB:", error);
-      throw error;
-    }
-  }
-}
@@ -1,5 +1,5 @@
 import { reconcileElements } from "@excalidraw/excalidraw";
-import { MIME_TYPES, toBrandedType } from "@excalidraw/common";
+import { MIME_TYPES } from "@excalidraw/common";
 import { decompressData } from "@excalidraw/excalidraw/data/encode";
 import {
  encryptData,
@@ -243,7 +243,7 @@ export const saveToFirebase = async (

  FirebaseSceneVersionCache.set(socket, storedElements);

-  return toBrandedType<RemoteExcalidrawElement[]>(storedElements);
+  return storedElements;
 };

 export const loadFromFirebase = async (
@@ -8,6 +8,7 @@ import {
  IV_LENGTH_BYTES,
 } from "@excalidraw/excalidraw/data/encryption";
 import { serializeAsJSON } from "@excalidraw/excalidraw/data/json";
+import { restore } from "@excalidraw/excalidraw/data/restore";
 import { isInvisiblySmallElement } from "@excalidraw/element";
 import { isInitializedImageElement } from "@excalidraw/element";
 import { t } from "@excalidraw/excalidraw/i18n";
@@ -83,13 +84,13 @@ export type SocketUpdateDataSource = {
  SCENE_INIT: {
    type: WS_SUBTYPES.INIT;
    payload: {
-      elements: readonly OrderedExcalidrawElement[];
+      elements: readonly ExcalidrawElement[];
    };
  };
  SCENE_UPDATE: {
    type: WS_SUBTYPES.UPDATE;
    payload: {
-      elements: readonly OrderedExcalidrawElement[];
+      elements: readonly ExcalidrawElement[];
    };
  };
  MOUSE_LOCATION: {
@@ -199,7 +200,7 @@ const legacy_decodeFromBackend = async ({
  };
 };

-export const importFromBackend = async (
+const importFromBackend = async (
  id: string,
  decryptionKey: string,
 ): Promise<ImportedDataState> => {
@@ -241,6 +242,45 @@ export const importFromBackend = async (
  }
 };

+export const loadScene = async (
+  id: string | null,
+  privateKey: string | null,
+  // Supply local state even if importing from backend to ensure we restore
+  // localStorage user settings which we do not persist on server.
+  // Non-optional so we don't forget to pass it even if `undefined`.
+  localDataState: ImportedDataState | undefined | null,
+) => {
+  let data;
+  if (id != null && privateKey != null) {
+    // the private key is used to decrypt the content from the server, take
+    // extra care not to leak it
+    data = restore(
+      await importFromBackend(id, privateKey),
+      localDataState?.appState,
+      localDataState?.elements,
+      {
+        repairBindings: true,
+        refreshDimensions: false,
+        deleteInvisibleElements: true,
+      },
+    );
+  } else {
+    data = restore(localDataState || null, null, null, {
+      repairBindings: true,
+      deleteInvisibleElements: true,
+    });
+  }
+
+  return {
+    elements: data.elements,
+    appState: data.appState,
+    // note: this will always be empty because we're not storing files
+    // in the scene database/localStorage, and instead fetch them async
+    // from a different database
+    files: data.files,
+  };
+};
+
 type ExportToBackendResult =
  | { url: null; errorMessage: string }
  | { url: string; errorMessage: null };
@@ -10,6 +10,8 @@ const lessPrecise = (num: number, precision = 5) =>
 const getAvgFrameTime = (times: number[]) =>
  lessPrecise(times.reduce((a, b) => a + b) / times.length);

+const getFps = (frametime: number) => lessPrecise(1000 / frametime);
+
 export class Debug {
  public static DEBUG_LOG_TIMES = true;

@@ -22,35 +24,34 @@ export class Debug {
  private static LAST_DEBUG_LOG_CALL = 0;
  private static DEBUG_LOG_INTERVAL_ID: null | number = null;

-  private static LAST_FRAME_TIMESTAMP = 0;
-  private static FRAME_COUNT = 0;
-  private static ANIMATION_FRAME_ID: null | number = null;
-
-  private static scheduleAnimationFrame = () => {
-    if (Debug.DEBUG_LOG_INTERVAL_ID !== null) {
-      Debug.ANIMATION_FRAME_ID = requestAnimationFrame((timestamp) => {
-        if (Debug.LAST_FRAME_TIMESTAMP !== timestamp) {
-          Debug.LAST_FRAME_TIMESTAMP = timestamp;
-          Debug.FRAME_COUNT++;
-        }
-
-        if (Debug.DEBUG_LOG_INTERVAL_ID !== null) {
-          Debug.scheduleAnimationFrame();
-        }
-      });
-    }
-  };
-
  private static setupInterval = () => {
    if (Debug.DEBUG_LOG_INTERVAL_ID === null) {
      console.info("%c(starting perf recording)", "color: lime");
      Debug.DEBUG_LOG_INTERVAL_ID = window.setInterval(Debug.debugLogger, 1000);
-      Debug.scheduleAnimationFrame();
    }
    Debug.LAST_DEBUG_LOG_CALL = Date.now();
  };

  private static debugLogger = () => {
+    if (
+      Date.now() - Debug.LAST_DEBUG_LOG_CALL > 600 &&
+      Debug.DEBUG_LOG_INTERVAL_ID !== null
+    ) {
+      window.clearInterval(Debug.DEBUG_LOG_INTERVAL_ID);
+      Debug.DEBUG_LOG_INTERVAL_ID = null;
+      for (const [name, { avg }] of Object.entries(Debug.TIMES_AVG)) {
+        if (avg != null) {
+          console.info(
+            `%c${name} run avg: ${avg}ms (${getFps(avg)} fps)`,
+            "color: blue",
+          );
+        }
+      }
+      console.info("%c(stopping perf recording)", "color: red");
+      Debug.TIMES_AGGR = {};
+      Debug.TIMES_AVG = {};
+      return;
+    }
    if (Debug.DEBUG_LOG_TIMES) {
      for (const [name, { t, times }] of Object.entries(Debug.TIMES_AGGR)) {
        if (times.length) {
@@ -64,18 +65,8 @@ export class Debug {
      }
      for (const [name, { t, times, avg }] of Object.entries(Debug.TIMES_AVG)) {
        if (times.length) {
-          // const avgFrameTime = getAvgFrameTime(times);
-          const totalTime = times.reduce((a, b) => a + b);
-          const avgFrameTime = lessPrecise(totalTime / Debug.FRAME_COUNT);
-          console.info(
-            name,
-            `- ${times.length} calls - ${avgFrameTime}ms/frame across ${
-              Debug.FRAME_COUNT
-            } frames (${lessPrecise(
-              (avgFrameTime / 16.67) * 100,
-              1,
-            )}% of frame budget)`,
-          );
+          const avgFrameTime = getAvgFrameTime(times);
+          console.info(name, `${avgFrameTime}ms (${getFps(avgFrameTime)} fps)`);
          Debug.TIMES_AVG[name] = {
            t,
            times: [],
@@ -85,24 +76,6 @@ export class Debug {
        }
      }
    }
-    Debug.FRAME_COUNT = 0;
-
-    // Check for stop condition after logging
-    if (
-      Date.now() - Debug.LAST_DEBUG_LOG_CALL > 600 &&
-      Debug.DEBUG_LOG_INTERVAL_ID !== null
-    ) {
-      console.info("%c(stopping perf recording)", "color: red");
-      window.clearInterval(Debug.DEBUG_LOG_INTERVAL_ID);
-      window.cancelAnimationFrame(Debug.ANIMATION_FRAME_ID!);
-      Debug.ANIMATION_FRAME_ID = null;
-      Debug.FRAME_COUNT = 0;
-      Debug.LAST_FRAME_TIMESTAMP = 0;
-
-      Debug.DEBUG_LOG_INTERVAL_ID = null;
-      Debug.TIMES_AGGR = {};
-      Debug.TIMES_AVG = {};
-    }
  };

  public static logTime = (time?: number, name = "default") => {
@@ -136,7 +109,7 @@ export class Debug {
      return (...args: T) => {
        const t0 = performance.now();
        const ret = fn(...args);
-        Debug[type](performance.now() - t0, name);
+        Debug.logTime(performance.now() - t0, name);
        return ret;
      };
    };
@@ -36,7 +36,6 @@
    "react": "19.0.0",
    "react-dom": "19.0.0",
    "socket.io-client": "4.7.2",
-    "uqr": "0.1.2",
    "vite-plugin-html": "3.2.2"
  },
  "prettier": "@excalidraw/prettier-config",
@@ -1,56 +0,0 @@
-import { useEffect, useState } from "react";
-import Spinner from "@excalidraw/excalidraw/components/Spinner";
-
-interface QRCodeProps {
-  value: string;
-}
-
-export const QRCode = ({ value }: QRCodeProps) => {
-  const [svgData, setSvgData] = useState<string | null>(null);
-  const [error, setError] = useState<boolean>(false);
-
-  useEffect(() => {
-    let mounted = true;
-
-    import("./qrcode.chunk")
-      .then(({ generateQRCodeSVG }) => {
-        if (mounted) {
-          try {
-            setSvgData(generateQRCodeSVG(value));
-          } catch {
-            setError(true);
-          }
-        }
-      })
-      .catch(() => {
-        if (mounted) {
-          setError(true);
-        }
-      });
-
-    return () => {
-      mounted = false;
-    };
-  }, [value]);
-
-  if (error) {
-    return null;
-  }
-
-  if (!svgData) {
-    return (
-      <div className="ShareDialog__active__qrcode ShareDialog__active__qrcode--loading">
-        <Spinner />
-      </div>
-    );
-  }
-
-  return (
-    <div
-      className="ShareDialog__active__qrcode"
-      role="img"
-      aria-label="QR code for collaboration link"
-      dangerouslySetInnerHTML={{ __html: svgData }}
-    />
-  );
-};
@@ -140,31 +140,6 @@
        gap: 0.75rem;
      }

-      &__qrcode {
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        align-self: center;
-        padding: 1rem;
-        background: #fff;
-        border-radius: 0.5rem;
-        border: 1px solid #e0e0e0;
-
-        $size: 150px;
-        width: $size;
-        height: $size;
-
-        & svg {
-          width: $size;
-          height: $size;
-        }
-
-        &--loading {
-          background: var(--island-bg-color);
-          border: 1px solid var(--dialog-border-color);
-        }
-      }
-
      &__description {
        border-top: 1px solid var(--color-gray-20);

@@ -22,7 +22,6 @@ import { atom, useAtom, useAtomValue } from "../app-jotai";
 import { activeRoomLinkAtom } from "../collab/Collab";

 import "./ShareDialog.scss";
-import { QRCode } from "./QRCode";

 import type { CollabAPI } from "../collab/Collab";

@@ -143,7 +142,6 @@ const ActiveRoomDialog = ({
          }}
        />
      </div>
-      <QRCode value={activeRoomLink} />
      <div className="ShareDialog__active__description">
        <p>
          <span
@@ -1,5 +0,0 @@
-import { renderSVG } from "uqr";
-
-export const generateQRCodeSVG = (text: string): string => {
-  return renderSVG(text);
-};
@@ -102,10 +102,6 @@ export default defineConfig(({ mode }) => {
              // Taking the substring after "locales/"
              return `locales/${id.substring(index + 8)}`;
            }
-
-            if (id.includes("@excalidraw/mermaid-to-excalidraw")) {
-              return "mermaid-to-excalidraw";
-            }
          },
        },
      },
@@ -200,7 +196,6 @@ export default defineConfig(({ mode }) => {
              },
            },
          ],
-          maximumFileSizeToCacheInBytes: 2.3 * 1024 ** 2, // 2.3MB
        },
        manifest: {
          short_name: "Excalidraw",
@@ -55,11 +55,5 @@
  "scripts": {
    "gen:types": "rimraf types && tsc",
    "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
-  },
-  "dependencies": {
-    "tinycolor2": "1.6.0"
-  },
-  "devDependencies": {
-    "@types/tinycolor2": "1.4.6"
  }
 }
@@ -1,185 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`COLOR_PALETTE > color palette doesn't regress 1`] = `
-{
-  "black": "#1e1e1e",
-  "blue": [
-    "#e7f5ff",
-    "#a5d8ff",
-    "#4dabf7",
-    "#228be6",
-    "#1971c2",
-  ],
-  "bronze": [
-    "#f8f1ee",
-    "#eaddd7",
-    "#d2bab0",
-    "#a18072",
-    "#846358",
-  ],
-  "cyan": [
-    "#e3fafc",
-    "#99e9f2",
-    "#3bc9db",
-    "#15aabf",
-    "#0c8599",
-  ],
-  "grape": [
-    "#f8f0fc",
-    "#eebefa",
-    "#da77f2",
-    "#be4bdb",
-    "#9c36b5",
-  ],
-  "gray": [
-    "#f8f9fa",
-    "#e9ecef",
-    "#ced4da",
-    "#868e96",
-    "#343a40",
-  ],
-  "green": [
-    "#ebfbee",
-    "#b2f2bb",
-    "#69db7c",
-    "#40c057",
-    "#2f9e44",
-  ],
-  "orange": [
-    "#fff4e6",
-    "#ffd8a8",
-    "#ffa94d",
-    "#fd7e14",
-    "#e8590c",
-  ],
-  "pink": [
-    "#fff0f6",
-    "#fcc2d7",
-    "#f783ac",
-    "#e64980",
-    "#c2255c",
-  ],
-  "red": [
-    "#fff5f5",
-    "#ffc9c9",
-    "#ff8787",
-    "#fa5252",
-    "#e03131",
-  ],
-  "teal": [
-    "#e6fcf5",
-    "#96f2d7",
-    "#38d9a9",
-    "#12b886",
-    "#099268",
-  ],
-  "transparent": "transparent",
-  "violet": [
-    "#f3f0ff",
-    "#d0bfff",
-    "#9775fa",
-    "#7950f2",
-    "#6741d9",
-  ],
-  "white": "#ffffff",
-  "yellow": [
-    "#fff9db",
-    "#ffec99",
-    "#ffd43b",
-    "#fab005",
-    "#f08c00",
-  ],
-}
-`;
-
-exports[`applyDarkModeFilter > COLOR_PALETTE regression tests > matches snapshot for all palette colors 1`] = `
-{
-  "black": "#d3d3d3",
-  "blue": [
-    "#121e26",
-    "#154162",
-    "#2273b4",
-    "#3791e0",
-    "#56a2e8",
-  ],
-  "bronze": [
-    "#221c1a",
-    "#362b26",
-    "#5a463d",
-    "#917569",
-    "#a98d84",
-  ],
-  "cyan": [
-    "#0a1e20",
-    "#004149",
-    "#007281",
-    "#0f8fa1",
-    "#3da5b6",
-  ],
-  "grape": [
-    "#211a25",
-    "#5b3165",
-    "#a954be",
-    "#d471ed",
-    "#e28af8",
-  ],
-  "gray": [
-    "#161718",
-    "#202325",
-    "#33383d",
-    "#6e757c",
-    "#b7bcc1",
-  ],
-  "green": [
-    "#0f1d12",
-    "#043b0c",
-    "#056715",
-    "#16842a",
-    "#39994b",
-  ],
-  "orange": [
-    "#22190d",
-    "#4c2b01",
-    "#924800",
-    "#cd6005",
-    "#f17634",
-  ],
-  "pink": [
-    "#26191e",
-    "#602e40",
-    "#b04d70",
-    "#f56e9d",
-    "#ff8dbc",
-  ],
-  "red": [
-    "#1f1717",
-    "#5a2c2c",
-    "#b44d4d",
-    "#fa6969",
-    "#ff8383",
-  ],
-  "teal": [
-    "#0a1d17",
-    "#00422b",
-    "#00744b",
-    "#039267",
-    "#32a783",
-  ],
-  "transparent": "#ededed00",
-  "violet": [
-    "#1f1c29",
-    "#4a3b72",
-    "#8a6cdf",
-    "#a885ff",
-    "#b595ff",
-  ],
-  "white": "#121212",
-  "yellow": [
-    "#1e1900",
-    "#362600",
-    "#5f3a00",
-    "#905000",
-    "#b86200",
-  ],
-}
-`;
@@ -1,286 +0,0 @@
-import {
-  applyDarkModeFilter,
-  COLOR_PALETTE,
-  rgbToHex,
-} from "@excalidraw/common";
-
-describe("COLOR_PALETTE", () => {
-  it("color palette doesn't regress", () => {
-    expect(COLOR_PALETTE).toMatchSnapshot();
-  });
-});
-
-describe("applyDarkModeFilter", () => {
-  describe("basic transformations", () => {
-    it("transforms black to near-white", () => {
-      const result = applyDarkModeFilter("#000000");
-      // Black inverted 93% + hue rotate should be near white/light gray
-      expect(result).toBe("#ededed");
-    });
-
-    it("transforms white to near-black", () => {
-      const result = applyDarkModeFilter("#ffffff");
-      // White inverted 93% should be near black/dark gray
-      expect(result).toBe("#121212");
-    });
-
-    it("transforms pure red", () => {
-      const result = applyDarkModeFilter("#ff0000");
-      // Invert 93% + hue rotate 180deg produces a cyan-ish tint
-      expect(result).toBe("#ff9090");
-    });
-
-    it("transforms pure green", () => {
-      const result = applyDarkModeFilter("#00ff00");
-      // Invert 93% + hue rotate 180deg
-      expect(result).toBe("#008f00");
-    });
-
-    it("transforms pure blue", () => {
-      const result = applyDarkModeFilter("#0000ff");
-      // Invert 93% + hue rotate 180deg produces a light purple
-      expect(result).toBe("#cdcdff");
-    });
-  });
-
-  describe("color formats", () => {
-    it("handles hex with hash", () => {
-      const result = applyDarkModeFilter("#ff0000");
-      // Fully opaque colors return 6-char hex
-      expect(result).toMatch(/^#[0-9a-f]{6}$/);
-    });
-
-    it("handles named colors", () => {
-      const result = applyDarkModeFilter("red");
-      // "red" = #ff0000, fully opaque
-      expect(result).toBe("#ff9090");
-    });
-
-    it("handles rgb format", () => {
-      const result = applyDarkModeFilter("rgb(255, 0, 0)");
-      expect(result).toBe("#ff9090");
-    });
-
-    it("handles rgba format and preserves alpha", () => {
-      const result = applyDarkModeFilter("rgba(255, 0, 0, 0.5)");
-      expect(result).toMatch(/^#[0-9a-f]{8}$/);
-      // Alpha 0.5 = 128 in hex = 80
-      expect(result).toBe("#ff909080");
-    });
-
-    it("handles transparent", () => {
-      const result = applyDarkModeFilter("transparent");
-      // transparent = rgba(0,0,0,0), inverted should still have 0 alpha
-      expect(result).toBe("#ededed00");
-    });
-
-    it("handles shorthand hex", () => {
-      const result = applyDarkModeFilter("#f00");
-      expect(result).toBe("#ff9090");
-    });
-  });
-
-  describe("alpha preservation", () => {
-    it("omits alpha for full opacity", () => {
-      const result = applyDarkModeFilter("#ff0000ff");
-      // Full opacity returns 6-char hex (no alpha suffix)
-      expect(result).toBe("#ff9090");
-    });
-
-    it("preserves 50% opacity", () => {
-      const result = applyDarkModeFilter("#ff000080");
-      expect(result.slice(-2)).toBe("80");
-    });
-
-    it("preserves 0% opacity", () => {
-      const result = applyDarkModeFilter("#ff000000");
-      expect(result.slice(-2)).toBe("00");
-    });
-  });
-
-  describe("COLOR_PALETTE regression tests", () => {
-    it("transforms black from palette", () => {
-      // COLOR_PALETTE.black is #1e1e1e (not pure black)
-      const result = applyDarkModeFilter(COLOR_PALETTE.black);
-      expect(result).toBe("#d3d3d3");
-    });
-
-    it("transforms white from palette", () => {
-      const result = applyDarkModeFilter(COLOR_PALETTE.white);
-      expect(result).toBe("#121212");
-    });
-
-    it("transforms transparent from palette", () => {
-      const result = applyDarkModeFilter(COLOR_PALETTE.transparent);
-      expect(result).toBe("#ededed00");
-    });
-
-    // Test each color family from the palette (all opaque, so 6-char hex)
-    describe("red shades", () => {
-      const redShades = COLOR_PALETTE.red;
-      it.each(redShades.map((color, i) => [color, i]))(
-        "transforms red shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("blue shades", () => {
-      const blueShades = COLOR_PALETTE.blue;
-      it.each(blueShades.map((color, i) => [color, i]))(
-        "transforms blue shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("green shades", () => {
-      const greenShades = COLOR_PALETTE.green;
-      it.each(greenShades.map((color, i) => [color, i]))(
-        "transforms green shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("gray shades", () => {
-      const grayShades = COLOR_PALETTE.gray;
-      it.each(grayShades.map((color, i) => [color, i]))(
-        "transforms gray shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("bronze shades", () => {
-      const bronzeShades = COLOR_PALETTE.bronze;
-      it.each(bronzeShades.map((color, i) => [color, i]))(
-        "transforms bronze shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    // Snapshot test for full palette to catch any regressions
-    it("matches snapshot for all palette colors", () => {
-      const transformedPalette: Record<string, string | string[]> = {};
-
-      transformedPalette.black = applyDarkModeFilter(COLOR_PALETTE.black);
-      transformedPalette.white = applyDarkModeFilter(COLOR_PALETTE.white);
-      transformedPalette.transparent = applyDarkModeFilter(
-        COLOR_PALETTE.transparent,
-      );
-
-      // Transform color arrays
-      for (const colorName of [
-        "gray",
-        "red",
-        "pink",
-        "grape",
-        "violet",
-        "blue",
-        "cyan",
-        "teal",
-        "green",
-        "yellow",
-        "orange",
-        "bronze",
-      ] as const) {
-        const shades = COLOR_PALETTE[colorName];
-        transformedPalette[colorName] = shades.map((shade) =>
-          applyDarkModeFilter(shade),
-        );
-      }
-
-      expect(transformedPalette).toMatchSnapshot();
-    });
-  });
-
-  describe("caching", () => {
-    it("returns same result for same input (cached)", () => {
-      const result1 = applyDarkModeFilter("#ff0000");
-      const result2 = applyDarkModeFilter("#ff0000");
-      expect(result1).toBe(result2);
-    });
-  });
-});
-
-describe("rgbToHex", () => {
-  describe("basic RGB conversion", () => {
-    it("converts black (0,0,0)", () => {
-      expect(rgbToHex(0, 0, 0)).toBe("#000000");
-    });
-
-    it("converts white (255,255,255)", () => {
-      expect(rgbToHex(255, 255, 255)).toBe("#ffffff");
-    });
-
-    it("converts red (255,0,0)", () => {
-      expect(rgbToHex(255, 0, 0)).toBe("#ff0000");
-    });
-
-    it("converts green (0,255,0)", () => {
-      expect(rgbToHex(0, 255, 0)).toBe("#00ff00");
-    });
-
-    it("converts blue (0,0,255)", () => {
-      expect(rgbToHex(0, 0, 255)).toBe("#0000ff");
-    });
-
-    it("converts arbitrary color", () => {
-      expect(rgbToHex(30, 30, 30)).toBe("#1e1e1e");
-    });
-  });
-
-  describe("leading zeros preservation", () => {
-    it("preserves leading zeros for low values", () => {
-      expect(rgbToHex(0, 0, 1)).toBe("#000001");
-      expect(rgbToHex(0, 1, 0)).toBe("#000100");
-      expect(rgbToHex(1, 0, 0)).toBe("#010000");
-    });
-
-    it("preserves zeros for single-digit hex values", () => {
-      expect(rgbToHex(15, 15, 15)).toBe("#0f0f0f");
-    });
-  });
-
-  describe("alpha handling", () => {
-    it("omits alpha when undefined", () => {
-      expect(rgbToHex(255, 0, 0)).toBe("#ff0000");
-      expect(rgbToHex(255, 0, 0, undefined)).toBe("#ff0000");
-    });
-
-    it("omits alpha when fully opaque (1)", () => {
-      expect(rgbToHex(255, 0, 0, 1)).toBe("#ff0000");
-    });
-
-    it("includes alpha for semi-transparent (0.5)", () => {
-      // 0.5 * 255 = 127.5 -> rounds to 128 = 0x80
-      expect(rgbToHex(255, 0, 0, 0.5)).toBe("#ff000080");
-    });
-
-    it("includes alpha for fully transparent (0)", () => {
-      expect(rgbToHex(255, 0, 0, 0)).toBe("#ff000000");
-    });
-
-    it("includes alpha for near-opaque (0.99)", () => {
-      // 0.99 * 255 = 252.45 -> rounds to 252 = 0xfc
-      expect(rgbToHex(255, 0, 0, 0.99)).toBe("#ff0000fc");
-    });
-
-    it("pads alpha with leading zero when needed", () => {
-      // 0.05 * 255 = 12.75 -> rounds to 13 = 0x0d
-      expect(rgbToHex(255, 0, 0, 0.05)).toBe("#ff00000d");
-    });
-  });
-});
@@ -1,117 +1,8 @@
-import tinycolor from "tinycolor2";
+import oc from "open-color";

-import { clamp } from "@excalidraw/math";
-import { degreesToRadians } from "@excalidraw/math";
+import type { Merge } from "./utility-types";

-import type { Degrees } from "@excalidraw/math";
-
-// ---------------------------------------------------------------------------
-// Dark mode color transformation
-// ---------------------------------------------------------------------------
-
-// Browser-only cache to avoid memory leaks on server
-const DARK_MODE_COLORS_CACHE: Map<string, string> | null =
-  typeof window !== "undefined" ? new Map() : null;
-
-function cssHueRotate(
-  red: number,
-  green: number,
-  blue: number,
-  degrees: Degrees,
-): { r: number; g: number; b: number } {
-  // normalize
-  const r = red / 255;
-  const g = green / 255;
-  const b = blue / 255;
-
-  // Convert degrees to radians
-  const a = degreesToRadians(degrees);
-
-  const c = Math.cos(a);
-  const s = Math.sin(a);
-
-  // rotation matrix
-  const matrix = [
-    0.213 + c * 0.787 - s * 0.213,
-    0.715 - c * 0.715 - s * 0.715,
-    0.072 - c * 0.072 + s * 0.928,
-    0.213 - c * 0.213 + s * 0.143,
-    0.715 + c * 0.285 + s * 0.14,
-    0.072 - c * 0.072 - s * 0.283,
-    0.213 - c * 0.213 - s * 0.787,
-    0.715 - c * 0.715 + s * 0.715,
-    0.072 + c * 0.928 + s * 0.072,
-  ];
-
-  // transform
-  const newR = r * matrix[0] + g * matrix[1] + b * matrix[2];
-  const newG = r * matrix[3] + g * matrix[4] + b * matrix[5];
-  const newB = r * matrix[6] + g * matrix[7] + b * matrix[8];
-
-  // clamp the values to [0, 1] range and convert back to [0, 255]
-  return {
-    r: Math.round(Math.max(0, Math.min(1, newR)) * 255),
-    g: Math.round(Math.max(0, Math.min(1, newG)) * 255),
-    b: Math.round(Math.max(0, Math.min(1, newB)) * 255),
-  };
-}
-
-const cssInvert = (
-  r: number,
-  g: number,
-  b: number,
-  percent: number,
-): { r: number; g: number; b: number } => {
-  const p = clamp(percent, 0, 100) / 100;
-
-  // Function to invert a single color component
-  const invertComponent = (color: number): number => {
-    // Apply the invert formula
-    const inverted = color * (1 - p) + (255 - color) * p;
-    // Round to the nearest integer and clamp to [0, 255]
-    return Math.round(clamp(inverted, 0, 255));
-  };
-
-  // Calculate the inverted RGB components
-  const invertedR = invertComponent(r);
-  const invertedG = invertComponent(g);
-  const invertedB = invertComponent(b);
-
-  return { r: invertedR, g: invertedG, b: invertedB };
-};
-
-export const applyDarkModeFilter = (color: string): string => {
-  const cached = DARK_MODE_COLORS_CACHE?.get(color);
-  if (cached) {
-    return cached;
-  }
-
-  const tc = tinycolor(color);
-  const alpha = tc.getAlpha();
-
-  // order of operations matters
-  // (corresponds to "filter: invert(invertPercent) hue-rotate(hueDegrees)" in css)
-  const rgb = tc.toRgb();
-  const inverted = cssInvert(rgb.r, rgb.g, rgb.b, 93);
-  const rotated = cssHueRotate(
-    inverted.r,
-    inverted.g,
-    inverted.b,
-    180 as Degrees,
-  );
-
-  const result = rgbToHex(rotated.r, rotated.g, rotated.b, alpha);
-
-  if (DARK_MODE_COLORS_CACHE) {
-    DARK_MODE_COLORS_CACHE.set(color, result);
-  }
-
-  return result;
-};
-
-// ---------------------------------------------------------------------------
-// Color palette
-// ---------------------------------------------------------------------------
+export const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;

 // FIXME can't put to utils.ts rn because of circular dependency
 const pick = <R extends Record<string, any>, K extends readonly (keyof R)[]>(
@@ -126,7 +17,15 @@ const pick = <R extends Record<string, any>, K extends readonly (keyof R)[]>(
  }, {} as Pick<R, K[number]>) as Pick<R, K[number]>;
 };

+export type ColorPickerColor =
+  | Exclude<keyof oc, "indigo" | "lime">
+  | "transparent"
+  | "bronze";
 export type ColorTuple = readonly [string, string, string, string, string];
+export type ColorPalette = Merge<
+  Record<ColorPickerColor, ColorTuple>,
+  { black: "#1e1e1e"; white: "#ffffff"; transparent: "transparent" }
+>;

 // used general type instead of specific type (ColorPalette) to support custom colors
 export type ColorPaletteCustom = { [key: string]: ColorTuple | string };
@@ -139,30 +38,38 @@ export const DEFAULT_CHART_COLOR_INDEX = 4;

 export const DEFAULT_ELEMENT_STROKE_COLOR_INDEX = 4;
 export const DEFAULT_ELEMENT_BACKGROUND_COLOR_INDEX = 1;
+export const ELEMENTS_PALETTE_SHADE_INDEXES = [0, 2, 4, 6, 8] as const;
+export const CANVAS_PALETTE_SHADE_INDEXES = [0, 1, 2, 3, 4] as const;
+
+export const getSpecificColorShades = (
+  color: Exclude<
+    ColorPickerColor,
+    "transparent" | "white" | "black" | "bronze"
+  >,
+  indexArr: Readonly<ColorShadesIndexes>,
+) => {
+  return indexArr.map((index) => oc[color][index]) as any as ColorTuple;
+};

 export const COLOR_PALETTE = {
  transparent: "transparent",
  black: "#1e1e1e",
  white: "#ffffff",
-  // open-color from https://github.com/yeun/open-color/blob/master/open-color.js
-  // corresponds to indexes [0,2,4,6,8] (weights: 50, 200, 400, 600, 800)
-  gray: ["#f8f9fa", "#e9ecef", "#ced4da", "#868e96", "#343a40"],
-  red: ["#fff5f5", "#ffc9c9", "#ff8787", "#fa5252", "#e03131"],
-  pink: ["#fff0f6", "#fcc2d7", "#f783ac", "#e64980", "#c2255c"],
-  grape: ["#f8f0fc", "#eebefa", "#da77f2", "#be4bdb", "#9c36b5"],
-  violet: ["#f3f0ff", "#d0bfff", "#9775fa", "#7950f2", "#6741d9"],
-  blue: ["#e7f5ff", "#a5d8ff", "#4dabf7", "#228be6", "#1971c2"],
-  cyan: ["#e3fafc", "#99e9f2", "#3bc9db", "#15aabf", "#0c8599"],
-  teal: ["#e6fcf5", "#96f2d7", "#38d9a9", "#12b886", "#099268"],
-  green: ["#ebfbee", "#b2f2bb", "#69db7c", "#40c057", "#2f9e44"],
-  yellow: ["#fff9db", "#ffec99", "#ffd43b", "#fab005", "#f08c00"],
-  orange: ["#fff4e6", "#ffd8a8", "#ffa94d", "#fd7e14", "#e8590c"],
-  // radix bronze shades [3,5,7,9,11]
+  // open-colors
+  gray: getSpecificColorShades("gray", ELEMENTS_PALETTE_SHADE_INDEXES),
+  red: getSpecificColorShades("red", ELEMENTS_PALETTE_SHADE_INDEXES),
+  pink: getSpecificColorShades("pink", ELEMENTS_PALETTE_SHADE_INDEXES),
+  grape: getSpecificColorShades("grape", ELEMENTS_PALETTE_SHADE_INDEXES),
+  violet: getSpecificColorShades("violet", ELEMENTS_PALETTE_SHADE_INDEXES),
+  blue: getSpecificColorShades("blue", ELEMENTS_PALETTE_SHADE_INDEXES),
+  cyan: getSpecificColorShades("cyan", ELEMENTS_PALETTE_SHADE_INDEXES),
+  teal: getSpecificColorShades("teal", ELEMENTS_PALETTE_SHADE_INDEXES),
+  green: getSpecificColorShades("green", ELEMENTS_PALETTE_SHADE_INDEXES),
+  yellow: getSpecificColorShades("yellow", ELEMENTS_PALETTE_SHADE_INDEXES),
+  orange: getSpecificColorShades("orange", ELEMENTS_PALETTE_SHADE_INDEXES),
+  // radix bronze shades 3,5,7,9,11
  bronze: ["#f8f1ee", "#eaddd7", "#d2bab0", "#a18072", "#846358"],
-} as const;
-
-export type ColorPalette = typeof COLOR_PALETTE;
-export type ColorPickerColor = keyof typeof COLOR_PALETTE;
+} as ColorPalette;

 const COMMON_ELEMENT_SHADES = pick(COLOR_PALETTE, [
  "cyan",
@@ -177,6 +84,7 @@ const COMMON_ELEMENT_SHADES = pick(COLOR_PALETTE, [
  "red",
 ]);

+// -----------------------------------------------------------------------------
 // quick picks defaults
 // -----------------------------------------------------------------------------

@@ -211,6 +119,7 @@ export const DEFAULT_CANVAS_BACKGROUND_PICKS = [
  "#fdf8f6",
 ] as ColorTuple;

+// -----------------------------------------------------------------------------
 // palette defaults
 // -----------------------------------------------------------------------------

@@ -236,7 +145,8 @@ export const DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE = {
  ...COMMON_ELEMENT_SHADES,
 } as const;

-// color palette helpers
+// -----------------------------------------------------------------------------
+// helpers
 // -----------------------------------------------------------------------------

 // !!!MUST BE WITHOUT GRAY, TRANSPARENT AND BLACK!!!
@@ -257,100 +167,7 @@ export const getAllColorsSpecificShade = (index: 0 | 1 | 2 | 3 | 4) =>
    COLOR_PALETTE.red[index],
  ] as const;

-// -----------------------------------------------------------------------------
-// other helpers
-// -----------------------------------------------------------------------------
-
-export const rgbToHex = (r: number, g: number, b: number, a?: number) => {
-  // (1 << 24) adds 0x1000000 to ensure the hex string is always 7 chars,
-  // then slice(1) removes the leading "1" to get exactly 6 hex digits
-  // e.g. rgb(0,0,0) -> 0x1000000 -> "1000000" -> "000000"
-  const hex6 = `#${((1 << 24) + (r << 16) + (g << 8) + b)
-    .toString(16)
-    .slice(1)}`;
-  if (a !== undefined && a < 1) {
-    // convert alpha from 0-1 float to 0-255 int, then to 2-digit hex
-    // e.g. 0.5 -> 128 -> "80"
-    const alphaHex = Math.round(a * 255)
-      .toString(16)
-      .padStart(2, "0");
-    return `${hex6}${alphaHex}`;
-  }
-  return hex6;
-};
-
-/**
- * @returns #RRGGBB or #RRGGBBAA based on color containing non-opaque alpha,
- *  null if not valid color
- */
-export const colorToHex = (color: string): string | null => {
-  const tc = tinycolor(color);
-  if (!tc.isValid()) {
-    return null;
-  }
-  const { r, g, b, a } = tc.toRgb();
-  return rgbToHex(r, g, b, a);
-};
-
-export const isTransparent = (color: string) => {
-  return tinycolor(color).getAlpha() === 0;
-};
+export const rgbToHex = (r: number, g: number, b: number) =>
+  `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;

 // -----------------------------------------------------------------------------
-// color contract helpers
-// -----------------------------------------------------------------------------
-
-export const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
-
-const calculateContrast = (r: number, g: number, b: number): number => {
-  const yiq = (r * 299 + g * 587 + b * 114) / 1000;
-  return yiq;
-};
-
-// YIQ algo, inspiration from https://stackoverflow.com/a/11868398
-export const isColorDark = (color: string, threshold = 160): boolean => {
-  // no color ("") -> assume it default to black
-  if (!color) {
-    return true;
-  }
-
-  if (isTransparent(color)) {
-    return false;
-  }
-
-  const tc = tinycolor(color);
-  if (!tc.isValid()) {
-    // invalid color -> assume it defaults to black
-    return true;
-  }
-
-  const { r, g, b } = tc.toRgb();
-  return calculateContrast(r, g, b) < threshold;
-};
-
-// -----------------------------------------------------------------------------
-// normalization
-// -----------------------------------------------------------------------------
-
-/**
- * tries to keep the input color as-is if it's valid, making minimal adjustments
- * (trimming whitespace or adding `#` to hex colors)
- */
-export const normalizeInputColor = (color: string): string | null => {
-  color = color.trim();
-  if (isTransparent(color)) {
-    return color;
-  }
-
-  const tc = tinycolor(color);
-  if (tc.isValid()) {
-    // testing for `#` first fixes a bug on Electron (more specfically, an
-    // Obsidian popout window), where a hex color without `#` is considered valid
-    if (tc.getFormat() === "hex" && !color.startsWith("#")) {
-      return `#${color}`;
-    }
-    return color;
-  }
-
-  return null;
-};
@@ -190,8 +190,6 @@ export const THEME = {
  DARK: "dark",
 } as const;

-export const DARK_THEME_FILTER = "invert(93%) hue-rotate(180deg)";
-
 export const FRAME_STYLE = {
  strokeColor: "#bbb" as ExcalidrawElement["strokeColor"],
  strokeWidth: 2 as ExcalidrawElement["strokeWidth"],
@@ -307,6 +305,9 @@ export const IDLE_THRESHOLD = 60_000;
 // Report a user active each ACTIVE_THRESHOLD milliseconds
 export const ACTIVE_THRESHOLD = 3_000;

+// duplicates --theme-filter, should be removed soon
+export const THEME_FILTER = "invert(93%) hue-rotate(180deg)";
+
 export const URL_QUERY_KEYS = {
  addLibrary: "addLibrary",
 } as const;
@@ -16,6 +16,7 @@ export type EditorInterface = Readonly<{
 const DESKTOP_UI_MODE_STORAGE_KEY = "excalidraw.desktopUIMode";

 // breakpoints
+// mobile: up to 699px
 export const MQ_MAX_MOBILE = 599;

 export const MQ_MAX_WIDTH_LANDSCAPE = 1000;
@@ -23,9 +24,9 @@ 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 = 1180; // ipad air
+export const MQ_MAX_TABLET = 1400; // upper bound (excludes laptops/desktops)

-// desktop/laptop (NOTE: not used for form factor detection)
+// desktop/laptop
 export const MQ_MIN_WIDTH_DESKTOP = 1440;

 // sidebar
@@ -11,4 +11,5 @@ export * from "./random";
 export * from "./url";
 export * from "./utils";
 export * from "./emitter";
+export * from "./visualdebug";
 export * from "./editorInterface";
@@ -10,6 +10,7 @@ import type {
  Zoom,
 } from "@excalidraw/excalidraw/types";

+import { COLOR_PALETTE } from "./colors";
 import {
  DEFAULT_VERSION,
  ENV,
@@ -547,6 +548,16 @@ export const mapFind = <T, K>(
  return undefined;
 };

+export const isTransparent = (color: string) => {
+  const isRGBTransparent = color.length === 5 && color.substr(4, 1) === "0";
+  const isRRGGBBTransparent = color.length === 9 && color.substr(7, 2) === "00";
+  return (
+    isRGBTransparent ||
+    isRRGGBBTransparent ||
+    color === COLOR_PALETTE.transparent
+  );
+};
+
 export type ResolvablePromise<T> = Promise<T> & {
  resolve: [T] extends [undefined]
    ? (value?: MaybePromise<Awaited<T>>) => void
@@ -1146,69 +1157,39 @@ export const normalizeEOL = (str: string) => {
 };

 // -----------------------------------------------------------------------------
-export type HasBrand<T> = {
+type HasBrand<T> = {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [K in keyof T]: K extends `~brand${infer _}` | "_brand" ? true : never;
+  [K in keyof T]: K extends `~brand${infer _}` ? true : never;
 }[keyof T];

 type RemoveAllBrands<T> = HasBrand<T> extends true
  ? {
      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      [K in keyof T as K extends `~brand~${infer _}` | "_brand"
-        ? never
-        : K]: T[K];
+      [K in keyof T as K extends `~brand~${infer _}` ? never : K]: T[K];
    }
-  : T;
+  : never;

-// For accepting values - uses loose matching for branded types
-// Preserves readonly modifier: mutable array requires mutable input
-type UnbrandForValue<T> = T extends Map<infer E, infer F>
-  ? Map<UnbrandForValue<E>, UnbrandForValue<F>>
+// adapted from https://github.com/colinhacks/zod/discussions/1994#discussioncomment-6068940
+// currently does not cover all types (e.g. tuples, promises...)
+type Unbrand<T> = T extends Map<infer E, infer F>
+  ? Map<E, F>
  : T extends Set<infer E>
-  ? Set<UnbrandForValue<E>>
-  : T extends readonly any[]
-  ? T extends any[]
-    ? unknown[] // mutable array - require mutable input
-    : readonly unknown[] // readonly array - accept readonly input
+  ? Set<E>
+  : T extends Array<infer E>
+  ? Array<E>
  : RemoveAllBrands<T>;

-// For return types - preserves array element unbranding
-export type Unbrand<T> = T extends Map<infer E, infer F>
-  ? Map<Unbrand<E>, Unbrand<F>>
-  : T extends Set<infer E>
-  ? Set<Unbrand<E>>
-  : T extends readonly (infer E)[]
-  ? Array<Unbrand<E>>
-  : RemoveAllBrands<T>;
-
-export type CombineBrands<BrandedType, CurrentType> =
-  BrandedType extends readonly (infer BE)[]
-    ? CurrentType extends readonly (infer CE)[]
-      ? Array<CE & BE>
-      : CurrentType & BrandedType
-    : CurrentType & BrandedType;
-
-export type CombineBrandsIfNeeded<T, Required> = [T] extends [Required]
-  ? T[]
-  : HasBrand<T> extends true
-  ? CombineBrands<T, Required>[]
-  : Required[];
-
 /**
 * Makes type into a branded type, ensuring that value is assignable to
- * the base unbranded type. Optionally you can explicitly supply current value
+ * the base ubranded type. Optionally you can explicitly supply current value
 * type to combine both (useful for composite branded types. Make sure you
 * compose branded types which are not composite themselves.)
 */
-export function toBrandedType<BrandedType>(
-  value: UnbrandForValue<BrandedType>,
-): BrandedType;
-export function toBrandedType<BrandedType, CurrentType>(
-  value: CurrentType,
-): CombineBrands<BrandedType, CurrentType>;
-export function toBrandedType(value: unknown) {
-  return value;
-}
+export const toBrandedType = <BrandedType, CurrentType = BrandedType>(
+  value: Unbrand<BrandedType>,
+) => {
+  return value as CurrentType & BrandedType;
+};

 // -----------------------------------------------------------------------------

@@ -1,24 +1,16 @@
 import {
  isLineSegment,
  lineSegment,
-  pointDistanceSq,
  pointFrom,
  type GlobalPoint,
  type LocalPoint,
 } from "@excalidraw/math";
-import { type Bounds, isBounds } from "@excalidraw/common";
-import {
-  getElementBounds,
-  intersectElementWithLineSegment,
-  isFreeDrawElement,
-  isLinearElement,
-  isPathALoop,
-} from "@excalidraw/element";

-import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 import type { Curve } from "@excalidraw/math";
 import type { LineSegment } from "@excalidraw/utils";

+import { type Bounds, isBounds } from "./bounds";
+
 // The global data holder to collect the debug operations
 declare global {
  interface Window {
@@ -31,69 +23,10 @@ declare global {

 export type DebugElement = {
  color: string;
-  data: LineSegment<GlobalPoint> | Curve<GlobalPoint> | DebugPolygon;
+  data: LineSegment<GlobalPoint> | Curve<GlobalPoint>;
  permanent: boolean;
 };

-export type DebugPolygon = {
-  type: "polygon";
-  points: GlobalPoint[];
-  fill?: boolean;
-  close?: boolean;
-};
-
-export const debugDrawHitVolume = (
-  element: ExcalidrawElement,
-  elementsMap: ElementsMap,
-  options?: {
-    rays?: number;
-    color?: string;
-    fill?: boolean;
-  },
-) => {
-  if (
-    (isLinearElement(element) || isFreeDrawElement(element)) &&
-    !isPathALoop(element.points)
-  ) {
-    return;
-  }
-
-  const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
-  const center = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
-  const rays = options?.rays ?? 100;
-  const radius = Math.max(x2 - x1, y2 - y1) * 2;
-  const points: GlobalPoint[] = [];
-
-  for (let i = 0; i < rays; i += 1) {
-    const angle = (i / rays) * Math.PI * 2;
-    const end = pointFrom<GlobalPoint>(
-      center[0] + Math.cos(angle) * radius,
-      center[1] + Math.sin(angle) * radius,
-    );
-    const hits = intersectElementWithLineSegment(
-      element,
-      elementsMap,
-      lineSegment(center, end),
-    );
-    if (hits.length === 0) {
-      continue;
-    }
-    hits.sort(pointDistanceSq);
-    points.push(hits[0]);
-  }
-
-  if (points.length >= 3) {
-    debugDrawPolygon(points, {
-      color: options?.color ?? "orange",
-      fill: options?.fill ?? true,
-    });
-  } else {
-    console.warn(
-      `debugDrawHitVolume: could not compute hit volume for element ${element.id}`,
-    );
-  }
-};
-
 export const debugDrawCubicBezier = (
  c: Curve<GlobalPoint>,
  opts?: {
@@ -128,31 +61,6 @@ export const debugDrawLine = (
  );
 };

-export const debugDrawPolygon = (
-  points: GlobalPoint[],
-  opts?: {
-    color?: string;
-    permanent?: boolean;
-    fill?: boolean;
-    close?: boolean;
-  },
-) => {
-  if (points.length < 2) {
-    return;
-  }
-
-  addToCurrentFrame({
-    color: opts?.color ?? "orange",
-    permanent: !!opts?.permanent,
-    data: {
-      type: "polygon",
-      points,
-      fill: opts?.fill,
-      close: opts?.close,
-    },
-  });
-};
-
 export const debugDrawPoint = (
  p: GlobalPoint,
  opts?: {
@@ -193,7 +101,7 @@ export const debugDrawBounds = (
    permanent?: boolean;
  },
 ) => {
-  (isBounds(box) ? [box] : box).forEach((bbox: Bounds) =>
+  (isBounds(box) ? [box] : box).forEach((bbox) =>
    debugDrawLine(
      [
        lineSegment(
@@ -17,12 +17,6 @@
      "development": "./dist/dev/index.js",
      "production": "./dist/prod/index.js",
      "default": "./dist/prod/index.js"
-    },
-    "./visualdebug": {
-      "types": "./dist/types/element/src/visualdebug.d.ts",
-      "development": "./dist/dev/visualdebug.js",
-      "production": "./dist/prod/visualdebug.js",
-      "default": "./dist/prod/visualdebug.js"
    }
  },
  "files": [
@@ -15,7 +15,6 @@ import {
  pointFrom,
  pointFromVector,
  pointRotateRads,
-  pointsEqual,
  vectorFromPoint,
  vectorNormalize,
  vectorScale,
@@ -1603,12 +1602,7 @@ export const updateBoundPoint = (
  if (
    binding == null ||
    // We only need to update the other end if this is a 2 point line element
-    (binding.elementId !== bindableElement.id && arrow.points.length > 2) ||
-    // Initial arrow created on pointer down needs to not update the points
-    pointsEqual(
-      arrow.points[arrow.points.length - 1],
-      pointFrom<LocalPoint>(0, 0),
-    )
+    (binding.elementId !== bindableElement.id && arrow.points.length > 2)
  ) {
    return null;
  }
@@ -897,7 +897,6 @@ export const getArrowheadPoints = (
  return [x2, y2, x3, y3, x4, y4];
 };

-// TODO reuse shape.ts
 const generateLinearElementShape = (
  element: ExcalidrawLinearElement,
 ): Drawable => {
@@ -955,7 +954,7 @@ const getLinearElementRotatedBounds = (
  }

  // first element is always the curve
-  const cachedShape = ShapeCache.get(element, null)?.[0];
+  const cachedShape = ShapeCache.get(element)?.[0];
  const shape = cachedShape ?? generateLinearElementShape(element);
  const ops = getCurvePathOps(shape);
  const transformXY = ([x, y]: GlobalPoint) =>
@@ -105,12 +105,6 @@ export type HitTestArgs = {
  overrideShouldTestInside?: boolean;
 };

-let cachedPoint: GlobalPoint | null = null;
-let cachedElement: WeakRef<ExcalidrawElement> | null = null;
-let cachedThreshold: number = Infinity;
-let cachedHit: boolean = false;
-let cachedOverrideShouldTestInside = false;
-
 export const hitElementItself = ({
  point,
  element,
@@ -119,24 +113,6 @@ export const hitElementItself = ({
  frameNameBound = null,
  overrideShouldTestInside = false,
 }: HitTestArgs) => {
-  // Return cached result if the same point and element version is tested again
-  if (
-    cachedPoint &&
-    pointsEqual(point, cachedPoint) &&
-    cachedThreshold <= threshold &&
-    overrideShouldTestInside === cachedOverrideShouldTestInside
-  ) {
-    const derefElement = cachedElement?.deref();
-    if (
-      derefElement &&
-      derefElement.id === element.id &&
-      derefElement.version === element.version &&
-      derefElement.versionNonce === element.versionNonce
-    ) {
-      return cachedHit;
-    }
-  }
-
  // Hit test against a frame's name
  const hitFrameName = frameNameBound
    ? isPointWithinBounds(
@@ -177,16 +153,7 @@ export const hitElementItself = ({
      isPointOnElementOutline(point, element, elementsMap, threshold)
    : isPointOnElementOutline(point, element, elementsMap, threshold);

-  const result = hitElement || hitFrameName;
-
-  // Cache end result
-  cachedPoint = point;
-  cachedElement = new WeakRef(element);
-  cachedThreshold = threshold;
-  cachedOverrideShouldTestInside = overrideShouldTestInside;
-  cachedHit = result;
-
-  return result;
+  return hitElement || hitFrameName;
 };

 export const hitElementBoundingBox = (
@@ -1,12 +1,10 @@
 import type { AppState } from "@excalidraw/excalidraw/types";

-import { updateBoundElements } from "./binding";
 import { getCommonBoundingBox } from "./bounds";
+import { newElementWith } from "./mutateElement";

 import { getSelectedElementsByGroup } from "./groups";

-import type { Scene } from "./Scene";
-
 import type { ElementsMap, ExcalidrawElement } from "./types";

 export interface Distribution {
@@ -19,7 +17,6 @@ export const distributeElements = (
  elementsMap: ElementsMap,
  distribution: Distribution,
  appState: Readonly<AppState>,
-  scene: Scene,
 ): ExcalidrawElement[] => {
  const [start, mid, end, extent] =
    distribution.axis === "x"
@@ -69,16 +66,12 @@ export const distributeElements = (
        translation[distribution.axis] = pos - box[mid];
      }

-      return group.map((element) => {
-        const updatedElement = scene.mutateElement(element, {
+      return group.map((element) =>
+        newElementWith(element, {
          x: element.x + translation.x,
          y: element.y + translation.y,
-        });
-        updateBoundElements(element, scene, {
-          simultaneouslyUpdated: group,
-        });
-        return updatedElement;
-      });
+        }),
+      );
    });
  }

@@ -97,15 +90,11 @@ export const distributeElements = (
    pos += step;
    pos += box[extent];

-    return group.map((element) => {
-      const updatedElement = scene.mutateElement(element, {
+    return group.map((element) =>
+      newElementWith(element, {
        x: element.x + translation.x,
        y: element.y + translation.y,
-      });
-      updateBoundElements(element, scene, {
-        simultaneouslyUpdated: group,
-      });
-      return updatedElement;
-    });
+      }),
+    );
  });
 };
@@ -724,6 +724,7 @@ export class LinearElementEditor {
          ? [pointerDownState.lastClickedPoint]
          : selectedPointsIndices,
      isDragging: false,
+      pointerOffset: { x: 0, y: 0 },
      customLineAngle: null,
      initialState: {
        ...editingLinearElement.initialState,
@@ -21,7 +21,7 @@ import {
  getResizedElementAbsoluteCoords,
 } from "./bounds";
 import { newElementWith } from "./mutateElement";
-import { getBoundTextMaxWidth } from "./textElement";
+import { getBoundTextMaxWidth, getInitialTextMetrics } from "./textElement";
 import { normalizeText, measureText } from "./textMeasurements";
 import { wrapText } from "./textWrapping";

@@ -236,27 +236,30 @@ const getTextElementPositionOffsets = (
  };
 };

+export type NewTextElementOptions = {
+  text: string;
+  originalText?: string;
+  fontSize?: number;
+  fontFamily?: FontFamilyValues;
+  textAlign?: TextAlign;
+  verticalAlign?: VerticalAlign;
+  containerId?: ExcalidrawTextContainer["id"] | null;
+  lineHeight?: ExcalidrawTextElement["lineHeight"];
+  autoResize?: ExcalidrawTextElement["autoResize"];
+} & ElementConstructorOpts;
+
 export const newTextElement = (
-  opts: {
-    text: string;
-    originalText?: string;
-    fontSize?: number;
-    fontFamily?: FontFamilyValues;
-    textAlign?: TextAlign;
-    verticalAlign?: VerticalAlign;
-    containerId?: ExcalidrawTextContainer["id"] | null;
-    lineHeight?: ExcalidrawTextElement["lineHeight"];
-    autoResize?: ExcalidrawTextElement["autoResize"];
-  } & ElementConstructorOpts,
+  opts: NewTextElementOptions,
 ): NonDeleted<ExcalidrawTextElement> => {
  const fontFamily = opts.fontFamily || DEFAULT_FONT_FAMILY;
  const fontSize = opts.fontSize || DEFAULT_FONT_SIZE;
  const lineHeight = opts.lineHeight || getLineHeight(fontFamily);
-  const text = normalizeText(opts.text);
-  const metrics = measureText(
-    text,
-    getFontString({ fontFamily, fontSize }),
-    lineHeight,
+  const normalizedText = normalizeText(opts.text);
+  const originalText = opts.originalText ?? normalizedText;
+  const metrics = getInitialTextMetrics(
+    { ...opts, text: normalizedText },
+    fontFamily,
+    fontSize,
  );
  const textAlign = opts.textAlign || DEFAULT_TEXT_ALIGN;
  const verticalAlign = opts.verticalAlign || DEFAULT_VERTICAL_ALIGN;
@@ -267,7 +270,7 @@ export const newTextElement = (

  const textElementProps: ExcalidrawTextElement = {
    ..._newElementBase<ExcalidrawTextElement>("text", opts),
-    text,
+    text: normalizedText,
    fontSize,
    fontFamily,
    textAlign,
@@ -277,7 +280,7 @@ export const newTextElement = (
    width: metrics.width,
    height: metrics.height,
    containerId: opts.containerId || null,
-    originalText: opts.originalText ?? text,
+    originalText,
    autoResize: opts.autoResize ?? true,
    lineHeight,
  };
@@ -1,4 +1,5 @@
 import rough from "roughjs/bin/rough";
+import { getStroke } from "perfect-freehand";

 import {
  type GlobalPoint,
@@ -14,7 +15,6 @@ import {
  DEFAULT_REDUCED_GLOBAL_ALPHA,
  ELEMENT_READY_TO_ERASE_OPACITY,
  FRAME_STYLE,
-  DARK_THEME_FILTER,
  MIME_TYPES,
  THEME,
  distance,
@@ -22,7 +22,6 @@ import {
  isRTL,
  getVerticalOffset,
  invariant,
-  applyDarkModeFilter,
 } from "@excalidraw/common";

 import type {
@@ -79,8 +78,16 @@ import type {
  ElementsMap,
 } from "./types";

+import type { StrokeOptions } from "perfect-freehand";
 import type { RoughCanvas } from "roughjs/bin/canvas";

+// using a stronger invert (100% vs our regular 93%) and saturate
+// as a temp hack to make images in dark theme look closer to original
+// color scheme (it's still not quite there and the colors look slightly
+// desatured, alas...)
+export const IMAGE_INVERT_FILTER =
+  "invert(100%) hue-rotate(180deg) saturate(1.25)";
+
 const isPendingImageElement = (
  element: ExcalidrawElement,
  renderConfig: StaticCanvasRenderConfig,
@@ -88,6 +95,19 @@ const isPendingImageElement = (
  isInitializedImageElement(element) &&
  !renderConfig.imageCache.has(element.fileId);

+const shouldResetImageFilter = (
+  element: ExcalidrawElement,
+  renderConfig: StaticCanvasRenderConfig,
+  appState: StaticCanvasAppState | InteractiveCanvasAppState,
+) => {
+  return (
+    appState.theme === THEME.DARK &&
+    isInitializedImageElement(element) &&
+    !isPendingImageElement(element, renderConfig) &&
+    renderConfig.imageCache.get(element.fileId)?.mimeType !== MIME_TYPES.svg
+  );
+};
+
 const getCanvasPadding = (element: ExcalidrawElement) => {
  switch (element.type) {
    case "freedraw":
@@ -252,6 +272,11 @@ const generateElementCanvas = (

  const rc = rough.canvas(canvas);

+  // in dark theme, revert the image color filter
+  if (shouldResetImageFilter(element, renderConfig, appState)) {
+    context.filter = IMAGE_INVERT_FILTER;
+  }
+
  drawElementOnCanvas(element, rc, context, renderConfig);

  context.restore();
@@ -396,8 +421,7 @@ const drawElementOnCanvas = (
    case "ellipse": {
      context.lineJoin = "round";
      context.lineCap = "round";
-
-      rc.draw(ShapeCache.generateElementShape(element, renderConfig));
+      rc.draw(ShapeCache.get(element)!);
      break;
    }
    case "arrow":
@@ -405,51 +429,33 @@ const drawElementOnCanvas = (
      context.lineJoin = "round";
      context.lineCap = "round";

-      ShapeCache.generateElementShape(element, renderConfig).forEach(
-        (shape) => {
-          rc.draw(shape);
-        },
-      );
+      ShapeCache.get(element)!.forEach((shape) => {
+        rc.draw(shape);
+      });
      break;
    }
    case "freedraw": {
      // Draw directly to canvas
      context.save();
+      context.fillStyle = element.strokeColor;

-      const shapes = ShapeCache.generateElementShape(element, renderConfig);
+      const path = getFreeDrawPath2D(element) as Path2D;
+      const fillShape = ShapeCache.get(element);

-      for (const shape of shapes) {
-        if (typeof shape === "string") {
-          context.fillStyle =
-            renderConfig.theme === THEME.DARK
-              ? applyDarkModeFilter(element.strokeColor)
-              : element.strokeColor;
-          context.fill(new Path2D(shape));
-        } else {
-          rc.draw(shape);
-        }
+      if (fillShape) {
+        rc.draw(fillShape);
      }

+      context.fillStyle = element.strokeColor;
+      context.fill(path);
+
      context.restore();
      break;
    }
    case "image": {
-      context.save();
-      const cacheEntry =
-        element.fileId !== null
-          ? renderConfig.imageCache.get(element.fileId)
-          : null;
      const img = isInitializedImageElement(element)
-        ? cacheEntry?.image
+        ? renderConfig.imageCache.get(element.fileId)?.image
        : undefined;
-
-      const shouldInvertImage =
-        renderConfig.theme === THEME.DARK &&
-        cacheEntry?.mimeType === MIME_TYPES.svg;
-
-      if (shouldInvertImage) {
-        context.filter = DARK_THEME_FILTER;
-      }
      if (img != null && !(img instanceof Promise)) {
        if (element.roundness && context.roundRect) {
          context.beginPath();
@@ -486,7 +492,6 @@ const drawElementOnCanvas = (
      } else {
        drawImagePlaceholder(element, context);
      }
-      context.restore();
      break;
    }
    default: {
@@ -501,10 +506,7 @@ const drawElementOnCanvas = (
        context.canvas.setAttribute("dir", rtl ? "rtl" : "ltr");
        context.save();
        context.font = getFontString(element);
-        context.fillStyle =
-          renderConfig.theme === THEME.DARK
-            ? applyDarkModeFilter(element.strokeColor)
-            : element.strokeColor;
+        context.fillStyle = element.strokeColor;
        context.textAlign = element.textAlign as CanvasTextAlign;

        // Canvas does not support multiline text by default
@@ -757,17 +759,12 @@ export const renderElement = (
        context.fillStyle = "rgba(0, 0, 200, 0.04)";

        context.lineWidth = FRAME_STYLE.strokeWidth / appState.zoom.value;
-        context.strokeStyle =
-          appState.theme === THEME.DARK
-            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
-            : FRAME_STYLE.strokeColor;
+        context.strokeStyle = FRAME_STYLE.strokeColor;

        // TODO change later to only affect AI frames
        if (isMagicFrameElement(element)) {
          context.strokeStyle =
-            appState.theme === THEME.LIGHT
-              ? "#7affd7"
-              : applyDarkModeFilter("#1d8264");
+            appState.theme === THEME.LIGHT ? "#7affd7" : "#1d8264";
        }

        if (FRAME_STYLE.radius && context.roundRect) {
@@ -790,6 +787,11 @@ export const renderElement = (
      break;
    }
    case "freedraw": {
+      // TODO investigate if we can do this in situ. Right now we need to call
+      // beforehand because math helpers (such as getElementAbsoluteCoords)
+      // rely on existing shapes
+      ShapeCache.generateElementShape(element, null);
+
      if (renderConfig.isExporting) {
        const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
        const cx = (x1 + x2) / 2 + appState.scrollX;
@@ -833,6 +835,10 @@ export const renderElement = (
    case "text":
    case "iframe":
    case "embeddable": {
+      // TODO investigate if we can do this in situ. Right now we need to call
+      // beforehand because math helpers (such as getElementAbsoluteCoords)
+      // rely on existing shapes
+      ShapeCache.generateElementShape(element, renderConfig);
      if (renderConfig.isExporting) {
        const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
        const cx = (x1 + x2) / 2 + appState.scrollX;
@@ -855,6 +861,9 @@ export const renderElement = (
        context.save();
        context.translate(cx, cy);

+        if (shouldResetImageFilter(element, renderConfig, appState)) {
+          context.filter = "none";
+        }
        const boundTextElement = getBoundTextElement(element, elementsMap);

        if (isArrowElement(element) && boundTextElement) {
@@ -1017,6 +1026,23 @@ export const renderElement = (
  context.globalAlpha = 1;
 };

+export const pathsCache = new WeakMap<ExcalidrawFreeDrawElement, Path2D>([]);
+
+export function generateFreeDrawShape(element: ExcalidrawFreeDrawElement) {
+  const svgPathData = getFreeDrawSvgPath(element);
+  const path = new Path2D(svgPathData);
+  pathsCache.set(element, path);
+  return path;
+}
+
+export function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement) {
+  return pathsCache.get(element);
+}
+
+export function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement) {
+  return getSvgPathFromStroke(getFreedrawOutlinePoints(element));
+}
+
 export function getFreedrawOutlineAsSegments(
  element: ExcalidrawFreeDrawElement,
  points: [number, number][],
@@ -1072,3 +1098,57 @@ export function getFreedrawOutlineAsSegments(
    ],
  );
 }
+
+export function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement) {
+  // If input points are empty (should they ever be?) return a dot
+  const inputPoints = element.simulatePressure
+    ? element.points
+    : element.points.length
+    ? element.points.map(([x, y], i) => [x, y, element.pressures[i]])
+    : [[0, 0, 0.5]];
+
+  // Consider changing the options for simulated pressure vs real pressure
+  const options: StrokeOptions = {
+    simulatePressure: element.simulatePressure,
+    size: element.strokeWidth * 4.25,
+    thinning: 0.6,
+    smoothing: 0.5,
+    streamline: 0.5,
+    easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
+    last: true,
+  };
+
+  return getStroke(inputPoints as number[][], options) as [number, number][];
+}
+
+function med(A: number[], B: number[]) {
+  return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
+}
+
+// Trim SVG path data so number are each two decimal points. This
+// improves SVG exports, and prevents rendering errors on points
+// with long decimals.
+const TO_FIXED_PRECISION = /(\s?[A-Z]?,?-?[0-9]*\.[0-9]{0,2})(([0-9]|e|-)*)/g;
+
+function getSvgPathFromStroke(points: number[][]): string {
+  if (!points.length) {
+    return "";
+  }
+
+  const max = points.length - 1;
+
+  return points
+    .reduce(
+      (acc, point, i, arr) => {
+        if (i === max) {
+          acc.push(point, med(point, arr[0]), "L", arr[0], "Z");
+        } else {
+          acc.push(point, med(point, arr[i + 1]));
+        }
+        return acc;
+      },
+      ["M", points[0], "Q"],
+    )
+    .join(" ")
+    .replace(TO_FIXED_PRECISION, "$1");
+}
@@ -318,18 +318,7 @@ export const resizeSingleTextElement = (
 ) => {
  const elementsMap = scene.getNonDeletedElementsMap();

-  const isCornerHandle = transformHandleType.length === 2;
-  let metricsWidth = element.width * (nextHeight / element.height);
-  let metricsHeight = nextHeight;
-
-  if (isCornerHandle) {
-    const widthRatio = Math.abs(nextWidth) / element.width;
-    const heightRatio = Math.abs(nextHeight) / element.height;
-    const ratio = Math.max(widthRatio, heightRatio);
-    const sign = Math.sign(nextHeight) || 1;
-    metricsWidth = element.width * ratio * sign;
-    metricsHeight = element.height * ratio * sign;
-  }
+  const metricsWidth = element.width * (nextHeight / element.height);

  const metrics = measureFontSizeFromWidth(element, elementsMap, metricsWidth);
  if (metrics === null) {
@@ -344,7 +333,7 @@ export const resizeSingleTextElement = (
      origElement.width,
      origElement.height,
      metricsWidth,
-      metricsHeight,
+      nextHeight,
      origElement.angle,
      transformHandleType,
      false,
@@ -354,7 +343,7 @@ export const resizeSingleTextElement = (
    scene.mutateElement(element, {
      fontSize: metrics.size,
      width: metricsWidth,
-      height: metricsHeight,
+      height: nextHeight,
      x: newOrigin.x,
      y: newOrigin.y,
    });
@@ -1,5 +1,4 @@
 import { simplify } from "points-on-curve";
-import { getStroke } from "perfect-freehand";

 import {
  type GeometricShape,
@@ -18,12 +17,10 @@ import {
 } from "@excalidraw/math";
 import {
  ROUGHNESS,
-  THEME,
  isTransparent,
  assertNever,
  COLOR_PALETTE,
  LINE_POLYGON_POINT_MERGE_DISTANCE,
-  applyDarkModeFilter,
 } from "@excalidraw/common";

 import { RoughGenerator } from "roughjs/bin/generator";
@@ -39,7 +36,6 @@ import type {
 import type {
  ElementShape,
  ElementShapes,
-  SVGPathString,
 } from "@excalidraw/excalidraw/scene/types";

 import { elementWithCanvasCache } from "./renderElement";
@@ -56,6 +52,7 @@ import { getCornerRadius, isPathALoop } from "./utils";
 import { headingForPointIsHorizontal } from "./heading";

 import { canChangeRoundness } from "./comparisons";
+import { generateFreeDrawShape } from "./renderElement";
 import {
  getArrowheadPoints,
  getCenterForBounds,
@@ -80,32 +77,29 @@ import type { Point as RoughPoint } from "roughjs/bin/geometry";

 export class ShapeCache {
  private static rg = new RoughGenerator();
-  private static cache = new WeakMap<
-    ExcalidrawElement,
-    { shape: ElementShape; theme: AppState["theme"] }
-  >();
+  private static cache = new WeakMap<ExcalidrawElement, ElementShape>();

  /**
   * Retrieves shape from cache if available. Use this only if shape
   * is optional and you have a fallback in case it's not cached.
   */
-  public static get = <T extends ExcalidrawElement>(
-    element: T,
-    theme: AppState["theme"] | null,
-  ) => {
-    const cached = ShapeCache.cache.get(element);
-    if (cached && (theme === null || cached.theme === theme)) {
-      return cached.shape as T["type"] extends keyof ElementShapes
-        ? ElementShapes[T["type"]] | undefined
-        : ElementShape | undefined;
-    }
-    return undefined;
+  public static get = <T extends ExcalidrawElement>(element: T) => {
+    return ShapeCache.cache.get(
+      element,
+    ) as T["type"] extends keyof ElementShapes
+      ? ElementShapes[T["type"]] | undefined
+      : ElementShape | undefined;
  };

-  public static delete = (element: ExcalidrawElement) => {
+  public static set = <T extends ExcalidrawElement>(
+    element: T,
+    shape: T["type"] extends keyof ElementShapes
+      ? ElementShapes[T["type"]]
+      : Drawable,
+  ) => ShapeCache.cache.set(element, shape);
+
+  public static delete = (element: ExcalidrawElement) =>
    ShapeCache.cache.delete(element);
-    elementWithCanvasCache.delete(element);
-  };

  public static destroy = () => {
    ShapeCache.cache = new WeakMap();
@@ -123,13 +117,12 @@ export class ShapeCache {
      isExporting: boolean;
      canvasBackgroundColor: AppState["viewBackgroundColor"];
      embedsValidationStatus: EmbedsValidationStatus;
-      theme: AppState["theme"];
    } | null,
  ) => {
    // when exporting, always regenerated to guarantee the latest shape
    const cachedShape = renderConfig?.isExporting
      ? undefined
-      : ShapeCache.get(element, renderConfig ? renderConfig.theme : null);
+      : ShapeCache.get(element);

    // `null` indicates no rc shape applicable for this element type,
    // but it's considered a valid cache value (= do not regenerate)
@@ -139,25 +132,19 @@ export class ShapeCache {

    elementWithCanvasCache.delete(element);

-    const shape = _generateElementShape(
+    const shape = generateElementShape(
      element,
      ShapeCache.rg,
      renderConfig || {
        isExporting: false,
        canvasBackgroundColor: COLOR_PALETTE.white,
        embedsValidationStatus: null,
-        theme: THEME.LIGHT,
      },
    ) as T["type"] extends keyof ElementShapes
      ? ElementShapes[T["type"]]
      : Drawable | null;

-    if (!renderConfig?.isExporting) {
-      ShapeCache.cache.set(element, {
-        shape,
-        theme: renderConfig?.theme || THEME.LIGHT,
-      });
-    }
+    ShapeCache.cache.set(element, shape);

    return shape;
  };
@@ -193,7 +180,6 @@ function adjustRoughness(element: ExcalidrawElement): number {
 export const generateRoughOptions = (
  element: ExcalidrawElement,
  continuousPath = false,
-  isDarkMode: boolean = false,
 ): Options => {
  const options: Options = {
    seed: element.seed,
@@ -218,9 +204,7 @@ export const generateRoughOptions = (
    fillWeight: element.strokeWidth / 2,
    hachureGap: element.strokeWidth * 4,
    roughness: adjustRoughness(element),
-    stroke: isDarkMode
-      ? applyDarkModeFilter(element.strokeColor)
-      : element.strokeColor,
+    stroke: element.strokeColor,
    preserveVertices:
      continuousPath || element.roughness < ROUGHNESS.cartoonist,
  };
@@ -234,8 +218,6 @@ export const generateRoughOptions = (
      options.fillStyle = element.fillStyle;
      options.fill = isTransparent(element.backgroundColor)
        ? undefined
-        : isDarkMode
-        ? applyDarkModeFilter(element.backgroundColor)
        : element.backgroundColor;
      if (element.type === "ellipse") {
        options.curveFitting = 1;
@@ -249,8 +231,6 @@ export const generateRoughOptions = (
        options.fill =
          element.backgroundColor === "transparent"
            ? undefined
-            : isDarkMode
-            ? applyDarkModeFilter(element.backgroundColor)
            : element.backgroundColor;
      }
      return options;
@@ -304,7 +284,6 @@ const getArrowheadShapes = (
  generator: RoughGenerator,
  options: Options,
  canvasBackgroundColor: string,
-  isDarkMode: boolean,
 ) => {
  const arrowheadPoints = getArrowheadPoints(
    element,
@@ -330,10 +309,6 @@ const getArrowheadShapes = (
    return [generator.line(x3, y3, x4, y4, options)];
  };

-  const strokeColor = isDarkMode
-    ? applyDarkModeFilter(element.strokeColor)
-    : element.strokeColor;
-
  switch (arrowhead) {
    case "dot":
    case "circle":
@@ -349,10 +324,10 @@ const getArrowheadShapes = (
          fill:
            arrowhead === "circle_outline"
              ? canvasBackgroundColor
-              : strokeColor,
+              : element.strokeColor,

          fillStyle: "solid",
-          stroke: strokeColor,
+          stroke: element.strokeColor,
          roughness: Math.min(0.5, options.roughness || 0),
        }),
      ];
@@ -377,7 +352,7 @@ const getArrowheadShapes = (
            fill:
              arrowhead === "triangle_outline"
                ? canvasBackgroundColor
-                : strokeColor,
+                : element.strokeColor,
            fillStyle: "solid",
            roughness: Math.min(1, options.roughness || 0),
          },
@@ -405,7 +380,7 @@ const getArrowheadShapes = (
            fill:
              arrowhead === "diamond_outline"
                ? canvasBackgroundColor
-                : strokeColor,
+                : element.strokeColor,
            fillStyle: "solid",
            roughness: Math.min(1, options.roughness || 0),
          },
@@ -627,22 +602,19 @@ export const generateLinearCollisionShape = (
 *
 * @private
 */
-const _generateElementShape = (
+const generateElementShape = (
  element: Exclude<NonDeletedExcalidrawElement, ExcalidrawSelectionElement>,
  generator: RoughGenerator,
  {
    isExporting,
    canvasBackgroundColor,
    embedsValidationStatus,
-    theme,
  }: {
    isExporting: boolean;
    canvasBackgroundColor: string;
    embedsValidationStatus: EmbedsValidationStatus | null;
-    theme?: AppState["theme"];
  },
-): ElementShape => {
-  const isDarkMode = theme === THEME.DARK;
+): Drawable | Drawable[] | null => {
  switch (element.type) {
    case "rectangle":
    case "iframe":
@@ -668,7 +640,6 @@ const _generateElementShape = (
              embedsValidationStatus,
            ),
            true,
-            isDarkMode,
          ),
        );
      } else {
@@ -684,7 +655,6 @@ const _generateElementShape = (
              embedsValidationStatus,
            ),
            false,
-            isDarkMode,
          ),
        );
      }
@@ -722,7 +692,7 @@ const _generateElementShape = (
            C ${topX} ${topY}, ${topX} ${topY}, ${topX + verticalRadius} ${
            topY + horizontalRadius
          }`,
-          generateRoughOptions(element, true, isDarkMode),
+          generateRoughOptions(element, true),
        );
      } else {
        shape = generator.polygon(
@@ -732,7 +702,7 @@ const _generateElementShape = (
            [bottomX, bottomY],
            [leftX, leftY],
          ],
-          generateRoughOptions(element, false, isDarkMode),
+          generateRoughOptions(element),
        );
      }
      return shape;
@@ -743,14 +713,14 @@ const _generateElementShape = (
        element.height / 2,
        element.width,
        element.height,
-        generateRoughOptions(element, false, isDarkMode),
+        generateRoughOptions(element),
      );
      return shape;
    }
    case "line":
    case "arrow": {
      let shape: ElementShapes[typeof element.type];
-      const options = generateRoughOptions(element, false, isDarkMode);
+      const options = generateRoughOptions(element);

      // points array can be empty in the beginning, so it is important to add
      // initial position to it
@@ -775,7 +745,7 @@ const _generateElementShape = (
          shape = [
            generator.path(
              generateElbowArrowShape(points, 16),
-              generateRoughOptions(element, true, isDarkMode),
+              generateRoughOptions(element, true),
            ),
          ];
        }
@@ -808,7 +778,6 @@ const _generateElementShape = (
            generator,
            options,
            canvasBackgroundColor,
-            isDarkMode,
          );
          shape.push(...shapes);
        }
@@ -826,7 +795,6 @@ const _generateElementShape = (
            generator,
            options,
            canvasBackgroundColor,
-            isDarkMode,
          );
          shape.push(...shapes);
        }
@@ -834,28 +802,23 @@ const _generateElementShape = (
      return shape;
    }
    case "freedraw": {
-      // oredered in terms of z-index [background, stroke]
-      const shapes: ElementShapes[typeof element.type] = [];
+      let shape: ElementShapes[typeof element.type];
+      generateFreeDrawShape(element);

-      // (1) background fill (rc shape), optional
      if (isPathALoop(element.points)) {
        // generate rough polygon to fill freedraw shape
        const simplifiedPoints = simplify(
          element.points as Mutable<LocalPoint[]>,
          0.75,
        );
-        shapes.push(
-          generator.curve(simplifiedPoints as [number, number][], {
-            ...generateRoughOptions(element, false, isDarkMode),
-            stroke: "none",
-          }),
-        );
+        shape = generator.curve(simplifiedPoints as [number, number][], {
+          ...generateRoughOptions(element),
+          stroke: "none",
+        });
+      } else {
+        shape = null;
      }
-
-      // (2) stroke
-      shapes.push(getFreeDrawSvgPath(element));
-
-      return shapes;
+      return shape;
    }
    case "frame":
    case "magicframe":
@@ -962,7 +925,9 @@ export const getElementShape = <Point extends GlobalPoint | LocalPoint>(
      return getPolygonShape(element);
    case "arrow":
    case "line": {
-      const roughShape = ShapeCache.generateElementShape(element, null)[0];
+      const roughShape =
+        ShapeCache.get(element)?.[0] ??
+        ShapeCache.generateElementShape(element, null)[0];
      const [, , , , cx, cy] = getElementAbsoluteCoords(element, elementsMap);

      return shouldTestInside(element)
@@ -1038,69 +1003,3 @@ export const toggleLinePolygonState = (

  return ret;
 };
-
-// -----------------------------------------------------------------------------
-//                         freedraw shape helper
-// -----------------------------------------------------------------------------
-
-// NOTE not cached (-> for SVG export)
-const getFreeDrawSvgPath = (element: ExcalidrawFreeDrawElement) => {
-  return getSvgPathFromStroke(
-    getFreedrawOutlinePoints(element),
-  ) as SVGPathString;
-};
-
-export const getFreedrawOutlinePoints = (
-  element: ExcalidrawFreeDrawElement,
-) => {
-  // If input points are empty (should they ever be?) return a dot
-  const inputPoints = element.simulatePressure
-    ? element.points
-    : element.points.length
-    ? element.points.map(([x, y], i) => [x, y, element.pressures[i]])
-    : [[0, 0, 0.5]];
-
-  return getStroke(inputPoints as number[][], {
-    simulatePressure: element.simulatePressure,
-    size: element.strokeWidth * 4.25,
-    thinning: 0.6,
-    smoothing: 0.5,
-    streamline: 0.5,
-    easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
-    last: true,
-  }) as [number, number][];
-};
-
-const med = (A: number[], B: number[]) => {
-  return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
-};
-
-// Trim SVG path data so number are each two decimal points. This
-// improves SVG exports, and prevents rendering errors on points
-// with long decimals.
-const TO_FIXED_PRECISION = /(\s?[A-Z]?,?-?[0-9]*\.[0-9]{0,2})(([0-9]|e|-)*)/g;
-
-const getSvgPathFromStroke = (points: number[][]): string => {
-  if (!points.length) {
-    return "";
-  }
-
-  const max = points.length - 1;
-
-  return points
-    .reduce(
-      (acc, point, i, arr) => {
-        if (i === max) {
-          acc.push(point, med(point, arr[0]), "L", arr[0], "Z");
-        } else {
-          acc.push(point, med(point, arr[i + 1]));
-        }
-        return acc;
-      },
-      ["M", points[0], "Q"],
-    )
-    .join(" ")
-    .replace(TO_FIXED_PRECISION, "$1");
-};
-
-// -----------------------------------------------------------------------------
@@ -8,6 +8,8 @@ import {
  getFontString,
  isProdEnv,
  invariant,
+  DEFAULT_FONT_FAMILY,
+  getLineHeight,
 } from "@excalidraw/common";

 import { pointFrom, pointRotateRads, type Radians } from "@excalidraw/math";
@@ -30,6 +32,8 @@ import {
  isTextElement,
 } from "./typeChecks";

+import type { NewTextElementOptions } from "./newElement";
+
 import type { Scene } from "./Scene";

 import type { MaybeTransformHandleType } from "./transformHandles";
@@ -40,6 +44,7 @@ import type {
  ExcalidrawTextContainer,
  ExcalidrawTextElement,
  ExcalidrawTextElementWithContainer,
+  FontFamilyValues,
  NonDeletedExcalidrawElement,
 } from "./types";

@@ -528,3 +533,24 @@ export const getTextFromElements = (
    .join(separator);
  return text;
 };
+
+/** When text is already measured and wrapped, we want to respect those dimensions */
+export const getInitialTextMetrics = (
+  text: NewTextElementOptions,
+  fontFamily: FontFamilyValues = DEFAULT_FONT_FAMILY,
+  fontSize: number = DEFAULT_FONT_SIZE,
+) => {
+  const shouldUseProvidedDimensions =
+    text.autoResize === false && text.width && text.height;
+
+  return shouldUseProvidedDimensions
+    ? {
+        width: text.width,
+        height: text.height,
+      }
+    : measureText(
+        text.text,
+        getFontString({ fontFamily, fontSize }),
+        text.lineHeight ?? getLineHeight(fontFamily),
+      );
+};
@@ -10,10 +10,8 @@ import {
  arrayToMap,
  assertNever,
  cloneJSON,
-  getFontString,
  isDevEnv,
  toBrandedType,
-  getLineHeight,
 } from "@excalidraw/common";

 import type { MarkOptional } from "@excalidraw/common/utility-types";
@@ -29,12 +27,11 @@ import {
  newTextElement,
  type ElementConstructorOpts,
 } from "./newElement";
-import { measureText, normalizeText } from "./textMeasurements";
 import { isArrowElement } from "./typeChecks";

 import { syncInvalidIndices } from "./fractionalIndex";

-import { redrawTextBoundingBox } from "./textElement";
+import { getInitialTextMetrics, redrawTextBoundingBox } from "./textElement";

 import { LinearElementEditor } from "./linearElementEditor";

@@ -579,14 +576,7 @@ export const convertToExcalidrawElements = (
      case "text": {
        const fontFamily = element?.fontFamily || DEFAULT_FONT_FAMILY;
        const fontSize = element?.fontSize || DEFAULT_FONT_SIZE;
-        const lineHeight = element?.lineHeight || getLineHeight(fontFamily);
-        const text = element.text ?? "";
-        const normalizedText = normalizeText(text);
-        const metrics = measureText(
-          normalizedText,
-          getFontString({ fontFamily, fontSize }),
-          lineHeight,
-        );
+        const metrics = getInitialTextMetrics(element, fontFamily, fontSize);

        excalidrawElement = newTextElement({
          width: metrics.width,
@@ -17,7 +17,7 @@ exports[`Test Linear Elements > Test bound text element > should match styles fo
  class="excalidraw-wysiwyg"
  data-type="wysiwyg"
  dir="auto"
-  style="position: absolute; display: inline-block; min-height: 1em; backface-visibility: hidden; margin: 0px; padding: 0px; border: 0px; outline: 0; resize: none; background: transparent; overflow: hidden; z-index: var(--zIndex-wysiwyg); word-break: break-word; white-space: pre-wrap; overflow-wrap: break-word; box-sizing: content-box; width: 10.5px; height: 26.25px; left: 35px; top: 7.5px; transform: translate(0px, 0px) scale(1) rotate(0deg); text-align: center; vertical-align: middle; color: rgb(30, 30, 30); opacity: 1; max-height: 992.5px; font: Emoji 20px 20px; line-height: 1.25; font-family: Excalifont, Xiaolai, sans-serif, Segoe UI Emoji;"
+  style="position: absolute; display: inline-block; min-height: 1em; backface-visibility: hidden; margin: 0px; padding: 0px; border: 0px; outline: 0; resize: none; background: transparent; overflow: hidden; z-index: var(--zIndex-wysiwyg); word-break: break-word; white-space: pre-wrap; overflow-wrap: break-word; box-sizing: content-box; width: 10.5px; height: 26.25px; left: 35px; top: 7.5px; transform: translate(0px, 0px) scale(1) rotate(0deg); text-align: center; vertical-align: middle; color: rgb(30, 30, 30); opacity: 1; filter: var(--theme-filter); max-height: 992.5px; font: Emoji 20px 20px; line-height: 1.25; font-family: Excalifont, Xiaolai, sans-serif, Segoe UI Emoji;"
  tabindex="0"
  wrap="off"
 />
@@ -1,12 +1,9 @@
-import { arrayToMap } from "@excalidraw/common";
 import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";
 import { Excalidraw } from "@excalidraw/excalidraw";
-import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 import { UI } from "@excalidraw/excalidraw/tests/helpers/ui";
 import "@excalidraw/utils/test-utils";
 import { render } from "@excalidraw/excalidraw/tests/test-utils";

-import * as distance from "../src/distance";
 import { hitElementItself } from "../src/collision";

 describe("check rotated elements can be hit:", () => {
@@ -28,6 +25,8 @@ describe("check rotated elements can be hit:", () => {
        [-4, -302],
      ] as LocalPoint[],
    });
+    //const p = [120, -211];
+    //const p = [0, 13];
    const hit = hitElementItself({
      point: pointFrom<GlobalPoint>(88, -68),
      element: window.h.elements[0],
@@ -37,182 +36,3 @@ describe("check rotated elements can be hit:", () => {
    expect(hit).toBe(true);
  });
 });
-
-describe("hitElementItself cache", () => {
-  beforeEach(async () => {
-    // reset cache
-    hitElementItself({
-      point: pointFrom<GlobalPoint>(50, 50),
-      element: API.createElement({
-        type: "rectangle",
-        x: 0,
-        y: 0,
-        width: 100,
-        height: 100,
-        backgroundColor: "#ffffff",
-      }),
-      threshold: Infinity,
-      elementsMap: new Map([]),
-    });
-
-    localStorage.clear();
-    await render(<Excalidraw handleKeyboardGlobally={true} />);
-  });
-
-  it("reuses cached result when threshold increases", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "#ffffff",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(100.5, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 1,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    distanceSpy.mockRestore();
-  });
-
-  it("does not reuse cache when threshold decreases", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(105, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 6,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(2);
-    distanceSpy.mockRestore();
-  });
-
-  it("invalidates cache when element version changes", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "#ffffff",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(100.5, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 1,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    const movedElement = {
-      ...element,
-      version: element.version + 1,
-      versionNonce: element.versionNonce + 1,
-    };
-
-    expect(
-      hitElementItself({
-        point,
-        element: movedElement,
-        threshold: 1,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(2);
-    distanceSpy.mockRestore();
-  });
-
-  it("override does not affect caching", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(50, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-      }),
-    ).toBe(false);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-        overrideShouldTestInside: true,
-      }),
-    ).toBe(true);
-  });
-});
@@ -218,7 +218,7 @@ describe("Test Linear Elements", () => {
    // drag line from midpoint
    drag(midpoint, pointFrom(midpoint[0] + delta, midpoint[1] + delta));
    expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(`8`);
-    expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`6`);
+    expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`7`);
    expect(line.points.length).toEqual(3);
    expect(line.points).toMatchInlineSnapshot(`
      [
@@ -563,24 +563,6 @@ describe("text element", () => {
    expect(text.fontSize).toBeCloseTo(fontSize * scale);
  });

-  it("resizes proportionally using horizontal delta from corner handles", async () => {
-    const text = UI.createElement("text");
-    await UI.editText(text, "hello\nworld");
-    const { x, y, width, height, fontSize } = text;
-    const deltaX = width;
-    const deltaY = 0;
-    const scale = (width + deltaX) / width;
-
-    UI.resize(text, "se", [deltaX, deltaY]);
-
-    expect(text.x).toBeCloseTo(x);
-    expect(text.y).toBeCloseTo(y);
-    expect(text.width).toBeCloseTo(width * scale);
-    expect(text.height).toBeCloseTo(height * scale);
-    expect(text.angle).toBeCloseTo(0);
-    expect(text.fontSize).toBeCloseTo(fontSize * scale);
-  });
-
  // TODO enable this test after adding single text element flipping
  it.skip("flips while resizing", async () => {
    const text = UI.createElement("text");
@@ -58,7 +58,6 @@ const distributeSelectedElements = (
    app.scene.getNonDeletedElementsMap(),
    distribution,
    appState,
-    app.scene,
  );

  const updatedElementsMap = arrayToMap(updatedElements);
@@ -82,10 +82,7 @@ export const actionFinalize = register<FormData>({
        app.scene,
      );

-      if (
-        isBindingElement(element) &&
-        !appState.selectedLinearElement.segmentMidPointHoveredCoords
-      ) {
+      if (isBindingElement(element)) {
        const newArrow = !!appState.newElement;

        const selectedPointsIndices =
@@ -98,10 +95,7 @@ export const actionFinalize = register<FormData>({
            map.set(index, {
              point: LinearElementEditor.pointFromAbsoluteCoords(
                element,
-                pointFrom<GlobalPoint>(
-                  sceneCoords.x - linearElementEditor.pointerOffset.x,
-                  sceneCoords.y - linearElementEditor.pointerOffset.y,
-                ),
+                pointFrom<GlobalPoint>(sceneCoords.x, sceneCoords.y),
                elementsMap,
              ),
            });
@@ -112,8 +106,8 @@ export const actionFinalize = register<FormData>({
        bindOrUnbindBindingElement(
          element,
          draggedPoints,
-          sceneCoords.x - linearElementEditor.pointerOffset.x,
-          sceneCoords.y - linearElementEditor.pointerOffset.y,
+          sceneCoords.x,
+          sceneCoords.y,
          scene,
          appState,
          {
@@ -176,7 +170,6 @@ export const actionFinalize = register<FormData>({
                    ...linearElementEditor.initialState,
                    lastClickedPoint: -1,
                  },
-                  pointerOffset: { x: 0, y: 0 },
                },
            selectionElement: null,
            suggestedBinding: null,
@@ -1263,9 +1263,9 @@ export const ShapesSwitcher = ({
              onSelect={() => app.onMagicframeToolSelect()}
              icon={MagicIcon}
              data-testid="toolbar-magicframe"
-              badge={<DropdownMenu.Item.Badge>AI</DropdownMenu.Item.Badge>}
            >
              {t("toolBar.magicframe")}
+              <DropdownMenu.Item.Badge>AI</DropdownMenu.Item.Badge>
            </DropdownMenu.Item>
          )}
        </DropdownMenu.Content>
@@ -47,6 +47,7 @@ import {
  TAP_TWICE_TIMEOUT,
  TEXT_TO_CENTER_SNAP_THRESHOLD,
  THEME,
+  THEME_FILTER,
  TOUCH_CTX_MENU_TIMEOUT,
  VERTICAL_ALIGN,
  YOUTUBE_STATES,
@@ -88,7 +89,6 @@ import {
  getDateTime,
  isShallowEqual,
  arrayToMap,
-  applyDarkModeFilter,
  type EXPORT_IMAGE_TYPES,
  randomInteger,
  CLASSES,
@@ -346,7 +346,7 @@ import {

 import { exportCanvas, loadFromBlob } from "../data";
 import Library, { distributeLibraryItemsOnSquareGrid } from "../data/library";
-import { restoreAppState, restoreElements } from "../data/restore";
+import { restore, restoreElements } from "../data/restore";
 import { getCenter, getDistance } from "../gesture";
 import { History } from "../history";
 import { defaultLang, getLanguage, languages, setLanguage, t } from "../i18n";
@@ -1770,9 +1770,8 @@ class App extends React.Component<AppProps, AppState> {
              }
            }}
            style={{
-              background: isDarkTheme
-                ? applyDarkModeFilter(this.state.viewBackgroundColor)
-                : this.state.viewBackgroundColor,
+              background: this.state.viewBackgroundColor,
+              filter: isDarkTheme ? THEME_FILTER : "none",
              zIndex: 2,
              border: "none",
              display: "block",
@@ -1782,9 +1781,7 @@ class App extends React.Component<AppProps, AppState> {
              fontFamily: "Assistant",
              fontSize: `${FRAME_STYLE.nameFontSize}px`,
              transform: `translate(-${FRAME_NAME_EDIT_PADDING}px, ${FRAME_NAME_EDIT_PADDING}px)`,
-              color: isDarkTheme
-                ? FRAME_STYLE.nameColorDarkTheme
-                : FRAME_STYLE.nameColorLightTheme,
+              color: "var(--color-gray-80)",
              overflow: "hidden",
              maxWidth: `${
                document.body.clientWidth - x1 - FRAME_NAME_EDIT_PADDING
@@ -2119,7 +2116,6 @@ class App extends React.Component<AppProps, AppState> {
                            elementsPendingErasure: this.elementsPendingErasure,
                            pendingFlowchartNodes:
                              this.flowChartCreator.pendingNodes,
-                            theme: this.state.theme,
                          }}
                        />
                        {this.state.newElement && (
@@ -2140,7 +2136,6 @@ class App extends React.Component<AppProps, AppState> {
                              elementsPendingErasure:
                                this.elementsPendingErasure,
                              pendingFlowchartNodes: null,
-                              theme: this.state.theme,
                            }}
                          />
                        )}
@@ -2706,47 +2701,46 @@ class App extends React.Component<AppProps, AppState> {
        },
      };
    }
-    const restoredElements = restoreElements(initialData?.elements, null, {
+    const scene = restore(initialData, null, null, {
      repairBindings: true,
      deleteInvisibleElements: true,
    });
-    let restoredAppState = restoreAppState(initialData?.appState, null);
-    const activeTool = restoredAppState.activeTool;
+    const activeTool = scene.appState.activeTool;

-    if (!restoredAppState.preferredSelectionTool.initialized) {
-      restoredAppState.preferredSelectionTool = {
+    if (!scene.appState.preferredSelectionTool.initialized) {
+      scene.appState.preferredSelectionTool = {
        type:
          this.editorInterface.formFactor === "phone" ? "lasso" : "selection",
        initialized: true,
      };
    }

-    restoredAppState = {
-      ...restoredAppState,
-      theme: this.props.theme || restoredAppState.theme,
+    scene.appState = {
+      ...scene.appState,
+      theme: this.props.theme || scene.appState.theme,
      // we're falling back to current (pre-init) state when deciding
      // whether to open the library, to handle a case where we
      // update the state outside of initialData (e.g. when loading the app
      // with a library install link, which should auto-open the library)
-      openSidebar: restoredAppState?.openSidebar || this.state.openSidebar,
+      openSidebar: scene.appState?.openSidebar || this.state.openSidebar,
      activeTool:
        activeTool.type === "image" ||
        activeTool.type === "lasso" ||
        activeTool.type === "selection"
          ? {
              ...activeTool,
-              type: restoredAppState.preferredSelectionTool.type,
+              type: scene.appState.preferredSelectionTool.type,
            }
-          : restoredAppState.activeTool,
+          : scene.appState.activeTool,
      isLoading: false,
      toast: this.state.toast,
    };

    if (initialData?.scrollToContent) {
-      restoredAppState = {
-        ...restoredAppState,
-        ...calculateScrollCenter(restoredElements, {
-          ...restoredAppState,
+      scene.appState = {
+        ...scene.appState,
+        ...calculateScrollCenter(scene.elements, {
+          ...scene.appState,
          width: this.state.width,
          height: this.state.height,
          offsetTop: this.state.offsetTop,
@@ -2758,9 +2752,7 @@ class App extends React.Component<AppProps, AppState> {
    this.resetStore();
    this.resetHistory();
    this.syncActionResult({
-      elements: restoredElements,
-      appState: restoredAppState,
-      files: initialData?.files,
+      ...scene,
      captureUpdate: CaptureUpdateAction.NEVER,
    });

@@ -2780,7 +2772,7 @@ class App extends React.Component<AppProps, AppState> {

  private getFormFactor = (editorWidth: number, editorHeight: number) => {
    return (
-      this.props.UIOptions.getFormFactor?.(editorWidth, editorHeight) ??
+      this.props.UIOptions.formFactor ??
      getFormFactor(editorWidth, editorHeight)
    );
  };
@@ -2804,7 +2796,10 @@ class App extends React.Component<AppProps, AppState> {
        ? this.props.UIOptions.dockedSidebarBreakpoint
        : MQ_RIGHT_SIDEBAR_MIN_WIDTH;
    const nextEditorInterface = updateObject(this.editorInterface, {
-      desktopUIMode: storedDesktopUIMode ?? this.editorInterface.desktopUIMode,
+      desktopUIMode:
+        this.props.UIOptions.desktopUIMode ??
+        storedDesktopUIMode ??
+        this.editorInterface.desktopUIMode,
      formFactor: this.getFormFactor(editorWidth, editorHeight),
      userAgent: userAgentDescriptor,
      canFitSidebar: editorWidth > sidebarBreakpoint,
@@ -3183,7 +3178,6 @@ class App extends React.Component<AppProps, AppState> {
    ) {
      setEraserCursor(this.interactiveCanvas, this.state.theme);
    }
-
    // Hide hyperlink popup if shown when element type is not selection
    if (
      prevState.activeTool.type === "selection" &&
@@ -10052,7 +10046,7 @@ class App extends React.Component<AppProps, AppState> {
            });
          }
        } else if (pointerDownState.drag.hasOccurred && !multiElement) {
-          if (isLinearElement(newElement)) {
+          if (isBindingElement(newElement, false)) {
            this.actionManager.executeAction(actionFinalize, "ui", {
              event: childEvent,
              sceneCoords,
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .Avatar {
@@ -1,4 +1,4 @@
-@use "../css/theme" as *;
+@import "../css/theme";

 .excalidraw {
  .excalidraw-button {
@@ -1,4 +1,4 @@
-@use "../css/theme" as *;
+@import "../css/theme";

 .excalidraw {
  button.standalone {
@@ -1,4 +1,4 @@
-@use "../css/variables.module.scss" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .Card {
@@ -19,7 +19,7 @@
      padding: 1.4rem;
      border-radius: 50%;
      background: var(--card-color);
-      color: #fff;
+      color: $oc-white;

      svg {
        width: 2.8rem;
@@ -46,7 +46,7 @@
        background-color: var(--card-color-darkest);
      }
      .ToolIcon__label {
-        color: #fff;
+        color: $oc-white;
      }

      .Spinner {
@@ -1,35 +1,25 @@
+import OpenColor from "open-color";
+
 import "./Card.scss";

-// for open-color see https://github.com/yeun/open-color/blob/master/open-color.scss
-const COLOR_MAP = {
-  primary: {
-    base: "var(--color-primary)",
-    darker: "var(--color-primary-darker)",
-    darkest: "var(--color-primary-darkest)",
-  },
-  lime: {
-    base: "#74b816", // open-color lime[7]
-    darker: "#66a80f", // open-color lime[8]
-    darkest: "#5c940d", // open-color lime[9]
-  },
-  pink: {
-    base: "#d6336c", // open-color pink[7]
-    darker: "#c2255c", // open-color pink[8]
-    darkest: "#a61e4d", // open-color pink[9]
-  },
-};
-
 export const Card: React.FC<{
-  color: "primary" | "lime" | "pink";
+  color: keyof OpenColor | "primary";
  children?: React.ReactNode;
 }> = ({ children, color }) => {
  return (
    <div
      className="Card"
      style={{
-        ["--card-color" as any]: COLOR_MAP[color].base,
-        ["--card-color-darker" as any]: COLOR_MAP[color].darker,
-        ["--card-color-darkest" as any]: COLOR_MAP[color].darkest,
+        ["--card-color" as any]:
+          color === "primary" ? "var(--color-primary)" : OpenColor[color][7],
+        ["--card-color-darker" as any]:
+          color === "primary"
+            ? "var(--color-primary-darker)"
+            : OpenColor[color][8],
+        ["--card-color-darkest" as any]:
+          color === "primary"
+            ? "var(--color-primary-darkest)"
+            : OpenColor[color][9],
      }}
    >
      {children}
@@ -1,5 +1,4 @@
-@use "sass:color";
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .Checkbox {
@@ -13,7 +12,7 @@
    -webkit-tap-highlight-color: transparent;

    &:hover:not(.is-checked) .Checkbox-box:not(:focus) {
-      box-shadow: 0 0 0 2px #{$color-blue-4};
+      box-shadow: 0 0 0 2px #{$oc-blue-4};
    }

    &:hover:not(.is-checked) .Checkbox-box:not(:focus) {
@@ -25,25 +24,25 @@

    &:active {
      .Checkbox-box {
-        box-shadow: 0 0 2px 1px inset #{$color-blue-7} !important;
+        box-shadow: 0 0 2px 1px inset #{$oc-blue-7} !important;
      }
    }

    &:hover {
      .Checkbox-box {
-        background-color: color.adjust($color-blue-1, $alpha: -0.8);
+        background-color: fade-out($oc-blue-1, 0.8);
      }
    }

    &.is-checked {
      .Checkbox-box {
-        background-color: #{$color-blue-1};
+        background-color: #{$oc-blue-1};
        svg {
          display: block;
        }
      }
      &:hover .Checkbox-box {
-        background-color: #{$color-blue-2};
+        background-color: #{$oc-blue-2};
      }
    }

@@ -59,16 +58,16 @@
      align-items: center;
      justify-content: center;

-      box-shadow: 0 0 0 2px #{$color-blue-7};
+      box-shadow: 0 0 0 2px #{$oc-blue-7};
      background-color: transparent;
      border-radius: 4px;

-      color: #{$color-blue-7};
+      color: #{$oc-blue-7};

      border: 0;

      &:focus {
-        box-shadow: 0 0 0 3px #{$color-blue-7};
+        box-shadow: 0 0 0 3px #{$oc-blue-7};
      }

      svg {
@@ -1,7 +1,7 @@
 import clsx from "clsx";
 import { useCallback, useEffect, useRef, useState } from "react";

-import { KEYS, normalizeInputColor } from "@excalidraw/common";
+import { KEYS } from "@excalidraw/common";

 import { getShortcutKey } from "../..//shortcut";
 import { useAtom } from "../../editor-jotai";
@@ -10,23 +10,26 @@ import { useEditorInterface } from "../App";
 import { activeEyeDropperAtom } from "../EyeDropper";
 import { eyeDropperIcon } from "../icons";

+import { getColor } from "./ColorPicker";
 import { activeColorPickerSectionAtom } from "./colorPickerUtils";

 import type { ColorPickerType } from "./colorPickerUtils";

+interface ColorInputProps {
+  color: string;
+  onChange: (color: string) => void;
+  label: string;
+  colorPickerType: ColorPickerType;
+  placeholder?: string;
+}
+
 export const ColorInput = ({
  color,
  onChange,
  label,
  colorPickerType,
  placeholder,
-}: {
-  color: string;
-  onChange: (color: string) => void;
-  label: string;
-  colorPickerType: ColorPickerType;
-  placeholder?: string;
-}) => {
+}: ColorInputProps) => {
  const editorInterface = useEditorInterface();
  const [innerValue, setInnerValue] = useState(color);
  const [activeSection, setActiveColorPickerSection] = useAtom(
@@ -40,7 +43,7 @@ export const ColorInput = ({
  const changeColor = useCallback(
    (inputValue: string) => {
      const value = inputValue.toLowerCase();
-      const color = normalizeInputColor(value);
+      const color = getColor(value);

      if (color) {
        onChange(color);
@@ -1,5 +1,4 @@
-@use "sass:color";
-@use "../../css/variables.module" as *;
+@import "../../css/variables.module.scss";

 .excalidraw {
  .focus-visible-none {
@@ -186,8 +185,8 @@

  .color-picker {
    background: var(--popup-bg-color);
-    border: 0 solid color.adjust(#fff, $alpha: -0.75);
-    box-shadow: color.adjust(#000, $alpha: -0.75) 0 1px 4px;
+    border: 0 solid transparentize($oc-white, 0.75);
+    box-shadow: transparentize($oc-black, 0.75) 0 1px 4px;
    border-radius: 4px;
    position: absolute;

@@ -244,7 +243,7 @@
  }

  .color-picker-triangle-shadow {
-    border-color: transparent transparent color.adjust(#000, $alpha: -0.9);
+    border-color: transparent transparent transparentize($oc-black, 0.9);

    :root[dir="ltr"] & {
      left: -14px;
@@ -281,7 +280,7 @@
    padding: 0.25rem;

    &-title {
-      color: $color-gray-6;
+      color: $oc-gray-6;
      font-size: 12px;
      padding: 0 0.25rem;
    }
@@ -320,7 +319,7 @@

  .color-picker-transparent {
    border-radius: 4px;
-    box-shadow: color.adjust(#000, $alpha: -0.9) 0 0 0 1px inset;
+    box-shadow: transparentize($oc-black, 0.9) 0 0 0 1px inset;
    position: absolute;
    top: 0;
    right: 0;
@@ -474,7 +473,7 @@
  }

  .color-picker-type-elementBackground .color-picker-keybinding {
-    color: #fff;
+    color: $oc-white;
  }

  .color-picker-swatch[aria-label="transparent"] .color-picker-keybinding {
@@ -487,10 +486,10 @@

  &.theme--dark {
    .color-picker-type-elementBackground .color-picker-keybinding {
-      color: #000;
+      color: $oc-black;
    }
    .color-picker-swatch[aria-label="transparent"] .color-picker-keybinding {
-      color: #000;
+      color: $oc-black;
    }
  }
 }
@@ -5,7 +5,7 @@ import { useRef, useEffect } from "react";
 import {
  COLOR_OUTLINE_CONTRAST_THRESHOLD,
  COLOR_PALETTE,
-  isColorDark,
+  isTransparent,
  isWritableElement,
 } from "@excalidraw/common";

@@ -30,7 +30,7 @@ import { ColorInput } from "./ColorInput";
 import { Picker } from "./Picker";
 import PickerHeading from "./PickerHeading";
 import { TopPicks } from "./TopPicks";
-import { activeColorPickerSectionAtom } from "./colorPickerUtils";
+import { activeColorPickerSectionAtom, isColorDark } from "./colorPickerUtils";

 import "./ColorPicker.scss";

@@ -38,6 +38,27 @@ import type { ColorPickerType } from "./colorPickerUtils";

 import type { AppState } from "../../types";

+const isValidColor = (color: string) => {
+  const style = new Option().style;
+  style.color = color;
+  return !!style.color;
+};
+
+export const getColor = (color: string): string | null => {
+  if (isTransparent(color)) {
+    return color;
+  }
+
+  // testing for `#` first fixes a bug on Electron (more specfically, an
+  // Obsidian popout window), where a hex color without `#` is (incorrectly)
+  // considered valid
+  return isValidColor(`#${color}`)
+    ? `#${color}`
+    : isValidColor(color)
+    ? color
+    : null;
+};
+
 interface ColorPickerProps {
  type: ColorPickerType;
  /**
@@ -1,5 +1,6 @@
 import React from "react";
-import { isColorDark } from "@excalidraw/common";
+
+import { isColorDark } from "./colorPickerUtils";

 interface HotkeyLabelProps {
  color: string;
@@ -5,9 +5,10 @@ import {
  DEFAULT_CANVAS_BACKGROUND_PICKS,
  DEFAULT_ELEMENT_BACKGROUND_PICKS,
  DEFAULT_ELEMENT_STROKE_PICKS,
-  isColorDark,
 } from "@excalidraw/common";

+import { isColorDark } from "./colorPickerUtils";
+
 import type { ColorPickerType } from "./colorPickerUtils";

 interface TopPicksProps {
@@ -96,6 +96,63 @@ export type ActiveColorPickerSectionAtomType =
 export const activeColorPickerSectionAtom =
  atom<ActiveColorPickerSectionAtomType>(null);

+const calculateContrast = (r: number, g: number, b: number): number => {
+  const yiq = (r * 299 + g * 587 + b * 114) / 1000;
+  return yiq;
+};
+
+// YIQ algo, inspiration from https://stackoverflow.com/a/11868398
+export const isColorDark = (color: string, threshold = 160): boolean => {
+  // no color ("") -> assume it default to black
+  if (!color) {
+    return true;
+  }
+
+  if (color === "transparent") {
+    return false;
+  }
+
+  // a string color (white etc) or any other format -> convert to rgb by way
+  // of creating a DOM node and retrieving the computeStyle
+  if (!color.startsWith("#")) {
+    const node = document.createElement("div");
+    node.style.color = color;
+
+    if (node.style.color) {
+      // making invisible so document doesn't reflow (hopefully).
+      // display=none works too, but supposedly not in all browsers
+      node.style.position = "absolute";
+      node.style.visibility = "hidden";
+      node.style.width = "0";
+      node.style.height = "0";
+
+      // needs to be in DOM else browser won't compute the style
+      document.body.appendChild(node);
+      const computedColor = getComputedStyle(node).color;
+      document.body.removeChild(node);
+      // computed style is in rgb() format
+      const rgb = computedColor
+        .replace(/^(rgb|rgba)\(/, "")
+        .replace(/\)$/, "")
+        .replace(/\s/g, "")
+        .split(",");
+      const r = parseInt(rgb[0]);
+      const g = parseInt(rgb[1]);
+      const b = parseInt(rgb[2]);
+
+      return calculateContrast(r, g, b) < threshold;
+    }
+    // invalid color -> assume it default to black
+    return true;
+  }
+
+  const r = parseInt(color.slice(1, 3), 16);
+  const g = parseInt(color.slice(3, 5), 16);
+  const b = parseInt(color.slice(5, 7), 16);
+
+  return calculateContrast(r, g, b) < threshold;
+};
+
 export type ColorPickerType =
  | "canvasBackground"
  | "elementBackground"
@@ -1,4 +1,4 @@
-@use "../../css/variables.module" as *;
+@import "../../css/variables.module.scss";

 $verticalBreakpoint: 861px;

@@ -44,6 +44,7 @@ import { getSelectedElements } from "../../scene";
 import {
  LockedIcon,
  UnlockedIcon,
+  clockIcon,
  searchIcon,
  boltIcon,
  bucketFillIcon,
@@ -51,7 +52,6 @@ import {
  mermaidLogoIcon,
  brainIconThin,
  LibraryIcon,
-  historyCommandIcon,
 } from "../icons";

 import { SHAPES } from "../shapes";
@@ -928,7 +928,7 @@ function CommandPaletteInner({
                  marginLeft: "6px",
                }}
              >
-                {historyCommandIcon}
+                {clockIcon}
              </div>
            </div>
            <CommandItem
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .confirm-dialog {
@@ -1,5 +1,4 @@
-@use "sass:color";
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .context-menu-popover {
@@ -9,7 +8,7 @@
  .context-menu {
    position: relative;
    border-radius: 4px;
-    box-shadow: 0 3px 10px color.adjust(#000, $alpha: -0.8);
+    box-shadow: 0 3px 10px transparentize($oc-black, 0.8);
    padding: 0;
    list-style: none;
    user-select: none;
@@ -50,7 +49,7 @@

    &.dangerous {
      .context-menu-item__label {
-        color: $color-red-7;
+        color: $oc-red-7;
      }
    }

@@ -74,7 +73,7 @@
      .context-menu-item__label {
        color: var(--popup-bg-color);
      }
-      background-color: $color-red-6;
+      background-color: $oc-red-6;
    }
  }

@@ -98,6 +97,6 @@

  .context-menu-item-separator {
    border: none;
-    border-top: 1px solid $color-gray-5;
+    border-top: 1px solid $oc-gray-5;
  }
 }
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css//variables.module.scss";

 .excalidraw {
  .ConvertElementTypePopup {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .Dialog {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .ElementLinkDialog {
@@ -59,7 +59,7 @@
      }

      .ElementLinkDialog__remove {
-        color: $color-red-9;
+        color: $oc-red-9;
        margin-left: 1rem;

        .ToolIcon__icon {
@@ -68,7 +68,7 @@
        }

        .ToolIcon__icon svg {
-          color: $color-red-6;
+          color: $oc-red-6;
        }
      }
    }
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .ExportDialog__preview {
@@ -112,7 +112,7 @@

    font-family: Cascadia;
    font-size: 1.8em;
-    color: #fff;
+    color: $oc-white;

    &:hover {
      background-color: var(--button-color-darker);
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

@keyframes successStatusAnimation {
  0% {
@@ -24,14 +24,6 @@
    background-color: var(--back-color);
    border-color: var(--border-color);

-    border-radius: 0.5rem;
-    border-width: 1px;
-    border-style: solid;
-
-    font-family: var(--font-family);
-
-    user-select: none;
-
    &:hover {
      transition: all 150ms ease-out;
    }
@@ -60,19 +52,7 @@
    }

    &[disabled] {
-      cursor: not-allowed;
-
-      &.ExcButton--variant-filled,
-      &:hover {
-        --back-color: var(--color-surface-low) !important;
-        --text-color: var(--color-on-surface-variant) !important;
-      }
-
-      &.ExcButton--variant-outlined,
-      &.ExcButton--variant-icon {
-        --text-color: var(--color-on-surface-variant);
-        --border-color: var(--color-surface-high);
-      }
+      pointer-events: none;
    }

    &,
@@ -286,6 +266,14 @@
      }
    }

+    border-radius: 0.5rem;
+    border-width: 1px;
+    border-style: solid;
+
+    font-family: var(--font-family);
+
+    user-select: none;
+
    &--size-large {
      font-weight: 600;
      font-size: 0.875rem;
@@ -33,7 +33,6 @@ export type FilledButtonProps = {
  fullWidth?: boolean;

  icon?: React.ReactNode;
-  disabled?: boolean;
 };

 export const FilledButton = forwardRef<HTMLButtonElement, FilledButtonProps>(
@@ -49,7 +48,6 @@ export const FilledButton = forwardRef<HTMLButtonElement, FilledButtonProps>(
      fullWidth,
      className,
      status,
-      disabled,
    },
    ref,
  ) => {
@@ -96,7 +94,7 @@ export const FilledButton = forwardRef<HTMLButtonElement, FilledButtonProps>(
        type="button"
        aria-label={label}
        ref={ref}
-        disabled={disabled || _status === "loading" || _status === "success"}
+        disabled={_status === "loading" || _status === "success"}
      >
        <div className="ExcButton__contents">
          {_status === "loading" ? (
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .FixedSideContainer {
@@ -1,4 +1,4 @@
-@use "../../css/variables.module" as *;
+@import "../../css/variables.module.scss";

 .excalidraw {
  .FontPicker__container {
@@ -290,15 +290,13 @@ export const FontPickerList = React.memo(
            onHover(font.value);
          }
        }}
-        badge={
-          font.badge && (
-            <DropDownMenuItemBadge type={font.badge.type}>
-              {font.badge.placeholder}
-            </DropDownMenuItemBadge>
-          )
-        }
      >
        {font.text}
+        {font.badge && (
+          <DropDownMenuItemBadge type={font.badge.type}>
+            {font.badge.placeholder}
+          </DropDownMenuItemBadge>
+        )}
      </DropdownMenuItem>
    );

@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .HelpDialog {
@@ -60,12 +60,11 @@

    &__islands-container {
      display: grid;
-      grid-column-gap: 1.5rem;
-      grid-row-gap: 2rem;
-
      @media screen and (min-width: 1024px) {
        grid-template-columns: 1fr 1fr;
      }
+      grid-column-gap: 1.5rem;
+      grid-row-gap: 2rem;
    }

    @media screen and (min-width: 1024px) {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 // this is loosely based on the longest hint text
 $wide-viewport-width: 1000px;
@@ -1,11 +1,10 @@
-@use "sass:color";
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .picker {
    padding: 0.5rem;
    background: var(--popup-bg-color);
-    border: 0 solid color.adjust(#fff, $alpha: -0.75);
+    border: 0 solid transparentize($oc-white, 0.75);
    box-shadow: var(--shadow-island);
    border-radius: 4px;
    position: absolute;
@@ -88,7 +87,7 @@
  }

  .picker-type-elementBackground .picker-keybinding {
-    color: #fff;
+    color: $oc-white;
  }

  .picker-swatch[aria-label="transparent"] .picker-keybinding {
@@ -101,10 +100,10 @@

  &.theme--dark {
    .picker-type-elementBackground .picker-keybinding {
-      color: #000;
+      color: $oc-black;
    }
    .picker-swatch[aria-label="transparent"] .picker-keybinding {
-      color: #000;
+      color: $oc-black;
    }
  }
 }
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  --ImageExportModal-preview-border: #d6d6d6;
@@ -40,6 +40,9 @@ import type { ActionManager } from "../actions/manager";

 import type { AppClassProperties, BinaryFiles, UIAppState } from "../types";

+const supportsContextFilters =
+  "filter" in document.createElement("canvas").getContext("2d")!;
+
 export const ErrorCanvasPreview = () => {
  return (
    <div>
@@ -227,23 +230,25 @@ const ImageExportModal = ({
            }}
          />
        </ExportSetting>
-        <ExportSetting
-          label={t("imageExportDialog.label.darkMode")}
-          name="exportDarkModeSwitch"
-        >
-          <Switch
+        {supportsContextFilters && (
+          <ExportSetting
+            label={t("imageExportDialog.label.darkMode")}
            name="exportDarkModeSwitch"
-            checked={exportDarkMode}
-            onChange={(checked) => {
-              setExportDarkMode(checked);
-              actionManager.executeAction(
-                actionExportWithDarkMode,
-                "ui",
-                checked,
-              );
-            }}
-          />
-        </ExportSetting>
+          >
+            <Switch
+              name="exportDarkModeSwitch"
+              checked={exportDarkMode}
+              onChange={(checked) => {
+                setExportDarkMode(checked);
+                actionManager.executeAction(
+                  actionExportWithDarkMode,
+                  "ui",
+                  checked,
+                );
+              }}
+            />
+          </ExportSetting>
+        )}
        <ExportSetting
          label={t("imageExportDialog.label.embedScene")}
          tooltip={t("imageExportDialog.tooltip.embedScene")}
@@ -1,4 +1,5 @@
-@use "../css/variables.module" as *;
+@import "open-color/open-color";
+@import "../css/variables.module.scss";

 .excalidraw {
  .layer-ui__wrapper.animate {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "open-color/open-color";

 .excalidraw {
  .layer-ui__library {
@@ -46,15 +46,15 @@
    }

    &-close.ToolIcon_type_button {
-      background-color: $color-blue-6;
+      background-color: $oc-blue-6;
      align-self: flex-end;
      &:hover {
-        background-color: $color-blue-8;
+        background-color: $oc-blue-8;
      }
      .ToolIcon__icon {
        width: auto;
        font-size: 1rem;
-        color: #fff;
+        color: $oc-white;
        padding: 0 0.5rem;
      }
    }
@@ -90,7 +90,7 @@

    border-radius: var(--border-radius-lg);
    background-color: var(--color-primary);
-    color: #fff;
+    color: $oc-white;
    text-align: center;
    white-space: nowrap;
    text-decoration: none !important;
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "open-color/open-color";

 .excalidraw {
  --container-padding-y: 1rem;
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .library-unit {
@@ -1,4 +1,5 @@
-@use "../css/variables.module" as *;
+@import "open-color/open-color.scss";
+@import "../css/variables.module.scss";

 .excalidraw {
  .mobile-toolbar {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  &.excalidraw-modal-container {
@@ -49,6 +49,7 @@ export const Modal: React.FC<{
      aria-modal="true"
      onKeyDown={handleKeydown}
      aria-labelledby={props.labelledBy}
+      data-prevent-outside-click
    >
      <div
        className="Modal__background"
@@ -1,4 +1,4 @@
-@use "../../css/variables.module" as *;
+@import "../../css/variables.module.scss";

 .excalidraw {
  .OverwriteConfirm {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .PasteChartDialog {
@@ -25,7 +25,7 @@
      height: 128px;
      border-radius: 2px;
      padding: 1px;
-      border: 1px solid $color-gray-4;
+      border: 1px solid $oc-gray-4;
      display: flex;
      align-items: center;
      justify-content: center;
@@ -39,7 +39,7 @@
      }
      &:hover {
        padding: 0;
-        border: 2px solid $color-blue-5;
+        border: 2px solid $oc-blue-5;
      }
    }
  }
@@ -1,3 +1,4 @@
+import oc from "open-color";
 import React, { useLayoutEffect, useRef, useState } from "react";

 import type { ChartType } from "@excalidraw/element/types";
@@ -48,7 +49,7 @@ const ChartPreviewBtn = (props: {
        elements,
        {
          exportBackground: false,
-          viewBackgroundColor: "#fff",
+          viewBackgroundColor: oc.white,
        },
        null, // files
        {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .publish-library {
@@ -14,7 +14,7 @@
        span {
          font-weight: 500;
          font-size: 1rem;
-          color: $color-gray-6;
+          color: $oc-gray-6;
        }
        input,
        textarea {
@@ -24,7 +24,7 @@
        }

        .required {
-          color: $color-red-8;
+          color: $oc-red-8;
          margin: 0.2rem;
        }
      }
@@ -48,22 +48,22 @@
      }

      &--confirm.ToolIcon_type_button {
-        background-color: $color-blue-6;
+        background-color: $oc-blue-6;

        &:hover {
-          background-color: $color-blue-8;
+          background-color: $oc-blue-8;
        }
      }

      &--cancel.ToolIcon_type_button {
-        background-color: $color-gray-5;
+        background-color: $oc-gray-5;
        &:hover {
-          background-color: $color-gray-6;
+          background-color: $oc-gray-6;
        }
      }

      .ToolIcon__icon {
-        color: #fff;
+        color: $oc-white;
        .Spinner {
          --spinner-color: #fff;
          svg {
@@ -83,7 +83,7 @@
    }

    &-warning {
-      color: $color-red-6;
+      color: $oc-red-6;
    }

    &-note {
@@ -102,14 +102,14 @@
      top: 0.3rem;
      left: 0.3rem;
      font-size: 0.7rem;
-      color: $color-red-7;
+      color: $oc-red-7;
      background: rgba(255, 255, 255, 0.9);
      padding: 0.1rem 0.2rem;
      border-radius: 0.2rem;
    }

    &__svg {
-      background-color: #fff;
+      background-color: $oc-white;
      padding: 0.3rem;
      width: 7.5rem;
      height: 7.5rem;
@@ -121,7 +121,7 @@
    }

    .ToolIcon__icon {
-      background-color: #fff;
+      background-color: $oc-white;
      width: auto;
      height: auto;
      margin: 0 0.5rem;
@@ -132,7 +132,7 @@
    }
    .required,
    .error {
-      color: $color-red-8;
+      color: $oc-red-8;
      font-weight: 700;
      font-size: 1rem;
      margin: 0.2rem;
@@ -152,16 +152,16 @@
        margin: 0;
      }
      .ToolIcon__icon {
-        background-color: $color-red-6;
+        background-color: $oc-red-6;
        &:hover {
-          background-color: $color-red-7;
+          background-color: $oc-red-7;
        }
        &:active {
-          background-color: $color-red-8;
+          background-color: $oc-red-8;
        }
      }
      svg {
-        color: #fff;
+        color: $oc-white;
        padding: 0.26rem;
        border-radius: 0.3em;
        width: 1rem;
@@ -1,4 +1,5 @@
 import { exportToCanvas, exportToSvg } from "@excalidraw/utils/export";
+import OpenColor from "open-color";
 import { useCallback, useEffect, useRef, useState } from "react";

 import {
@@ -56,7 +57,7 @@ const generatePreviewImage = async (libraryItems: LibraryItems) => {

  const ctx = canvas.getContext("2d")!;

-  ctx.fillStyle = "#fff";
+  ctx.fillStyle = OpenColor.white;
  ctx.fillRect(0, 0, canvas.width, canvas.height);

  // draw items
@@ -86,7 +87,7 @@ const generatePreviewImage = async (libraryItems: LibraryItems) => {
    // draw item border
    // -------------------------------------------------------------------------
    ctx.lineWidth = BORDER_WIDTH;
-    ctx.strokeStyle = "#ced4da";
+    ctx.strokeStyle = OpenColor.gray[4];
    ctx.strokeRect(
      colOffset + BOX_PADDING / 2,
      rowOffset + BOX_PADDING / 2,
@@ -130,7 +131,7 @@ const SingleLibraryItem = ({
        elements: libItem.elements,
        appState: {
          ...appState,
-          viewBackgroundColor: "#fff",
+          viewBackgroundColor: OpenColor.white,
          exportBackground: true,
        },
        files: null,
@@ -174,7 +175,7 @@ const SingleLibraryItem = ({
          }}
        >
          <div style={{ padding: "0.5em 0" }}>
-            <span style={{ fontWeight: 500, color: "#868e96" }}>
+            <span style={{ fontWeight: 500, color: OpenColor.gray[6] }}>
              {t("publishDialog.itemName")}
            </span>
            <span aria-hidden="true" className="required">
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  --RadioGroup-background: var(--island-bg-color);
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  --slider-thumb-size: 16px;
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .SVGLayer {
@@ -1,4 +1,5 @@
-@use "../css/variables.module" as *;
+@import "open-color/open-color";
+@import "../css//variables.module.scss";

 .excalidraw {
  .layer-ui__search {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  .ShareableLinkDialog {
@@ -1,4 +1,5 @@
-@use "../../css/variables.module" as *;
+@import "open-color/open-color";
+@import "../../css/variables.module.scss";

 .excalidraw {
  .sidebar {
@@ -18,12 +19,6 @@

    pointer-events: var(--ui-pointerEvents);

-    overflow: hidden;
-    border-radius: 0;
-    width: calc(var(--right-sidebar-width) - var(--space-factor) * 2);
-
-    border-left: 1px solid var(--sidebar-border-color);
-
    :root[dir="rtl"] & {
      left: 0;
      right: auto;
@@ -33,6 +28,12 @@
      box-shadow: none;
    }

+    overflow: hidden;
+    border-radius: 0;
+    width: calc(var(--right-sidebar-width) - var(--space-factor) * 2);
+
+    border-left: 1px solid var(--sidebar-border-color);
+
    :root[dir="rtl"] & {
      border-right: 1px solid var(--sidebar-border-color);
      border-left: 0;
@@ -1,4 +1,4 @@
-@use "../../css/variables.module" as *;
+@import "../../css/variables.module.scss";

 .excalidraw {
  .sidebar-trigger {
@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "open-color/open-color.scss";

 $duration: 1.6s;

@@ -1,4 +1,4 @@
-@use "../css/variables.module" as *;
+@import "../css/variables.module.scss";

 .excalidraw {
  --Switch-disabled-color: var(--color-border-outline);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ryan Di	be5d0bd925	refactor	2025-12-31 14:53:20 +11:00
Ryan Di	292aa1cddb	fix: to support wrapping with autoResize and given dimensions	2025-12-29 17:35:00 +11:00