remove debug

import lazily
feat: compress non-transparent PNGs as JPGs and allow larger dimensions
2021-11-22 23:20:40 +01:00 · 2021-11-22 22:11:10 +01:00 · 2021-11-22 17:39:59 +01:00
208 changed files with 4669 additions and 17524 deletions
@@ -4,5 +4,5 @@ REACT_APP_BACKEND_V2_POST_URL=https://json-dev.excalidraw.com/api/v2/post/
 REACT_APP_LIBRARY_URL=https://libraries.excalidraw.com
 REACT_APP_LIBRARY_BACKEND=https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries

-REACT_APP_SOCKET_SERVER_URL=http://localhost:3002
+REACT_APP_SOCKET_SERVER_URL=http://localhost:3000
 REACT_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"}'
@@ -23,5 +23,4 @@ jobs:
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
      - name: Auto release
        run: |
-          yarn add @actions/core
          yarn autorelease
@@ -1,55 +0,0 @@
-name: Auto release preview @excalidraw/excalidraw-preview
-on:
-  issue_comment:
-    types: [created, edited]
-
-jobs:
-  Auto-release-excalidraw-preview:
-    name: Auto release preview
-    if: github.event.comment.body == '@excalibot release package' && github.event.issue.pull_request
-    runs-on: ubuntu-latest
-    steps:
-      - name: React to release comment
-        uses: peter-evans/create-or-update-comment@v1
-        with:
-          token: ${{ secrets.PUSH_TRANSLATIONS_COVERAGE_PAT }}
-          comment-id: ${{ github.event.comment.id }}
-          reactions: "+1"
-      - name: Get PR SHA
-        id: sha
-        uses: actions/github-script@v4
-        with:
-          result-encoding: string
-          script: |
-            const { owner, repo, number } = context.issue;
-            const pr = await github.pulls.get({
-              owner,
-              repo,
-              pull_number: number,
-            });
-            return pr.data.head.sha
-      - uses: actions/checkout@v2
-        with:
-          ref: ${{ steps.sha.outputs.result }}
-          fetch-depth: 2
-      - name: Setup Node.js 14.x
-        uses: actions/setup-node@v2
-        with:
-          node-version: 14.x
-      - name: Set up publish access
-        run: |
-          npm config set //registry.npmjs.org/:_authToken ${NPM_TOKEN}
-        env:
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - name: Auto release preview
-        id: "autorelease"
-        run: |
-          yarn add @actions/core
-          yarn autorelease preview ${{ github.event.issue.number }}
-      - name: Post comment post release
-        if: always()
-        uses: peter-evans/create-or-update-comment@v1
-        with:
-          token: ${{ secrets.PUSH_TRANSLATIONS_COVERAGE_PAT }}
-          issue-number: ${{ github.event.issue.number }}
-          body: "@${{ github.event.comment.user.login }} ${{ steps.autorelease.outputs.result }}"
@@ -23,7 +23,3 @@ static
 yarn-debug.log*
 yarn-error.log*
 src/packages/excalidraw/types
-src/packages/excalidraw/example/public/bundle.js
-src/packages/excalidraw/example/public/excalidraw-assets-dev
-src/packages/excalidraw/example/public/excalidraw.development.js
-
@@ -1,2 +1 @@
-#!/bin/sh
 yarn lint-staged
@@ -118,10 +118,6 @@ yarn start

 Now you can open [http://localhost:3000](http://localhost:3000) and start coding in your favorite code editor.

-#### Collaboration
-
-For collaboration, you will need to set up [collab server](https://github.com/excalidraw/excalidraw-room) in local.
-
 #### Commands

 | Command            | Description                       |
@@ -21,15 +21,15 @@
  "dependencies": {
    "@sentry/browser": "6.2.5",
    "@sentry/integrations": "6.2.5",
-    "@testing-library/jest-dom": "5.16.2",
+    "@testing-library/jest-dom": "5.15.0",
    "@testing-library/react": "12.1.2",
-    "@tldraw/vec": "1.4.3",
-    "@types/jest": "27.4.0",
+    "@tldraw/vec": "0.1.3",
+    "@types/jest": "27.0.2",
    "@types/pica": "5.1.3",
-    "@types/react": "17.0.39",
+    "@types/react": "17.0.34",
    "@types/react-dom": "17.0.11",
    "@types/socket.io-client": "1.4.36",
-    "browser-fs-access": "0.23.0",
+    "browser-fs-access": "0.21.1",
    "clsx": "1.1.1",
    "fake-indexeddb": "3.1.7",
    "firebase": "8.3.3",
@@ -37,7 +37,7 @@
    "idb-keyval": "6.0.3",
    "image-blob-reduce": "3.0.1",
    "lodash.throttle": "4.1.1",
-    "nanoid": "3.1.32",
+    "nanoid": "3.1.30",
    "open-color": "1.9.1",
    "pako": "1.0.11",
    "perfect-freehand": "1.0.16",
@@ -49,32 +49,31 @@
    "react": "17.0.2",
    "react-dom": "17.0.2",
    "react-scripts": "4.0.3",
-    "roughjs": "4.5.2",
-    "sass": "1.49.7",
+    "roughjs": "4.5.0",
+    "sass": "1.43.4",
    "socket.io-client": "2.3.1",
-    "typescript": "4.5.5"
+    "typescript": "4.5.2"
  },
  "devDependencies": {
    "@excalidraw/eslint-config": "1.0.0",
    "@excalidraw/prettier-config": "1.0.2",
-    "@types/chai": "4.3.0",
+    "@types/chai": "4.2.22",
    "@types/lodash.throttle": "4.1.6",
-    "@types/pako": "1.0.3",
+    "@types/pako": "1.0.2",
    "@types/resize-observer-browser": "0.1.6",
-    "chai": "4.3.6",
-    "dotenv": "10.0.0",
+    "chai": "4.3.4",
    "eslint-config-prettier": "8.3.0",
    "eslint-plugin-prettier": "3.3.1",
-    "firebase-tools": "9.23.0",
+    "firebase-tools": "9.22.0",
    "husky": "7.0.4",
    "jest-canvas-mock": "2.3.1",
-    "lint-staged": "12.3.3",
+    "lint-staged": "12.0.1",
    "pepjs": "0.5.3",
-    "prettier": "2.5.1",
+    "prettier": "2.4.1",
    "rewire": "5.0.0"
  },
  "resolutions": {
-    "@typescript-eslint/typescript-estree": "5.10.2"
+    "@typescript-eslint/typescript-estree": "5.3.0"
  },
  "engines": {
    "node": ">=14.0.0"
@@ -1,6 +1,5 @@
 const fs = require("fs");
 const { exec, execSync } = require("child_process");
-const core = require("@actions/core");

 const excalidrawDir = `${__dirname}/../src/packages/excalidraw`;
 const excalidrawPackage = `${excalidrawDir}/package.json`;
@@ -16,25 +15,18 @@ const publish = () => {
    execSync(`yarn --frozen-lockfile`, { cwd: excalidrawDir });
    execSync(`yarn run build:umd`, { cwd: excalidrawDir });
    execSync(`yarn --cwd ${excalidrawDir} publish`);
-    console.info("Published 🎉");
-    core.setOutput(
-      "result",
-      `**Preview version has been shipped** :rocket:
-    You can use [@excalidraw/excalidraw-preview@${pkg.version}](https://www.npmjs.com/package/@excalidraw/excalidraw-preview/v/${pkg.version}) for testing!`,
-    );
  } catch (error) {
-    core.setOutput("result", "package couldn't be published :warning:!");
    console.error(error);
-    process.exit(1);
  }
 };
+
 // get files changed between prev and head commit
 exec(`git diff --name-only HEAD^ HEAD`, async (error, stdout, stderr) => {
  if (error || stderr) {
    console.error(error);
-    core.setOutput("result", ":warning: Package couldn't be published!");
    process.exit(1);
  }
+
  const changedFiles = stdout.trim().split("\n");
  const filesToIgnoreRegex = /src\/excalidraw-app|packages\/utils/;

@@ -45,33 +37,16 @@ exec(`git diff --name-only HEAD^ HEAD`, async (error, stdout, stderr) => {
    );
  });
  if (!excalidrawPackageFiles.length) {
-    console.info("Skipping release as no valid diff found");
-    core.setOutput("result", "Skipping release as no valid diff found");
    process.exit(0);
  }

  // update package.json
+  pkg.version = `${pkg.version}-${getShortCommitHash()}`;
  pkg.name = "@excalidraw/excalidraw-next";
-  let version = `${pkg.version}-${getShortCommitHash()}`;
-
-  // update readme
-  let data = fs.readFileSync(`${excalidrawDir}/README_NEXT.md`, "utf8");
-
-  const isPreview = process.argv.slice(2)[0] === "preview";
-  if (isPreview) {
-    // use pullNumber-commithash as the version for preview
-    const pullRequestNumber = process.argv.slice(3)[0];
-    version = `${pkg.version}-${pullRequestNumber}-${getShortCommitHash()}`;
-    // replace "excalidraw-next" with "excalidraw-preview"
-    pkg.name = "@excalidraw/excalidraw-preview";
-    data = data.replace(/excalidraw-next/g, "excalidraw-preview");
-    data = data.trim();
-  }
-  pkg.version = version;
-
  fs.writeFileSync(excalidrawPackage, JSON.stringify(pkg, null, 2), "utf8");

+  // update readme
+  const data = fs.readFileSync(`${excalidrawDir}/README_NEXT.md`, "utf8");
  fs.writeFileSync(`${excalidrawDir}/README.md`, data, "utf8");
-  console.info("Publish in progress...");
  publish();
 });
@@ -11,7 +11,6 @@ const crowdinMap = {
  "de-DE": "en-de",
  "el-GR": "en-el",
  "es-ES": "en-es",
-  "eu-ES": "en-eu",
  "fa-IR": "en-fa",
  "fi-FI": "en-fi",
  "fr-FR": "en-fr",
@@ -43,7 +42,6 @@ const crowdinMap = {
  "zh-CN": "en-zhcn",
  "zh-HK": "en-zhhk",
  "zh-TW": "en-zhtw",
-  "lt-LT": "en-lt",
  "lv-LV": "en-lv",
  "cs-CZ": "en-cs",
  "kk-KZ": "en-kk",
@@ -71,7 +69,6 @@ const flags = {
  "kab-KAB": "🏳",
  "kk-KZ": "🇰🇿",
  "ko-KR": "🇰🇷",
-  "lt-LT": "🇱🇹",
  "lv-LV": "🇱🇻",
  "my-MM": "🇲🇲",
  "nb-NO": "🇳🇴",
@@ -105,7 +102,6 @@ const languages = {
  "de-DE": "Deutsch",
  "el-GR": "Ελληνικά",
  "es-ES": "Español",
-  "eu-ES": "Euskara",
  "fa-IR": "فارسی",
  "fi-FI": "Suomi",
  "fr-FR": "Français",
@@ -118,7 +114,6 @@ const languages = {
  "kab-KAB": "Taqbaylit",
  "kk-KZ": "Қазақ тілі",
  "ko-KR": "한국어",
-  "lt-LT": "Lietuvių",
  "lv-LV": "Latviešu",
  "my-MM": "Burmese",
  "nb-NO": "Norsk bokmål",
@@ -20,7 +20,7 @@ const headerForType = {
  perf: "Performance",
  build: "Build",
 };
-const badCommits = [];
+
 const getCommitHashForLastVersion = async () => {
  try {
    const commitMessage = `"release @excalidraw/excalidraw@${lastVersion}"`;
@@ -53,26 +53,19 @@ const getLibraryCommitsSinceLastRelease = async () => {
    const messageWithoutType = commit.slice(indexOfColon + 1).trim();
    const messageWithCapitalizeFirst =
      messageWithoutType.charAt(0).toUpperCase() + messageWithoutType.slice(1);
-    const prMatch = commit.match(/\(#([0-9]*)\)/);
-    if (prMatch) {
-      const prNumber = prMatch[1];
+    const prNumber = commit.match(/\(#([0-9]*)\)/)[1];

-      // return if the changelog already contains the pr number which would happen for package updates
-      if (existingChangeLog.includes(prNumber)) {
-        return;
-      }
-      const prMarkdown = `[#${prNumber}](https://github.com/excalidraw/excalidraw/pull/${prNumber})`;
-      const messageWithPRLink = messageWithCapitalizeFirst.replace(
-        /\(#[0-9]*\)/,
-        prMarkdown,
-      );
-      commitList[type].push(messageWithPRLink);
-    } else {
-      badCommits.push(commit);
-      commitList[type].push(messageWithCapitalizeFirst);
+    // return if the changelog already contains the pr number which would happen for package updates
+    if (existingChangeLog.includes(prNumber)) {
+      return;
    }
+    const prMarkdown = `[#${prNumber}](https://github.com/excalidraw/excalidraw/pull/${prNumber})`;
+    const messageWithPRLink = messageWithCapitalizeFirst.replace(
+      /\(#[0-9]*\)/,
+      prMarkdown,
+    );
+    commitList[type].push(messageWithPRLink);
  });
-  console.info("Bad commits:", badCommits);
  return commitList;
 };

@@ -8,12 +8,7 @@ import { t } from "../i18n";
 export const actionAddToLibrary = register({
  name: "addToLibrary",
  perform: (elements, appState, _, app) => {
-    const selectedElements = getSelectedElements(
-      getNonDeletedElements(elements),
-      appState,
-      true,
-    );
-    if (selectedElements.some((element) => element.type === "image")) {
+    if (elements.some((element) => element.type === "image")) {
      return {
        commitToHistory: false,
        appState: {
@@ -30,7 +25,10 @@ export const actionAddToLibrary = register({
          {
            id: randomId(),
            status: "unpublished",
-            elements: selectedElements.map(deepCopyElement),
+            elements: getSelectedElements(
+              getNonDeletedElements(elements),
+              appState,
+            ).map(deepCopyElement),
            created: Date.now(),
          },
          ...items,
@@ -8,13 +8,13 @@ import {
  CenterVerticallyIcon,
 } from "../components/icons";
 import { ToolButton } from "../components/ToolButton";
-import { getNonDeletedElements } from "../element";
+import { getElementMap, getNonDeletedElements } from "../element";
 import { ExcalidrawElement } from "../element/types";
 import { t } from "../i18n";
 import { KEYS } from "../keys";
 import { getSelectedElements, isSomeElementSelected } from "../scene";
 import { AppState } from "../types";
-import { arrayToMap, getShortcutKey } from "../utils";
+import { getShortcutKey } from "../utils";
 import { register } from "./register";

 const enableActionGroup = (
@@ -34,11 +34,9 @@ const alignSelectedElements = (

  const updatedElements = alignElements(selectedElements, alignment);

-  const updatedElementsMap = arrayToMap(updatedElements);
+  const updatedElementsMap = getElementMap(updatedElements);

-  return elements.map(
-    (element) => updatedElementsMap.get(element.id) || element,
-  );
+  return elements.map((element) => updatedElementsMap[element.id] || element);
 };

 export const actionAlignTop = register({
@@ -9,7 +9,7 @@ import { t } from "../i18n";
 import { CODES, KEYS } from "../keys";
 import { getNormalizedZoom, getSelectedElements } from "../scene";
 import { centerScrollOn } from "../scene/scroll";
-import { getStateForZoom } from "../scene/zoom";
+import { getNewZoom } from "../scene/zoom";
 import { AppState, NormalizedZoomValue } from "../types";
 import { getShortcutKey } from "../utils";
 import { register } from "./register";
@@ -58,15 +58,11 @@ export const actionClearCanvas = register({
        files: {},
        theme: appState.theme,
        elementLocked: appState.elementLocked,
-        penMode: appState.penMode,
-        penDetected: appState.penDetected,
        exportBackground: appState.exportBackground,
        exportEmbedScene: appState.exportEmbedScene,
        gridSize: appState.gridSize,
        showStats: appState.showStats,
        pasteDialog: appState.pasteDialog,
-        elementType:
-          appState.elementType === "image" ? "selection" : appState.elementType,
      },
      commitToHistory: true,
    };
@@ -77,18 +73,17 @@ export const actionClearCanvas = register({

 export const actionZoomIn = register({
  name: "zoomIn",
-  perform: (_elements, appState, _, app) => {
+  perform: (_elements, appState) => {
+    const zoom = getNewZoom(
+      getNormalizedZoom(appState.zoom.value + ZOOM_STEP),
+      appState.zoom,
+      { left: appState.offsetLeft, top: appState.offsetTop },
+      { x: appState.width / 2, y: appState.height / 2 },
+    );
    return {
      appState: {
        ...appState,
-        ...getStateForZoom(
-          {
-            viewportX: appState.width / 2 + appState.offsetLeft,
-            viewportY: appState.height / 2 + appState.offsetTop,
-            nextZoom: getNormalizedZoom(appState.zoom.value + ZOOM_STEP),
-          },
-          appState,
-        ),
+        zoom,
      },
      commitToHistory: false,
    };
@@ -112,18 +107,18 @@ export const actionZoomIn = register({

 export const actionZoomOut = register({
  name: "zoomOut",
-  perform: (_elements, appState, _, app) => {
+  perform: (_elements, appState) => {
+    const zoom = getNewZoom(
+      getNormalizedZoom(appState.zoom.value - ZOOM_STEP),
+      appState.zoom,
+      { left: appState.offsetLeft, top: appState.offsetTop },
+      { x: appState.width / 2, y: appState.height / 2 },
+    );
+
    return {
      appState: {
        ...appState,
-        ...getStateForZoom(
-          {
-            viewportX: appState.width / 2 + appState.offsetLeft,
-            viewportY: appState.height / 2 + appState.offsetTop,
-            nextZoom: getNormalizedZoom(appState.zoom.value - ZOOM_STEP),
-          },
-          appState,
-        ),
+        zoom,
      },
      commitToHistory: false,
    };
@@ -147,24 +142,25 @@ export const actionZoomOut = register({

 export const actionResetZoom = register({
  name: "resetZoom",
-  perform: (_elements, appState, _, app) => {
+  perform: (_elements, appState) => {
    return {
      appState: {
        ...appState,
-        ...getStateForZoom(
+        zoom: getNewZoom(
+          1 as NormalizedZoomValue,
+          appState.zoom,
+          { left: appState.offsetLeft, top: appState.offsetTop },
          {
-            viewportX: appState.width / 2 + appState.offsetLeft,
-            viewportY: appState.height / 2 + appState.offsetTop,
-            nextZoom: getNormalizedZoom(1),
+            x: appState.width / 2,
+            y: appState.height / 2,
          },
-          appState,
        ),
      },
      commitToHistory: false,
    };
  },
  PanelComponent: ({ updateData, appState }) => (
-    <Tooltip label={t("buttons.resetZoom")} style={{ height: "100%" }}>
+    <Tooltip label={t("buttons.resetZoom")}>
      <ToolButton
        type="button"
        className="reset-zoom-button"
@@ -216,12 +212,14 @@ const zoomToFitElements = (
      ? getCommonBounds(selectedElements)
      : getCommonBounds(nonDeletedElements);

-  const newZoom = {
-    value: zoomValueToFitBoundsOnViewport(commonBounds, {
-      width: appState.width,
-      height: appState.height,
-    }),
-  };
+  const zoomValue = zoomValueToFitBoundsOnViewport(commonBounds, {
+    width: appState.width,
+    height: appState.height,
+  });
+  const newZoom = getNewZoom(zoomValue, appState.zoom, {
+    left: appState.offsetLeft,
+    top: appState.offsetTop,
+  });

  const [x1, y1, x2, y2] = commonBounds;
  const centerX = (x1 + x2) / 2;
@@ -25,7 +25,7 @@ export const actionCut = register({
  name: "cut",
  perform: (elements, appState, data, app) => {
    actionCopy.perform(elements, appState, data, app);
-    return actionDeleteSelected.perform(elements, appState);
+    return actionDeleteSelected.perform(elements, appState, data, app);
  },
  contextItemLabel: "labels.cut",
  keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.code === CODES.X,
@@ -42,7 +42,6 @@ export const actionCopyAsSvg = register({
    const selectedElements = getSelectedElements(
      getNonDeletedElements(elements),
      appState,
-      true,
    );
    try {
      await exportCanvas(
@@ -82,7 +81,6 @@ export const actionCopyAsPng = register({
    const selectedElements = getSelectedElements(
      getNonDeletedElements(elements),
      appState,
-      true,
    );
    try {
      await exportCanvas(
@@ -11,7 +11,6 @@ import { newElementWith } from "../element/mutateElement";
 import { getElementsInGroup } from "../groups";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import { fixBindingsAfterDeletion } from "../element/binding";
-import { isBoundToContainer } from "../element/typeChecks";

 const deleteSelectedElements = (
  elements: readonly ExcalidrawElement[],
@@ -22,12 +21,6 @@ const deleteSelectedElements = (
      if (appState.selectedElementIds[el.id]) {
        return newElementWith(el, { isDeleted: true });
      }
-      if (
-        isBoundToContainer(el) &&
-        appState.selectedElementIds[el.containerId]
-      ) {
-        return newElementWith(el, { isDeleted: true });
-      }
      return el;
    }),
    appState: {
@@ -62,7 +55,7 @@ export const actionDeleteSelected = register({
    if (appState.editingLinearElement) {
      const {
        elementId,
-        selectedPointsIndices,
+        activePointIndex,
        startBindingElement,
        endBindingElement,
      } = appState.editingLinearElement;
@@ -72,7 +65,8 @@ export const actionDeleteSelected = register({
      }
      if (
        // case: no point selected → delete whole element
-        selectedPointsIndices == null ||
+        activePointIndex == null ||
+        activePointIndex === -1 ||
        // case: deleting last remaining point
        element.points.length < 2
      ) {
@@ -92,17 +86,15 @@ export const actionDeleteSelected = register({
      // We cannot do this inside `movePoint` because it is also called
      // when deleting the uncommitted point (which hasn't caused any binding)
      const binding = {
-        startBindingElement: selectedPointsIndices?.includes(0)
-          ? null
-          : startBindingElement,
-        endBindingElement: selectedPointsIndices?.includes(
-          element.points.length - 1,
-        )
-          ? null
-          : endBindingElement,
+        startBindingElement:
+          activePointIndex === 0 ? null : startBindingElement,
+        endBindingElement:
+          activePointIndex === element.points.length - 1
+            ? null
+            : endBindingElement,
      };

-      LinearElementEditor.deletePoints(element, selectedPointsIndices);
+      LinearElementEditor.movePoint(element, activePointIndex, "delete");

      return {
        elements,
@@ -111,15 +103,13 @@ export const actionDeleteSelected = register({
          editingLinearElement: {
            ...appState.editingLinearElement,
            ...binding,
-            selectedPointsIndices:
-              selectedPointsIndices?.[0] > 0
-                ? [selectedPointsIndices[0] - 1]
-                : [0],
+            activePointIndex: activePointIndex > 0 ? activePointIndex - 1 : 0,
          },
        },
        commitToHistory: true,
      };
    }
+
    let { elements: nextElements, appState: nextAppState } =
      deleteSelectedElements(elements, appState);
    fixBindingsAfterDeletion(
@@ -4,13 +4,13 @@ import {
 } from "../components/icons";
 import { ToolButton } from "../components/ToolButton";
 import { distributeElements, Distribution } from "../disitrubte";
-import { getNonDeletedElements } from "../element";
+import { getElementMap, getNonDeletedElements } from "../element";
 import { ExcalidrawElement } from "../element/types";
 import { t } from "../i18n";
 import { CODES } from "../keys";
 import { getSelectedElements, isSomeElementSelected } from "../scene";
 import { AppState } from "../types";
-import { arrayToMap, getShortcutKey } from "../utils";
+import { getShortcutKey } from "../utils";
 import { register } from "./register";

 const enableActionGroup = (
@@ -30,11 +30,9 @@ const distributeSelectedElements = (

  const updatedElements = distributeElements(selectedElements, distribution);

-  const updatedElementsMap = arrayToMap(updatedElements);
+  const updatedElementsMap = getElementMap(updatedElements);

-  return elements.map(
-    (element) => updatedElementsMap.get(element.id) || element,
-  );
+  return elements.map((element) => updatedElementsMap[element.id] || element);
 };

 export const distributeHorizontally = register({
@@ -2,12 +2,13 @@ import { KEYS } from "../keys";
 import { register } from "./register";
 import { ExcalidrawElement } from "../element/types";
 import { duplicateElement, getNonDeletedElements } from "../element";
-import { getSelectedElements, isSomeElementSelected } from "../scene";
+import { isSomeElementSelected } from "../scene";
 import { ToolButton } from "../components/ToolButton";
 import { clone } from "../components/icons";
 import { t } from "../i18n";
-import { arrayToMap, getShortcutKey } from "../utils";
+import { getShortcutKey } from "../utils";
 import { LinearElementEditor } from "../element/linearElementEditor";
+import { mutateElement } from "../element/mutateElement";
 import {
  selectGroupsForSelectedElements,
  getSelectedGroupForElement,
@@ -17,23 +18,41 @@ import { AppState } from "../types";
 import { fixBindingsAfterDuplication } from "../element/binding";
 import { ActionResult } from "./types";
 import { GRID_SIZE } from "../constants";
-import { bindTextToShapeAfterDuplication } from "../element/textElement";
-import { isBoundToContainer } from "../element/typeChecks";

 export const actionDuplicateSelection = register({
  name: "duplicateSelection",
  perform: (elements, appState) => {
-    // duplicate selected point(s) if editing a line
+    // duplicate point if selected while editing multi-point element
    if (appState.editingLinearElement) {
-      const ret = LinearElementEditor.duplicateSelectedPoints(appState);
-
-      if (!ret) {
+      const { activePointIndex, elementId } = appState.editingLinearElement;
+      const element = LinearElementEditor.getElement(elementId);
+      if (!element || activePointIndex === null) {
        return false;
      }
-
+      const { points } = element;
+      const selectedPoint = points[activePointIndex];
+      const nextPoint = points[activePointIndex + 1];
+      mutateElement(element, {
+        points: [
+          ...points.slice(0, activePointIndex + 1),
+          nextPoint
+            ? [
+                (selectedPoint[0] + nextPoint[0]) / 2,
+                (selectedPoint[1] + nextPoint[1]) / 2,
+              ]
+            : [selectedPoint[0] + 30, selectedPoint[1] + 30],
+          ...points.slice(activePointIndex + 1),
+        ],
+      });
      return {
+        appState: {
+          ...appState,
+          editingLinearElement: {
+            ...appState.editingLinearElement,
+            activePointIndex: activePointIndex + 1,
+          },
+        },
        elements,
-        appState: ret.appState,
        commitToHistory: true,
      };
    }
@@ -87,12 +106,9 @@ const duplicateElements = (
  const finalElements: ExcalidrawElement[] = [];

  let index = 0;
-  const selectedElementIds = arrayToMap(
-    getSelectedElements(elements, appState, true),
-  );
  while (index < elements.length) {
    const element = elements[index];
-    if (selectedElementIds.get(element.id)) {
+    if (appState.selectedElementIds[element.id]) {
      if (element.groupIds.length) {
        const groupId = getSelectedGroupForElement(appState, element);
        // if group selected, duplicate it atomically
@@ -114,11 +130,7 @@ const duplicateElements = (
    }
    index++;
  }
-  bindTextToShapeAfterDuplication(
-    finalElements,
-    oldElements,
-    oldIdToDuplicatedId,
-  );
+
  fixBindingsAfterDuplication(finalElements, oldElements, oldIdToDuplicatedId);

  return {
@@ -128,9 +140,7 @@ const duplicateElements = (
        ...appState,
        selectedGroupIds: {},
        selectedElementIds: newElements.reduce((acc, element) => {
-          if (!isBoundToContainer(element)) {
-            acc[element.id] = true;
-          }
+          acc[element.id] = true;
          return acc;
        }, {} as any),
      },
@@ -1,6 +1,6 @@
 import { register } from "./register";
 import { getSelectedElements } from "../scene";
-import { getNonDeletedElements } from "../element";
+import { getElementMap, getNonDeletedElements } from "../element";
 import { mutateElement } from "../element/mutateElement";
 import { ExcalidrawElement, NonDeleted } from "../element/types";
 import { normalizeAngle, resizeSingleElement } from "../element/resizeElements";
@@ -9,7 +9,6 @@ import { getTransformHandles } from "../element/transformHandles";
 import { isFreeDrawElement, isLinearElement } from "../element/typeChecks";
 import { updateBoundElements } from "../element/binding";
 import { LinearElementEditor } from "../element/linearElementEditor";
-import { arrayToMap } from "../utils";

 const enableActionFlipHorizontal = (
  elements: readonly ExcalidrawElement[],
@@ -84,11 +83,9 @@ const flipSelectedElements = (
    flipDirection,
  );

-  const updatedElementsMap = arrayToMap(updatedElements);
+  const updatedElementsMap = getElementMap(updatedElements);

-  return elements.map(
-    (element) => updatedElementsMap.get(element.id) || element,
-  );
+  return elements.map((element) => updatedElementsMap[element.id] || element);
 };

 const flipElements = (
@@ -145,9 +142,10 @@ const flipElement = (
  }

  if (isLinearElement(element)) {
-    for (let index = 1; index < element.points.length; index++) {
-      LinearElementEditor.movePoints(element, [
-        { index, point: [-element.points[index][0], element.points[index][1]] },
+    for (let i = 1; i < element.points.length; i++) {
+      LinearElementEditor.movePoint(element, i, [
+        -element.points[i][0],
+        element.points[i][1],
      ]);
    }
    LinearElementEditor.normalizePoints(element);
@@ -1,6 +1,6 @@
 import { CODES, KEYS } from "../keys";
 import { t } from "../i18n";
-import { arrayToMap, getShortcutKey } from "../utils";
+import { getShortcutKey } from "../utils";
 import { register } from "./register";
 import { UngroupIcon, GroupIcon } from "../components/icons";
 import { newElementWith } from "../element/mutateElement";
@@ -17,9 +17,8 @@ import {
 import { getNonDeletedElements } from "../element";
 import { randomId } from "../random";
 import { ToolButton } from "../components/ToolButton";
-import { ExcalidrawElement, ExcalidrawTextElement } from "../element/types";
+import { ExcalidrawElement } from "../element/types";
 import { AppState } from "../types";
-import { isBoundToContainer } from "../element/typeChecks";

 const allElementsInSameGroup = (elements: readonly ExcalidrawElement[]) => {
  if (elements.length >= 2) {
@@ -45,7 +44,6 @@ const enableActionGroup = (
  const selectedElements = getSelectedElements(
    getNonDeletedElements(elements),
    appState,
-    true,
  );
  return (
    selectedElements.length >= 2 && !allElementsInSameGroup(selectedElements)
@@ -58,7 +56,6 @@ export const actionGroup = register({
    const selectedElements = getSelectedElements(
      getNonDeletedElements(elements),
      appState,
-      true,
    );
    if (selectedElements.length < 2) {
      // nothing to group
@@ -86,9 +83,8 @@ export const actionGroup = register({
      }
    }
    const newGroupId = randomId();
-    const selectElementIds = arrayToMap(selectedElements);
    const updatedElements = elements.map((element) => {
-      if (!selectElementIds.get(element.id)) {
+      if (!appState.selectedElementIds[element.id]) {
        return element;
      }
      return newElementWith(element, {
@@ -152,12 +148,7 @@ export const actionUngroup = register({
    if (groupIds.length === 0) {
      return { appState, elements, commitToHistory: false };
    }
-
-    const boundTextElementIds: ExcalidrawTextElement["id"][] = [];
    const nextElements = elements.map((element) => {
-      if (isBoundToContainer(element)) {
-        boundTextElementIds.push(element.id);
-      }
      const nextGroupIds = removeFromSelectedGroups(
        element.groupIds,
        appState.selectedGroupIds,
@@ -169,19 +160,11 @@ export const actionUngroup = register({
        groupIds: nextGroupIds,
      });
    });
-
-    const updateAppState = selectGroupsForSelectedElements(
-      { ...appState, selectedGroupIds: {} },
-      getNonDeletedElements(nextElements),
-    );
-
-    // remove binded text elements from selection
-    boundTextElementIds.forEach(
-      (id) => (updateAppState.selectedElementIds[id] = false),
-    );
    return {
-      appState: updateAppState,
-
+      appState: selectGroupsForSelectedElements(
+        { ...appState, selectedGroupIds: {} },
+        getNonDeletedElements(nextElements),
+      ),
      elements: nextElements,
      commitToHistory: true,
    };
@@ -6,9 +6,9 @@ import History, { HistoryEntry } from "../history";
 import { ExcalidrawElement } from "../element/types";
 import { AppState } from "../types";
 import { isWindows, KEYS } from "../keys";
+import { getElementMap } from "../element";
 import { newElementWith } from "../element/mutateElement";
 import { fixBindingsAfterDeletion } from "../element/binding";
-import { arrayToMap } from "../utils";

 const writeData = (
  prevElements: readonly ExcalidrawElement[],
@@ -27,17 +27,17 @@ const writeData = (
      return { commitToHistory };
    }

-    const prevElementMap = arrayToMap(prevElements);
+    const prevElementMap = getElementMap(prevElements);
    const nextElements = data.elements;
-    const nextElementMap = arrayToMap(nextElements);
+    const nextElementMap = getElementMap(nextElements);

    const deletedElements = prevElements.filter(
-      (prevElement) => !nextElementMap.has(prevElement.id),
+      (prevElement) => !nextElementMap.hasOwnProperty(prevElement.id),
    );
    const elements = nextElements
      .map((nextElement) =>
        newElementWith(
-          prevElementMap.get(nextElement.id) || nextElement,
+          prevElementMap[nextElement.id] || nextElement,
          nextElement,
        ),
      )
@@ -41,16 +41,8 @@ import {
  isTextElement,
  redrawTextBoundingBox,
 } from "../element";
-import { mutateElement, newElementWith } from "../element/mutateElement";
-import {
-  getBoundTextElement,
-  getContainerElement,
-} from "../element/textElement";
-import {
-  isBoundToContainer,
-  isLinearElement,
-  isLinearElementType,
-} from "../element/typeChecks";
+import { newElementWith } from "../element/mutateElement";
+import { isLinearElement, isLinearElementType } from "../element/typeChecks";
 import {
  Arrowhead,
  ExcalidrawElement,
@@ -60,34 +52,25 @@ import {
  TextAlign,
 } from "../element/types";
 import { getLanguage, t } from "../i18n";
-import { KEYS } from "../keys";
 import { randomInteger } from "../random";
 import {
  canChangeSharpness,
  canHaveArrowheads,
  getCommonAttributeOfSelectedElements,
-  getSelectedElements,
  getTargetElements,
  isSomeElementSelected,
 } from "../scene";
 import { hasStrokeColor } from "../scene/comparisons";
-import { arrayToMap } from "../utils";
 import { register } from "./register";

-const FONT_SIZE_RELATIVE_INCREASE_STEP = 0.1;
-
 const changeProperty = (
  elements: readonly ExcalidrawElement[],
  appState: AppState,
  callback: (element: ExcalidrawElement) => ExcalidrawElement,
-  includeBoundText = false,
 ) => {
-  const selectedElementIds = arrayToMap(
-    getSelectedElements(elements, appState, includeBoundText),
-  );
  return elements.map((element) => {
    if (
-      selectedElementIds.get(element.id) ||
+      appState.selectedElementIds[element.id] ||
      element.id === appState.editingElement?.id
    ) {
      return callback(element);
@@ -117,97 +100,18 @@ const getFormValue = function <T>(
  );
 };

-const offsetElementAfterFontResize = (
-  prevElement: ExcalidrawTextElement,
-  nextElement: ExcalidrawTextElement,
-) => {
-  if (isBoundToContainer(nextElement)) {
-    return nextElement;
-  }
-  return mutateElement(
-    nextElement,
-    {
-      x:
-        prevElement.textAlign === "left"
-          ? prevElement.x
-          : prevElement.x +
-            (prevElement.width - nextElement.width) /
-              (prevElement.textAlign === "center" ? 2 : 1),
-      // centering vertically is non-standard, but for Excalidraw I think
-      // it makes sense
-      y: prevElement.y + (prevElement.height - nextElement.height) / 2,
-    },
-    false,
-  );
-};
-
-const changeFontSize = (
-  elements: readonly ExcalidrawElement[],
-  appState: AppState,
-  getNewFontSize: (element: ExcalidrawTextElement) => number,
-  fallbackValue?: ExcalidrawTextElement["fontSize"],
-) => {
-  const newFontSizes = new Set<number>();
-
-  return {
-    elements: changeProperty(
-      elements,
-      appState,
-      (oldElement) => {
-        if (isTextElement(oldElement)) {
-          const newFontSize = getNewFontSize(oldElement);
-          newFontSizes.add(newFontSize);
-
-          let newElement: ExcalidrawTextElement = newElementWith(oldElement, {
-            fontSize: newFontSize,
-          });
-          redrawTextBoundingBox(
-            newElement,
-            getContainerElement(oldElement),
-            appState,
-          );
-
-          newElement = offsetElementAfterFontResize(oldElement, newElement);
-
-          return newElement;
-        }
-
-        return oldElement;
-      },
-      true,
-    ),
-    appState: {
-      ...appState,
-      // update state only if we've set all select text elements to
-      // the same font size
-      currentItemFontSize:
-        newFontSizes.size === 1
-          ? [...newFontSizes][0]
-          : fallbackValue ?? appState.currentItemFontSize,
-    },
-    commitToHistory: true,
-  };
-};
-
-// -----------------------------------------------------------------------------
-
 export const actionChangeStrokeColor = register({
  name: "changeStrokeColor",
  perform: (elements, appState, value) => {
    return {
      ...(value.currentItemStrokeColor && {
-        elements: changeProperty(
-          elements,
-          appState,
-          (el) => {
-            return hasStrokeColor(el.type)
-              ? newElementWith(el, {
-                  strokeColor: value.currentItemStrokeColor,
-                })
-              : el;
-          },
-          true,
-        ),
+        elements: changeProperty(elements, appState, (el) => {
+          return hasStrokeColor(el.type)
+            ? newElementWith(el, {
+                strokeColor: value.currentItemStrokeColor,
+              })
+            : el;
+        }),
      }),
      appState: {
        ...appState,
@@ -521,7 +425,24 @@ export const actionChangeOpacity = register({
 export const actionChangeFontSize = register({
  name: "changeFontSize",
  perform: (elements, appState, value) => {
-    return changeFontSize(elements, appState, () => value, value);
+    return {
+      elements: changeProperty(elements, appState, (el) => {
+        if (isTextElement(el)) {
+          const element: ExcalidrawTextElement = newElementWith(el, {
+            fontSize: value,
+          });
+          redrawTextBoundingBox(element);
+          return element;
+        }
+
+        return el;
+      }),
+      appState: {
+        ...appState,
+        currentItemFontSize: value,
+      },
+      commitToHistory: true,
+    };
  },
  PanelComponent: ({ elements, appState, updateData }) => (
    <fieldset>
@@ -533,40 +454,27 @@ export const actionChangeFontSize = register({
            value: 16,
            text: t("labels.small"),
            icon: <FontSizeSmallIcon theme={appState.theme} />,
-            testId: "fontSize-small",
          },
          {
            value: 20,
            text: t("labels.medium"),
            icon: <FontSizeMediumIcon theme={appState.theme} />,
-            testId: "fontSize-medium",
          },
          {
            value: 28,
            text: t("labels.large"),
            icon: <FontSizeLargeIcon theme={appState.theme} />,
-            testId: "fontSize-large",
          },
          {
            value: 36,
            text: t("labels.veryLarge"),
            icon: <FontSizeExtraLargeIcon theme={appState.theme} />,
-            testId: "fontSize-veryLarge",
          },
        ]}
        value={getFormValue(
          elements,
          appState,
-          (element) => {
-            if (isTextElement(element)) {
-              return element.fontSize;
-            }
-            const boundTextElement = getBoundTextElement(element);
-            if (boundTextElement) {
-              return boundTextElement.fontSize;
-            }
-            return null;
-          },
+          (element) => isTextElement(element) && element.fontSize,
          appState.currentItemFontSize || DEFAULT_FONT_SIZE,
        )}
        onChange={(value) => updateData(value)}
@@ -575,71 +483,21 @@ export const actionChangeFontSize = register({
  ),
 });

-export const actionDecreaseFontSize = register({
-  name: "decreaseFontSize",
-  perform: (elements, appState, value) => {
-    return changeFontSize(elements, appState, (element) =>
-      Math.round(
-        // get previous value before relative increase (doesn't work fully
-        // due to rounding and float precision issues)
-        (1 / (1 + FONT_SIZE_RELATIVE_INCREASE_STEP)) * element.fontSize,
-      ),
-    );
-  },
-  keyTest: (event) => {
-    return (
-      event[KEYS.CTRL_OR_CMD] &&
-      event.shiftKey &&
-      // KEYS.COMMA needed for MacOS
-      (event.key === KEYS.CHEVRON_LEFT || event.key === KEYS.COMMA)
-    );
-  },
-});
-
-export const actionIncreaseFontSize = register({
-  name: "increaseFontSize",
-  perform: (elements, appState, value) => {
-    return changeFontSize(elements, appState, (element) =>
-      Math.round(element.fontSize * (1 + FONT_SIZE_RELATIVE_INCREASE_STEP)),
-    );
-  },
-  keyTest: (event) => {
-    return (
-      event[KEYS.CTRL_OR_CMD] &&
-      event.shiftKey &&
-      // KEYS.PERIOD needed for MacOS
-      (event.key === KEYS.CHEVRON_RIGHT || event.key === KEYS.PERIOD)
-    );
-  },
-});
-
 export const actionChangeFontFamily = register({
  name: "changeFontFamily",
  perform: (elements, appState, value) => {
    return {
-      elements: changeProperty(
-        elements,
-        appState,
-        (oldElement) => {
-          if (isTextElement(oldElement)) {
-            const newElement: ExcalidrawTextElement = newElementWith(
-              oldElement,
-              {
-                fontFamily: value,
-              },
-            );
-            redrawTextBoundingBox(
-              newElement,
-              getContainerElement(oldElement),
-              appState,
-            );
-            return newElement;
-          }
+      elements: changeProperty(elements, appState, (el) => {
+        if (isTextElement(el)) {
+          const element: ExcalidrawTextElement = newElementWith(el, {
+            fontFamily: value,
+          });
+          redrawTextBoundingBox(element);
+          return element;
+        }

-          return oldElement;
-        },
-        true,
-      ),
+        return el;
+      }),
      appState: {
        ...appState,
        currentItemFontFamily: value,
@@ -679,16 +537,7 @@ export const actionChangeFontFamily = register({
          value={getFormValue(
            elements,
            appState,
-            (element) => {
-              if (isTextElement(element)) {
-                return element.fontFamily;
-              }
-              const boundTextElement = getBoundTextElement(element);
-              if (boundTextElement) {
-                return boundTextElement.fontFamily;
-              }
-              return null;
-            },
+            (element) => isTextElement(element) && element.fontFamily,
            appState.currentItemFontFamily || DEFAULT_FONT_FAMILY,
          )}
          onChange={(value) => updateData(value)}
@@ -702,29 +551,17 @@ export const actionChangeTextAlign = register({
  name: "changeTextAlign",
  perform: (elements, appState, value) => {
    return {
-      elements: changeProperty(
-        elements,
-        appState,
-        (oldElement) => {
-          if (isTextElement(oldElement)) {
-            const newElement: ExcalidrawTextElement = newElementWith(
-              oldElement,
-              {
-                textAlign: value,
-              },
-            );
-            redrawTextBoundingBox(
-              newElement,
-              getContainerElement(oldElement),
-              appState,
-            );
-            return newElement;
-          }
+      elements: changeProperty(elements, appState, (el) => {
+        if (isTextElement(el)) {
+          const element: ExcalidrawTextElement = newElementWith(el, {
+            textAlign: value,
+          });
+          redrawTextBoundingBox(element);
+          return element;
+        }

-          return oldElement;
-        },
-        true,
-      ),
+        return el;
+      }),
      appState: {
        ...appState,
        currentItemTextAlign: value,
@@ -757,16 +594,7 @@ export const actionChangeTextAlign = register({
        value={getFormValue(
          elements,
          appState,
-          (element) => {
-            if (isTextElement(element)) {
-              return element.textAlign;
-            }
-            const boundTextElement = getBoundTextElement(element);
-            if (boundTextElement) {
-              return boundTextElement.textAlign;
-            }
-            return null;
-          },
+          (element) => isTextElement(element) && element.textAlign,
          appState.currentItemTextAlign,
        )}
        onChange={(value) => updateData(value)}
@@ -1,7 +1,7 @@
 import { KEYS } from "../keys";
 import { register } from "./register";
 import { selectGroupsForSelectedElements } from "../groups";
-import { getNonDeletedElements, isTextElement } from "../element";
+import { getNonDeletedElements } from "../element";

 export const actionSelectAll = register({
  name: "selectAll",
@@ -15,10 +15,7 @@ export const actionSelectAll = register({
          ...appState,
          editingGroupId: null,
          selectedElementIds: elements.reduce((map, element) => {
-            if (
-              !element.isDeleted &&
-              !(isTextElement(element) && element.containerId)
-            ) {
+            if (!element.isDeleted) {
              map[element.id] = true;
            }
            return map;
@@ -12,7 +12,6 @@ import {
  DEFAULT_FONT_FAMILY,
  DEFAULT_TEXT_ALIGN,
 } from "../constants";
-import { getContainerElement } from "../element/textElement";

 // `copiedStyles` is exported only for tests.
 export let copiedStyles: string = "{}";
@@ -56,18 +55,13 @@ export const actionPasteStyles = register({
            opacity: pastedElement?.opacity,
            roughness: pastedElement?.roughness,
          });
-          if (isTextElement(newElement) && isTextElement(element)) {
+          if (isTextElement(newElement)) {
            mutateElement(newElement, {
              fontSize: pastedElement?.fontSize || DEFAULT_FONT_SIZE,
              fontFamily: pastedElement?.fontFamily || DEFAULT_FONT_FAMILY,
              textAlign: pastedElement?.textAlign || DEFAULT_TEXT_ALIGN,
            });
-
-            redrawTextBoundingBox(
-              element,
-              getContainerElement(element),
-              appState,
-            );
+            redrawTextBoundingBox(newElement);
          }
          return newElement;
        }
@@ -1,44 +0,0 @@
-import { getNonDeletedElements } from "../element";
-import { mutateElement } from "../element/mutateElement";
-import { getBoundTextElement, measureText } from "../element/textElement";
-import { ExcalidrawTextElement } from "../element/types";
-import { getSelectedElements } from "../scene";
-import { getFontString } from "../utils";
-import { register } from "./register";
-
-export const actionUnbindText = register({
-  name: "unbindText",
-  contextItemLabel: "labels.unbindText",
-  perform: (elements, appState) => {
-    const selectedElements = getSelectedElements(
-      getNonDeletedElements(elements),
-      appState,
-    );
-    selectedElements.forEach((element) => {
-      const boundTextElement = getBoundTextElement(element);
-      if (boundTextElement) {
-        const { width, height, baseline } = measureText(
-          boundTextElement.originalText,
-          getFontString(boundTextElement),
-        );
-        mutateElement(boundTextElement as ExcalidrawTextElement, {
-          containerId: null,
-          width,
-          height,
-          baseline,
-          text: boundTextElement.originalText,
-        });
-        mutateElement(element, {
-          boundElements: element.boundElements?.filter(
-            (ele) => ele.id !== boundTextElement.id,
-          ),
-        });
-      }
-    });
-    return {
-      elements,
-      appState,
-      commitToHistory: true,
-    };
-  },
-});
@@ -80,5 +80,3 @@ export { actionToggleGridMode } from "./actionToggleGridMode";
 export { actionToggleZenMode } from "./actionToggleZenMode";

 export { actionToggleStats } from "./actionToggleStats";
-export { actionUnbindText } from "./actionUnbindText";
-export { actionLink } from "../element/Hyperlink";
@@ -2,9 +2,7 @@ import { Action } from "./types";

 export let actions: readonly Action[] = [];

-export const register = <T extends Action>(action: T) => {
+export const register = (action: Action): Action => {
  actions = actions.concat(action);
-  return action as T & {
-    keyTest?: unknown extends T["keyTest"] ? never : T["keyTest"];
-  };
+  return action;
 };
@@ -25,8 +25,7 @@ export type ShortcutName =
  | "addToLibrary"
  | "viewMode"
  | "flipHorizontal"
-  | "flipVertical"
-  | "link";
+  | "flipVertical";

 const shortcutMap: Record<ShortcutName, string[]> = {
  cut: [getShortcutKey("CtrlOrCmd+X")],
@@ -63,7 +62,6 @@ const shortcutMap: Record<ShortcutName, string[]> = {
  flipHorizontal: [getShortcutKey("Shift+H")],
  flipVertical: [getShortcutKey("Shift+V")],
  viewMode: [getShortcutKey("Alt+R")],
-  link: [getShortcutKey("CtrlOrCmd+K")],
 };

 export const getShortcutFromShortcutName = (name: ShortcutName) => {
@@ -101,11 +101,7 @@ export type ActionName =
  | "flipVertical"
  | "viewMode"
  | "exportWithDarkMode"
-  | "toggleTheme"
-  | "increaseFontSize"
-  | "decreaseFontSize"
-  | "unbindText"
-  | "link";
+  | "toggleTheme";

 export type PanelComponentProps = {
  elements: readonly ExcalidrawElement[];
@@ -125,12 +121,7 @@ export interface Action {
    appState: AppState,
    elements: readonly ExcalidrawElement[],
  ) => boolean;
-  contextItemLabel?:
-    | string
-    | ((
-        elements: readonly ExcalidrawElement[],
-        appState: Readonly<AppState>,
-      ) => string);
+  contextItemLabel?: string;
  contextItemPredicate?: (
    elements: readonly ExcalidrawElement[],
    appState: AppState,
@@ -1,7 +1,6 @@
 import { ExcalidrawElement } from "./element/types";
 import { newElementWith } from "./element/mutateElement";
 import { Box, getCommonBoundingBox } from "./element/bounds";
-import { getMaximumGroups } from "./groups";

 export interface Alignment {
  position: "start" | "center" | "end";
@@ -31,6 +30,28 @@ export const alignElements = (
  });
 };

+export const getMaximumGroups = (
+  elements: ExcalidrawElement[],
+): ExcalidrawElement[][] => {
+  const groups: Map<String, ExcalidrawElement[]> = new Map<
+    String,
+    ExcalidrawElement[]
+  >();
+
+  elements.forEach((element: ExcalidrawElement) => {
+    const groupId =
+      element.groupIds.length === 0
+        ? element.id
+        : element.groupIds[element.groupIds.length - 1];
+
+    const currentGroupMembers = groups.get(groupId) || [];
+
+    groups.set(groupId, [...currentGroupMembers, element]);
+  });
+
+  return Array.from(groups.values());
+};
+
 const calculateTranslation = (
  group: ExcalidrawElement[],
  selectionBoundingBox: Box,
@@ -43,8 +43,6 @@ export const getDefaultAppState = (): Omit<
    editingLinearElement: null,
    elementLocked: false,
    elementType: "selection",
-    penMode: false,
-    penDetected: false,
    errorMessage: null,
    exportBackground: true,
    exportScale: defaultExportScale,
@@ -79,12 +77,9 @@ export const getDefaultAppState = (): Omit<
    toastMessage: null,
    viewBackgroundColor: oc.white,
    zenModeEnabled: false,
-    zoom: {
-      value: 1 as NormalizedZoomValue,
-    },
+    zoom: { value: 1 as NormalizedZoomValue, translation: { x: 0, y: 0 } },
    viewModeEnabled: false,
    pendingImageElement: null,
-    showHyperlinkPopup: false,
  };
 };

@@ -132,8 +127,6 @@ const APP_STATE_STORAGE_CONF = (<
  editingLinearElement: { browser: false, export: false, server: false },
  elementLocked: { browser: true, export: false, server: false },
  elementType: { browser: true, export: false, server: false },
-  penMode: { browser: false, export: false, server: false },
-  penDetected: { browser: false, export: false, server: false },
  errorMessage: { browser: false, export: false, server: false },
  exportBackground: { browser: true, export: false, server: false },
  exportEmbedScene: { browser: true, export: false, server: false },
@@ -175,7 +168,6 @@ const APP_STATE_STORAGE_CONF = (<
  zoom: { browser: true, export: false, server: false },
  viewModeEnabled: { browser: false, export: false, server: false },
  pendingImageElement: { browser: false, export: false, server: false },
-  showHyperlinkPopup: { browser: false, export: false, server: false },
 });

 const _clearAppStateForStorage = <
@@ -58,8 +58,7 @@ export const copyToClipboard = async (
  appState: AppState,
  files: BinaryFiles,
 ) => {
-  // select binded text elements when copying
-  const selectedElements = getSelectedElements(elements, appState, true);
+  const selectedElements = getSelectedElements(elements, appState);
  const contents: ElementsClipboard = {
    type: EXPORT_DATA_TYPES.excalidrawClipboard,
    elements: selectedElements,
@@ -150,15 +150,14 @@ export const SelectedShapeActions = ({
          </div>
        </fieldset>
      )}
-      {!isEditing && targetElements.length > 0 && (
+      {!isMobile && !isEditing && targetElements.length > 0 && (
        <fieldset>
          <legend>{t("labels.actions")}</legend>
          <div className="buttonList">
-            {!isMobile && renderAction("duplicateSelection")}
-            {!isMobile && renderAction("deleteSelectedElements")}
+            {renderAction("duplicateSelection")}
+            {renderAction("deleteSelectedElements")}
            {renderAction("group")}
            {renderAction("ungroup")}
-            {targetElements.length === 1 && renderAction("link")}
          </div>
        </fieldset>
      )}
@@ -7,7 +7,7 @@ export const ButtonIconSelect = <T extends Object>({
  onChange,
  group,
 }: {
-  options: { value: T; text: string; icon: JSX.Element; testId?: string }[];
+  options: { value: T; text: string; icon: JSX.Element }[];
  value: T | null;
  onChange: (value: T) => void;
  group: string;
@@ -24,7 +24,6 @@ export const ButtonIconSelect = <T extends Object>({
          name={group}
          onChange={() => onChange(option.value)}
          checked={value === option.value}
-          data-testid={option.testId}
        />
        {option.icon}
      </label>
@@ -3,22 +3,15 @@ import OpenColor from "open-color";
 import "./Card.scss";

 export const Card: React.FC<{
-  color: keyof OpenColor | "primary";
+  color: keyof OpenColor;
 }> = ({ children, color }) => {
  return (
    <div
      className="Card"
      style={{
-        ["--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],
+        ["--card-color" as any]: OpenColor[color][7],
+        ["--card-color-darker" as any]: OpenColor[color][8],
+        ["--card-color-darkest" as any]: OpenColor[color][9],
      }}
    >
      {children}
@@ -6,14 +6,14 @@ import "./CheckboxItem.scss";

 export const CheckboxItem: React.FC<{
  checked: boolean;
-  onChange: (checked: boolean, event: React.MouseEvent) => void;
+  onChange: (checked: boolean) => void;
  className?: string;
 }> = ({ children, checked, onChange, className }) => {
  return (
    <div
      className={clsx("Checkbox", className, { "is-checked": checked })}
      onClick={(event) => {
-        onChange(!checked, event);
+        onChange(!checked);
        (
          (event.currentTarget as HTMLDivElement).querySelector(
            ".Checkbox-box",
@@ -11,7 +11,6 @@ import {
 import { Action } from "../actions/types";
 import { ActionManager } from "../actions/manager";
 import { AppState } from "../types";
-import { NonDeletedExcalidrawElement } from "../element/types";

 export type ContextMenuOption = "separator" | Action;

@@ -22,7 +21,6 @@ type ContextMenuProps = {
  left: number;
  actionManager: ActionManager;
  appState: Readonly<AppState>;
-  elements: readonly NonDeletedExcalidrawElement[];
 };

 const ContextMenu = ({
@@ -32,7 +30,6 @@ const ContextMenu = ({
  left,
  actionManager,
  appState,
-  elements,
 }: ContextMenuProps) => {
  return (
    <Popover
@@ -40,10 +37,6 @@ const ContextMenu = ({
      top={top}
      left={left}
      fitInViewport={true}
-      offsetLeft={appState.offsetLeft}
-      offsetTop={appState.offsetTop}
-      viewportWidth={appState.width}
-      viewportHeight={appState.height}
    >
      <ul
        className="context-menu"
@@ -55,14 +48,9 @@ const ContextMenu = ({
          }

          const actionName = option.name;
-          let label = "";
-          if (option.contextItemLabel) {
-            if (typeof option.contextItemLabel === "function") {
-              label = t(option.contextItemLabel(elements, appState));
-            } else {
-              label = t(option.contextItemLabel);
-            }
-          }
+          const label = option.contextItemLabel
+            ? t(option.contextItemLabel)
+            : "";
          return (
            <li key={idx} data-testid={actionName} onClick={onCloseRequest}>
              <button
@@ -109,7 +97,6 @@ type ContextMenuParams = {
  actionManager: ContextMenuProps["actionManager"];
  appState: Readonly<AppState>;
  container: HTMLElement;
-  elements: readonly NonDeletedExcalidrawElement[];
 };

 const handleClose = (container: HTMLElement) => {
@@ -138,7 +125,6 @@ export default {
          onCloseRequest={() => handleClose(params.container)}
          actionManager={params.actionManager}
          appState={params.appState}
-          elements={params.elements}
        />,
        getContextMenuNode(params.container),
      );
@@ -154,7 +154,7 @@ export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
                <Shortcut label={t("toolBar.line")} shortcuts={["P", "6"]} />
                <Shortcut
                  label={t("toolBar.freedraw")}
-                  shortcuts={["Shift + P", "X", "7"]}
+                  shortcuts={["Shift+P", "7"]}
                />
                <Shortcut label={t("toolBar.text")} shortcuts={["T", "8"]} />
                <Shortcut label={t("toolBar.image")} shortcuts={["9"]} />
@@ -205,10 +205,6 @@ export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
                  label={t("helpDialog.preventBinding")}
                  shortcuts={[getShortcutKey("CtrlOrCmd")]}
                />
-                <Shortcut
-                  label={t("toolBar.link")}
-                  shortcuts={[getShortcutKey("CtrlOrCmd+K")]}
-                />
              </ShortcutIsland>
              <ShortcutIsland caption={t("helpDialog.view")}>
                <Shortcut
@@ -264,18 +260,6 @@ export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
                  label={t("labels.multiSelect")}
                  shortcuts={[getShortcutKey(`Shift+${t("helpDialog.click")}`)]}
                />
-                <Shortcut
-                  label={t("helpDialog.deepSelect")}
-                  shortcuts={[
-                    getShortcutKey(`CtrlOrCmd+${t("helpDialog.click")}`),
-                  ]}
-                />
-                <Shortcut
-                  label={t("helpDialog.deepBoxSelect")}
-                  shortcuts={[
-                    getShortcutKey(`CtrlOrCmd+${t("helpDialog.drag")}`),
-                  ]}
-                />
                <Shortcut
                  label={t("labels.moveCanvas")}
                  shortcuts={[
@@ -398,14 +382,6 @@ export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
                  label={t("labels.showBackground")}
                  shortcuts={[getShortcutKey("G")]}
                />
-                <Shortcut
-                  label={t("labels.decreaseFontSize")}
-                  shortcuts={[getShortcutKey("CtrlOrCmd+Shift+<")]}
-                />
-                <Shortcut
-                  label={t("labels.increaseFontSize")}
-                  shortcuts={[getShortcutKey("CtrlOrCmd+Shift+>")]}
-                />
              </ShortcutIsland>
            </Column>
          </Columns>
@@ -7,7 +7,6 @@ import { AppState } from "../types";
 import {
  isImageElement,
  isLinearElement,
-  isTextBindableContainer,
  isTextElement,
 } from "../element/typeChecks";
 import { getShortcutKey } from "../utils";
@@ -61,6 +60,15 @@ const getHints = ({ appState, elements, isMobile }: HintViewerProps) => {
    return t("hints.rotate");
  }

+  if (selectedElements.length === 1 && isLinearElement(selectedElements[0])) {
+    if (appState.editingLinearElement) {
+      return appState.editingLinearElement.activePointIndex
+        ? t("hints.lineEditor_pointSelected")
+        : t("hints.lineEditor_nothingSelected");
+    }
+    return t("hints.lineEditor_info");
+  }
+
  if (selectedElements.length === 1 && isTextElement(selectedElements[0])) {
    return t("hints.text_selected");
  }
@@ -69,31 +77,8 @@ const getHints = ({ appState, elements, isMobile }: HintViewerProps) => {
    return t("hints.text_editing");
  }

-  if (elementType === "selection") {
-    if (
-      appState.draggingElement?.type === "selection" &&
-      !appState.editingElement &&
-      !appState.editingLinearElement
-    ) {
-      return t("hints.deepBoxSelect");
-    }
-    if (!selectedElements.length && !isMobile) {
-      return t("hints.canvasPanning");
-    }
-  }
-
-  if (selectedElements.length === 1) {
-    if (isLinearElement(selectedElements[0])) {
-      if (appState.editingLinearElement) {
-        return appState.editingLinearElement.selectedPointsIndices
-          ? t("hints.lineEditor_pointSelected")
-          : t("hints.lineEditor_nothingSelected");
-      }
-      return t("hints.lineEditor_info");
-    }
-    if (isTextBindableContainer(selectedElements[0])) {
-      return t("hints.bindTextToElement");
-    }
+  if (elementType === "selection" && !selectedElements.length && !isMobile) {
+    return t("hints.canvasPanning");
  }

  return null;
@@ -22,7 +22,7 @@
    align-items: center;
    justify-content: center;

-    &:focus-visible {
+    &:focus {
      outline: transparent;
      background-color: var(--button-gray-2);
      & svg {
@@ -102,7 +102,7 @@ const ImageExportModal = ({
  const { exportBackground, viewBackgroundColor } = appState;

  const exportedElements = exportSelected
-    ? getSelectedElements(elements, appState, true)
+    ? getSelectedElements(elements, appState)
    : elements;

  useEffect(() => {
@@ -3,7 +3,7 @@
    --padding: 0;
    background-color: var(--island-bg-color);
    box-shadow: var(--shadow-island);
-    border-radius: var(--border-radius-lg);
+    border-radius: 4px;
    padding: calc(var(--padding) * var(--space-factor));
    position: relative;
    transition: box-shadow 0.5s ease-in-out;
@@ -19,6 +19,7 @@ import { ExportCB, ImageExportDialog } from "./ImageExportDialog";
 import { FixedSideContainer } from "./FixedSideContainer";
 import { HintViewer } from "./HintViewer";
 import { Island } from "./Island";
+import "./LayerUI.scss";
 import { LoadingMessage } from "./LoadingMessage";
 import { LockButton } from "./LockButton";
 import { MobileMenu } from "./MobileMenu";
@@ -34,10 +35,6 @@ import { LibraryButton } from "./LibraryButton";
 import { isImageFileHandle } from "../data/blob";
 import { LibraryMenu } from "./LibraryMenu";

-import "./LayerUI.scss";
-import "./Toolbar.scss";
-import { PenModeButton } from "./PenModeButton";
-
 interface LayerUIProps {
  actionManager: ActionManager;
  appState: AppState;
@@ -47,7 +44,6 @@ interface LayerUIProps {
  elements: readonly NonDeletedExcalidrawElement[];
  onCollabButtonClick?: () => void;
  onLockToggle: () => void;
-  onPenModeToggle: () => void;
  onInsertElements: (elements: readonly NonDeletedExcalidrawElement[]) => void;
  zenModeEnabled: boolean;
  showExitZenModeBtn: boolean;
@@ -78,7 +74,6 @@ const LayerUI = ({
  elements,
  onCollabButtonClick,
  onLockToggle,
-  onPenModeToggle,
  onInsertElements,
  zenModeEnabled,
  showExitZenModeBtn,
@@ -273,7 +268,7 @@ const LayerUI = ({

  const libraryMenu = appState.isLibraryOpen ? (
    <LibraryMenu
-      pendingElements={getSelectedElements(elements, appState, true)}
+      pendingElements={getSelectedElements(elements, appState)}
      onClose={closeLibrary}
      onInsertShape={onInsertElements}
      onAddToLibrary={deselectItems}
@@ -310,19 +305,7 @@ const LayerUI = ({
            <Section heading="shapes">
              {(heading) => (
                <Stack.Col gap={4} align="start">
-                  <Stack.Row
-                    gap={1}
-                    className={clsx("App-toolbar-container", {
-                      "zen-mode": zenModeEnabled,
-                    })}
-                  >
-                    <PenModeButton
-                      zenModeEnabled={zenModeEnabled}
-                      checked={appState.penMode}
-                      onChange={onPenModeToggle}
-                      title={t("toolBar.penMode")}
-                      penDetected={appState.penDetected}
-                    />
+                  <Stack.Row gap={1}>
                    <LockButton
                      zenModeEnabled={zenModeEnabled}
                      checked={appState.elementLocked}
@@ -331,9 +314,7 @@ const LayerUI = ({
                    />
                    <Island
                      padding={1}
-                      className={clsx("App-toolbar", {
-                        "zen-mode": zenModeEnabled,
-                      })}
+                      className={clsx({ "zen-mode": zenModeEnabled })}
                    >
                      <HintViewer
                        appState={appState}
@@ -508,7 +489,6 @@ const LayerUI = ({
        setAppState={setAppState}
        onCollabButtonClick={onCollabButtonClick}
        onLockToggle={onLockToggle}
-        onPenModeToggle={onPenModeToggle}
        canvas={canvas}
        isCollaborating={isCollaborating}
        renderCustomFooter={renderCustomFooter}
@@ -16,18 +16,18 @@ const LIBRARY_ICON = (
 export const LibraryButton: React.FC<{
  appState: AppState;
  setAppState: React.Component<any, AppState>["setState"];
-  isMobile?: boolean;
-}> = ({ appState, setAppState, isMobile }) => {
+}> = ({ appState, setAppState }) => {
  return (
    <label
      className={clsx(
-        "ToolIcon ToolIcon_type_floating ToolIcon__library",
+        "ToolIcon ToolIcon_type_floating ToolIcon__library zen-mode-visibility",
        `ToolIcon_size_medium`,
        {
-          "is-mobile": isMobile,
+          "zen-mode-visibility--hidden": appState.zenModeEnabled,
        },
      )}
      title={`${capitalizeString(t("toolBar.library"))} — 0`}
+      style={{ marginInlineStart: "var(--space-factor)" }}
    >
      <input
        className="ToolIcon_type_checkbox"
@@ -18,7 +18,6 @@ import "./LibraryMenu.scss";
 import LibraryMenuItems from "./LibraryMenuItems";
 import { EVENT } from "../constants";
 import { KEYS } from "../keys";
-import { arrayToMap } from "../utils";

 const useOnClickOutside = (
  ref: RefObject<HTMLElement>,
@@ -237,10 +236,6 @@ export const LibraryMenu = ({
    ],
  );

-  const [lastSelectedItem, setLastSelectedItem] = useState<
-    LibraryItem["id"] | null
-  >(null);
-
  return loadingState === "preloading" ? null : (
    <Island padding={1} ref={ref} className="layer-ui__library">
      {showPublishLibraryDialog && (
@@ -276,44 +271,10 @@ export const LibraryMenu = ({
          files={files}
          id={id}
          selectedItems={selectedItems}
-          onToggle={(id, event) => {
-            const shouldSelect = !selectedItems.includes(id);
-
-            if (shouldSelect) {
-              if (event.shiftKey && lastSelectedItem) {
-                const rangeStart = libraryItems.findIndex(
-                  (item) => item.id === lastSelectedItem,
-                );
-                const rangeEnd = libraryItems.findIndex(
-                  (item) => item.id === id,
-                );
-
-                if (rangeStart === -1 || rangeEnd === -1) {
-                  setSelectedItems([...selectedItems, id]);
-                  return;
-                }
-
-                const selectedItemsMap = arrayToMap(selectedItems);
-                const nextSelectedIds = libraryItems.reduce(
-                  (acc: LibraryItem["id"][], item, idx) => {
-                    if (
-                      (idx >= rangeStart && idx <= rangeEnd) ||
-                      selectedItemsMap.has(item.id)
-                    ) {
-                      acc.push(item.id);
-                    }
-                    return acc;
-                  },
-                  [],
-                );
-
-                setSelectedItems(nextSelectedIds);
-              } else {
-                setSelectedItems([...selectedItems, id]);
-              }
-              setLastSelectedItem(id);
+          onToggle={(id) => {
+            if (!selectedItems.includes(id)) {
+              setSelectedItems([...selectedItems, id]);
            } else {
-              setLastSelectedItem(null);
              setSelectedItems(selectedItems.filter((_id) => _id !== id));
            }
          }}
@@ -21,7 +21,6 @@ import { ToolButton } from "./ToolButton";
 import { Tooltip } from "./Tooltip";

 import "./LibraryMenuItems.scss";
-import { VERSIONS } from "../constants";

 const LibraryMenuItems = ({
  libraryItems,
@@ -52,7 +51,7 @@ const LibraryMenuItems = ({
  library: Library;
  id: string;
  selectedItems: LibraryItem["id"][];
-  onToggle: (id: LibraryItem["id"], event: React.MouseEvent) => void;
+  onToggle: (id: LibraryItem["id"]) => void;
  onPublish: () => void;
  resetLibrary: () => void;
 }) => {
@@ -213,8 +212,10 @@ const LibraryMenuItems = ({
          onClick={params.onClick || (() => {})}
          id={params.item?.id || null}
          selected={!!params.item?.id && selectedItems.includes(params.item.id)}
-          onToggle={(id, event) => {
-            onToggle(id, event);
+          onToggle={() => {
+            if (params.item?.id) {
+              onToggle(params.item.id);
+            }
          }}
        />
      </Stack.Col>
@@ -292,9 +293,7 @@ const LibraryMenuItems = ({
        <a
          href={`${process.env.REACT_APP_LIBRARY_URL}?target=${
            window.name || "_blank"
-          }&referrer=${referrer}&useHash=true&token=${id}&theme=${theme}&version=${
-            VERSIONS.excalidrawLibrary
-          }`}
+          }&referrer=${referrer}&useHash=true&token=${id}&theme=${theme}`}
          target="_excalidraw_libraries"
        >
          {t("labels.libraries")}
@@ -27,8 +27,6 @@

  .library-unit__dragger {
    display: flex;
-    align-items: center;
-    justify-content: center;
    height: 100%;
    width: 100%;
  }
@@ -101,13 +99,8 @@
    margin-top: -10px;
    pointer-events: none;
  }
-  .library-unit:hover .library-unit__adder {
-    fill: $oc-blue-7;
-  }
-  .library-unit:active .library-unit__adder {
-    animation: none;
-    transform: scale(0.8);
-    fill: $oc-black;
+  .library-unit--hover .library-unit__adder {
+    color: $oc-blue-7;
  }

  .library-unit__active {
@@ -8,15 +8,12 @@ import { BinaryFiles, LibraryItem } from "../types";
 import "./LibraryUnit.scss";
 import { CheckboxItem } from "./CheckboxItem";

+// fa-plus
 const PLUS_ICON = (
  <svg viewBox="0 0 1792 1792">
    <path
-      d="M1600 736v192c0 26.667-9.33 49.333-28 68-18.67 18.67-41.33 28-68 28h-416v416c0 26.67-9.33 49.33-28 68s-41.33 28-68 28H800c-26.667 0-49.333-9.33-68-28s-28-41.33-28-68v-416H288c-26.667 0-49.333-9.33-68-28-18.667-18.667-28-41.333-28-68V736c0-26.667 9.333-49.333 28-68s41.333-28 68-28h416V224c0-26.667 9.333-49.333 28-68s41.333-28 68-28h192c26.67 0 49.33 9.333 68 28s28 41.333 28 68v416h416c26.67 0 49.33 9.333 68 28s28 41.333 28 68Z"
-      style={{
-        stroke: "#fff",
-        strokeWidth: 140,
-      }}
-      transform="translate(0 64)"
+      fill="currentColor"
+      d="M1600 736v192q0 40-28 68t-68 28h-416v416q0 40-28 68t-68 28h-192q-40 0-68-28t-28-68v-416h-416q-40 0-68-28t-28-68v-192q0-40 28-68t68-28h416v-416q0-40 28-68t68-28h192q40 0 68 28t28 68v416h416q40 0 68 28t28 68z"
    />
  </svg>
 );
@@ -36,7 +33,7 @@ export const LibraryUnit = ({
  isPending?: boolean;
  onClick: () => void;
  selected: boolean;
-  onToggle: (id: string, event: React.MouseEvent) => void;
+  onToggle: (id: string) => void;
 }) => {
  const ref = useRef<HTMLDivElement | null>(null);
  useEffect(() => {
@@ -87,17 +84,7 @@ export const LibraryUnit = ({
        })}
        ref={ref}
        draggable={!!elements}
-        onClick={
-          !!elements || !!isPending
-            ? (event) => {
-                if (id && event.shiftKey) {
-                  onToggle(id, event);
-                } else {
-                  onClick();
-                }
-              }
-            : undefined
-        }
+        onClick={!!elements || !!isPending ? onClick : undefined}
        onDragStart={(event) => {
          setIsHovered(false);
          event.dataTransfer.setData(
@@ -110,7 +97,7 @@ export const LibraryUnit = ({
      {id && elements && (isHovered || isMobile || selected) && (
        <CheckboxItem
          checked={selected}
-          onChange={(checked, event) => onToggle(id, event)}
+          onChange={() => onToggle(id)}
          className="library-unit__checkbox"
        />
      )}
@@ -10,7 +10,6 @@ type LockIconProps = {
  checked: boolean;
  onChange?(): void;
  zenModeEnabled?: boolean;
-  isMobile?: boolean;
 };

 const DEFAULT_SIZE: ToolButtonSize = "medium";
@@ -43,10 +42,10 @@ export const LockButton = (props: LockIconProps) => {
  return (
    <label
      className={clsx(
-        "ToolIcon ToolIcon__lock ToolIcon_type_floating",
+        "ToolIcon ToolIcon__lock ToolIcon_type_floating zen-mode-visibility",
        `ToolIcon_size_${DEFAULT_SIZE}`,
        {
-          "is-mobile": props.isMobile,
+          "zen-mode-visibility--hidden": props.zenModeEnabled,
        },
      )}
      title={`${props.title} — Q`}
@@ -17,7 +17,6 @@ import { LockButton } from "./LockButton";
 import { UserList } from "./UserList";
 import { BackgroundPickerAndDarkModeToggle } from "./BackgroundPickerAndDarkModeToggle";
 import { LibraryButton } from "./LibraryButton";
-import { PenModeButton } from "./PenModeButton";

 type MobileMenuProps = {
  appState: AppState;
@@ -29,7 +28,6 @@ type MobileMenuProps = {
  libraryMenu: JSX.Element | null;
  onCollabButtonClick?: () => void;
  onLockToggle: () => void;
-  onPenModeToggle: () => void;
  canvas: HTMLCanvasElement | null;
  isCollaborating: boolean;
  renderCustomFooter?: (isMobile: boolean, appState: AppState) => JSX.Element;
@@ -52,7 +50,6 @@ export const MobileMenu = ({
  setAppState,
  onCollabButtonClick,
  onLockToggle,
-  onPenModeToggle,
  canvas,
  isCollaborating,
  renderCustomFooter,
@@ -67,8 +64,8 @@ export const MobileMenu = ({
        <Section heading="shapes">
          {(heading) => (
            <Stack.Col gap={4} align="center">
-              <Stack.Row gap={1} className="App-toolbar-container">
-                <Island padding={1} className="App-toolbar">
+              <Stack.Row gap={1}>
+                <Island padding={1}>
                  {heading}
                  <Stack.Row gap={1}>
                    <ShapesSwitcher
@@ -88,20 +85,8 @@ export const MobileMenu = ({
                  checked={appState.elementLocked}
                  onChange={onLockToggle}
                  title={t("toolBar.lock")}
-                  isMobile
-                />
-                <LibraryButton
-                  appState={appState}
-                  setAppState={setAppState}
-                  isMobile
-                />
-                <PenModeButton
-                  checked={appState.penMode}
-                  onChange={onPenModeToggle}
-                  title={t("toolBar.penMode")}
-                  isMobile
-                  penDetected={appState.penDetected}
                />
+                <LibraryButton appState={appState} setAppState={setAppState} />
              </Stack.Row>
              {libraryMenu}
            </Stack.Col>
@@ -1,91 +0,0 @@
-import "./ToolIcon.scss";
-
-import clsx from "clsx";
-import { ToolButtonSize } from "./ToolButton";
-
-type PenModeIconProps = {
-  title?: string;
-  name?: string;
-  checked: boolean;
-  onChange?(): void;
-  zenModeEnabled?: boolean;
-  isMobile?: boolean;
-  penDetected: boolean;
-};
-
-const DEFAULT_SIZE: ToolButtonSize = "medium";
-
-const ICONS = {
-  CHECKED: (
-    <svg
-      width="205"
-      height="205"
-      viewBox="0 0 205 205"
-      xmlns="http://www.w3.org/2000/svg"
-    >
-      <path d="m35 195-25-29.17V50h50v115l-25 30" />
-      <path d="M10 40V10h50v30H10" />
-      <path d="M125 145h70v50h-70" />
-      <path d="M190 145v-30l-10-20h-40l-10 20v30h15v-30l5-5h20l5 5v30h15" />
-    </svg>
-  ),
-  UNCHECKED: (
-    <svg
-      width="205"
-      height="205"
-      viewBox="0 0 205 205"
-      xmlns="http://www.w3.org/2000/svg"
-      className="unlocked-icon rtl-mirror"
-    >
-      <path d="m35 195-25-29.17V50h50v115l-25 30" />
-      <path d="M10 40V10h50v30H10" />
-      <path d="M125 145h70v50h-70" />
-      <path d="M145 145v-30l-10-20H95l-10 20v30h15v-30l5-5h20l5 5v30h15" />
-    </svg>
-  ),
-};
-
-export const PenModeButton = (props: PenModeIconProps) => {
-  if (!props.penDetected) {
-    if (props.isMobile) {
-      return null;
-    }
-    return (
-      <label
-        className={clsx(
-          "ToolIcon ToolIcon__penMode ToolIcon_type_floating",
-          `ToolIcon_size_${DEFAULT_SIZE}`,
-          {
-            "is-mobile": props.isMobile,
-          },
-        )}
-      >
-        <div className="ToolIcon__icon ToolIcon__hidden" />
-      </label>
-    );
-  }
-  return (
-    <label
-      className={clsx(
-        "ToolIcon ToolIcon__penMode ToolIcon_type_floating",
-        `ToolIcon_size_${DEFAULT_SIZE}`,
-        {
-          "is-mobile": props.isMobile,
-        },
-      )}
-      title={`${props.title}`}
-    >
-      <input
-        className="ToolIcon_type_checkbox"
-        type="checkbox"
-        name={props.name}
-        onChange={props.onChange}
-        checked={props.checked}
-        aria-label={props.title}
-      />
-      <div className="ToolIcon__icon">
-        {props.checked ? ICONS.CHECKED : ICONS.UNCHECKED}
-      </div>
-    </label>
-  );
-};
@@ -8,10 +8,6 @@ type Props = {
  children?: React.ReactNode;
  onCloseRequest?(event: PointerEvent): void;
  fitInViewport?: boolean;
-  offsetLeft?: number;
-  offsetTop?: number;
-  viewportWidth?: number;
-  viewportHeight?: number;
 };

 export const Popover = ({
@@ -20,10 +16,6 @@ export const Popover = ({
  top,
  onCloseRequest,
  fitInViewport = false,
-  offsetLeft = 0,
-  offsetTop = 0,
-  viewportWidth = window.innerWidth,
-  viewportHeight = window.innerHeight,
 }: Props) => {
  const popoverRef = useRef<HTMLDivElement>(null);

@@ -32,14 +24,17 @@ export const Popover = ({
    if (fitInViewport && popoverRef.current) {
      const element = popoverRef.current;
      const { x, y, width, height } = element.getBoundingClientRect();
-      if (x + width - offsetLeft > viewportWidth) {
+
+      const viewportWidth = window.innerWidth;
+      if (x + width > viewportWidth) {
        element.style.left = `${viewportWidth - width}px`;
      }
-      if (y + height - offsetTop > viewportHeight) {
+      const viewportHeight = window.innerHeight;
+      if (y + height > viewportHeight) {
        element.style.top = `${viewportHeight - height}px`;
      }
    }
-  }, [fitInViewport, viewportWidth, viewportHeight, offsetLeft, offsetTop]);
+  }, [fitInViewport]);

  useEffect(() => {
    if (onCloseRequest) {
@@ -1,5 +1,5 @@
 import { ReactNode, useCallback, useEffect, useState } from "react";
-import OpenColor from "open-color";
+import oc from "open-color";

 import { Dialog } from "./Dialog";
 import { t } from "../i18n";
@@ -7,19 +7,16 @@ import { t } from "../i18n";
 import { ToolButton } from "./ToolButton";

 import { AppState, LibraryItems, LibraryItem } from "../types";
-import { exportToCanvas } from "../packages/utils";
-import {
-  EXPORT_DATA_TYPES,
-  EXPORT_SOURCE,
-  MIME_TYPES,
-  VERSIONS,
-} from "../constants";
+import { exportToBlob } from "../packages/utils";
+import { EXPORT_DATA_TYPES, EXPORT_SOURCE } from "../constants";
 import { ExportedLibraryData } from "../data/types";

 import "./PublishLibrary.scss";
+import { ExcalidrawElement } from "../element/types";
+import { newElement } from "../element";
+import { mutateElement } from "../element/mutateElement";
+import { getCommonBoundingBox } from "../element/bounds";
 import SingleLibraryItem from "./SingleLibraryItem";
-import { canvasToBlob, resizeImageFile } from "../data/blob";
-import { chunk } from "../utils";

 interface PublishLibraryDataParams {
  authorName: string;
@@ -58,75 +55,6 @@ const importPublishLibDataFromStorage = () => {
  return null;
 };

-const generatePreviewImage = async (libraryItems: LibraryItems) => {
-  const MAX_ITEMS_PER_ROW = 6;
-  const BOX_SIZE = 128;
-  const BOX_PADDING = Math.round(BOX_SIZE / 16);
-  const BORDER_WIDTH = Math.max(Math.round(BOX_SIZE / 64), 2);
-
-  const rows = chunk(libraryItems, MAX_ITEMS_PER_ROW);
-
-  const canvas = document.createElement("canvas");
-
-  canvas.width =
-    rows[0].length * BOX_SIZE +
-    (rows[0].length + 1) * (BOX_PADDING * 2) -
-    BOX_PADDING * 2;
-  canvas.height =
-    rows.length * BOX_SIZE +
-    (rows.length + 1) * (BOX_PADDING * 2) -
-    BOX_PADDING * 2;
-
-  const ctx = canvas.getContext("2d")!;
-
-  ctx.fillStyle = OpenColor.white;
-  ctx.fillRect(0, 0, canvas.width, canvas.height);
-
-  // draw items
-  // ---------------------------------------------------------------------------
-  for (const [index, item] of libraryItems.entries()) {
-    const itemCanvas = await exportToCanvas({
-      elements: item.elements,
-      files: null,
-      maxWidthOrHeight: BOX_SIZE,
-    });
-
-    const { width, height } = itemCanvas;
-
-    // draw item
-    // -------------------------------------------------------------------------
-    const rowOffset =
-      Math.floor(index / MAX_ITEMS_PER_ROW) * (BOX_SIZE + BOX_PADDING * 2);
-    const colOffset =
-      (index % MAX_ITEMS_PER_ROW) * (BOX_SIZE + BOX_PADDING * 2);
-
-    ctx.drawImage(
-      itemCanvas,
-      colOffset + (BOX_SIZE - width) / 2 + BOX_PADDING,
-      rowOffset + (BOX_SIZE - height) / 2 + BOX_PADDING,
-    );
-
-    // draw item border
-    // -------------------------------------------------------------------------
-    ctx.lineWidth = BORDER_WIDTH;
-    ctx.strokeStyle = OpenColor.gray[4];
-    ctx.strokeRect(
-      colOffset + BOX_PADDING / 2,
-      rowOffset + BOX_PADDING / 2,
-      BOX_SIZE + BOX_PADDING,
-      BOX_SIZE + BOX_PADDING,
-    );
-  }
-
-  return await resizeImageFile(
-    new File([await canvasToBlob(canvas)], "preview", { type: MIME_TYPES.png }),
-    {
-      outputType: MIME_TYPES.jpg,
-      maxWidthOrHeight: 5000,
-    },
-  );
-};
-
 const PublishLibrary = ({
  onClose,
  libraryItems,
@@ -201,12 +129,59 @@ const PublishLibrary = ({
      setIsSubmitting(false);
      return;
    }
+    const elements: ExcalidrawElement[] = [];
+    const prevBoundingBox = { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+    clonedLibItems.forEach((libItem) => {
+      const boundingBox = getCommonBoundingBox(libItem.elements);
+      const width = boundingBox.maxX - boundingBox.minX + 30;
+      const height = boundingBox.maxY - boundingBox.minY + 30;
+      const offset = {
+        x: prevBoundingBox.maxX - boundingBox.minX,
+        y: prevBoundingBox.maxY - boundingBox.minY,
+      };

-    const previewImage = await generatePreviewImage(clonedLibItems);
+      const itemsWithUpdatedCoords = libItem.elements.map((element) => {
+        element = mutateElement(element, {
+          x: element.x + offset.x + 15,
+          y: element.y + offset.y + 15,
+        });
+        return element;
+      });
+      const items = [
+        ...itemsWithUpdatedCoords,
+        newElement({
+          type: "rectangle",
+          width,
+          height,
+          x: prevBoundingBox.maxX,
+          y: prevBoundingBox.maxY,
+          strokeColor: "#ced4da",
+          backgroundColor: "transparent",
+          strokeStyle: "solid",
+          opacity: 100,
+          roughness: 0,
+          strokeSharpness: "sharp",
+          fillStyle: "solid",
+          strokeWidth: 1,
+        }),
+      ];
+      elements.push(...items);
+      prevBoundingBox.maxX = prevBoundingBox.maxX + width + 30;
+    });
+    const png = await exportToBlob({
+      elements,
+      mimeType: "image/png",
+      appState: {
+        ...appState,
+        viewBackgroundColor: oc.white,
+        exportBackground: true,
+      },
+      files: null,
+    });

    const libContent: ExportedLibraryData = {
      type: EXPORT_DATA_TYPES.excalidrawLibrary,
-      version: VERSIONS.excalidrawLibrary,
+      version: 2,
      source: EXPORT_SOURCE,
      libraryItems: clonedLibItems,
    };
@@ -215,8 +190,7 @@ const PublishLibrary = ({

    const formData = new FormData();
    formData.append("excalidrawLib", lib);
-    formData.append("previewImage", previewImage);
-    formData.append("previewImageType", previewImage.type);
+    formData.append("excalidrawPng", png!);
    formData.append("title", libraryData.name);
    formData.append("authorName", libraryData.authorName);
    formData.append("githubHandle", libraryData.githubHandle);
@@ -8,7 +8,17 @@
    position: relative;
    cursor: pointer;
    -webkit-tap-highlight-color: transparent;
+    border-radius: var(--space-factor);
    user-select: none;
+
+    background-color: var(--button-gray-1);
+
+    &:hover {
+      background-color: var(--button-gray-2);
+    }
+    &:active {
+      background-color: var(--button-gray-3);
+    }
  }

  .ToolIcon--plain {
@@ -19,20 +29,6 @@
    }
  }

-  .ToolIcon_type_radio,
-  .ToolIcon_type_checkbox {
-    & + .ToolIcon__icon {
-      background-color: var(--button-gray-1);
-
-      &:hover {
-        background-color: var(--button-gray-2);
-      }
-      &:active {
-        background-color: var(--button-gray-3);
-      }
-    }
-  }
-
  .ToolIcon__icon {
    width: 2.5rem;
    height: 2.5rem;
@@ -42,11 +38,7 @@
    justify-content: center;
    align-items: center;

-    border-radius: var(--border-radius-lg);
-
-    & + .ToolIcon__label {
-      margin-inline-start: 0;
-    }
+    border-radius: var(--space-factor);

    svg {
      position: relative;
@@ -54,6 +46,10 @@
      fill: var(--icon-fill-color);
      color: var(--icon-fill-color);
    }
+
+    & + .ToolIcon__label {
+      margin-inline-start: 0;
+    }
  }

  .ToolIcon__label {
@@ -83,7 +79,7 @@
    margin: 0;
    font-size: inherit;

-    &:focus-visible {
+    &:focus {
      box-shadow: 0 0 0 2px var(--focus-highlight-color);
    }

@@ -125,7 +121,7 @@
      }
    }

-    &:focus-visible + .ToolIcon__icon {
+    &:focus + .ToolIcon__icon {
      box-shadow: 0 0 0 2px var(--focus-highlight-color);
    }

@@ -145,6 +141,10 @@
      background-color: transparent;
    }

+    &:focus {
+      box-shadow: none;
+    }
+
    .ToolIcon__icon {
      background-color: var(--button-gray-1);
      &:hover {
@@ -159,6 +159,13 @@
    }
  }

+  .ToolIcon.ToolIcon__lock {
+    margin-inline-end: var(--space-factor);
+    &.ToolIcon_type_floating {
+      margin-left: 0.1rem;
+    }
+  }
+
  .ToolIcon__keybinding {
    position: absolute;
    bottom: 2px;
@@ -219,10 +226,6 @@
      margin-inline-end: 0;
      top: 60px;
    }
-    .ToolIcon.ToolIcon__penMode {
-      margin-inline-end: 0;
-      top: 140px;
-    }
  }

  .unlocked-icon {
@@ -1,124 +0,0 @@
-@import "open-color/open-color.scss";
-
-@mixin toolbarButtonColorStates {
-  .ToolIcon_type_radio,
-  .ToolIcon_type_checkbox {
-    & + .ToolIcon__icon:active {
-      background: var(--color-primary-light);
-    }
-    &:checked + .ToolIcon__icon {
-      background: var(--color-primary);
-      --icon-fill-color: #{$oc-white};
-      --keybinding-color: #{$oc-white};
-    }
-    &:checked + .ToolIcon__icon:active {
-      background: var(--color-primary-darker);
-    }
-  }
-
-  .ToolIcon__keybinding {
-    bottom: 4px;
-    right: 4px;
-  }
-}
-
-.excalidraw {
-  .App-toolbar-container {
-    .ToolIcon_type_floating {
-      @include toolbarButtonColorStates;
-
-      &:not(.is-mobile) {
-        .ToolIcon__icon {
-          padding: 1px;
-          background-color: var(--island-bg-color);
-          box-shadow: 1px 3px 4px 0px rgb(0 0 0 / 15%);
-          border-radius: 50%;
-          transition: box-shadow 0.5s ease, transform 0.5s ease;
-        }
-      }
-
-      .ToolIcon_type_radio,
-      .ToolIcon_type_checkbox {
-        &:focus-within + .ToolIcon__icon {
-          // override for custom floating button shadow
-          box-shadow: 0 0 0 2px var(--focus-highlight-color);
-        }
-      }
-    }
-
-    .ToolIcon__hidden {
-      box-shadow: none !important;
-      background-color: transparent !important;
-      pointer-events: none !important;
-    }
-
-    .ToolIcon.ToolIcon__lock {
-      margin-inline-end: var(--space-factor);
-      &.ToolIcon_type_floating {
-        margin-left: 0.1rem;
-      }
-    }
-
-    .ToolIcon__library {
-      margin-inline-start: var(--space-factor);
-    }
-
-    &.zen-mode {
-      .ToolIcon_type_floating {
-        .ToolIcon__icon {
-          box-shadow: none;
-          transform: scale(0.9);
-        }
-        .ToolIcon_type_checkbox:not(:checked):not(:hover):not(:active) {
-          & + .ToolIcon__icon {
-            svg {
-              fill: $oc-gray-5;
-              color: $oc-gray-5;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  .App-toolbar {
-    border-radius: var(--border-radius-lg);
-    box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.01), 1px 1px 5px rgb(0 0 0 / 15%);
-
-    .ToolIcon {
-      &:hover {
-        --icon-fill-color: var(
-          --color-primary-contrast-offset,
-          var(--color-primary)
-        );
-        --keybinding-color: var(
-          --color-primary-contrast-offset,
-          var(--color-primary)
-        );
-      }
-      &:active {
-        --icon-fill-color: #{$oc-gray-9};
-        --keybinding-color: #{$oc-gray-9};
-      }
-
-      .ToolIcon__icon {
-        background: transparent;
-        border-radius: var(--border-radius-lg);
-      }
-
-      @include toolbarButtonColorStates;
-    }
-
-    &.zen-mode {
-      .ToolIcon__keybinding,
-      .HintViewer {
-        display: none;
-      }
-    }
-  }
-
-  &.theme--dark .App-toolbar .ToolIcon:active {
-    --icon-fill-color: #{$oc-gray-3};
-    --keybinding-color: #{$oc-gray-3};
-  }
-}
@@ -29,6 +29,7 @@
 // wraps the element we want to apply the tooltip to
 .excalidraw-tooltip-wrapper {
  display: flex;
+  height: 100%;
 }

 .excalidraw-tooltip-icon {
@@ -2,7 +2,7 @@ import "./Tooltip.scss";

 import React, { useEffect } from "react";

-export const getTooltipDiv = () => {
+const getTooltipDiv = () => {
  const existingDiv = document.querySelector<HTMLDivElement>(
    ".excalidraw-tooltip",
  );
@@ -15,50 +15,6 @@ export const getTooltipDiv = () => {
  return div;
 };

-export const updateTooltipPosition = (
-  tooltip: HTMLDivElement,
-  item: {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-  },
-  position: "bottom" | "top" = "bottom",
-) => {
-  const tooltipRect = tooltip.getBoundingClientRect();
-
-  const viewportWidth = window.innerWidth;
-  const viewportHeight = window.innerHeight;
-
-  const margin = 5;
-
-  let left = item.left + item.width / 2 - tooltipRect.width / 2;
-  if (left < 0) {
-    left = margin;
-  } else if (left + tooltipRect.width >= viewportWidth) {
-    left = viewportWidth - tooltipRect.width - margin;
-  }
-
-  let top: number;
-
-  if (position === "bottom") {
-    top = item.top + item.height + margin;
-    if (top + tooltipRect.height >= viewportHeight) {
-      top = item.top - tooltipRect.height - margin;
-    }
-  } else {
-    top = item.top - tooltipRect.height - margin;
-    if (top < 0) {
-      top = item.top + item.height + margin;
-    }
-  }
-
-  Object.assign(tooltip.style, {
-    top: `${top}px`,
-    left: `${left}px`,
-  });
-};
-
 const updateTooltip = (
  item: HTMLDivElement,
  tooltip: HTMLDivElement,
@@ -71,27 +27,49 @@ const updateTooltip = (

  tooltip.textContent = label;

-  const itemRect = item.getBoundingClientRect();
-  updateTooltipPosition(tooltip, itemRect);
+  const {
+    x: itemX,
+    bottom: itemBottom,
+    top: itemTop,
+    width: itemWidth,
+  } = item.getBoundingClientRect();
+
+  const { width: labelWidth, height: labelHeight } =
+    tooltip.getBoundingClientRect();
+
+  const viewportWidth = window.innerWidth;
+  const viewportHeight = window.innerHeight;
+
+  const margin = 5;
+
+  const left = itemX + itemWidth / 2 - labelWidth / 2;
+  const offsetLeft =
+    left + labelWidth >= viewportWidth ? left + labelWidth - viewportWidth : 0;
+
+  const top = itemBottom + margin;
+  const offsetTop =
+    top + labelHeight >= viewportHeight
+      ? itemBottom - itemTop + labelHeight + margin * 2
+      : 0;
+
+  Object.assign(tooltip.style, {
+    top: `${top - offsetTop}px`,
+    left: `${left - offsetLeft}px`,
+  });
 };

 type TooltipProps = {
  children: React.ReactNode;
  label: string;
  long?: boolean;
-  style?: React.CSSProperties;
 };

-export const Tooltip = ({
-  children,
-  label,
-  long = false,
-  style,
-}: TooltipProps) => {
+export const Tooltip = ({ children, label, long = false }: TooltipProps) => {
  useEffect(() => {
    return () =>
      getTooltipDiv().classList.remove("excalidraw-tooltip--visible");
  }, []);
+
  return (
    <div
      className="excalidraw-tooltip-wrapper"
@@ -106,7 +84,6 @@ export const Tooltip = ({
      onPointerLeave={() =>
        getTooltipDiv().classList.remove("excalidraw-tooltip--visible")
      }
-      style={style}
    >
      {children}
    </div>
@@ -7,10 +7,6 @@
    display: flex;
    flex-wrap: wrap;
    justify-content: flex-end;
-
-    &:empty {
-      display: none;
-    }
  }

  .UserList > * {
@@ -15,9 +15,8 @@ import { THEME } from "../constants";

 const activeElementColor = (theme: Theme) =>
  theme === THEME.LIGHT ? oc.orange[4] : oc.orange[9];
-
-const iconFillColor = (theme: Theme) => "var(--icon-fill-color)";
-
+const iconFillColor = (theme: Theme) =>
+  theme === THEME.LIGHT ? oc.black : oc.gray[4];
 const handlerColor = (theme: Theme) =>
  theme === THEME.LIGHT ? oc.white : "#1e1e1e";

@@ -892,11 +891,3 @@ export const publishIcon = createIcon(
  />,
  { width: 640, height: 512 },
 );
-
-export const editIcon = createIcon(
-  <path
-    fill="currentColor"
-    d="M402.3 344.9l32-32c5-5 13.7-1.5 13.7 5.7V464c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V112c0-26.5 21.5-48 48-48h273.5c7.1 0 10.7 8.6 5.7 13.7l-32 32c-1.5 1.5-3.5 2.3-5.7 2.3H48v352h352V350.5c0-2.1.8-4.1 2.3-5.6zm156.6-201.8L296.3 405.7l-90.4 10c-26.2 2.9-48.5-19.2-45.6-45.6l10-90.4L432.9 17.1c22.9-22.9 59.9-22.9 82.7 0l43.2 43.2c22.9 22.9 22.9 60 .1 82.8zM460.1 174L402 115.9 216.2 301.8l-7.3 65.3 65.3-7.3L460.1 174zm64.8-79.7l-43.2-43.2c-4.1-4.1-10.8-4.1-14.8 0L436 82l58.1 58.1 30.9-30.9c4-4.2 4-10.8-.1-14.9z"
-  ></path>,
-  { width: 640, height: 512 },
-);
@@ -24,7 +24,7 @@ export const POINTER_BUTTON = {
  WHEEL: 1,
  SECONDARY: 2,
  TOUCH: -1,
-} as const;
+};

 export enum EVENT {
  COPY = "copy",
@@ -52,8 +52,6 @@ export enum EVENT {
  HASHCHANGE = "hashchange",
  VISIBILITY_CHANGE = "visibilitychange",
  SCROLL = "scroll",
-  // custom events
-  EXCALIDRAW_LINK = "excalidraw-link",
 }

 export const ENV = {
@@ -108,6 +106,10 @@ export const EXPORT_DATA_TYPES = {

 export const EXPORT_SOURCE = window.location.origin;

+export const STORAGE_KEYS = {
+  LOCAL_STORAGE_LIBRARY: "excalidraw-library",
+} as const;
+
 // time in milliseconds
 export const IMAGE_RENDER_TIMEOUT = 500;
 export const TAP_TWICE_TIMEOUT = 300;
@@ -117,7 +119,6 @@ export const TOAST_TIMEOUT = 5000;
 export const VERSION_TIMEOUT = 30000;
 export const SCROLL_TIMEOUT = 100;
 export const ZOOM_STEP = 0.1;
-export const HYPERLINK_TOOLTIP_DELAY = 300;

 // Report a user inactive after IDLE_THRESHOLD milliseconds
 export const IDLE_THRESHOLD = 60_000;
@@ -161,7 +162,8 @@ export const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export const EXPORT_SCALES = [1, 2, 3];
 export const DEFAULT_EXPORT_PADDING = 10; // px

-export const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
+export const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT_JPG = 10000;
+export const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT_OTHER = 1440;

 export const ALLOWED_IMAGE_MIME_TYPES = [
  MIME_TYPES.png,
@@ -175,10 +177,3 @@ export const MAX_ALLOWED_FILE_BYTES = 2 * 1024 * 1024;
 export const SVG_NS = "http://www.w3.org/2000/svg";

 export const ENCRYPTION_KEY_BITS = 128;
-
-export const VERSIONS = {
-  excalidraw: 2,
-  excalidrawLibrary: 2,
-} as const;
-
-export const BOUND_TEXT_PADDING = 5;
@@ -180,7 +180,7 @@
  }

  .buttonList label:focus-within,
-  input:focus-visible {
+  input:focus {
    outline: transparent;
    box-shadow: 0 0 0 2px var(--focus-highlight-color);
  }
@@ -190,14 +190,14 @@
    user-select: none;
    background-color: var(--button-gray-1);
    border: 0;
-    border-radius: var(--border-radius-md);
+    border-radius: 4px;
    margin: 0.125rem 0;
    padding: 0.25rem;
    white-space: nowrap;

    cursor: pointer;

-    &:focus-visible {
+    &:focus {
      outline: transparent;
      box-shadow: 0 0 0 2px var(--focus-highlight-color);
    }
@@ -217,16 +217,14 @@

  .active,
  .buttonList label.active {
-    background-color: var(--color-primary);
-
-    --icon-fill-color: #{$oc-white};
+    background-color: var(--button-gray-2);

    &:hover {
-      background-color: var(--color-primary-darker);
+      background-color: var(--button-gray-2);
    }

    &:active {
-      background-color: var(--color-primary-darkest);
+      background-color: var(--button-gray-3);
    }
  }

@@ -236,7 +234,7 @@
      justify-content: center;
      align-items: center;
      svg {
-        width: 35px;
+        width: 36px;
        height: 14px;
        padding: 2px;
        opacity: 0.6;
@@ -313,7 +311,7 @@
  }

  .App-menu_top {
-    grid-template-columns: auto max-content auto;
+    grid-template-columns: 1fr auto 1fr;
    grid-gap: 4px;
    align-items: flex-start;
    cursor: default;
@@ -12,7 +12,7 @@
  --dialog-border-color: #{$oc-gray-6};
  --dropdown-icon: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="292.4" height="292.4" viewBox="0 0 292 292"><path d="M287 197L159 69c-4-3-8-5-13-5s-9 2-13 5L5 197c-3 4-5 8-5 13s2 9 5 13c4 4 8 5 13 5h256c5 0 9-1 13-5s5-8 5-13-1-9-5-13z"/></svg>');
  --focus-highlight-color: #{$oc-blue-2};
-  --icon-fill-color: #{$oc-gray-9};
+  --icon-fill-color: #{$oc-black};
  --icon-green-fill-color: #{$oc-green-9};
  --default-bg-color: #{$oc-white};
  --input-bg-color: #{$oc-white};
@@ -32,19 +32,10 @@
  --sar: env(safe-area-inset-right);
  --sat: env(safe-area-inset-top);
  --select-highlight-color: #{$oc-blue-5};
-  --shadow-island: 0 0 0 1px rgba(0, 0, 0, 0.01), 1px 1px 5px rgb(0 0 0 / 12%);
-
+  --shadow-island: 0 1px 5px #{transparentize($oc-black, 0.85)};
  --space-factor: 0.25rem;
  --text-primary-color: #{$oc-gray-8};

-  --color-primary: #6965db;
-  --color-primary-darker: #5b57d1;
-  --color-primary-darkest: #4a47b1;
-  --color-primary-light: #e2e1fc;
-
-  --border-radius-md: 0.375rem;
-  --border-radius-lg: 0.5rem;
-
  &.theme--dark {
    background: $oc-black;

@@ -80,12 +71,7 @@
    --popup-text-color: #{$oc-gray-4};
    --popup-text-inverted-color: #2c2c2c;
    --select-highlight-color: #{$oc-blue-4};
-    --shadow-island: 1px 1px 5px #{transparentize($oc-black, 0.7)};
+    --shadow-island: 0 1px 5px #{transparentize($oc-black, 0.7)};
    --text-primary-color: #{$oc-gray-4};
-
-    --color-primary: #5650f0;
-    --color-primary-darker: #4b46d8;
-    --color-primary-darkest: #3e39be;
-    --color-primary-light: #3f3d64;
  }
 }
@@ -271,6 +271,8 @@ export const resizeImageFile = async (
    };
  }

+  const fileType = file.type;
+
  if (!isSupportedImageFile(file)) {
    throw new Error(t("errors.unsupportedFileType"));
  }
@@ -279,7 +281,7 @@ export const resizeImageFile = async (
    [await reduce.toBlob(file, { max: opts.maxWidthOrHeight })],
    file.name,
    {
-      type: opts.outputType || file.type,
+      type: fileType,
    },
  );
 };
@@ -234,19 +234,7 @@ const splitBuffers = (concatenatedBuffer: Uint8Array) => {

  let cursor = 0;

-  // first chunk is the version
-  const version = dataView(
-    concatenatedBuffer,
-    NEXT_CHUNK_SIZE_DATAVIEW_BYTES,
-    cursor,
-  );
-  // If version is outside of the supported versions, throw an error.
-  // This usually means the buffer wasn't encoded using this API, so we'd only
-  // waste compute.
-  if (version > CONCAT_BUFFERS_VERSION) {
-    throw new Error(`invalid version ${version}`);
-  }
-
+  // first chunk is the version (ignored for now)
  cursor += VERSION_DATAVIEW_BYTES;

  while (true) {
@@ -1,8 +1,11 @@
-import decodePng from "png-chunks-extract";
+import extractPngChunks from "png-chunks-extract";
 import tEXt from "png-chunk-text";
 import encodePng from "png-chunks-encode";
 import { stringToBase64, encode, decode, base64ToString } from "./encode";
 import { EXPORT_DATA_TYPES, MIME_TYPES } from "../constants";
+import { PngChunk } from "../types";
+
+export { extractPngChunks };

 // -----------------------------------------------------------------------------
 // PNG
@@ -28,7 +31,9 @@ const blobToArrayBuffer = (blob: Blob): Promise<ArrayBuffer> => {
 export const getTEXtChunk = async (
  blob: Blob,
 ): Promise<{ keyword: string; text: string } | null> => {
-  const chunks = decodePng(new Uint8Array(await blobToArrayBuffer(blob)));
+  const chunks = extractPngChunks(
+    new Uint8Array(await blobToArrayBuffer(blob)),
+  );
  const metadataChunk = chunks.find((chunk) => chunk.name === "tEXt");
  if (metadataChunk) {
    return tEXt.decode(metadataChunk.data);
@@ -36,6 +41,28 @@ export const getTEXtChunk = async (
  return null;
 };

+export const findPngChunk = (
+  chunks: PngChunk[],
+  name: PngChunk["name"],
+  /** this makes the search stop before IDAT chunk (before which most
+   * metadata chunks reside). This is a perf optim. */
+  breakBeforeIDAT = true,
+) => {
+  let i = 0;
+  const len = chunks.length;
+  while (i <= len) {
+    const chunk = chunks[i];
+    if (chunk.name === name) {
+      return chunk;
+    }
+    if (breakBeforeIDAT && chunk.name === "IDAT") {
+      return null;
+    }
+    i++;
+  }
+  return null;
+};
+
 export const encodePngMetadata = async ({
  blob,
  metadata,
@@ -43,7 +70,9 @@ export const encodePngMetadata = async ({
  blob: Blob;
  metadata: string;
 }) => {
-  const chunks = decodePng(new Uint8Array(await blobToArrayBuffer(blob)));
+  const chunks = extractPngChunks(
+    new Uint8Array(await blobToArrayBuffer(blob)),
+  );

  const metadataChunk = tEXt.encode(
    MIME_TYPES.excalidraw,
@@ -1,11 +1,6 @@
 import { fileOpen, fileSave } from "./filesystem";
 import { cleanAppStateForExport, clearAppStateForDatabase } from "../appState";
-import {
-  EXPORT_DATA_TYPES,
-  EXPORT_SOURCE,
-  MIME_TYPES,
-  VERSIONS,
-} from "../constants";
+import { EXPORT_DATA_TYPES, EXPORT_SOURCE, MIME_TYPES } from "../constants";
 import { clearElementsForDatabase, clearElementsForExport } from "../element";
 import { ExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles, LibraryItems } from "../types";
@@ -47,7 +42,7 @@ export const serializeAsJSON = (
 ): string => {
  const data: ExportedDataState = {
    type: EXPORT_DATA_TYPES.excalidraw,
-    version: VERSIONS.excalidraw,
+    version: 2,
    source: EXPORT_SOURCE,
    elements:
      type === "local"
@@ -126,7 +121,7 @@ export const isValidLibrary = (json: any) => {
 export const saveLibraryAsJSON = async (libraryItems: LibraryItems) => {
  const data: ExportedLibraryData = {
    type: EXPORT_DATA_TYPES.excalidrawLibrary,
-    version: VERSIONS.excalidrawLibrary,
+    version: 2,
    source: EXPORT_SOURCE,
    libraryItems,
  };
@@ -10,7 +10,11 @@ import {
  NormalizedZoomValue,
 } from "../types";
 import { ImportedDataState } from "./types";
-import { getNormalizedDimensions, isInvisiblySmallElement } from "../element";
+import {
+  getElementMap,
+  getNormalizedDimensions,
+  isInvisiblySmallElement,
+} from "../element";
 import { isLinearElementType } from "../element/typeChecks";
 import { randomId } from "../random";
 import {
@@ -22,8 +26,6 @@ import {
 import { getDefaultAppState } from "../appState";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import { bumpVersion } from "../element/mutateElement";
-import { getUpdatedTimestamp } from "../utils";
-import { arrayToMap } from "../utils";

 type RestoredAppState = Omit<
  AppState,
@@ -64,10 +66,7 @@ const restoreElementWithProperties = <
  T extends ExcalidrawElement,
  K extends Pick<T, keyof Omit<Required<T>, keyof ExcalidrawElement>>,
 >(
-  element: Required<T> & {
-    /** @deprecated */
-    boundElementIds?: readonly ExcalidrawElement["id"][];
-  },
+  element: Required<T>,
  extra: Pick<
    T,
    // This extra Pick<T, keyof K> ensure no excess properties are passed.
@@ -101,11 +100,7 @@ const restoreElementWithProperties = <
    strokeSharpness:
      element.strokeSharpness ??
      (isLinearElementType(element.type) ? "round" : "sharp"),
-    boundElements: element.boundElementIds
-      ? element.boundElementIds.map((id) => ({ type: "arrow", id }))
-      : element.boundElements ?? [],
-    updated: element.updated ?? getUpdatedTimestamp(),
-    link: element.link ?? null,
+    boundElementIds: element.boundElementIds ?? [],
  };

  return {
@@ -136,8 +131,6 @@ const restoreElement = (
        baseline: element.baseline,
        textAlign: element.textAlign || DEFAULT_TEXT_ALIGN,
        verticalAlign: element.verticalAlign || DEFAULT_VERTICAL_ALIGN,
-        containerId: element.containerId ?? null,
-        originalText: element.originalText || element.text,
      });
    case "freedraw": {
      return restoreElementWithProperties(element, {
@@ -211,14 +204,14 @@ export const restoreElements = (
  /** NOTE doesn't serve for reconciliation */
  localElements: readonly ExcalidrawElement[] | null | undefined,
 ): ExcalidrawElement[] => {
-  const localElementsMap = localElements ? arrayToMap(localElements) : null;
+  const localElementsMap = localElements ? getElementMap(localElements) : null;
  return (elements || []).reduce((elements, element) => {
    // filtering out selection, which is legacy, no longer kept in elements,
    // and causing issues if retained
    if (element.type !== "selection" && !isInvisiblySmallElement(element)) {
      let migratedElement: ExcalidrawElement | null = restoreElement(element);
      if (migratedElement) {
-        const localElement = localElementsMap?.get(element.id);
+        const localElement = localElementsMap?.[element.id];
        if (localElement && localElement.version > migratedElement.version) {
          migratedElement = bumpVersion(migratedElement, localElement.version);
        }
@@ -262,6 +255,7 @@ export const restoreAppState = (
      typeof appState.zoom === "number"
        ? {
            value: appState.zoom as NormalizedZoomValue,
+            translation: defaultAppState.zoom.translation,
          }
        : appState.zoom || defaultAppState.zoom,
  };
@@ -1,7 +1,6 @@
 import { ExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles, LibraryItems, LibraryItems_v1 } from "../types";
 import type { cleanAppStateForExport } from "../appState";
-import { VERSIONS } from "../constants";

 export interface ExportedDataState {
  type: string;
@@ -25,7 +24,7 @@ export interface ImportedDataState {

 export interface ExportedLibraryData {
  type: string;
-  version: typeof VERSIONS.excalidrawLibrary;
+  version: 2;
  source: string;
  libraryItems: LibraryItems;
 }
@@ -1,7 +1,17 @@
 import { ExcalidrawElement } from "./element/types";
 import { newElementWith } from "./element/mutateElement";
-import { getMaximumGroups } from "./groups";
-import { getCommonBoundingBox } from "./element/bounds";
+import { getCommonBounds } from "./element";
+
+interface Box {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+  midX: number;
+  midY: number;
+  width: number;
+  height: number;
+}

 export interface Distribution {
  space: "between";
@@ -88,3 +98,39 @@ export const distributeElements = (
    );
  });
 };
+
+export const getMaximumGroups = (
+  elements: ExcalidrawElement[],
+): ExcalidrawElement[][] => {
+  const groups: Map<String, ExcalidrawElement[]> = new Map<
+    String,
+    ExcalidrawElement[]
+  >();
+
+  elements.forEach((element: ExcalidrawElement) => {
+    const groupId =
+      element.groupIds.length === 0
+        ? element.id
+        : element.groupIds[element.groupIds.length - 1];
+
+    const currentGroupMembers = groups.get(groupId) || [];
+
+    groups.set(groupId, [...currentGroupMembers, element]);
+  });
+
+  return Array.from(groups.values());
+};
+
+const getCommonBoundingBox = (elements: ExcalidrawElement[]): Box => {
+  const [minX, minY, maxX, maxY] = getCommonBounds(elements);
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    width: maxX - minX,
+    height: maxY - minY,
+    midX: (minX + maxX) / 2,
+    midY: (minY + maxY) / 2,
+  };
+};
@@ -1,74 +0,0 @@
-@import "../css/variables.module";
-
-.excalidraw-hyperlinkContainer {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  position: absolute;
-  box-shadow: 0px 2px 4px 0 rgb(0 0 0 / 30%);
-  z-index: 100;
-  background: var(--island-bg-color);
-  border-radius: var(--border-radius-md);
-  box-sizing: border-box;
-  // to account for LS due to rendering icons after new link created
-  min-height: 42px;
-
-  &-input,
-  button {
-    z-index: 100;
-  }
-
-  &-input,
-  &-link {
-    height: 24px;
-    padding: 0 8px;
-    line-height: 24px;
-    font-size: 0.9rem;
-    font-weight: 500;
-    font-family: var(--ui-font);
-  }
-
-  &-input {
-    width: 18rem;
-    border: none;
-    background-color: transparent;
-    color: var(--text-primary-color);
-
-    outline: none;
-    border: none;
-    box-shadow: none !important;
-  }
-
-  &-link {
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    max-width: 15rem;
-  }
-
-  button {
-    color: $oc-blue-6;
-    background-color: transparent !important;
-    font-weight: 500;
-    &.excalidraw-hyperlinkContainer--remove {
-      color: $oc-red-9;
-    }
-  }
-
-  .d-none {
-    display: none;
-  }
-
-  &--remove .ToolIcon__icon svg {
-    color: $oc-red-6;
-  }
-
-  .ToolIcon__icon {
-    width: 2rem;
-    height: 2rem;
-  }
-
-  &__buttons {
-    flex: 0 0 auto;
-  }
-}
@@ -1,453 +0,0 @@
-import { AppState, ExcalidrawProps, Point } from "../types";
-import {
-  getShortcutKey,
-  sceneCoordsToViewportCoords,
-  viewportCoordsToSceneCoords,
-  wrapEvent,
-} from "../utils";
-import { mutateElement } from "./mutateElement";
-import { NonDeletedExcalidrawElement } from "./types";
-
-import { register } from "../actions/register";
-import { ToolButton } from "../components/ToolButton";
-import { editIcon, link, trash } from "../components/icons";
-import { t } from "../i18n";
-import {
-  useCallback,
-  useEffect,
-  useLayoutEffect,
-  useRef,
-  useState,
-} from "react";
-import clsx from "clsx";
-import { KEYS } from "../keys";
-import { DEFAULT_LINK_SIZE } from "../renderer/renderElement";
-import { rotate } from "../math";
-import { EVENT, HYPERLINK_TOOLTIP_DELAY, MIME_TYPES } from "../constants";
-import { Bounds } from "./bounds";
-import { getTooltipDiv, updateTooltipPosition } from "../components/Tooltip";
-import { getSelectedElements } from "../scene";
-import { isPointHittingElementBoundingBox } from "./collision";
-import { getElementAbsoluteCoords } from "./";
-
-import "./Hyperlink.scss";
-
-const CONTAINER_WIDTH = 320;
-const SPACE_BOTTOM = 85;
-const CONTAINER_PADDING = 5;
-const CONTAINER_HEIGHT = 42;
-const AUTO_HIDE_TIMEOUT = 500;
-
-export const EXTERNAL_LINK_IMG = document.createElement("img");
-EXTERNAL_LINK_IMG.src = `data:${MIME_TYPES.svg}, ${encodeURIComponent(
-  `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#1971c2" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-external-link"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></svg>`,
-)}`;
-
-let IS_HYPERLINK_TOOLTIP_VISIBLE = false;
-
-export const Hyperlink = ({
-  element,
-  appState,
-  setAppState,
-  onLinkOpen,
-}: {
-  element: NonDeletedExcalidrawElement;
-  appState: AppState;
-  setAppState: React.Component<any, AppState>["setState"];
-  onLinkOpen: ExcalidrawProps["onLinkOpen"];
-}) => {
-  const linkVal = element.link || "";
-
-  const [inputVal, setInputVal] = useState(linkVal);
-  const inputRef = useRef<HTMLInputElement>(null);
-  const isEditing = appState.showHyperlinkPopup === "editor" || !linkVal;
-
-  const handleSubmit = useCallback(() => {
-    if (!inputRef.current) {
-      return;
-    }
-
-    const link = normalizeLink(inputRef.current.value);
-
-    mutateElement(element, { link });
-    setAppState({ showHyperlinkPopup: "info" });
-  }, [element, setAppState]);
-
-  useLayoutEffect(() => {
-    return () => {
-      handleSubmit();
-    };
-  }, [handleSubmit]);
-
-  useEffect(() => {
-    let timeoutId: number | null = null;
-    const handlePointerMove = (event: PointerEvent) => {
-      if (isEditing) {
-        return;
-      }
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      const shouldHide = shouldHideLinkPopup(element, appState, [
-        event.clientX,
-        event.clientY,
-      ]) as boolean;
-      if (shouldHide) {
-        timeoutId = window.setTimeout(() => {
-          setAppState({ showHyperlinkPopup: false });
-        }, AUTO_HIDE_TIMEOUT);
-      }
-    };
-    window.addEventListener(EVENT.POINTER_MOVE, handlePointerMove, false);
-    return () => {
-      window.removeEventListener(EVENT.POINTER_MOVE, handlePointerMove, false);
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    };
-  }, [appState, element, isEditing, setAppState]);
-
-  const handleRemove = useCallback(() => {
-    mutateElement(element, { link: null });
-    if (isEditing) {
-      inputRef.current!.value = "";
-    }
-    setAppState({ showHyperlinkPopup: false });
-  }, [setAppState, element, isEditing]);
-
-  const onEdit = () => {
-    setAppState({ showHyperlinkPopup: "editor" });
-  };
-  const { x, y } = getCoordsForPopover(element, appState);
-  if (
-    appState.draggingElement ||
-    appState.resizingElement ||
-    appState.isRotating ||
-    appState.openMenu
-  ) {
-    return null;
-  }
-  return (
-    <div
-      className="excalidraw-hyperlinkContainer"
-      style={{
-        top: `${y}px`,
-        left: `${x}px`,
-        width: CONTAINER_WIDTH,
-        padding: CONTAINER_PADDING,
-      }}
-    >
-      {isEditing ? (
-        <input
-          className={clsx("excalidraw-hyperlinkContainer-input")}
-          placeholder="Type or paste your link here"
-          ref={inputRef}
-          value={inputVal}
-          onChange={(event) => setInputVal(event.target.value)}
-          autoFocus
-          onKeyDown={(event) => {
-            event.stopPropagation();
-            // prevent cmd/ctrl+k shortcut when editing link
-            if (event[KEYS.CTRL_OR_CMD] && event.key === KEYS.K) {
-              event.preventDefault();
-            }
-            if (event.key === KEYS.ENTER || event.key === KEYS.ESCAPE) {
-              handleSubmit();
-            }
-          }}
-        />
-      ) : (
-        <a
-          href={element.link || ""}
-          className={clsx("excalidraw-hyperlinkContainer-link", {
-            "d-none": isEditing,
-          })}
-          target={isLocalLink(element.link) ? "_self" : "_blank"}
-          onClick={(event) => {
-            if (element.link && onLinkOpen) {
-              const customEvent = wrapEvent(
-                EVENT.EXCALIDRAW_LINK,
-                event.nativeEvent,
-              );
-              onLinkOpen(element, customEvent);
-              if (customEvent.defaultPrevented) {
-                event.preventDefault();
-              }
-            }
-          }}
-          rel="noopener noreferrer"
-        >
-          {element.link}
-        </a>
-      )}
-      <div className="excalidraw-hyperlinkContainer__buttons">
-        {!isEditing && (
-          <ToolButton
-            type="button"
-            title={t("buttons.edit")}
-            aria-label={t("buttons.edit")}
-            label={t("buttons.edit")}
-            onClick={onEdit}
-            className="excalidraw-hyperlinkContainer--edit"
-            icon={editIcon}
-          />
-        )}
-
-        {linkVal && (
-          <ToolButton
-            type="button"
-            title={t("buttons.remove")}
-            aria-label={t("buttons.remove")}
-            label={t("buttons.remove")}
-            onClick={handleRemove}
-            className="excalidraw-hyperlinkContainer--remove"
-            icon={trash}
-          />
-        )}
-      </div>
-    </div>
-  );
-};
-
-const getCoordsForPopover = (
-  element: NonDeletedExcalidrawElement,
-  appState: AppState,
-) => {
-  const [x1, y1] = getElementAbsoluteCoords(element);
-  const { x: viewportX, y: viewportY } = sceneCoordsToViewportCoords(
-    { sceneX: x1 + element.width / 2, sceneY: y1 },
-    appState,
-  );
-  const x = viewportX - appState.offsetLeft - CONTAINER_WIDTH / 2;
-  const y = viewportY - appState.offsetTop - SPACE_BOTTOM;
-  return { x, y };
-};
-
-export const normalizeLink = (link: string) => {
-  link = link.trim();
-  if (link) {
-    // prefix with protocol if not fully-qualified
-    if (!link.includes("://") && !/^[[\\/]/.test(link)) {
-      link = `https://${link}`;
-    }
-  }
-  return link;
-};
-
-export const isLocalLink = (link: string | null) => {
-  return !!(link?.includes(location.origin) || link?.startsWith("/"));
-};
-
-export const actionLink = register({
-  name: "link",
-  perform: (elements, appState) => {
-    if (appState.showHyperlinkPopup === "editor") {
-      return false;
-    }
-    return {
-      elements,
-      appState: {
-        ...appState,
-        showHyperlinkPopup: "editor",
-        openMenu: null,
-      },
-      commitToHistory: true,
-    };
-  },
-  keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.key === KEYS.K,
-  contextItemLabel: (elements, appState) =>
-    getContextMenuLabel(elements, appState),
-  contextItemPredicate: (elements, appState) => {
-    const selectedElements = getSelectedElements(elements, appState);
-    return selectedElements.length === 1;
-  },
-  PanelComponent: ({ elements, appState, updateData }) => {
-    const selectedElements = getSelectedElements(elements, appState);
-
-    return (
-      <ToolButton
-        type="button"
-        icon={link}
-        aria-label={t(getContextMenuLabel(elements, appState))}
-        title={`${t("labels.link.label")} - ${getShortcutKey("CtrlOrCmd+K")}`}
-        onClick={() => updateData(null)}
-        selected={selectedElements.length === 1 && !!selectedElements[0].link}
-      />
-    );
-  },
-});
-
-export const getContextMenuLabel = (
-  elements: readonly NonDeletedExcalidrawElement[],
-  appState: AppState,
-) => {
-  const selectedElements = getSelectedElements(elements, appState);
-  const label = selectedElements[0]!.link
-    ? "labels.link.edit"
-    : "labels.link.create";
-  return label;
-};
-export const getLinkHandleFromCoords = (
-  [x1, y1, x2, y2]: Bounds,
-  angle: number,
-  appState: AppState,
-): [x: number, y: number, width: number, height: number] => {
-  const size = DEFAULT_LINK_SIZE;
-  const linkWidth = size / appState.zoom.value;
-  const linkHeight = size / appState.zoom.value;
-  const linkMarginY = size / appState.zoom.value;
-  const centerX = (x1 + x2) / 2;
-  const centerY = (y1 + y2) / 2;
-  const centeringOffset = (size - 8) / (2 * appState.zoom.value);
-  const dashedLineMargin = 4 / appState.zoom.value;
-
-  // Same as `ne` resize handle
-  const x = x2 + dashedLineMargin - centeringOffset;
-  const y = y1 - dashedLineMargin - linkMarginY + centeringOffset;
-
-  const [rotatedX, rotatedY] = rotate(
-    x + linkWidth / 2,
-    y + linkHeight / 2,
-    centerX,
-    centerY,
-    angle,
-  );
-  return [
-    rotatedX - linkWidth / 2,
-    rotatedY - linkHeight / 2,
-    linkWidth,
-    linkHeight,
-  ];
-};
-
-export const isPointHittingLinkIcon = (
-  element: NonDeletedExcalidrawElement,
-  appState: AppState,
-  [x, y]: Point,
-  isMobile: boolean,
-) => {
-  const threshold = 4 / appState.zoom.value;
-  if (
-    !isMobile &&
-    appState.viewModeEnabled &&
-    isPointHittingElementBoundingBox(element, [x, y], threshold)
-  ) {
-    return true;
-  }
-  const [x1, y1, x2, y2] = getElementAbsoluteCoords(element);
-
-  const [linkX, linkY, linkWidth, linkHeight] = getLinkHandleFromCoords(
-    [x1, y1, x2, y2],
-    element.angle,
-    appState,
-  );
-  const hitLink =
-    x > linkX - threshold &&
-    x < linkX + threshold + linkWidth &&
-    y > linkY - threshold &&
-    y < linkY + linkHeight + threshold;
-  return hitLink;
-};
-
-let HYPERLINK_TOOLTIP_TIMEOUT_ID: number | null = null;
-export const showHyperlinkTooltip = (
-  element: NonDeletedExcalidrawElement,
-  appState: AppState,
-) => {
-  if (HYPERLINK_TOOLTIP_TIMEOUT_ID) {
-    clearTimeout(HYPERLINK_TOOLTIP_TIMEOUT_ID);
-  }
-  HYPERLINK_TOOLTIP_TIMEOUT_ID = window.setTimeout(
-    () => renderTooltip(element, appState),
-    HYPERLINK_TOOLTIP_DELAY,
-  );
-};
-
-const renderTooltip = (
-  element: NonDeletedExcalidrawElement,
-  appState: AppState,
-) => {
-  if (!element.link) {
-    return;
-  }
-
-  const tooltipDiv = getTooltipDiv();
-
-  tooltipDiv.classList.add("excalidraw-tooltip--visible");
-  tooltipDiv.style.maxWidth = "20rem";
-  tooltipDiv.textContent = element.link;
-
-  const [x1, y1, x2, y2] = getElementAbsoluteCoords(element);
-
-  const [linkX, linkY, linkWidth, linkHeight] = getLinkHandleFromCoords(
-    [x1, y1, x2, y2],
-    element.angle,
-    appState,
-  );
-
-  const linkViewportCoords = sceneCoordsToViewportCoords(
-    { sceneX: linkX, sceneY: linkY },
-    appState,
-  );
-
-  updateTooltipPosition(
-    tooltipDiv,
-    {
-      left: linkViewportCoords.x,
-      top: linkViewportCoords.y,
-      width: linkWidth,
-      height: linkHeight,
-    },
-    "top",
-  );
-
-  IS_HYPERLINK_TOOLTIP_VISIBLE = true;
-};
-export const hideHyperlinkToolip = () => {
-  if (HYPERLINK_TOOLTIP_TIMEOUT_ID) {
-    clearTimeout(HYPERLINK_TOOLTIP_TIMEOUT_ID);
-  }
-  if (IS_HYPERLINK_TOOLTIP_VISIBLE) {
-    IS_HYPERLINK_TOOLTIP_VISIBLE = false;
-    getTooltipDiv().classList.remove("excalidraw-tooltip--visible");
-  }
-};
-
-export const shouldHideLinkPopup = (
-  element: NonDeletedExcalidrawElement,
-  appState: AppState,
-  [clientX, clientY]: Point,
-): Boolean => {
-  const { x: sceneX, y: sceneY } = viewportCoordsToSceneCoords(
-    { clientX, clientY },
-    appState,
-  );
-
-  const threshold = 15 / appState.zoom.value;
-  // hitbox to prevent hiding when hovered in element bounding box
-  if (isPointHittingElementBoundingBox(element, [sceneX, sceneY], threshold)) {
-    return false;
-  }
-  const [x1, y1, x2] = getElementAbsoluteCoords(element);
-  // hit box to prevent hiding when hovered in the vertical area between element and popover
-  if (
-    sceneX >= x1 &&
-    sceneX <= x2 &&
-    sceneY >= y1 - SPACE_BOTTOM &&
-    sceneY <= y1
-  ) {
-    return false;
-  }
-  // hit box to prevent hiding when hovered around popover within threshold
-  const { x: popoverX, y: popoverY } = getCoordsForPopover(element, appState);
-
-  if (
-    clientX >= popoverX - threshold &&
-    clientX <= popoverX + CONTAINER_WIDTH + CONTAINER_PADDING * 2 + threshold &&
-    clientY >= popoverY - threshold &&
-    clientY <= popoverY + threshold + CONTAINER_PADDING * 2 + CONTAINER_HEIGHT
-  ) {
-    return false;
-  }
-  return true;
-};
@@ -8,11 +8,7 @@ import {
 } from "./types";
 import { getElementAtPosition } from "../scene";
 import { AppState } from "../types";
-import {
-  isBindableElement,
-  isBindingElement,
-  isLinearElement,
-} from "./typeChecks";
+import { isBindableElement, isBindingElement } from "./typeChecks";
 import {
  bindingBorderTest,
  distanceToBindableElement,
@@ -24,7 +20,7 @@ import {
 import { mutateElement } from "./mutateElement";
 import Scene from "../scene/Scene";
 import { LinearElementEditor } from "./linearElementEditor";
-import { arrayToMap, tupleToCoors } from "../utils";
+import { tupleToCoors } from "../utils";
 import { KEYS } from "../keys";

 export type SuggestedBinding =
@@ -78,9 +74,8 @@ export const bindOrUnbindLinearElement = (
    .getNonDeletedElements(onlyUnbound)
    .forEach((element) => {
      mutateElement(element, {
-        boundElements: element.boundElements?.filter(
-          (element) =>
-            element.type !== "arrow" || element.id !== linearElement.id,
+        boundElementIds: element.boundElementIds?.filter(
+          (id) => id !== linearElement.id,
        ),
      });
    });
@@ -185,16 +180,11 @@ const bindLinearElement = (
      ...calculateFocusAndGap(linearElement, hoveredElement, startOrEnd),
    } as PointBinding,
  });
-
-  const boundElementsMap = arrayToMap(hoveredElement.boundElements || []);
-  if (!boundElementsMap.has(linearElement.id)) {
-    mutateElement(hoveredElement, {
-      boundElements: (hoveredElement.boundElements || []).concat({
-        id: linearElement.id,
-        type: "arrow",
-      }),
-    });
-  }
+  mutateElement(hoveredElement, {
+    boundElementIds: Array.from(
+      new Set([...(hoveredElement.boundElementIds ?? []), linearElement.id]),
+    ),
+  });
 };

 // Don't bind both ends of a simple segment
@@ -294,56 +284,52 @@ export const updateBoundElements = (
    newSize?: { width: number; height: number };
  },
 ) => {
-  const boundLinearElements = (changedElement.boundElements ?? []).filter(
-    (el) => el.type === "arrow",
-  );
-  if (boundLinearElements.length === 0) {
+  const boundElementIds = changedElement.boundElementIds ?? [];
+  if (boundElementIds.length === 0) {
    return;
  }
  const { newSize, simultaneouslyUpdated } = options ?? {};
  const simultaneouslyUpdatedElementIds = getSimultaneouslyUpdatedElementIds(
    simultaneouslyUpdated,
  );
-  Scene.getScene(changedElement)!
-    .getNonDeletedElements(boundLinearElements.map((el) => el.id))
-    .forEach((element) => {
-      if (!isLinearElement(element)) {
-        return;
-      }
-
-      const bindableElement = changedElement as ExcalidrawBindableElement;
-      // In case the boundElements are stale
-      if (!doesNeedUpdate(element, bindableElement)) {
-        return;
-      }
-      const startBinding = maybeCalculateNewGapWhenScaling(
-        bindableElement,
-        element.startBinding,
-        newSize,
-      );
-      const endBinding = maybeCalculateNewGapWhenScaling(
-        bindableElement,
-        element.endBinding,
-        newSize,
-      );
-      // `linearElement` is being moved/scaled already, just update the binding
-      if (simultaneouslyUpdatedElementIds.has(element.id)) {
-        mutateElement(element, { startBinding, endBinding });
-        return;
-      }
-      updateBoundPoint(
-        element,
-        "start",
-        startBinding,
-        changedElement as ExcalidrawBindableElement,
-      );
-      updateBoundPoint(
-        element,
-        "end",
-        endBinding,
-        changedElement as ExcalidrawBindableElement,
-      );
-    });
+  (
+    Scene.getScene(changedElement)!.getNonDeletedElements(
+      boundElementIds,
+    ) as NonDeleted<ExcalidrawLinearElement>[]
+  ).forEach((linearElement) => {
+    const bindableElement = changedElement as ExcalidrawBindableElement;
+    // In case the boundElementIds are stale
+    if (!doesNeedUpdate(linearElement, bindableElement)) {
+      return;
+    }
+    const startBinding = maybeCalculateNewGapWhenScaling(
+      bindableElement,
+      linearElement.startBinding,
+      newSize,
+    );
+    const endBinding = maybeCalculateNewGapWhenScaling(
+      bindableElement,
+      linearElement.endBinding,
+      newSize,
+    );
+    // `linearElement` is being moved/scaled already, just update the binding
+    if (simultaneouslyUpdatedElementIds.has(linearElement.id)) {
+      mutateElement(linearElement, { startBinding, endBinding });
+      return;
+    }
+    updateBoundPoint(
+      linearElement,
+      "start",
+      startBinding,
+      changedElement as ExcalidrawBindableElement,
+    );
+    updateBoundPoint(
+      linearElement,
+      "end",
+      endBinding,
+      changedElement as ExcalidrawBindableElement,
+    );
+  });
 };

 const doesNeedUpdate = (
@@ -415,17 +401,10 @@ const updateBoundPoint = (
      newEdgePoint = intersections[0];
    }
  }
-  LinearElementEditor.movePoints(
+  LinearElementEditor.movePoint(
    linearElement,
-    [
-      {
-        index: edgePointIndex,
-        point: LinearElementEditor.pointFromAbsoluteCoords(
-          linearElement,
-          newEdgePoint,
-        ),
-      },
-    ],
+    edgePointIndex,
+    LinearElementEditor.pointFromAbsoluteCoords(linearElement, newEdgePoint),
    { [startOrEnd === "start" ? "startBinding" : "endBinding"]: binding },
  );
 };
@@ -573,11 +552,11 @@ export const fixBindingsAfterDuplication = (
  const allBindableElementIds: Set<ExcalidrawElement["id"]> = new Set();
  const shouldReverseRoles = duplicatesServeAsOld === "duplicatesServeAsOld";
  oldElements.forEach((oldElement) => {
-    const { boundElements } = oldElement;
-    if (boundElements != null && boundElements.length > 0) {
-      boundElements.forEach((boundElement) => {
-        if (shouldReverseRoles && !oldIdToDuplicatedId.has(boundElement.id)) {
-          allBoundElementIds.add(boundElement.id);
+    const { boundElementIds } = oldElement;
+    if (boundElementIds != null && boundElementIds.length > 0) {
+      boundElementIds.forEach((boundElementId) => {
+        if (shouldReverseRoles && !oldIdToDuplicatedId.has(boundElementId)) {
+          allBoundElementIds.add(boundElementId);
        }
      });
      allBindableElementIds.add(oldIdToDuplicatedId.get(oldElement.id)!);
@@ -621,16 +600,12 @@ export const fixBindingsAfterDuplication = (
  sceneElements
    .filter(({ id }) => allBindableElementIds.has(id))
    .forEach((bindableElement) => {
-      const { boundElements } = bindableElement;
-      if (boundElements != null && boundElements.length > 0) {
+      const { boundElementIds } = bindableElement;
+      if (boundElementIds != null && boundElementIds.length > 0) {
        mutateElement(bindableElement, {
-          boundElements: boundElements.map((boundElement) =>
-            oldIdToDuplicatedId.has(boundElement.id)
-              ? {
-                  id: oldIdToDuplicatedId.get(boundElement.id)!,
-                  type: boundElement.type,
-                }
-              : boundElement,
+          boundElementIds: boundElementIds.map(
+            (boundElementId) =>
+              oldIdToDuplicatedId.get(boundElementId) ?? boundElementId,
          ),
        });
      }
@@ -663,9 +638,9 @@ export const fixBindingsAfterDeletion = (
  const boundElementIds: Set<ExcalidrawElement["id"]> = new Set();
  deletedElements.forEach((deletedElement) => {
    if (isBindableElement(deletedElement)) {
-      deletedElement.boundElements?.forEach((element) => {
-        if (!deletedElementIds.has(element.id)) {
-          boundElementIds.add(element.id);
+      deletedElement.boundElementIds?.forEach((id) => {
+        if (!deletedElementIds.has(id)) {
+          boundElementIds.add(id);
        }
      });
    }
@@ -185,7 +185,7 @@ const getLinearElementAbsoluteCoords = (
      maxY + element.y,
    ];
  } else {
-    const shape = getShapeForElement(element)!;
+    const shape = getShapeForElement(element) as Drawable[];

    // first element is always the curve
    const ops = getCurvePathOps(shape[0]);
@@ -326,7 +326,7 @@ const getLinearElementRotatedBounds = (
    return [minX, minY, maxX, maxY];
  }

-  const shape = getShapeForElement(element)!;
+  const shape = getShapeForElement(element) as Drawable[];

  // first element is always the curve
  const ops = getCurvePathOps(shape[0]);
@@ -520,24 +520,11 @@ export interface Box {
  minY: number;
  maxX: number;
  maxY: number;
-  midX: number;
-  midY: number;
-  width: number;
-  height: number;
 }

 export const getCommonBoundingBox = (
  elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[],
 ): Box => {
  const [minX, minY, maxX, maxY] = getCommonBounds(elements);
-  return {
-    minX,
-    minY,
-    maxX,
-    maxY,
-    width: maxX - minX,
-    height: maxY - minY,
-    midX: (minX + maxX) / 2,
-    midY: (minY + maxY) / 2,
-  };
+  return { minX, minY, maxX, maxY };
 };
@@ -24,7 +24,6 @@ import {
  NonDeleted,
  ExcalidrawFreeDrawElement,
  ExcalidrawImageElement,
-  ExcalidrawLinearElement,
 } from "./types";

 import { getElementAbsoluteCoords, getCurvePathOps, Bounds } from "./bounds";
@@ -32,9 +31,7 @@ import { Point } from "../types";
 import { Drawable } from "roughjs/bin/core";
 import { AppState } from "../types";
 import { getShapeForElement } from "../renderer/renderElement";
-import { hasBoundTextElement, isImageElement } from "./typeChecks";
-import { isTextElement } from ".";
-import { isTransparent } from "../utils";
+import { isImageElement } from "./typeChecks";

 const isElementDraggableFromInside = (
  element: NonDeletedExcalidrawElement,
@@ -46,8 +43,9 @@ const isElementDraggableFromInside = (
  if (element.type === "freedraw") {
    return true;
  }
-  const isDraggableFromInside =
-    !isTransparent(element.backgroundColor) || hasBoundTextElement(element);
+
+  const isDraggableFromInside = element.backgroundColor !== "transparent";
+
  if (element.type === "line") {
    return isDraggableFromInside && isPathALoop(element.points);
  }
@@ -85,18 +83,20 @@ export const isHittingElementBoundingBoxWithoutHittingElement = (
  );
 };

-export const isHittingElementNotConsideringBoundingBox = (
+const isHittingElementNotConsideringBoundingBox = (
  element: NonDeletedExcalidrawElement,
  appState: AppState,
  point: Point,
 ): boolean => {
  const threshold = 10 / appState.zoom.value;

-  const check = isTextElement(element)
-    ? isStrictlyInside
-    : isElementDraggableFromInside(element)
-    ? isInsideCheck
-    : isNearCheck;
+  const check =
+    element.type === "text"
+      ? isStrictlyInside
+      : isElementDraggableFromInside(element)
+      ? isInsideCheck
+      : isNearCheck;
+
  return hitTestPointAgainstElement({ element, point, threshold, check });
 };

@@ -105,7 +105,7 @@ const isElementSelected = (
  element: NonDeleted<ExcalidrawElement>,
 ) => appState.selectedElementIds[element.id];

-export const isPointHittingElementBoundingBox = (
+const isPointHittingElementBoundingBox = (
  element: NonDeleted<ExcalidrawElement>,
  [x, y]: Point,
  threshold: number,
@@ -362,14 +362,6 @@ const hitTestFreeDrawElement = (
    B = element.points[i + 1];
  }

-  const shape = getShapeForElement(element);
-
-  // for filled freedraw shapes, support
-  // selecting from inside
-  if (shape && shape.sets.length) {
-    return hitTestRoughShape(shape, x, y, threshold);
-  }
-
  return false;
 };

@@ -392,11 +384,7 @@ const hitTestLinear = (args: HitTestArgs): boolean => {
  }
  const [relX, relY] = GAPoint.toTuple(point);

-  const shape = getShapeForElement(element as ExcalidrawLinearElement);
-
-  if (!shape) {
-    return false;
-  }
+  const shape = getShapeForElement(element) as Drawable[];

  if (args.check === isInsideCheck) {
    const hit = shape.some((subshape) =>
@@ -834,7 +822,7 @@ const hitTestCurveInside = (
  sharpness: ExcalidrawElement["strokeSharpness"],
 ) => {
  const ops = getCurvePathOps(drawable);
-  const points: Mutable<Point>[] = [];
+  const points: Point[] = [];
  let odd = false; // select one line out of double lines
  for (const operation of ops) {
    if (operation.op === "move") {
@@ -848,17 +836,13 @@ const hitTestCurveInside = (
        points.push([operation.data[2], operation.data[3]]);
        points.push([operation.data[4], operation.data[5]]);
      }
-    } else if (operation.op === "lineTo") {
-      if (odd) {
-        points.push([operation.data[0], operation.data[1]]);
-      }
    }
  }
  if (points.length >= 4) {
    if (sharpness === "sharp") {
      return isPointInPolygon(points, x, y);
    }
-    const polygonPoints = pointsOnBezierCurves(points, 10, 5);
+    const polygonPoints = pointsOnBezierCurves(points as any, 10, 5);
    return isPointInPolygon(polygonPoints, x, y);
  }
  return false;
@@ -913,10 +897,9 @@ const hitTestRoughShape = (
      // position of the previous operation
      return retVal;
    } else if (op === "lineTo") {
-      return hitTestCurveInside(drawable, x, y, "sharp");
+      // TODO: Implement this
    } else if (op === "qcurveTo") {
      // TODO: Implement this
-      console.warn("qcurveTo is not implemented yet");
    }

    return false;
@@ -5,86 +5,45 @@ import { mutateElement } from "./mutateElement";
 import { getPerfectElementSize } from "./sizeHelpers";
 import Scene from "../scene/Scene";
 import { NonDeletedExcalidrawElement } from "./types";
-import { AppState, PointerDownState } from "../types";
-import { getBoundTextElementId } from "./textElement";
-import { isSelectedViaGroup } from "../groups";
+import { PointerDownState } from "../types";

 export const dragSelectedElements = (
  pointerDownState: PointerDownState,
  selectedElements: NonDeletedExcalidrawElement[],
  pointerX: number,
  pointerY: number,
+  scene: Scene,
  lockDirection: boolean = false,
  distanceX: number = 0,
  distanceY: number = 0,
-  appState: AppState,
 ) => {
  const [x1, y1] = getCommonBounds(selectedElements);
  const offset = { x: pointerX - x1, y: pointerY - y1 };
  selectedElements.forEach((element) => {
-    updateElementCoords(
-      lockDirection,
-      distanceX,
-      distanceY,
-      pointerDownState,
-      element,
-      offset,
-    );
-    // update coords of bound text only if we're dragging the container directly
-    // (we don't drag the group that it's part of)
-    if (
-      // container isn't part of any group
-      // (perf optim so we don't check `isSelectedViaGroup()` in every case)
-      !element.groupIds.length ||
-      // container is part of a group, but we're dragging the container directly
-      (appState.editingGroupId && !isSelectedViaGroup(appState, element))
-    ) {
-      const boundTextElementId = getBoundTextElementId(element);
-      if (boundTextElementId) {
-        const textElement =
-          Scene.getScene(element)!.getElement(boundTextElementId);
-        updateElementCoords(
-          lockDirection,
-          distanceX,
-          distanceY,
-          pointerDownState,
-          textElement!,
-          offset,
-        );
-      }
+    let x: number;
+    let y: number;
+    if (lockDirection) {
+      const lockX = lockDirection && distanceX < distanceY;
+      const lockY = lockDirection && distanceX > distanceY;
+      const original = pointerDownState.originalElements.get(element.id);
+      x = lockX && original ? original.x : element.x + offset.x;
+      y = lockY && original ? original.y : element.y + offset.y;
+    } else {
+      x = element.x + offset.x;
+      y = element.y + offset.y;
    }
+
+    mutateElement(element, {
+      x,
+      y,
+    });
+
    updateBoundElements(element, {
      simultaneouslyUpdated: selectedElements,
    });
  });
 };

-const updateElementCoords = (
-  lockDirection: boolean,
-  distanceX: number,
-  distanceY: number,
-  pointerDownState: PointerDownState,
-  element: NonDeletedExcalidrawElement,
-  offset: { x: number; y: number },
-) => {
-  let x: number;
-  let y: number;
-  if (lockDirection) {
-    const lockX = lockDirection && distanceX < distanceY;
-    const lockY = lockDirection && distanceX > distanceY;
-    const original = pointerDownState.originalElements.get(element.id);
-    x = lockX && original ? original.x : element.x + offset.x;
-    y = lockY && original ? original.y : element.y + offset.y;
-  } else {
-    x = element.x + offset.x;
-    y = element.y + offset.y;
-  }
-
-  mutateElement(element, {
-    x,
-    y,
-  });
-};
 export const getDragOffsetXY = (
  selectedElements: NonDeletedExcalidrawElement[],
  x: number,
@@ -3,6 +3,7 @@
 // -----------------------------------------------------------------------------

 import { MIME_TYPES, SVG_NS } from "../constants";
+import { getDataURL } from "../data/blob";
 import { t } from "../i18n";
 import { AppClassProperties, DataURL, BinaryFiles } from "../types";
 import { isInitializedImageElement } from "./typeChecks";
@@ -109,3 +110,81 @@ export const normalizeSVG = async (SVGString: string) => {
    return svg.outerHTML;
  }
 };
+
+/**
+ * To improve perf, uses `createImageBitmap` is available. But there are
+ * quality issues across browsers, so don't use this API where quality matters.
+ */
+export const speedyImageToCanvas = async (imageFile: Blob | File) => {
+  let imageSrc: HTMLImageElement | ImageBitmap;
+  if (
+    typeof ImageBitmap !== "undefined" &&
+    ImageBitmap.prototype &&
+    ImageBitmap.prototype.close &&
+    window.createImageBitmap
+  ) {
+    imageSrc = await window.createImageBitmap(imageFile);
+  } else {
+    imageSrc = await loadHTMLImageElement(await getDataURL(imageFile));
+  }
+  const { width, height } = imageSrc;
+
+  const canvas = document.createElement("canvas");
+  canvas.height = height;
+  canvas.width = width;
+  const context = canvas.getContext("2d")!;
+  context.drawImage(imageSrc, 0, 0, width, height);
+
+  if (typeof ImageBitmap !== "undefined" && imageSrc instanceof ImageBitmap) {
+    imageSrc.close();
+  }
+
+  return { canvas, context, width, height };
+};
+
+/**
+ * Does its best at figuring out if an image (PNG) has any (semi)transparent
+ * pixels. If not PNG, always returns false.
+ */
+export const hasTransparentPixels = async (imageFile: Blob | File) => {
+  if (imageFile.type !== MIME_TYPES.png) {
+    return false;
+  }
+
+  const { findPngChunk, extractPngChunks } = await import("../data/image");
+
+  const buffer = await imageFile.arrayBuffer();
+  const chunks = extractPngChunks(new Uint8Array(buffer));
+
+  // early exit if tRNS not found and IHDR states no support for alpha
+  // -----------------------------------------------------------------------
+
+  const IHDR = findPngChunk(chunks, "IHDR");
+
+  if (
+    IHDR &&
+    IHDR.data[9] !== 4 &&
+    IHDR.data[9] !== 6 &&
+    !findPngChunk(chunks, "tRNS")
+  ) {
+    return false;
+  }
+
+  // otherwise loop through pixels to check if there's any actually
+  // (semi)transparent pixel
+  // -----------------------------------------------------------------------
+
+  const { width, height, context } = await speedyImageToCanvas(imageFile);
+  {
+    const { data } = context.getImageData(0, 0, width, height);
+    const len = data.byteLength;
+    let i = 3;
+    while (i <= len) {
+      if (data[i] !== 255) {
+        return true;
+      }
+      i += 4;
+    }
+  }
+  return false;
+};
@@ -59,6 +59,15 @@ export {
 } from "./sizeHelpers";
 export { showSelectedShapeActions } from "./showSelectedShapeActions";

+export const getElementMap = (elements: readonly ExcalidrawElement[]) =>
+  elements.reduce(
+    (acc: { [key: string]: ExcalidrawElement }, element: ExcalidrawElement) => {
+      acc[element.id] = element;
+      return acc;
+    },
+    {},
+  );
+
 export const getSceneVersion = (elements: readonly ExcalidrawElement[]) =>
  elements.reduce((acc, el) => acc + el.version, 0);

@@ -25,19 +25,11 @@ export class LinearElementEditor {
  public elementId: ExcalidrawElement["id"] & {
    _brand: "excalidrawLinearElementId";
  };
-  /** indices */
-  public selectedPointsIndices: readonly number[] | null;
-
-  public pointerDownState: Readonly<{
-    prevSelectedPointsIndices: readonly number[] | null;
-    /** index */
-    lastClickedPoint: number;
-  }>;
-
+  public activePointIndex: number | null;
  /** whether you're dragging a point */
  public isDragging: boolean;
  public lastUncommittedPoint: Point | null;
-  public pointerOffset: Readonly<{ x: number; y: number }>;
+  public pointerOffset: { x: number; y: number };
  public startBindingElement: ExcalidrawBindableElement | null | "keep";
  public endBindingElement: ExcalidrawBindableElement | null | "keep";

@@ -48,16 +40,12 @@ export class LinearElementEditor {
    Scene.mapElementToScene(this.elementId, scene);
    LinearElementEditor.normalizePoints(element);

-    this.selectedPointsIndices = null;
+    this.activePointIndex = null;
    this.lastUncommittedPoint = null;
    this.isDragging = false;
    this.pointerOffset = { x: 0, y: 0 };
    this.startBindingElement = "keep";
    this.endBindingElement = "keep";
-    this.pointerDownState = {
-      prevSelectedPointsIndices: null,
-      lastClickedPoint: -1,
-    };
  }

  // ---------------------------------------------------------------------------
@@ -78,58 +66,6 @@ export class LinearElementEditor {
    return null;
  }

-  static handleBoxSelection(
-    event: PointerEvent,
-    appState: AppState,
-    setState: React.Component<any, AppState>["setState"],
-  ) {
-    if (
-      !appState.editingLinearElement ||
-      appState.draggingElement?.type !== "selection"
-    ) {
-      return false;
-    }
-    const { editingLinearElement } = appState;
-    const { selectedPointsIndices, elementId } = editingLinearElement;
-
-    const element = LinearElementEditor.getElement(elementId);
-    if (!element) {
-      return false;
-    }
-
-    const [selectionX1, selectionY1, selectionX2, selectionY2] =
-      getElementAbsoluteCoords(appState.draggingElement);
-
-    const pointsSceneCoords =
-      LinearElementEditor.getPointsGlobalCoordinates(element);
-
-    const nextSelectedPoints = pointsSceneCoords.reduce(
-      (acc: number[], point, index) => {
-        if (
-          (point[0] >= selectionX1 &&
-            point[0] <= selectionX2 &&
-            point[1] >= selectionY1 &&
-            point[1] <= selectionY2) ||
-          (event.shiftKey && selectedPointsIndices?.includes(index))
-        ) {
-          acc.push(index);
-        }
-
-        return acc;
-      },
-      [],
-    );
-
-    setState({
-      editingLinearElement: {
-        ...editingLinearElement,
-        selectedPointsIndices: nextSelectedPoints.length
-          ? nextSelectedPoints
-          : null,
-      },
-    });
-  }
-
  /** @returns whether point was dragged */
  static handlePointDragging(
    appState: AppState,
@@ -138,27 +74,21 @@ export class LinearElementEditor {
    scenePointerY: number,
    maybeSuggestBinding: (
      element: NonDeleted<ExcalidrawLinearElement>,
-      pointSceneCoords: { x: number; y: number }[],
+      startOrEnd: "start" | "end",
    ) => void,
  ): boolean {
    if (!appState.editingLinearElement) {
      return false;
    }
    const { editingLinearElement } = appState;
-    const { selectedPointsIndices, elementId, isDragging } =
-      editingLinearElement;
+    const { activePointIndex, elementId, isDragging } = editingLinearElement;

    const element = LinearElementEditor.getElement(elementId);
    if (!element) {
      return false;
    }

-    // point that's being dragged (out of all selected points)
-    const draggingPoint = element.points[
-      editingLinearElement.pointerDownState.lastClickedPoint
-    ] as [number, number] | undefined;
-
-    if (selectedPointsIndices && draggingPoint) {
+    if (activePointIndex != null && activePointIndex > -1) {
      if (isDragging === false) {
        setState({
          editingLinearElement: {
@@ -168,79 +98,18 @@ export class LinearElementEditor {
        });
      }

-      const newDraggingPointPosition = LinearElementEditor.createPointAt(
+      const newPoint = LinearElementEditor.createPointAt(
        element,
        scenePointerX - editingLinearElement.pointerOffset.x,
        scenePointerY - editingLinearElement.pointerOffset.y,
        appState.gridSize,
      );
-
-      const deltaX = newDraggingPointPosition[0] - draggingPoint[0];
-      const deltaY = newDraggingPointPosition[1] - draggingPoint[1];
-
-      LinearElementEditor.movePoints(
-        element,
-        selectedPointsIndices.map((pointIndex) => {
-          const newPointPosition =
-            pointIndex ===
-            editingLinearElement.pointerDownState.lastClickedPoint
-              ? LinearElementEditor.createPointAt(
-                  element,
-                  scenePointerX - editingLinearElement.pointerOffset.x,
-                  scenePointerY - editingLinearElement.pointerOffset.y,
-                  appState.gridSize,
-                )
-              : ([
-                  element.points[pointIndex][0] + deltaX,
-                  element.points[pointIndex][1] + deltaY,
-                ] as const);
-          return {
-            index: pointIndex,
-            point: newPointPosition,
-            isDragging:
-              pointIndex ===
-              editingLinearElement.pointerDownState.lastClickedPoint,
-          };
-        }),
-      );
-
-      // suggest bindings for first and last point if selected
+      LinearElementEditor.movePoint(element, activePointIndex, newPoint);
      if (isBindingElement(element)) {
-        const coords: { x: number; y: number }[] = [];
-
-        const firstSelectedIndex = selectedPointsIndices[0];
-        if (firstSelectedIndex === 0) {
-          coords.push(
-            tupleToCoors(
-              LinearElementEditor.getPointGlobalCoordinates(
-                element,
-                element.points[0],
-              ),
-            ),
-          );
-        }
-
-        const lastSelectedIndex =
-          selectedPointsIndices[selectedPointsIndices.length - 1];
-        if (lastSelectedIndex === element.points.length - 1) {
-          coords.push(
-            tupleToCoors(
-              LinearElementEditor.getPointGlobalCoordinates(
-                element,
-                element.points[lastSelectedIndex],
-              ),
-            ),
-          );
-        }
-
-        if (coords.length) {
-          maybeSuggestBinding(element, coords);
-        }
+        maybeSuggestBinding(element, activePointIndex === 0 ? "start" : "end");
      }
-
      return true;
    }
-
    return false;
  }

@@ -249,79 +118,45 @@ export class LinearElementEditor {
    editingLinearElement: LinearElementEditor,
    appState: AppState,
  ): LinearElementEditor {
-    const { elementId, selectedPointsIndices, isDragging, pointerDownState } =
-      editingLinearElement;
+    const { elementId, activePointIndex, isDragging } = editingLinearElement;
    const element = LinearElementEditor.getElement(elementId);
    if (!element) {
      return editingLinearElement;
    }

-    const bindings: Partial<
-      Pick<
-        InstanceType<typeof LinearElementEditor>,
-        "startBindingElement" | "endBindingElement"
-      >
-    > = {};
-
-    if (isDragging && selectedPointsIndices) {
-      for (const selectedPoint of selectedPointsIndices) {
-        if (
-          selectedPoint === 0 ||
-          selectedPoint === element.points.length - 1
-        ) {
-          if (isPathALoop(element.points, appState.zoom.value)) {
-            LinearElementEditor.movePoints(element, [
-              {
-                index: selectedPoint,
-                point:
-                  selectedPoint === 0
-                    ? element.points[element.points.length - 1]
-                    : element.points[0],
-              },
-            ]);
-          }
-
-          const bindingElement = isBindingEnabled(appState)
-            ? getHoveredElementForBinding(
-                tupleToCoors(
-                  LinearElementEditor.getPointAtIndexGlobalCoordinates(
-                    element,
-                    selectedPoint!,
-                  ),
-                ),
-                Scene.getScene(element)!,
-              )
-            : null;
-
-          bindings[
-            selectedPoint === 0 ? "startBindingElement" : "endBindingElement"
-          ] = bindingElement;
-        }
+    let binding = {};
+    if (
+      isDragging &&
+      (activePointIndex === 0 || activePointIndex === element.points.length - 1)
+    ) {
+      if (isPathALoop(element.points, appState.zoom.value)) {
+        LinearElementEditor.movePoint(
+          element,
+          activePointIndex,
+          activePointIndex === 0
+            ? element.points[element.points.length - 1]
+            : element.points[0],
+        );
      }
+      const bindingElement = isBindingEnabled(appState)
+        ? getHoveredElementForBinding(
+            tupleToCoors(
+              LinearElementEditor.getPointAtIndexGlobalCoordinates(
+                element,
+                activePointIndex!,
+              ),
+            ),
+            Scene.getScene(element)!,
+          )
+        : null;
+      binding = {
+        [activePointIndex === 0 ? "startBindingElement" : "endBindingElement"]:
+          bindingElement,
+      };
    }
-
    return {
      ...editingLinearElement,
-      ...bindings,
-      // if clicking without previously dragging a point(s), and not holding
-      // shift, deselect all points except the one clicked. If holding shift,
-      // toggle the point.
-      selectedPointsIndices:
-        isDragging || event.shiftKey
-          ? !isDragging &&
-            event.shiftKey &&
-            pointerDownState.prevSelectedPointsIndices?.includes(
-              pointerDownState.lastClickedPoint,
-            )
-            ? selectedPointsIndices &&
-              selectedPointsIndices.filter(
-                (pointIndex) =>
-                  pointIndex !== pointerDownState.lastClickedPoint,
-              )
-            : selectedPointsIndices
-          : selectedPointsIndices?.includes(pointerDownState.lastClickedPoint)
-          ? [pointerDownState.lastClickedPoint]
-          : selectedPointsIndices,
+      ...binding,
      isDragging: false,
      pointerOffset: { x: 0, y: 0 },
    };
@@ -371,12 +206,7 @@ export class LinearElementEditor {
      setState({
        editingLinearElement: {
          ...appState.editingLinearElement,
-          pointerDownState: {
-            prevSelectedPointsIndices:
-              appState.editingLinearElement.selectedPointsIndices,
-            lastClickedPoint: -1,
-          },
-          selectedPointsIndices: [element.points.length - 1],
+          activePointIndex: element.points.length - 1,
          lastUncommittedPoint: null,
          endBindingElement: getHoveredElementForBinding(
            scenePointer,
@@ -429,28 +259,10 @@ export class LinearElementEditor {
        element.angle,
      );

-    const nextSelectedPointsIndices =
-      clickedPointIndex > -1 || event.shiftKey
-        ? event.shiftKey ||
-          appState.editingLinearElement.selectedPointsIndices?.includes(
-            clickedPointIndex,
-          )
-          ? normalizeSelectedPoints([
-              ...(appState.editingLinearElement.selectedPointsIndices || []),
-              clickedPointIndex,
-            ])
-          : [clickedPointIndex]
-        : null;
-
    setState({
      editingLinearElement: {
        ...appState.editingLinearElement,
-        pointerDownState: {
-          prevSelectedPointsIndices:
-            appState.editingLinearElement.selectedPointsIndices,
-          lastClickedPoint: clickedPointIndex,
-        },
-        selectedPointsIndices: nextSelectedPointsIndices,
+        activePointIndex: clickedPointIndex > -1 ? clickedPointIndex : null,
        pointerOffset: targetPoint
          ? {
              x: scenePointer.x - targetPoint[0],
@@ -480,7 +292,7 @@ export class LinearElementEditor {

    if (!event.altKey) {
      if (lastPoint === lastUncommittedPoint) {
-        LinearElementEditor.deletePoints(element, [points.length - 1]);
+        LinearElementEditor.movePoint(element, points.length - 1, "delete");
      }
      return { ...editingLinearElement, lastUncommittedPoint: null };
    }
@@ -493,14 +305,13 @@ export class LinearElementEditor {
    );

    if (lastPoint === lastUncommittedPoint) {
-      LinearElementEditor.movePoints(element, [
-        {
-          index: element.points.length - 1,
-          point: newPoint,
-        },
-      ]);
+      LinearElementEditor.movePoint(
+        element,
+        element.points.length - 1,
+        newPoint,
+      );
    } else {
-      LinearElementEditor.addPoints(element, [{ point: newPoint }]);
+      LinearElementEditor.movePoint(element, "new", newPoint);
    }

    return {
@@ -509,21 +320,6 @@ export class LinearElementEditor {
    };
  }

-  /** scene coords */
-  static getPointGlobalCoordinates(
-    element: NonDeleted<ExcalidrawLinearElement>,
-    point: Point,
-  ) {
-    const [x1, y1, x2, y2] = getElementAbsoluteCoords(element);
-    const cx = (x1 + x2) / 2;
-    const cy = (y1 + y2) / 2;
-
-    let { x, y } = element;
-    [x, y] = rotate(x + point[0], y + point[1], cx, cy, element.angle);
-    return [x, y] as const;
-  }
-
-  /** scene coords */
  static getPointsGlobalCoordinates(
    element: NonDeleted<ExcalidrawLinearElement>,
  ) {
@@ -643,122 +439,22 @@ export class LinearElementEditor {
    mutateElement(element, LinearElementEditor.getNormalizedPoints(element));
  }

-  static duplicateSelectedPoints(appState: AppState) {
-    if (!appState.editingLinearElement) {
-      return false;
-    }
-
-    const { selectedPointsIndices, elementId } = appState.editingLinearElement;
-
-    const element = LinearElementEditor.getElement(elementId);
-
-    if (!element || selectedPointsIndices === null) {
-      return false;
-    }
-
-    const { points } = element;
-
-    const nextSelectedIndices: number[] = [];
-
-    let pointAddedToEnd = false;
-    let indexCursor = -1;
-    const nextPoints = points.reduce((acc: Point[], point, index) => {
-      ++indexCursor;
-      acc.push(point);
-
-      const isSelected = selectedPointsIndices.includes(index);
-      if (isSelected) {
-        const nextPoint = points[index + 1];
-
-        if (!nextPoint) {
-          pointAddedToEnd = true;
-        }
-        acc.push(
-          nextPoint
-            ? [(point[0] + nextPoint[0]) / 2, (point[1] + nextPoint[1]) / 2]
-            : [point[0], point[1]],
-        );
-
-        nextSelectedIndices.push(indexCursor + 1);
-        ++indexCursor;
-      }
-
-      return acc;
-    }, []);
-
-    mutateElement(element, { points: nextPoints });
-
-    // temp hack to ensure the line doesn't move when adding point to the end,
-    // potentially expanding the bounding box
-    if (pointAddedToEnd) {
-      const lastPoint = element.points[element.points.length - 1];
-      LinearElementEditor.movePoints(element, [
-        {
-          index: element.points.length - 1,
-          point: [lastPoint[0] + 30, lastPoint[1] + 30],
-        },
-      ]);
-    }
-
-    return {
-      appState: {
-        ...appState,
-        editingLinearElement: {
-          ...appState.editingLinearElement,
-          selectedPointsIndices: nextSelectedIndices,
-        },
-      },
-    };
-  }
-
-  static deletePoints(
+  static movePointByOffset(
    element: NonDeleted<ExcalidrawLinearElement>,
-    pointIndices: readonly number[],
+    pointIndex: number,
+    offset: { x: number; y: number },
  ) {
-    let offsetX = 0;
-    let offsetY = 0;
-
-    const isDeletingOriginPoint = pointIndices.includes(0);
-
-    // if deleting first point, make the next to be [0,0] and recalculate
-    // positions of the rest with respect to it
-    if (isDeletingOriginPoint) {
-      const firstNonDeletedPoint = element.points.find((point, idx) => {
-        return !pointIndices.includes(idx);
-      });
-      if (firstNonDeletedPoint) {
-        offsetX = firstNonDeletedPoint[0];
-        offsetY = firstNonDeletedPoint[1];
-      }
-    }
-
-    const nextPoints = element.points.reduce((acc: Point[], point, idx) => {
-      if (!pointIndices.includes(idx)) {
-        acc.push(
-          !acc.length ? [0, 0] : [point[0] - offsetX, point[1] - offsetY],
-        );
-      }
-      return acc;
-    }, []);
-
-    LinearElementEditor._updatePoints(element, nextPoints, offsetX, offsetY);
+    const [x, y] = element.points[pointIndex];
+    LinearElementEditor.movePoint(element, pointIndex, [
+      x + offset.x,
+      y + offset.y,
+    ]);
  }

-  static addPoints(
+  static movePoint(
    element: NonDeleted<ExcalidrawLinearElement>,
-    targetPoints: { point: Point }[],
-  ) {
-    const offsetX = 0;
-    const offsetY = 0;
-
-    const nextPoints = [...element.points, ...targetPoints.map((x) => x.point)];
-
-    LinearElementEditor._updatePoints(element, nextPoints, offsetX, offsetY);
-  }
-
-  static movePoints(
-    element: NonDeleted<ExcalidrawLinearElement>,
-    targetPoints: { index: number; point: Point; isDragging?: boolean }[],
+    pointIndex: number | "new",
+    targetPosition: Point | "delete",
    otherUpdates?: { startBinding?: PointBinding; endBinding?: PointBinding },
  ) {
    const { points } = element;
@@ -771,50 +467,49 @@ export class LinearElementEditor {
    let offsetX = 0;
    let offsetY = 0;

-    const selectedOriginPoint = targetPoints.find(({ index }) => index === 0);
+    let nextPoints: (readonly [number, number])[];
+    if (targetPosition === "delete") {
+      // remove point
+      if (pointIndex === "new") {
+        throw new Error("invalid args in movePoint");
+      }
+      nextPoints = points.slice();
+      nextPoints.splice(pointIndex, 1);
+      if (pointIndex === 0) {
+        // if deleting first point, make the next to be [0,0] and recalculate
+        // positions of the rest with respect to it
+        offsetX = nextPoints[0][0];
+        offsetY = nextPoints[0][1];
+        nextPoints = nextPoints.map((point, idx) => {
+          if (idx === 0) {
+            return [0, 0];
+          }
+          return [point[0] - offsetX, point[1] - offsetY];
+        });
+      }
+    } else if (pointIndex === "new") {
+      nextPoints = [...points, targetPosition];
+    } else {
+      const deltaX = targetPosition[0] - points[pointIndex][0];
+      const deltaY = targetPosition[1] - points[pointIndex][1];
+      nextPoints = points.map((point, idx) => {
+        if (idx === pointIndex) {
+          if (idx === 0) {
+            offsetX = deltaX;
+            offsetY = deltaY;
+            return point;
+          }
+          offsetX = 0;
+          offsetY = 0;

-    if (selectedOriginPoint) {
-      offsetX =
-        selectedOriginPoint.point[0] - points[selectedOriginPoint.index][0];
-      offsetY =
-        selectedOriginPoint.point[1] - points[selectedOriginPoint.index][1];
+          return [point[0] + deltaX, point[1] + deltaY] as const;
+        }
+        return offsetX || offsetY
+          ? ([point[0] - offsetX, point[1] - offsetY] as const)
+          : point;
+      });
    }

-    const nextPoints = points.map((point, idx) => {
-      const selectedPointData = targetPoints.find((p) => p.index === idx);
-      if (selectedPointData) {
-        if (selectedOriginPoint) {
-          return point;
-        }
-
-        const deltaX =
-          selectedPointData.point[0] - points[selectedPointData.index][0];
-        const deltaY =
-          selectedPointData.point[1] - points[selectedPointData.index][1];
-
-        return [point[0] + deltaX, point[1] + deltaY] as const;
-      }
-      return offsetX || offsetY
-        ? ([point[0] - offsetX, point[1] - offsetY] as const)
-        : point;
-    });
-
-    LinearElementEditor._updatePoints(
-      element,
-      nextPoints,
-      offsetX,
-      offsetY,
-      otherUpdates,
-    );
-  }
-
-  private static _updatePoints(
-    element: NonDeleted<ExcalidrawLinearElement>,
-    nextPoints: readonly Point[],
-    offsetX: number,
-    offsetY: number,
-    otherUpdates?: { startBinding?: PointBinding; endBinding?: PointBinding },
-  ) {
    const nextCoords = getElementPointsCoords(
      element,
      nextPoints,
@@ -822,7 +517,7 @@ export class LinearElementEditor {
    );
    const prevCoords = getElementPointsCoords(
      element,
-      element.points,
+      points,
      element.strokeSharpness || "round",
    );
    const nextCenterX = (nextCoords[0] + nextCoords[2]) / 2;
@@ -841,13 +536,3 @@ export class LinearElementEditor {
    });
  }
 }
-
-const normalizeSelectedPoints = (
-  points: (number | null)[],
-): number[] | null => {
-  let nextPoints = [
-    ...new Set(points.filter((p) => p !== null && p !== -1)),
-  ] as number[];
-  nextPoints = nextPoints.sort((a, b) => a - b);
-  return nextPoints.length ? nextPoints : null;
-};
@@ -4,7 +4,6 @@ import Scene from "../scene/Scene";
 import { getSizeFromPoints } from "../points";
 import { randomInteger } from "../random";
 import { Point } from "../types";
-import { getUpdatedTimestamp } from "../utils";

 type ElementUpdate<TElement extends ExcalidrawElement> = Omit<
  Partial<TElement>,
@@ -93,7 +92,6 @@ export const mutateElement = <TElement extends Mutable<ExcalidrawElement>>(

  element.version++;
  element.versionNonce = randomInteger();
-  element.updated = getUpdatedTimestamp();

  if (informMutation) {
    Scene.getScene(element)?.informMutation();
@@ -128,14 +126,13 @@ export const newElementWith = <TElement extends ExcalidrawElement>(
  return {
    ...element,
    ...updates,
-    updated: getUpdatedTimestamp(),
    version: element.version + 1,
    versionNonce: randomInteger(),
  };
 };

 /**
- * Mutates element, bumping `version`, `versionNonce`, and `updated`.
+ * Mutates element and updates `version` & `versionNonce`.
 *
 * NOTE: does not trigger re-render.
 */
@@ -145,6 +142,5 @@ export const bumpVersion = (
 ) => {
  element.version = (version ?? element.version) + 1;
  element.versionNonce = randomInteger();
-  element.updated = getUpdatedTimestamp();
  return element;
 };
@@ -11,31 +11,26 @@ import {
  Arrowhead,
  ExcalidrawFreeDrawElement,
  FontFamilyValues,
-  ExcalidrawRectangleElement,
 } from "../element/types";
-import { getFontString, getUpdatedTimestamp, isTestEnv } from "../utils";
+import { measureText, getFontString } from "../utils";
 import { randomInteger, randomId } from "../random";
-import { mutateElement, newElementWith } from "./mutateElement";
+import { newElementWith } from "./mutateElement";
 import { getNewGroupIdsForDuplication } from "../groups";
 import { AppState } from "../types";
 import { getElementAbsoluteCoords } from ".";
 import { adjustXYWithRotation } from "../math";
 import { getResizedElementAbsoluteCoords } from "./bounds";
-import { getContainerElement, measureText, wrapText } from "./textElement";
-import { isBoundToContainer } from "./typeChecks";
-import { BOUND_TEXT_PADDING } from "../constants";

 type ElementConstructorOpts = MarkOptional<
-  Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">,
+  Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted">,
  | "width"
  | "height"
  | "angle"
  | "groupIds"
-  | "boundElements"
+  | "boundElementIds"
  | "seed"
  | "version"
  | "versionNonce"
-  | "link"
 >;

 const _newElementBase = <T extends ExcalidrawElement>(
@@ -55,38 +50,32 @@ const _newElementBase = <T extends ExcalidrawElement>(
    angle = 0,
    groupIds = [],
    strokeSharpness,
-    boundElements = null,
-    link = null,
+    boundElementIds = null,
    ...rest
  }: ElementConstructorOpts & Omit<Partial<ExcalidrawGenericElement>, "type">,
-) => {
-  const element = {
-    id: rest.id || randomId(),
-    type,
-    x,
-    y,
-    width,
-    height,
-    angle,
-    strokeColor,
-    backgroundColor,
-    fillStyle,
-    strokeWidth,
-    strokeStyle,
-    roughness,
-    opacity,
-    groupIds,
-    strokeSharpness,
-    seed: rest.seed ?? randomInteger(),
-    version: rest.version || 1,
-    versionNonce: rest.versionNonce ?? 0,
-    isDeleted: false as false,
-    boundElements,
-    updated: getUpdatedTimestamp(),
-    link,
-  };
-  return element;
-};
+) => ({
+  id: rest.id || randomId(),
+  type,
+  x,
+  y,
+  width,
+  height,
+  angle,
+  strokeColor,
+  backgroundColor,
+  fillStyle,
+  strokeWidth,
+  strokeStyle,
+  roughness,
+  opacity,
+  groupIds,
+  strokeSharpness,
+  seed: rest.seed ?? randomInteger(),
+  version: rest.version || 1,
+  versionNonce: rest.versionNonce ?? 0,
+  isDeleted: false as false,
+  boundElementIds,
+});

 export const newElement = (
  opts: {
@@ -124,7 +113,6 @@ export const newTextElement = (
    fontFamily: FontFamilyValues;
    textAlign: TextAlign;
    verticalAlign: VerticalAlign;
-    containerId?: ExcalidrawRectangleElement["id"];
  } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawTextElement> => {
  const metrics = measureText(opts.text, getFontString(opts));
@@ -142,8 +130,6 @@ export const newTextElement = (
      width: metrics.width,
      height: metrics.height,
      baseline: metrics.baseline,
-      containerId: opts.containerId || null,
-      originalText: opts.text,
    },
    {},
  );
@@ -160,29 +146,18 @@ const getAdjustedDimensions = (
  height: number;
  baseline: number;
 } => {
-  let maxWidth = null;
-  const container = getContainerElement(element);
-  if (container) {
-    maxWidth = container.width - BOUND_TEXT_PADDING * 2;
-  }
  const {
    width: nextWidth,
    height: nextHeight,
    baseline: nextBaseline,
-  } = measureText(nextText, getFontString(element), maxWidth);
+  } = measureText(nextText, getFontString(element));
  const { textAlign, verticalAlign } = element;
+
  let x: number;
  let y: number;
-  if (
-    textAlign === "center" &&
-    verticalAlign === "middle" &&
-    !element.containerId
-  ) {
-    const prevMetrics = measureText(
-      element.text,
-      getFontString(element),
-      maxWidth,
-    );
+
+  if (textAlign === "center" && verticalAlign === "middle") {
+    const prevMetrics = measureText(element.text, getFontString(element));
    const offsets = getTextElementPositionOffsets(element, {
      width: nextWidth - prevMetrics.width,
      height: nextHeight - prevMetrics.height,
@@ -219,22 +194,6 @@ const getAdjustedDimensions = (
    );
  }

-  // make sure container dimensions are set properly when
-  // text editor overflows beyond viewport dimensions
-  if (isBoundToContainer(element)) {
-    const container = getContainerElement(element)!;
-    let height = container.height;
-    let width = container.width;
-    if (nextHeight > height - BOUND_TEXT_PADDING * 2) {
-      height = nextHeight + BOUND_TEXT_PADDING * 2;
-    }
-    if (nextWidth > width - BOUND_TEXT_PADDING * 2) {
-      width = nextWidth + BOUND_TEXT_PADDING * 2;
-    }
-    if (height !== container.height || width !== container.width) {
-      mutateElement(container, { height, width });
-    }
-  }
  return {
    width: nextWidth,
    height: nextHeight,
@@ -246,26 +205,12 @@ const getAdjustedDimensions = (

 export const updateTextElement = (
  element: ExcalidrawTextElement,
-  {
-    text,
-    isDeleted,
-    originalText,
-  }: {
-    text: string;
-    isDeleted?: boolean;
-    originalText: string;
-  },
+  { text, isDeleted }: { text: string; isDeleted?: boolean },
 ): ExcalidrawTextElement => {
-  const container = getContainerElement(element);
-  if (container) {
-    text = wrapText(text, getFontString(element), container.width);
-  }
-  const dimensions = getAdjustedDimensions(element, text);
  return newElementWith(element, {
    text,
-    originalText,
    isDeleted: isDeleted ?? element.isDeleted,
-    ...dimensions,
+    ...getAdjustedDimensions(element, text),
  });
 };

@@ -379,7 +324,7 @@ export const duplicateElement = <TElement extends Mutable<ExcalidrawElement>>(
  overrides?: Partial<TElement>,
 ): TElement => {
  let copy: TElement = deepCopyElement(element);
-  if (isTestEnv()) {
+  if (process.env.NODE_ENV === "test") {
    copy.id = `${copy.id}_copy`;
    // `window.h` may not be defined in some unit tests
    if (
@@ -392,7 +337,6 @@ export const duplicateElement = <TElement extends Mutable<ExcalidrawElement>>(
  } else {
    copy.id = randomId();
  }
-  copy.updated = getUpdatedTimestamp();
  copy.seed = randomInteger();
  copy.groupIds = getNewGroupIdsForDuplication(
    copy.groupIds,
@@ -25,7 +25,7 @@ import {
 } from "./typeChecks";
 import { mutateElement } from "./mutateElement";
 import { getPerfectElementSize } from "./sizeHelpers";
-import { getFontString } from "../utils";
+import { measureText, getFontString } from "../utils";
 import { updateBoundElements } from "./binding";
 import {
  TransformHandleType,
@@ -33,14 +33,6 @@ import {
  TransformHandleDirection,
 } from "./transformHandles";
 import { Point, PointerDownState } from "../types";
-import Scene from "../scene/Scene";
-import {
-  getApproxMinLineWidth,
-  getBoundTextElement,
-  getBoundTextElementId,
-  handleBindTextResize,
-  measureText,
-} from "./textElement";

 export const normalizeAngle = (angle: number): number => {
  if (angle >= 2 * Math.PI) {
@@ -140,7 +132,6 @@ export const transformElements = (
        pointerX,
        pointerY,
      );
-      handleBindTextResize(selectedElements, transformHandleType);
      return true;
    }
  }
@@ -163,11 +154,6 @@ const rotateSingleElement = (
  }
  angle = normalizeAngle(angle);
  mutateElement(element, { angle });
-  const boundTextElementId = getBoundTextElementId(element);
-  if (boundTextElementId) {
-    const textElement = Scene.getScene(element)!.getElement(boundTextElementId);
-    mutateElement(textElement!, { angle });
-  }
 };

 // used in DEV only
@@ -286,7 +272,6 @@ const measureFontSizeFromWH = (
  const metrics = measureText(
    element.text,
    getFontString({ fontSize: nextFontSize, fontFamily: element.fontFamily }),
-    element.containerId ? element.width : null,
  );
  return {
    size: nextFontSize,
@@ -428,9 +413,6 @@ export const resizeSingleElement = (
    element.width,
    element.height,
  );
-
-  const boundTextElementId = getBoundTextElementId(element);
-
  const boundsCurrentWidth = esx2 - esx1;
  const boundsCurrentHeight = esy2 - esy1;

@@ -491,11 +473,6 @@ export const resizeSingleElement = (
  const newBoundsWidth = newBoundsX2 - newBoundsX1;
  const newBoundsHeight = newBoundsY2 - newBoundsY1;

-  // don't allow resize to negative dimensions when text is bounded to container
-  if ((newBoundsWidth < 0 || newBoundsHeight < 0) && boundTextElementId) {
-    return;
-  }
-
  // Calculate new topLeft based on fixed corner during resize
  let newTopLeft = [...startTopLeft] as [number, number];
  if (["n", "w", "nw"].includes(transformHandleDirection)) {
@@ -588,13 +565,9 @@ export const resizeSingleElement = (
      ],
    });
  }
-  let minWidth = 0;
-  const boundTextElement = getBoundTextElement(element);
-  if (boundTextElement) {
-    minWidth = getApproxMinLineWidth(getFontString(boundTextElement));
-  }
+
  if (
-    resizedElement.width >= minWidth &&
+    resizedElement.width !== 0 &&
    resizedElement.height !== 0 &&
    Number.isFinite(resizedElement.x) &&
    Number.isFinite(resizedElement.y)
@@ -603,7 +576,6 @@ export const resizeSingleElement = (
      newSize: { width: resizedElement.width, height: resizedElement.height },
    });
    mutateElement(element, resizedElement);
-    handleBindTextResize([element], transformHandleDirection);
  }
 };

@@ -675,7 +647,7 @@ const resizeMultipleElements = (
        const width = element.width * scale;
        const height = element.height * scale;
        let font: { fontSize?: number; baseline?: number } = {};
-        if (isTextElement(element)) {
+        if (element.type === "text") {
          const nextFont = measureFontSizeFromWH(element, width, height);
          if (nextFont === null) {
            return null;
@@ -756,16 +728,6 @@ const rotateMultipleElements = (
      y: element.y + (rotatedCY - cy),
      angle: normalizeAngle(centerAngle + origAngle),
    });
-    const boundTextElementId = getBoundTextElementId(element);
-    if (boundTextElementId) {
-      const textElement =
-        Scene.getScene(element)!.getElement(boundTextElementId)!;
-      mutateElement(textElement, {
-        x: textElement.x + (rotatedCX - cx),
-        y: textElement.y + (rotatedCY - cy),
-        angle: normalizeAngle(centerAngle + origAngle),
-      });
-    }
  });
 };

@@ -1,140 +0,0 @@
-import { wrapText } from "./textElement";
-import { FontString } from "./types";
-
-describe("Test wrapText", () => {
-  const font = "20px Cascadia, width: Segoe UI Emoji" as FontString;
-
-  describe("When text doesn't contain new lines", () => {
-    const text = "Hello whats up";
-    [
-      {
-        desc: "break all words when width of each word is less than container width",
-        width: 90,
-        res: `Hello 
-whats 
-up`,
-      },
-      {
-        desc: "break all characters when width of each character is less than container width",
-        width: 25,
-        res: `H
-e
-l
-l
-o
-w
-h
-a
-t
-s
-u
-p`,
-      },
-      {
-        desc: "break words as per the width",
-
-        width: 150,
-        res: `Hello whats 
-up`,
-      },
-      {
-        desc: "fit the container",
-
-        width: 250,
-        res: "Hello whats up",
-      },
-    ].forEach((data) => {
-      it(`should ${data.desc}`, () => {
-        const res = wrapText(text, font, data.width);
-        expect(res).toEqual(data.res);
-      });
-    });
-  });
-  describe("When text contain new lines", () => {
-    const text = `Hello
-whats up`;
-    [
-      {
-        desc: "break all words when width of each word is less than container width",
-        width: 90,
-        res: `Hello
-whats 
-up`,
-      },
-      {
-        desc: "break all characters when width of each character is less than container width",
-        width: 25,
-        res: `H
-e
-l
-l
-o
-w
-h
-a
-t
-s
-u
-p`,
-      },
-      {
-        desc: "break words as per the width",
-
-        width: 150,
-        res: `Hello
-whats up`,
-      },
-      {
-        desc: "fit the container",
-
-        width: 250,
-        res: `Hello
-whats up`,
-      },
-    ].forEach((data) => {
-      it(`should respect new lines and ${data.desc}`, () => {
-        const res = wrapText(text, font, data.width);
-        expect(res).toEqual(data.res);
-      });
-    });
-  });
-  describe("When text is long", () => {
-    const text = `hellolongtextthisiswhatsupwithyouIamtypingggggandtypinggg break it now`;
-    [
-      {
-        desc: "fit characters of long string as per container width",
-        width: 170,
-        res: `hellolongtextth
-isiswhatsupwith
-youIamtypingggg
-gandtypinggg 
-break it now`,
-      },
-
-      {
-        desc: "fit characters of long string as per container width and break words as per the width",
-
-        width: 130,
-        res: `hellolongte
-xtthisiswha
-tsupwithyou
-Iamtypinggg
-ggandtyping
-gg break it
-now`,
-      },
-      {
-        desc: "fit the long text when container width is greater than text length and move the rest to next line",
-
-        width: 600,
-        res: `hellolongtextthisiswhatsupwithyouIamtypingggggandtypinggg 
-break it now`,
-      },
-    ].forEach((data) => {
-      it(`should ${data.desc}`, () => {
-        const res = wrapText(text, font, data.width);
-        expect(res).toEqual(data.res);
-      });
-    });
-  });
-});
@@ -1,449 +1,12 @@
-import { getFontString, arrayToMap, isTestEnv } from "../utils";
-import {
-  ExcalidrawBindableElement,
-  ExcalidrawElement,
-  ExcalidrawTextElement,
-  ExcalidrawTextElementWithContainer,
-  FontString,
-  NonDeletedExcalidrawElement,
-} from "./types";
+import { measureText, getFontString } from "../utils";
+import { ExcalidrawTextElement } from "./types";
 import { mutateElement } from "./mutateElement";
-import { BOUND_TEXT_PADDING } from "../constants";
-import { MaybeTransformHandleType } from "./transformHandles";
-import Scene from "../scene/Scene";
-import { AppState } from "../types";
-
-export const redrawTextBoundingBox = (
-  element: ExcalidrawTextElement,
-  container: ExcalidrawElement | null,
-  appState: AppState,
-) => {
-  const maxWidth = container
-    ? container.width - BOUND_TEXT_PADDING * 2
-    : undefined;
-  let text = element.text;
-
-  if (container) {
-    text = wrapText(
-      element.originalText,
-      getFontString(element),
-      container.width,
-    );
-  }
-  const metrics = measureText(
-    element.originalText,
-    getFontString(element),
-    maxWidth,
-  );
-
-  let coordY = element.y;
-  // Resize container and vertically center align the text
-  if (container) {
-    coordY = container.y + container.height / 2 - metrics.height / 2;
-    let nextHeight = container.height;
-    if (metrics.height > container.height - BOUND_TEXT_PADDING * 2) {
-      nextHeight = metrics.height + BOUND_TEXT_PADDING * 2;
-      coordY = container.y + nextHeight / 2 - metrics.height / 2;
-    }
-    mutateElement(container, { height: nextHeight });
-  }

+export const redrawTextBoundingBox = (element: ExcalidrawTextElement) => {
+  const metrics = measureText(element.text, getFontString(element));
  mutateElement(element, {
    width: metrics.width,
    height: metrics.height,
    baseline: metrics.baseline,
-    y: coordY,
-    text,
  });
 };
-
-export const bindTextToShapeAfterDuplication = (
-  sceneElements: ExcalidrawElement[],
-  oldElements: ExcalidrawElement[],
-  oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>,
-): void => {
-  const sceneElementMap = arrayToMap(sceneElements) as Map<
-    ExcalidrawElement["id"],
-    ExcalidrawElement
-  >;
-  oldElements.forEach((element) => {
-    const newElementId = oldIdToDuplicatedId.get(element.id) as string;
-    const boundTextElementId = getBoundTextElementId(element);
-
-    if (boundTextElementId) {
-      const newTextElementId = oldIdToDuplicatedId.get(boundTextElementId)!;
-      mutateElement(
-        sceneElementMap.get(newElementId) as ExcalidrawBindableElement,
-        {
-          boundElements: element.boundElements?.concat({
-            type: "text",
-            id: newTextElementId,
-          }),
-        },
-      );
-      mutateElement(
-        sceneElementMap.get(newTextElementId) as ExcalidrawTextElement,
-        {
-          containerId: newElementId,
-        },
-      );
-    }
-  });
-};
-
-export const handleBindTextResize = (
-  elements: readonly NonDeletedExcalidrawElement[],
-  transformHandleType: MaybeTransformHandleType,
-) => {
-  elements.forEach((element) => {
-    const boundTextElementId = getBoundTextElementId(element);
-    if (boundTextElementId) {
-      const textElement = Scene.getScene(element)!.getElement(
-        boundTextElementId,
-      ) as ExcalidrawTextElement;
-      if (textElement && textElement.text) {
-        if (!element) {
-          return;
-        }
-        let text = textElement.text;
-        let nextHeight = textElement.height;
-        let containerHeight = element.height;
-        let nextBaseLine = textElement.baseline;
-        if (transformHandleType !== "n" && transformHandleType !== "s") {
-          if (text) {
-            text = wrapText(
-              textElement.originalText,
-              getFontString(textElement),
-              element.width,
-            );
-          }
-
-          const dimensions = measureText(
-            text,
-            getFontString(textElement),
-            element.width,
-          );
-          nextHeight = dimensions.height;
-          nextBaseLine = dimensions.baseline;
-        }
-        // increase height in case text element height exceeds
-        if (nextHeight > element.height - BOUND_TEXT_PADDING * 2) {
-          containerHeight = nextHeight + BOUND_TEXT_PADDING * 2;
-          const diff = containerHeight - element.height;
-          // fix the y coord when resizing from ne/nw/n
-          const updatedY =
-            transformHandleType === "ne" ||
-            transformHandleType === "nw" ||
-            transformHandleType === "n"
-              ? element.y - diff
-              : element.y;
-          mutateElement(element, {
-            height: containerHeight,
-            y: updatedY,
-          });
-        }
-
-        const updatedY = element.y + containerHeight / 2 - nextHeight / 2;
-        mutateElement(textElement, {
-          text,
-          // preserve padding and set width correctly
-          width: element.width - BOUND_TEXT_PADDING * 2,
-          height: nextHeight,
-          x: element.x + BOUND_TEXT_PADDING,
-          y: updatedY,
-          baseline: nextBaseLine,
-        });
-      }
-    }
-  });
-};
-
-// https://github.com/grassator/canvas-text-editor/blob/master/lib/FontMetrics.js
-export const measureText = (
-  text: string,
-  font: FontString,
-  maxWidth?: number | null,
-) => {
-  text = text
-    .split("\n")
-    // replace empty lines with single space because leading/trailing empty
-    // lines would be stripped from computation
-    .map((x) => x || " ")
-    .join("\n");
-  const container = document.createElement("div");
-  container.style.position = "absolute";
-  container.style.whiteSpace = "pre";
-  container.style.font = font;
-  container.style.minHeight = "1em";
-  if (maxWidth) {
-    const lineHeight = getApproxLineHeight(font);
-    container.style.width = `${String(maxWidth)}px`;
-    container.style.maxWidth = `${String(maxWidth)}px`;
-    container.style.overflow = "hidden";
-    container.style.wordBreak = "break-word";
-    container.style.lineHeight = `${String(lineHeight)}px`;
-    container.style.whiteSpace = "pre-wrap";
-  }
-  document.body.appendChild(container);
-  container.innerText = text;
-
-  const span = document.createElement("span");
-  span.style.display = "inline-block";
-  span.style.overflow = "hidden";
-  span.style.width = "1px";
-  span.style.height = "1px";
-  container.appendChild(span);
-  // Baseline is important for positioning text on canvas
-  const baseline = span.offsetTop + span.offsetHeight;
-  const width = container.offsetWidth;
-
-  const height = container.offsetHeight;
-  document.body.removeChild(container);
-
-  return { width, height, baseline };
-};
-
-const DUMMY_TEXT = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toLocaleUpperCase();
-const cacheApproxLineHeight: { [key: FontString]: number } = {};
-
-export const getApproxLineHeight = (font: FontString) => {
-  if (cacheApproxLineHeight[font]) {
-    return cacheApproxLineHeight[font];
-  }
-  cacheApproxLineHeight[font] = measureText(DUMMY_TEXT, font, null).height;
-  return cacheApproxLineHeight[font];
-};
-
-let canvas: HTMLCanvasElement | undefined;
-const getTextWidth = (text: string, font: FontString) => {
-  if (!canvas) {
-    canvas = document.createElement("canvas");
-  }
-  const canvas2dContext = canvas.getContext("2d")!;
-  canvas2dContext.font = font;
-
-  const metrics = canvas2dContext.measureText(text);
-  // since in test env the canvas measureText algo
-  // doesn't measure text and instead just returns number of
-  // characters hence we assume that each letteris 10px
-  if (isTestEnv()) {
-    return metrics.width * 10;
-  }
-
-  return metrics.width;
-};
-
-export const wrapText = (
-  text: string,
-  font: FontString,
-  containerWidth: number,
-) => {
-  const maxWidth = containerWidth - BOUND_TEXT_PADDING * 2;
-
-  const lines: Array<string> = [];
-  const originalLines = text.split("\n");
-  const spaceWidth = getTextWidth(" ", font);
-  originalLines.forEach((originalLine) => {
-    const words = originalLine.split(" ");
-    // This means its newline so push it
-    if (words.length === 1 && words[0] === "") {
-      lines.push(words[0]);
-    } else {
-      let currentLine = "";
-      let currentLineWidthTillNow = 0;
-
-      let index = 0;
-      while (index < words.length) {
-        const currentWordWidth = getTextWidth(words[index], font);
-
-        // Start breaking longer words exceeding max width
-        if (currentWordWidth >= maxWidth) {
-          // push current line since the current word exceeds the max width
-          // so will be appended in next line
-          if (currentLine) {
-            lines.push(currentLine);
-          }
-          currentLine = "";
-          currentLineWidthTillNow = 0;
-          while (words[index].length > 0) {
-            const currentChar = words[index][0];
-            const width = charWidth.calculate(currentChar, font);
-            currentLineWidthTillNow += width;
-            words[index] = words[index].slice(1);
-
-            if (currentLineWidthTillNow >= maxWidth) {
-              // only remove last trailing space which we have added when joining words
-              if (currentLine.slice(-1) === " ") {
-                currentLine = currentLine.slice(0, -1);
-              }
-              lines.push(currentLine);
-              currentLine = currentChar;
-              currentLineWidthTillNow = width;
-              if (currentLineWidthTillNow === maxWidth) {
-                currentLine = "";
-                currentLineWidthTillNow = 0;
-              }
-            } else {
-              currentLine += currentChar;
-            }
-          }
-          // push current line if appending space exceeds max width
-          if (currentLineWidthTillNow + spaceWidth >= maxWidth) {
-            lines.push(currentLine);
-            currentLine = "";
-            currentLineWidthTillNow = 0;
-          } else {
-            // space needs to be appended before next word
-            // as currentLine contains chars which couldn't be appended
-            // to previous line
-            currentLine += " ";
-            currentLineWidthTillNow += spaceWidth;
-          }
-
-          index++;
-        } else {
-          // Start appending words in a line till max width reached
-          while (currentLineWidthTillNow < maxWidth && index < words.length) {
-            const word = words[index];
-            currentLineWidthTillNow = getTextWidth(currentLine + word, font);
-
-            if (currentLineWidthTillNow >= maxWidth) {
-              lines.push(currentLine);
-              currentLineWidthTillNow = 0;
-              currentLine = "";
-
-              break;
-            }
-            index++;
-            currentLine += `${word} `;
-
-            // Push the word if appending space exceeds max width
-            if (currentLineWidthTillNow + spaceWidth >= maxWidth) {
-              lines.push(currentLine.slice(0, -1));
-              currentLine = "";
-              currentLineWidthTillNow = 0;
-              break;
-            }
-          }
-          if (currentLineWidthTillNow === maxWidth) {
-            currentLine = "";
-            currentLineWidthTillNow = 0;
-          }
-        }
-      }
-      if (currentLine) {
-        // only remove last trailing space which we have added when joining words
-        if (currentLine.slice(-1) === " ") {
-          currentLine = currentLine.slice(0, -1);
-        }
-        lines.push(currentLine);
-      }
-    }
-  });
-  return lines.join("\n");
-};
-
-export const charWidth = (() => {
-  const cachedCharWidth: { [key: FontString]: Array<number> } = {};
-
-  const calculate = (char: string, font: FontString) => {
-    const ascii = char.charCodeAt(0);
-    if (!cachedCharWidth[font]) {
-      cachedCharWidth[font] = [];
-    }
-    if (!cachedCharWidth[font][ascii]) {
-      const width = getTextWidth(char, font);
-      cachedCharWidth[font][ascii] = width;
-    }
-    return cachedCharWidth[font][ascii];
-  };
-
-  const getCache = (font: FontString) => {
-    return cachedCharWidth[font];
-  };
-  return {
-    calculate,
-    getCache,
-  };
-})();
-export const getApproxMinLineWidth = (font: FontString) => {
-  const minCharWidth = getMinCharWidth(font);
-  if (minCharWidth === 0) {
-    return (
-      measureText(DUMMY_TEXT.split("").join("\n"), font).width +
-      BOUND_TEXT_PADDING * 2
-    );
-  }
-  return minCharWidth + BOUND_TEXT_PADDING * 2;
-};
-
-export const getApproxMinLineHeight = (font: FontString) => {
-  return getApproxLineHeight(font) + BOUND_TEXT_PADDING * 2;
-};
-
-export const getMinCharWidth = (font: FontString) => {
-  const cache = charWidth.getCache(font);
-  if (!cache) {
-    return 0;
-  }
-  const cacheWithOutEmpty = cache.filter((val) => val !== undefined);
-
-  return Math.min(...cacheWithOutEmpty);
-};
-
-export const getApproxCharsToFitInWidth = (font: FontString, width: number) => {
-  // Generally lower case is used so converting to lower case
-  const dummyText = DUMMY_TEXT.toLocaleLowerCase();
-  const batchLength = 6;
-  let index = 0;
-  let widthTillNow = 0;
-  let str = "";
-  while (widthTillNow <= width) {
-    const batch = dummyText.substr(index, index + batchLength);
-    str += batch;
-    widthTillNow += getTextWidth(str, font);
-    if (index === dummyText.length - 1) {
-      index = 0;
-    }
-    index = index + batchLength;
-  }
-
-  while (widthTillNow > width) {
-    str = str.substr(0, str.length - 1);
-    widthTillNow = getTextWidth(str, font);
-  }
-  return str.length;
-};
-
-export const getBoundTextElementId = (container: ExcalidrawElement | null) => {
-  return container?.boundElements?.filter((ele) => ele.type === "text")[0]?.id;
-};
-
-export const getBoundTextElement = (element: ExcalidrawElement | null) => {
-  if (!element) {
-    return null;
-  }
-  const boundTextElementId = getBoundTextElementId(element);
-  if (boundTextElementId) {
-    return (
-      (Scene.getScene(element)?.getElement(
-        boundTextElementId,
-      ) as ExcalidrawTextElementWithContainer) || null
-    );
-  }
-  return null;
-};
-
-export const getContainerElement = (
-  element:
-    | (ExcalidrawElement & { containerId: ExcalidrawElement["id"] | null })
-    | null,
-) => {
-  if (!element) {
-    return null;
-  }
-  if (element.containerId) {
-    return Scene.getScene(element)?.getElement(element.containerId) || null;
-  }
-  return null;
-};
@@ -1,520 +1,169 @@
 import ReactDOM from "react-dom";
 import ExcalidrawApp from "../excalidraw-app";
-import { GlobalTestState, render, screen } from "../tests/test-utils";
-import { Keyboard, Pointer, UI } from "../tests/helpers/ui";
-import { CODES, KEYS } from "../keys";
-import { fireEvent } from "../tests/test-utils";
-import { queryByText } from "@testing-library/react";
+import { render } from "../tests/test-utils";
+import { Pointer, UI } from "../tests/helpers/ui";
+import { KEYS } from "../keys";

-import { BOUND_TEXT_PADDING, FONT_FAMILY } from "../constants";
-import {
-  ExcalidrawTextElement,
-  ExcalidrawTextElementWithContainer,
-} from "./types";
-import * as textElementUtils from "./textElement";
 // Unmount ReactDOM from root
 ReactDOM.unmountComponentAtNode(document.getElementById("root")!);

 const tab = "    ";
-const mouse = new Pointer("mouse");

 describe("textWysiwyg", () => {
-  describe("Test unbounded text", () => {
-    const { h } = window;
+  let textarea: HTMLTextAreaElement;
+  beforeEach(async () => {
+    await render(<ExcalidrawApp />);

-    let textarea: HTMLTextAreaElement;
-    let textElement: ExcalidrawTextElement;
-    beforeEach(async () => {
-      await render(<ExcalidrawApp />);
+    const element = UI.createElement("text");

-      textElement = UI.createElement("text");
-
-      mouse.clickOn(textElement);
-      textarea = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      )!;
-    });
-
-    it("should add a tab at the start of the first line", () => {
-      const event = new KeyboardEvent("keydown", { key: KEYS.TAB });
-      textarea.value = "Line#1\nLine#2";
-      // cursor: "|Line#1\nLine#2"
-      textarea.selectionStart = 0;
-      textarea.selectionEnd = 0;
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`${tab}Line#1\nLine#2`);
-      // cursor: "    |Line#1\nLine#2"
-      expect(textarea.selectionStart).toEqual(4);
-      expect(textarea.selectionEnd).toEqual(4);
-    });
-
-    it("should add a tab at the start of the second line", () => {
-      const event = new KeyboardEvent("keydown", { key: KEYS.TAB });
-      textarea.value = "Line#1\nLine#2";
-      // cursor: "Line#1\nLin|e#2"
-      textarea.selectionStart = 10;
-      textarea.selectionEnd = 10;
-
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`Line#1\n${tab}Line#2`);
-
-      // cursor: "Line#1\n    Lin|e#2"
-      expect(textarea.selectionStart).toEqual(14);
-      expect(textarea.selectionEnd).toEqual(14);
-    });
-
-    it("should add a tab at the start of the first and second line", () => {
-      const event = new KeyboardEvent("keydown", { key: KEYS.TAB });
-      textarea.value = "Line#1\nLine#2\nLine#3";
-      // cursor: "Li|ne#1\nLi|ne#2\nLine#3"
-      textarea.selectionStart = 2;
-      textarea.selectionEnd = 9;
-
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`${tab}Line#1\n${tab}Line#2\nLine#3`);
-
-      // cursor: "    Li|ne#1\n    Li|ne#2\nLine#3"
-      expect(textarea.selectionStart).toEqual(6);
-      expect(textarea.selectionEnd).toEqual(17);
-    });
-
-    it("should remove a tab at the start of the first line", () => {
-      const event = new KeyboardEvent("keydown", {
-        key: KEYS.TAB,
-        shiftKey: true,
-      });
-      textarea.value = `${tab}Line#1\nLine#2`;
-      // cursor: "|    Line#1\nLine#2"
-      textarea.selectionStart = 0;
-      textarea.selectionEnd = 0;
-
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`Line#1\nLine#2`);
-
-      // cursor: "|Line#1\nLine#2"
-      expect(textarea.selectionStart).toEqual(0);
-      expect(textarea.selectionEnd).toEqual(0);
-    });
-
-    it("should remove a tab at the start of the second line", () => {
-      const event = new KeyboardEvent("keydown", {
-        key: KEYS.TAB,
-        shiftKey: true,
-      });
-      // cursor: "Line#1\n    Lin|e#2"
-      textarea.value = `Line#1\n${tab}Line#2`;
-      textarea.selectionStart = 15;
-      textarea.selectionEnd = 15;
-
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`Line#1\nLine#2`);
-      // cursor: "Line#1\nLin|e#2"
-      expect(textarea.selectionStart).toEqual(11);
-      expect(textarea.selectionEnd).toEqual(11);
-    });
-
-    it("should remove a tab at the start of the first and second line", () => {
-      const event = new KeyboardEvent("keydown", {
-        key: KEYS.TAB,
-        shiftKey: true,
-      });
-      // cursor: "    Li|ne#1\n    Li|ne#2\nLine#3"
-      textarea.value = `${tab}Line#1\n${tab}Line#2\nLine#3`;
-      textarea.selectionStart = 6;
-      textarea.selectionEnd = 17;
-
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`Line#1\nLine#2\nLine#3`);
-      // cursor: "Li|ne#1\nLi|ne#2\nLine#3"
-      expect(textarea.selectionStart).toEqual(2);
-      expect(textarea.selectionEnd).toEqual(9);
-    });
-
-    it("should remove a tab at the start of the second line and cursor stay on this line", () => {
-      const event = new KeyboardEvent("keydown", {
-        key: KEYS.TAB,
-        shiftKey: true,
-      });
-      // cursor: "Line#1\n  |  Line#2"
-      textarea.value = `Line#1\n${tab}Line#2`;
-      textarea.selectionStart = 9;
-      textarea.selectionEnd = 9;
-      textarea.dispatchEvent(event);
-
-      // cursor: "Line#1\n|Line#2"
-      expect(textarea.selectionStart).toEqual(7);
-      // expect(textarea.selectionEnd).toEqual(7);
-    });
-
-    it("should remove partial tabs", () => {
-      const event = new KeyboardEvent("keydown", {
-        key: KEYS.TAB,
-        shiftKey: true,
-      });
-      // cursor: "Line#1\n  Line#|2"
-      textarea.value = `Line#1\n  Line#2`;
-      textarea.selectionStart = 15;
-      textarea.selectionEnd = 15;
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`Line#1\nLine#2`);
-    });
-
-    it("should remove nothing", () => {
-      const event = new KeyboardEvent("keydown", {
-        key: KEYS.TAB,
-        shiftKey: true,
-      });
-      // cursor: "Line#1\n  Li|ne#2"
-      textarea.value = `Line#1\nLine#2`;
-      textarea.selectionStart = 9;
-      textarea.selectionEnd = 9;
-      textarea.dispatchEvent(event);
-
-      expect(textarea.value).toEqual(`Line#1\nLine#2`);
-    });
-
-    it("should resize text via shortcuts while in wysiwyg", () => {
-      textarea.value = "abc def";
-      const origFontSize = textElement.fontSize;
-      textarea.dispatchEvent(
-        new KeyboardEvent("keydown", {
-          key: KEYS.CHEVRON_RIGHT,
-          ctrlKey: true,
-          shiftKey: true,
-        }),
-      );
-      expect(textElement.fontSize).toBe(origFontSize * 1.1);
-
-      textarea.dispatchEvent(
-        new KeyboardEvent("keydown", {
-          key: KEYS.CHEVRON_LEFT,
-          ctrlKey: true,
-          shiftKey: true,
-        }),
-      );
-      expect(textElement.fontSize).toBe(origFontSize);
-    });
-
-    it("zooming via keyboard should zoom canvas", () => {
-      expect(h.state.zoom.value).toBe(1);
-      textarea.dispatchEvent(
-        new KeyboardEvent("keydown", {
-          code: CODES.MINUS,
-          ctrlKey: true,
-        }),
-      );
-      expect(h.state.zoom.value).toBe(0.9);
-      textarea.dispatchEvent(
-        new KeyboardEvent("keydown", {
-          code: CODES.NUM_SUBTRACT,
-          ctrlKey: true,
-        }),
-      );
-      expect(h.state.zoom.value).toBe(0.8);
-      textarea.dispatchEvent(
-        new KeyboardEvent("keydown", {
-          code: CODES.NUM_ADD,
-          ctrlKey: true,
-        }),
-      );
-      expect(h.state.zoom.value).toBe(0.9);
-      textarea.dispatchEvent(
-        new KeyboardEvent("keydown", {
-          code: CODES.EQUAL,
-          ctrlKey: true,
-        }),
-      );
-      expect(h.state.zoom.value).toBe(1);
-    });
+    new Pointer("mouse").clickOn(element);
+    textarea = document.querySelector(
+      ".excalidraw-textEditorContainer > textarea",
+    )!;
  });

-  describe("Test bounded text", () => {
-    let rectangle: any;
-    const { h } = window;
+  it("should add a tab at the start of the first line", () => {
+    const event = new KeyboardEvent("keydown", { key: KEYS.TAB });
+    textarea.value = "Line#1\nLine#2";
+    // cursor: "|Line#1\nLine#2"
+    textarea.selectionStart = 0;
+    textarea.selectionEnd = 0;
+    textarea.dispatchEvent(event);

-    const DUMMY_HEIGHT = 240;
-    const DUMMY_WIDTH = 160;
-    const APPROX_LINE_HEIGHT = 25;
-    const INITIAL_WIDTH = 10;
+    expect(textarea.value).toEqual(`${tab}Line#1\nLine#2`);
+    // cursor: "    |Line#1\nLine#2"
+    expect(textarea.selectionStart).toEqual(4);
+    expect(textarea.selectionEnd).toEqual(4);
+  });

-    beforeAll(() => {
-      jest
-        .spyOn(textElementUtils, "getApproxLineHeight")
-        .mockReturnValue(APPROX_LINE_HEIGHT);
+  it("should add a tab at the start of the second line", () => {
+    const event = new KeyboardEvent("keydown", { key: KEYS.TAB });
+    textarea.value = "Line#1\nLine#2";
+    // cursor: "Line#1\nLin|e#2"
+    textarea.selectionStart = 10;
+    textarea.selectionEnd = 10;
+
+    textarea.dispatchEvent(event);
+
+    expect(textarea.value).toEqual(`Line#1\n${tab}Line#2`);
+
+    // cursor: "Line#1\n    Lin|e#2"
+    expect(textarea.selectionStart).toEqual(14);
+    expect(textarea.selectionEnd).toEqual(14);
+  });
+
+  it("should add a tab at the start of the first and second line", () => {
+    const event = new KeyboardEvent("keydown", { key: KEYS.TAB });
+    textarea.value = "Line#1\nLine#2\nLine#3";
+    // cursor: "Li|ne#1\nLi|ne#2\nLine#3"
+    textarea.selectionStart = 2;
+    textarea.selectionEnd = 9;
+
+    textarea.dispatchEvent(event);
+
+    expect(textarea.value).toEqual(`${tab}Line#1\n${tab}Line#2\nLine#3`);
+
+    // cursor: "    Li|ne#1\n    Li|ne#2\nLine#3"
+    expect(textarea.selectionStart).toEqual(6);
+    expect(textarea.selectionEnd).toEqual(17);
+  });
+
+  it("should remove a tab at the start of the first line", () => {
+    const event = new KeyboardEvent("keydown", {
+      key: KEYS.TAB,
+      shiftKey: true,
    });
+    textarea.value = `${tab}Line#1\nLine#2`;
+    // cursor: "|    Line#1\nLine#2"
+    textarea.selectionStart = 0;
+    textarea.selectionEnd = 0;

-    beforeEach(async () => {
-      await render(<ExcalidrawApp />);
-      h.elements = [];
+    textarea.dispatchEvent(event);

-      rectangle = UI.createElement("rectangle", {
-        x: 10,
-        y: 20,
-        width: 90,
-        height: 75,
-      });
+    expect(textarea.value).toEqual(`Line#1\nLine#2`);
+
+    // cursor: "|Line#1\nLine#2"
+    expect(textarea.selectionStart).toEqual(0);
+    expect(textarea.selectionEnd).toEqual(0);
+  });
+
+  it("should remove a tab at the start of the second line", () => {
+    const event = new KeyboardEvent("keydown", {
+      key: KEYS.TAB,
+      shiftKey: true,
    });
+    // cursor: "Line#1\n    Lin|e#2"
+    textarea.value = `Line#1\n${tab}Line#2`;
+    textarea.selectionStart = 15;
+    textarea.selectionEnd = 15;

-    it("should bind text to container when double clicked on center", async () => {
-      expect(h.elements.length).toBe(1);
-      expect(h.elements[0].id).toBe(rectangle.id);
+    textarea.dispatchEvent(event);

-      mouse.doubleClickAt(
-        rectangle.x + rectangle.width / 2,
-        rectangle.y + rectangle.height / 2,
-      );
-      expect(h.elements.length).toBe(2);
+    expect(textarea.value).toEqual(`Line#1\nLine#2`);
+    // cursor: "Line#1\nLin|e#2"
+    expect(textarea.selectionStart).toEqual(11);
+    expect(textarea.selectionEnd).toEqual(11);
+  });

-      const text = h.elements[1] as ExcalidrawTextElementWithContainer;
-      expect(text.type).toBe("text");
-      expect(text.containerId).toBe(rectangle.id);
-      mouse.down();
-      const editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      fireEvent.change(editor, { target: { value: "Hello World!" } });
-
-      await new Promise((r) => setTimeout(r, 0));
-      editor.blur();
-      expect(rectangle.boundElements).toStrictEqual([
-        { id: text.id, type: "text" },
-      ]);
+  it("should remove a tab at the start of the first and second line", () => {
+    const event = new KeyboardEvent("keydown", {
+      key: KEYS.TAB,
+      shiftKey: true,
    });
+    // cursor: "    Li|ne#1\n    Li|ne#2\nLine#3"
+    textarea.value = `${tab}Line#1\n${tab}Line#2\nLine#3`;
+    textarea.selectionStart = 6;
+    textarea.selectionEnd = 17;

-    it("should bind text to container when clicked on container and enter pressed", async () => {
-      expect(h.elements.length).toBe(1);
-      expect(h.elements[0].id).toBe(rectangle.id);
+    textarea.dispatchEvent(event);

-      Keyboard.withModifierKeys({}, () => {
-        Keyboard.keyPress(KEYS.ENTER);
-      });
+    expect(textarea.value).toEqual(`Line#1\nLine#2\nLine#3`);
+    // cursor: "Li|ne#1\nLi|ne#2\nLine#3"
+    expect(textarea.selectionStart).toEqual(2);
+    expect(textarea.selectionEnd).toEqual(9);
+  });

-      expect(h.elements.length).toBe(2);
-
-      const text = h.elements[1] as ExcalidrawTextElementWithContainer;
-      expect(text.type).toBe("text");
-      expect(text.containerId).toBe(rectangle.id);
-      const editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      await new Promise((r) => setTimeout(r, 0));
-
-      fireEvent.change(editor, { target: { value: "Hello World!" } });
-      editor.blur();
-      expect(rectangle.boundElements).toStrictEqual([
-        { id: text.id, type: "text" },
-      ]);
+  it("should remove a tab at the start of the second line and cursor stay on this line", () => {
+    const event = new KeyboardEvent("keydown", {
+      key: KEYS.TAB,
+      shiftKey: true,
    });
+    // cursor: "Line#1\n  |  Line#2"
+    textarea.value = `Line#1\n${tab}Line#2`;
+    textarea.selectionStart = 9;
+    textarea.selectionEnd = 9;
+    textarea.dispatchEvent(event);

-    it("should update font family correctly on undo/redo by selecting bounded text when font family was updated", async () => {
-      expect(h.elements.length).toBe(1);
+    // cursor: "Line#1\n|Line#2"
+    expect(textarea.selectionStart).toEqual(7);
+    // expect(textarea.selectionEnd).toEqual(7);
+  });

-      mouse.doubleClickAt(
-        rectangle.x + rectangle.width / 2,
-        rectangle.y + rectangle.height / 2,
-      );
-      mouse.down();
-
-      const text = h.elements[1] as ExcalidrawTextElementWithContainer;
-      let editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      await new Promise((r) => setTimeout(r, 0));
-      fireEvent.change(editor, { target: { value: "Hello World!" } });
-      editor.blur();
-      expect(text.fontFamily).toEqual(FONT_FAMILY.Virgil);
-      UI.clickTool("text");
-
-      mouse.clickAt(
-        rectangle.x + rectangle.width / 2,
-        rectangle.y + rectangle.height / 2,
-      );
-      mouse.down();
-      editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      editor.select();
-      fireEvent.click(screen.getByTitle(/code/i));
-
-      await new Promise((r) => setTimeout(r, 0));
-      editor.blur();
-      expect(
-        (h.elements[1] as ExcalidrawTextElementWithContainer).fontFamily,
-      ).toEqual(FONT_FAMILY.Cascadia);
-
-      //undo
-      Keyboard.withModifierKeys({ ctrl: true }, () => {
-        Keyboard.keyPress(KEYS.Z);
-      });
-      expect(
-        (h.elements[1] as ExcalidrawTextElementWithContainer).fontFamily,
-      ).toEqual(FONT_FAMILY.Virgil);
-
-      //redo
-      Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
-        Keyboard.keyPress(KEYS.Z);
-      });
-      expect(
-        (h.elements[1] as ExcalidrawTextElementWithContainer).fontFamily,
-      ).toEqual(FONT_FAMILY.Cascadia);
+  it("should remove partial tabs", () => {
+    const event = new KeyboardEvent("keydown", {
+      key: KEYS.TAB,
+      shiftKey: true,
    });
+    // cursor: "Line#1\n  Line#|2"
+    textarea.value = `Line#1\n  Line#2`;
+    textarea.selectionStart = 15;
+    textarea.selectionEnd = 15;
+    textarea.dispatchEvent(event);

-    it("should wrap text and vertcially center align once text submitted", async () => {
-      jest
-        .spyOn(textElementUtils, "measureText")
-        .mockImplementation((text, font, maxWidth) => {
-          let width = INITIAL_WIDTH;
-          let height = APPROX_LINE_HEIGHT;
-          let baseline = 10;
-          if (!text) {
-            return {
-              width,
-              height,
-              baseline,
-            };
-          }
-          baseline = 30;
-          width = DUMMY_WIDTH;
-          if (text === "Hello \nWorld!") {
-            height = APPROX_LINE_HEIGHT * 2;
-          }
-          if (maxWidth) {
-            width = maxWidth;
-            // To capture cases where maxWidth passed is initial width
-            // due to which the text is not wrapped correctly
-            if (maxWidth === INITIAL_WIDTH) {
-              height = DUMMY_HEIGHT;
-            }
-          }
-          return {
-            width,
-            height,
-            baseline,
-          };
-        });
+    expect(textarea.value).toEqual(`Line#1\nLine#2`);
+  });

-      expect(h.elements.length).toBe(1);
-
-      Keyboard.keyDown(KEYS.ENTER);
-      let text = h.elements[1] as ExcalidrawTextElementWithContainer;
-      let editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      // mock scroll height
-      jest
-        .spyOn(editor, "scrollHeight", "get")
-        .mockImplementation(() => APPROX_LINE_HEIGHT * 2);
-
-      fireEvent.change(editor, {
-        target: {
-          value: "Hello World!",
-        },
-      });
-
-      editor.dispatchEvent(new Event("input"));
-
-      await new Promise((cb) => setTimeout(cb, 0));
-      editor.blur();
-      text = h.elements[1] as ExcalidrawTextElementWithContainer;
-      expect(text.text).toBe("Hello \nWorld!");
-      expect(text.originalText).toBe("Hello World!");
-      expect(text.y).toBe(
-        rectangle.y + rectangle.height / 2 - (APPROX_LINE_HEIGHT * 2) / 2,
-      );
-      expect(text.x).toBe(rectangle.x + BOUND_TEXT_PADDING);
-      expect(text.height).toBe(APPROX_LINE_HEIGHT * 2);
-      expect(text.width).toBe(rectangle.width - BOUND_TEXT_PADDING * 2);
-
-      // Edit and text by removing second line and it should
-      // still vertically align correctly
-      mouse.select(rectangle);
-      Keyboard.withModifierKeys({}, () => {
-        Keyboard.keyPress(KEYS.ENTER);
-      });
-      editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      fireEvent.change(editor, {
-        target: {
-          value: "Hello",
-        },
-      });
-
-      // mock scroll height
-      jest
-        .spyOn(editor, "scrollHeight", "get")
-        .mockImplementation(() => APPROX_LINE_HEIGHT);
-      editor.style.height = "25px";
-      editor.dispatchEvent(new Event("input"));
-
-      await new Promise((r) => setTimeout(r, 0));
-
-      editor.blur();
-      text = h.elements[1] as ExcalidrawTextElementWithContainer;
-
-      expect(text.text).toBe("Hello");
-      expect(text.originalText).toBe("Hello");
-      expect(text.y).toBe(
-        rectangle.y + rectangle.height / 2 - APPROX_LINE_HEIGHT / 2,
-      );
-      expect(text.x).toBe(rectangle.x + BOUND_TEXT_PADDING);
-      expect(text.height).toBe(APPROX_LINE_HEIGHT);
-      expect(text.width).toBe(rectangle.width - BOUND_TEXT_PADDING * 2);
+  it("should remove nothing", () => {
+    const event = new KeyboardEvent("keydown", {
+      key: KEYS.TAB,
+      shiftKey: true,
    });
+    // cursor: "Line#1\n  Li|ne#2"
+    textarea.value = `Line#1\nLine#2`;
+    textarea.selectionStart = 9;
+    textarea.selectionEnd = 9;
+    textarea.dispatchEvent(event);

-    it("should unbind bound text when unbind action from context menu is triggred", async () => {
-      expect(h.elements.length).toBe(1);
-      expect(h.elements[0].id).toBe(rectangle.id);
-
-      Keyboard.withModifierKeys({}, () => {
-        Keyboard.keyPress(KEYS.ENTER);
-      });
-
-      expect(h.elements.length).toBe(2);
-
-      const text = h.elements[1] as ExcalidrawTextElementWithContainer;
-      expect(text.containerId).toBe(rectangle.id);
-
-      const editor = document.querySelector(
-        ".excalidraw-textEditorContainer > textarea",
-      ) as HTMLTextAreaElement;
-
-      await new Promise((r) => setTimeout(r, 0));
-
-      fireEvent.change(editor, { target: { value: "Hello World!" } });
-      editor.blur();
-      expect(rectangle.boundElements).toStrictEqual([
-        { id: text.id, type: "text" },
-      ]);
-      mouse.reset();
-      UI.clickTool("selection");
-      mouse.clickAt(10, 20);
-      mouse.down();
-      mouse.up();
-      fireEvent.contextMenu(GlobalTestState.canvas, {
-        button: 2,
-        clientX: 20,
-        clientY: 30,
-      });
-      const contextMenu = document.querySelector(".context-menu");
-      fireEvent.click(queryByText(contextMenu as HTMLElement, "Unbind text")!);
-      expect(h.elements[0].boundElements).toEqual([]);
-      expect((h.elements[1] as ExcalidrawTextElement).containerId).toEqual(
-        null,
-      );
-    });
+    expect(textarea.value).toEqual(`Line#1\nLine#2`);
  });
 });
@@ -1,32 +1,10 @@
 import { CODES, KEYS } from "../keys";
-import {
-  isWritableElement,
-  getFontString,
-  getFontFamilyString,
-  isTestEnv,
-} from "../utils";
+import { isWritableElement, getFontString } from "../utils";
 import Scene from "../scene/Scene";
-import { isBoundToContainer, isTextElement } from "./typeChecks";
-import { CLASSES, BOUND_TEXT_PADDING } from "../constants";
-import {
-  ExcalidrawElement,
-  ExcalidrawTextElement,
-  ExcalidrawLinearElement,
-} from "./types";
+import { isTextElement } from "./typeChecks";
+import { CLASSES } from "../constants";
+import { ExcalidrawElement } from "./types";
 import { AppState } from "../types";
-import { mutateElement } from "./mutateElement";
-import {
-  getApproxLineHeight,
-  getBoundTextElementId,
-  getContainerElement,
-  wrapText,
-} from "./textElement";
-import {
-  actionDecreaseFontSize,
-  actionIncreaseFontSize,
-} from "../actions/actionProperties";
-import { actionZoomIn, actionZoomOut } from "../actions/actionCanvas";
-import App from "../components/App";

 const normalizeText = (text: string) => {
  return (
@@ -44,169 +22,82 @@ const getTransform = (
  angle: number,
  appState: AppState,
  maxWidth: number,
-  maxHeight: number,
 ) => {
-  const { zoom } = appState;
+  const { zoom, offsetTop, offsetLeft } = appState;
  const degree = (180 * angle) / Math.PI;
-  let translateX = (width * (zoom.value - 1)) / 2;
-  let translateY = (height * (zoom.value - 1)) / 2;
+  // offsets must be multiplied by 2 to account for the division by 2 of
+  // the whole expression afterwards
+  let translateX = ((width - offsetLeft * 2) * (zoom.value - 1)) / 2;
+  const translateY = ((height - offsetTop * 2) * (zoom.value - 1)) / 2;
  if (width > maxWidth && zoom.value !== 1) {
-    translateX = (maxWidth * (zoom.value - 1)) / 2;
-  }
-  if (height > maxHeight && zoom.value !== 1) {
-    translateY = (maxHeight * (zoom.value - 1)) / 2;
+    translateX = (maxWidth / 2) * (zoom.value - 1);
  }
  return `translate(${translateX}px, ${translateY}px) scale(${zoom.value}) rotate(${degree}deg)`;
 };

 export const textWysiwyg = ({
  id,
+  appState,
  onChange,
  onSubmit,
  getViewportCoords,
  element,
  canvas,
  excalidrawContainer,
-  app,
 }: {
  id: ExcalidrawElement["id"];
+  appState: AppState;
  onChange?: (text: string) => void;
-  onSubmit: (data: {
-    text: string;
-    viaKeyboard: boolean;
-    originalText: string;
-  }) => void;
+  onSubmit: (data: { text: string; viaKeyboard: boolean }) => void;
  getViewportCoords: (x: number, y: number) => [number, number];
-  element: ExcalidrawTextElement;
+  element: ExcalidrawElement;
  canvas: HTMLCanvasElement | null;
  excalidrawContainer: HTMLDivElement | null;
-  app: App;
 }) => {
-  const textPropertiesUpdated = (
-    updatedElement: ExcalidrawTextElement,
-    editable: HTMLTextAreaElement,
-  ) => {
-    const currentFont = editable.style.fontFamily.replace(/"/g, "");
-    if (
-      getFontFamilyString({ fontFamily: updatedElement.fontFamily }) !==
-      currentFont
-    ) {
-      return true;
-    }
-    if (`${updatedElement.fontSize}px` !== editable.style.fontSize) {
-      return true;
-    }
-    return false;
-  };
-  let originalContainerHeight: number;
-
  const updateWysiwygStyle = () => {
-    const appState = app.state;
-    const updatedElement = Scene.getScene(element)?.getElement(
-      id,
-    ) as ExcalidrawTextElement;
-    const approxLineHeight = getApproxLineHeight(getFontString(updatedElement));
+    const updatedElement = Scene.getScene(element)?.getElement(id);
    if (updatedElement && isTextElement(updatedElement)) {
-      let coordX = updatedElement.x;
-      let coordY = updatedElement.y;
-      const container = getContainerElement(updatedElement);
-      let maxWidth = updatedElement.width;
+      const [viewportX, viewportY] = getViewportCoords(
+        updatedElement.x,
+        updatedElement.y,
+      );
+      const { textAlign, angle } = updatedElement;

-      let maxHeight = updatedElement.height;
-      let width = updatedElement.width;
-      // Set to element height by default since thats
-      // what is going to be used for unbounded text
-      let height = updatedElement.height;
-      if (container && updatedElement.containerId) {
-        const propertiesUpdated = textPropertiesUpdated(
-          updatedElement,
-          editable,
+      editable.value = updatedElement.text;
+
+      const lines = updatedElement.text.replace(/\r\n?/g, "\n").split("\n");
+      const lineHeight = updatedElement.height / lines.length;
+      const maxWidth =
+        (appState.offsetLeft + appState.width - viewportX - 8) /
+          appState.zoom.value -
+        // margin-right of parent if any
+        Number(
+          getComputedStyle(
+            excalidrawContainer?.parentNode as Element,
+          ).marginRight.slice(0, -2),
        );
-        // using editor.style.height to get the accurate height of text editor
-        const editorHeight = Number(editable.style.height.slice(0, -2));
-        if (editorHeight > 0) {
-          height = editorHeight;
-        }
-        if (propertiesUpdated) {
-          originalContainerHeight = container.height;

-          // update height of the editor after properties updated
-          height = updatedElement.height;
-        }
-        if (!originalContainerHeight) {
-          originalContainerHeight = container.height;
-        }
-        maxWidth = container.width - BOUND_TEXT_PADDING * 2;
-        maxHeight = container.height - BOUND_TEXT_PADDING * 2;
-        width = maxWidth;
-        // The coordinates of text box set a distance of
-        // 30px to preserve padding
-        coordX = container.x + BOUND_TEXT_PADDING;
-        // autogrow container height if text exceeds
-        if (height > maxHeight) {
-          const diff = Math.min(height - maxHeight, approxLineHeight);
-          mutateElement(container, { height: container.height + diff });
-          return;
-        } else if (
-          // autoshrink container height until original container height
-          // is reached when text is removed
-          container.height > originalContainerHeight &&
-          height < maxHeight
-        ) {
-          const diff = Math.min(maxHeight - height, approxLineHeight);
-          mutateElement(container, { height: container.height - diff });
-        }
-        // Start pushing text upward until a diff of 30px (padding)
-        // is reached
-        else {
-          // vertically center align the text
-          coordY = container.y + container.height / 2 - height / 2;
-        }
-      }
-      const [viewportX, viewportY] = getViewportCoords(coordX, coordY);
-      const { textAlign } = updatedElement;
-      editable.value = updatedElement.originalText;
-      const lines = updatedElement.originalText.split("\n");
-      const lineHeight = updatedElement.containerId
-        ? approxLineHeight
-        : updatedElement.height / lines.length;
-      if (!container) {
-        maxWidth = (appState.width - 8 - viewportX) / appState.zoom.value;
-      }
-
-      // Make sure text editor height doesn't go beyond viewport
-      const editorMaxHeight =
-        (appState.height - viewportY) / appState.zoom.value;
-      const angle = container ? container.angle : updatedElement.angle;
      Object.assign(editable.style, {
        font: getFontString(updatedElement),
        // must be defined *after* font ¯\_(ツ)_/¯
        lineHeight: `${lineHeight}px`,
-        width: `${width}px`,
-        height: `${height}px`,
+        width: `${updatedElement.width}px`,
+        height: `${updatedElement.height}px`,
        left: `${viewportX}px`,
        top: `${viewportY}px`,
        transform: getTransform(
-          width,
-          height,
+          updatedElement.width,
+          updatedElement.height,
          angle,
          appState,
          maxWidth,
-          editorMaxHeight,
        ),
        textAlign,
        color: updatedElement.strokeColor,
        opacity: updatedElement.opacity / 100,
        filter: "var(--theme-filter)",
        maxWidth: `${maxWidth}px`,
-        maxHeight: `${editorMaxHeight}px`,
      });
-      // For some reason updating font attribute doesn't set font family
-      // hence updating font family explicitly for test environment
-      if (isTestEnv()) {
-        editable.style.fontFamily = getFontFamilyString(updatedElement);
-      }
-      mutateElement(updatedElement, { x: coordX, y: coordY });
    }
  };

@@ -219,13 +110,6 @@ export const textWysiwyg = ({
  editable.wrap = "off";
  editable.classList.add("excalidraw-wysiwyg");

-  let whiteSpace = "pre";
-  let wordBreak = "normal";
-
-  if (isBoundToContainer(element)) {
-    whiteSpace = "pre-wrap";
-    wordBreak = "break-word";
-  }
  Object.assign(editable.style, {
    position: "absolute",
    display: "inline-block",
@@ -238,72 +122,23 @@ export const textWysiwyg = ({
    resize: "none",
    background: "transparent",
    overflow: "hidden",
+    // prevent line wrapping (`whitespace: nowrap` doesn't work on FF)
+    whiteSpace: "pre",
    // must be specified because in dark mode canvas creates a stacking context
    zIndex: "var(--zIndex-wysiwyg)",
-    wordBreak,
-    // prevent line wrapping (`whitespace: nowrap` doesn't work on FF)
-    whiteSpace,
-    overflowWrap: "break-word",
  });
+
  updateWysiwygStyle();

  if (onChange) {
    editable.oninput = () => {
-      const updatedElement = Scene.getScene(element)?.getElement(
-        id,
-      ) as ExcalidrawTextElement;
-      const font = getFontString(updatedElement);
-      // using scrollHeight here since we need to calculate
-      // number of lines so cannot use editable.style.height
-      // as that gets updated below
-      const lines = editable.scrollHeight / getApproxLineHeight(font);
-      // auto increase height only when lines  > 1 so its
-      // measured correctly and vertically alignes for
-      // first line as well as setting height to "auto"
-      // doubles the height as soon as user starts typing
-      if (isBoundToContainer(element) && lines > 1) {
-        let height = "auto";
-
-        if (lines === 2) {
-          const container = getContainerElement(element);
-          const actualLineCount = wrapText(
-            editable.value,
-            font,
-            container!.width,
-          ).split("\n").length;
-
-          // This is browser behaviour when setting height to "auto"
-          // It sets the height needed for 2 lines even if actual
-          // line count is 1 as mentioned above as well
-          // hence reducing the height by half if actual line count is 1
-          // so single line aligns vertically when deleting
-          if (actualLineCount === 1) {
-            height = `${editable.scrollHeight / 2}px`;
-          }
-        }
-        editable.style.height = height;
-        editable.style.height = `${editable.scrollHeight}px`;
-      }
      onChange(normalizeText(editable.value));
    };
  }

  editable.onkeydown = (event) => {
    event.stopPropagation();
-
-    if (!event.shiftKey && actionZoomIn.keyTest(event)) {
-      event.preventDefault();
-      app.actionManager.executeAction(actionZoomIn);
-      updateWysiwygStyle();
-    } else if (!event.shiftKey && actionZoomOut.keyTest(event)) {
-      event.preventDefault();
-      app.actionManager.executeAction(actionZoomOut);
-      updateWysiwygStyle();
-    } else if (actionDecreaseFontSize.keyTest(event)) {
-      app.actionManager.executeAction(actionDecreaseFontSize);
-    } else if (actionIncreaseFontSize.keyTest(event)) {
-      app.actionManager.executeAction(actionIncreaseFontSize);
-    } else if (event.key === KEYS.ESCAPE) {
+    if (event.key === KEYS.ESCAPE) {
      event.preventDefault();
      submittedViaKeyboard = true;
      handleSubmit();
@@ -339,7 +174,7 @@ export const textWysiwyg = ({
    const linesStartIndices = getSelectedLinesStartIndices();

    let value = editable.value;
-    linesStartIndices.forEach((startIndex: number) => {
+    linesStartIndices.forEach((startIndex) => {
      const startValue = value.slice(0, startIndex);
      const endValue = value.slice(startIndex);

@@ -439,43 +274,9 @@ export const textWysiwyg = ({
    // it'd get stuck in an infinite loop of blur→onSubmit after we re-focus the
    // wysiwyg on update
    cleanup();
-    const updateElement = Scene.getScene(element)?.getElement(
-      element.id,
-    ) as ExcalidrawTextElement;
-    if (!updateElement) {
-      return;
-    }
-    let text = editable.value;
-    const container = getContainerElement(updateElement);
-
-    if (container) {
-      text = updateElement.text;
-      if (editable.value) {
-        const boundTextElementId = getBoundTextElementId(container);
-        if (!boundTextElementId || boundTextElementId !== element.id) {
-          mutateElement(container, {
-            boundElements: (container.boundElements || []).concat({
-              type: "text",
-              id: element.id,
-            }),
-          });
-        }
-      } else {
-        mutateElement(container, {
-          boundElements: container.boundElements?.filter(
-            (ele) =>
-              !isTextElement(
-                ele as ExcalidrawTextElement | ExcalidrawLinearElement,
-              ),
-          ),
-        });
-      }
-    }
-
    onSubmit({
-      text,
+      text: normalizeText(editable.value),
      viaKeyboard: submittedViaKeyboard,
-      originalText: editable.value,
    });
  };

@@ -504,45 +305,26 @@ export const textWysiwyg = ({
    editable.remove();
  };

-  const bindBlurEvent = (event?: MouseEvent) => {
+  const bindBlurEvent = () => {
    window.removeEventListener("pointerup", bindBlurEvent);
    // Deferred so that the pointerdown that initiates the wysiwyg doesn't
    // trigger the blur on ensuing pointerup.
    // Also to handle cases such as picking a color which would trigger a blur
    // in that same tick.
-    const target = event?.target;
-
-    const isTargetColorPicker =
-      target instanceof HTMLInputElement &&
-      target.closest(".color-picker-input") &&
-      isWritableElement(target);
-
    setTimeout(() => {
      editable.onblur = handleSubmit;
-      if (target && isTargetColorPicker) {
-        target.onblur = () => {
-          editable.focus();
-        };
-      }
      // case: clicking on the same property → no change → no update → no focus
-      if (!isTargetColorPicker) {
-        editable.focus();
-      }
+      editable.focus();
    });
  };

  // prevent blur when changing properties from the menu
  const onPointerDown = (event: MouseEvent) => {
-    const isTargetColorPicker =
-      event.target instanceof HTMLInputElement &&
-      event.target.closest(".color-picker-input") &&
-      isWritableElement(event.target);
    if (
-      ((event.target instanceof HTMLElement ||
+      (event.target instanceof HTMLElement ||
        event.target instanceof SVGElement) &&
-        event.target.closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) &&
-        !isWritableElement(event.target)) ||
-      isTargetColorPicker
+      event.target.closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) &&
+      !isWritableElement(event.target)
    ) {
      editable.onblur = null;
      window.addEventListener("pointerup", bindBlurEvent);
@@ -555,12 +337,7 @@ export const textWysiwyg = ({
  // handle updates of textElement properties of editing element
  const unbindUpdate = Scene.getScene(element)!.addCallback(() => {
    updateWysiwygStyle();
-    const isColorPickerActive = !!document.activeElement?.closest(
-      ".color-picker-input",
-    );
-    if (!isColorPickerActive) {
-      editable.focus();
-    }
+    editable.focus();
  });

  // ---------------------------------------------------------------------------
@@ -3,7 +3,6 @@ import { ExcalidrawElement, PointerType } from "./types";
 import { getElementAbsoluteCoords, Bounds } from "./bounds";
 import { rotate } from "../math";
 import { Zoom } from "../types";
-import { isTextElement } from ".";

 export type TransformHandleDirection =
  | "n"
@@ -243,7 +242,7 @@ export const getTransformHandles = (
        omitSides = OMIT_SIDES_FOR_LINE_BACKSLASH;
      }
    }
-  } else if (isTextElement(element)) {
+  } else if (element.type === "text") {
    omitSides = OMIT_SIDES_FOR_TEXT_ELEMENT;
  }

@@ -7,7 +7,6 @@ import {
  ExcalidrawFreeDrawElement,
  InitializedExcalidrawImageElement,
  ExcalidrawImageElement,
-  ExcalidrawTextElementWithContainer,
 } from "./types";

 export const isGenericElement = (
@@ -86,18 +85,7 @@ export const isBindableElement = (
    (element.type === "rectangle" ||
      element.type === "diamond" ||
      element.type === "ellipse" ||
-      element.type === "image" ||
-      (element.type === "text" && !element.containerId))
-  );
-};
-
-export const isTextBindableContainer = (element: ExcalidrawElement | null) => {
-  return (
-    element != null &&
-    (element.type === "rectangle" ||
-      element.type === "diamond" ||
-      element.type === "ellipse" ||
-      element.type === "image")
+      element.type === "text")
  );
 };

@@ -112,20 +100,3 @@ export const isExcalidrawElement = (element: any): boolean => {
    element?.type === "line"
  );
 };
-
-export const hasBoundTextElement = (
-  element: ExcalidrawElement | null,
-): element is ExcalidrawBindableElement => {
-  return (
-    isBindableElement(element) &&
-    !!element.boundElements?.some(({ type }) => type === "text")
-  );
-};
-
-export const isBoundToContainer = (
-  element: ExcalidrawElement | null,
-): element is ExcalidrawTextElementWithContainer => {
-  return (
-    element !== null && isTextElement(element) && element.containerId !== null
-  );
-};
@@ -43,16 +43,8 @@ type _ExcalidrawElementBase = Readonly<{
  /** List of groups the element belongs to.
      Ordered from deepest to shallowest. */
  groupIds: readonly GroupId[];
-  /** other elements that are bound to this element */
-  boundElements:
-    | readonly Readonly<{
-        id: ExcalidrawLinearElement["id"];
-        type: "arrow" | "text";
-      }>[]
-    | null;
-  /** epoch (ms) timestamp of last element update */
-  updated: number;
-  link: string | null;
+  /** Ids of (linear) elements that are bound to this element. */
+  boundElementIds: readonly ExcalidrawLinearElement["id"][] | null;
 }>;

 export type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
@@ -122,8 +114,6 @@ export type ExcalidrawTextElement = _ExcalidrawElementBase &
    baseline: number;
    textAlign: TextAlign;
    verticalAlign: VerticalAlign;
-    containerId: ExcalidrawGenericElement["id"] | null;
-    originalText: string;
  }>;

 export type ExcalidrawBindableElement =
@@ -133,10 +123,6 @@ export type ExcalidrawBindableElement =
  | ExcalidrawTextElement
  | ExcalidrawImageElement;

-export type ExcalidrawTextElementWithContainer = {
-  containerId: ExcalidrawGenericElement["id"];
-} & ExcalidrawTextElement;
-
 export type PointBinding = {
  elementId: ExcalidrawBindableElement["id"];
  focus: number;
@@ -4,7 +4,6 @@ export const INITIAL_SCENE_UPDATE_TIMEOUT = 5000;
 export const FILE_UPLOAD_TIMEOUT = 300;
 export const LOAD_IMAGES_TIMEOUT = 500;
 export const SYNC_FULL_SCENE_INTERVAL_MS = 20000;
-export const SYNC_BROWSER_TABS_TIMEOUT = 50;

 export const FILE_UPLOAD_MAX_BYTES = 3 * 1024 * 1024; // 3 MiB
 // 1 year (https://stackoverflow.com/a/25201898/927631)
@@ -26,13 +25,3 @@ export const FIREBASE_STORAGE_PREFIXES = {
 };

 export const ROOM_ID_BYTES = 10;
-
-export const STORAGE_KEYS = {
-  LOCAL_STORAGE_ELEMENTS: "excalidraw",
-  LOCAL_STORAGE_APP_STATE: "excalidraw-state",
-  LOCAL_STORAGE_COLLAB: "excalidraw-collab",
-  LOCAL_STORAGE_KEY_COLLAB_FORCE_FLAG: "collabLinkForceLoadFlag",
-  LOCAL_STORAGE_LIBRARY: "excalidraw-library",
-  VERSION_DATA_STATE: "version-dataState",
-  VERSION_FILES: "version-files",
-} as const;
@@ -21,7 +21,6 @@ import {
  INITIAL_SCENE_UPDATE_TIMEOUT,
  LOAD_IMAGES_TIMEOUT,
  SCENE,
-  STORAGE_KEYS,
  SYNC_FULL_SCENE_INTERVAL_MS,
 } from "../app_constants";
 import {
@@ -40,6 +39,7 @@ import {
 import {
  importUsernameFromLocalStorage,
  saveUsernameToLocalStorage,
+  STORAGE_KEYS,
 } from "../data/localStorage";
 import Portal from "./Portal";
 import RoomDialog from "./RoomDialog";
@@ -65,7 +65,6 @@ import {
  reconcileElements as _reconcileElements,
 } from "./reconciliation";
 import { decryptData } from "../../data/encryption";
-import { resetBrowserStateVersions } from "../data/tabSync";

 interface CollabState {
  modalIsShown: boolean;
@@ -87,7 +86,6 @@ export interface CollabAPI {
  onCollabButtonClick: CollabInstance["onCollabButtonClick"];
  broadcastElements: CollabInstance["broadcastElements"];
  fetchImageFilesFromFirebase: CollabInstance["fetchImageFilesFromFirebase"];
-  setUsername: (username: string) => void;
 }

 interface Props {
@@ -248,10 +246,6 @@ class CollabWrapper extends PureComponent<Props, CollabState> {

    this.saveCollabRoomToFirebase();
    if (window.confirm(t("alerts.collabStopOverridePrompt"))) {
-      // hack to ensure that we prefer we disregard any new browser state
-      // that could have been saved in other tabs while we were collaborating
-      resetBrowserStateVersions();
-
      window.history.pushState({}, APP_NAME, window.location.origin);
      this.destroySocketClient();
      trackEvent("share", "room closed");
@@ -683,12 +677,8 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
    this.setState({ modalIsShown: false });
  };

-  setUsername = (username: string) => {
-    this.setState({ username });
-  };
-
  onUsernameChange = (username: string) => {
-    this.setUsername(username);
+    this.setState({ username });
    saveUsernameToLocalStorage(username);
  };

@@ -722,7 +712,6 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
    this.contextValue.broadcastElements = this.broadcastElements;
    this.contextValue.fetchImageFilesFromFirebase =
      this.fetchImageFilesFromFirebase;
-    this.contextValue.setUsername = this.setUsername;
    return this.contextValue;
  };

@@ -78,7 +78,7 @@ export const ExportToExcalidrawPlus: React.FC<{
  onError: (error: Error) => void;
 }> = ({ elements, appState, files, onError }) => {
  return (
-    <Card color="primary">
+    <Card color="indigo">
      <div className="Card-icon">{excalidrawPlusIcon}</div>
      <h2>Excalidraw+</h2>
      <div className="Card-details">
@@ -199,11 +199,7 @@ export const encodeFilesForUpload = async ({
    });

    if (buffer.byteLength > maxBytes) {
-      throw new Error(
-        t("errors.fileTooBig", {
-          maxSize: `${Math.trunc(maxBytes / 1024 / 1024)}MB`,
-        }),
-      );
+      throw new Error(t("errors.fileTooBig"));
    }

    processedFiles.push({
@@ -11,15 +11,7 @@ import { MIME_TYPES } from "../../constants";
 // private
 // -----------------------------------------------------------------------------

-let FIREBASE_CONFIG: Record<string, any>;
-try {
-  FIREBASE_CONFIG = JSON.parse(process.env.REACT_APP_FIREBASE_CONFIG);
-} catch (error: any) {
-  console.warn(
-    `Error JSON parsing firebase config. Supplied value: ${process.env.REACT_APP_FIREBASE_CONFIG}`,
-  );
-  FIREBASE_CONFIG = {};
-}
+const FIREBASE_CONFIG = JSON.parse(process.env.REACT_APP_FIREBASE_CONFIG);

 let firebasePromise: Promise<typeof import("firebase/app").default> | null =
  null;
@@ -1,6 +1,6 @@
-import { compressData, decompressData } from "../../data/encode";
 import {
  decryptData,
+  encryptData,
  generateEncryptionKey,
  IV_LENGTH_BYTES,
 } from "../../data/encryption";
@@ -109,45 +109,9 @@ export const getCollaborationLink = (data: {
  return `${window.location.origin}${window.location.pathname}#room=${data.roomId},${data.roomKey}`;
 };

-/**
- * Decodes shareLink data using the legacy buffer format.
- * @deprecated
- */
-const legacy_decodeFromBackend = async ({
-  buffer,
-  decryptionKey,
-}: {
-  buffer: ArrayBuffer;
-  decryptionKey: string;
-}) => {
-  let decrypted: ArrayBuffer;
-
-  try {
-    // Buffer should contain both the IV (fixed length) and encrypted data
-    const iv = buffer.slice(0, IV_LENGTH_BYTES);
-    const encrypted = buffer.slice(IV_LENGTH_BYTES, buffer.byteLength);
-    decrypted = await decryptData(new Uint8Array(iv), encrypted, decryptionKey);
-  } catch (error: any) {
-    // Fixed IV (old format, backward compatibility)
-    const fixedIv = new Uint8Array(IV_LENGTH_BYTES);
-    decrypted = await decryptData(fixedIv, buffer, decryptionKey);
-  }
-
-  // We need to convert the decrypted array buffer to a string
-  const string = new window.TextDecoder("utf-8").decode(
-    new Uint8Array(decrypted),
-  );
-  const data: ImportedDataState = JSON.parse(string);
-
-  return {
-    elements: data.elements || null,
-    appState: data.appState || null,
-  };
-};
-
 const importFromBackend = async (
  id: string,
-  decryptionKey: string,
+  privateKey: string,
 ): Promise<ImportedDataState> => {
  try {
    const response = await fetch(`${BACKEND_V2_GET}${id}`);
@@ -158,28 +122,28 @@ const importFromBackend = async (
    }
    const buffer = await response.arrayBuffer();

+    let decrypted: ArrayBuffer;
    try {
-      const { data: decodedBuffer } = await decompressData(
-        new Uint8Array(buffer),
-        {
-          decryptionKey,
-        },
-      );
-      const data: ImportedDataState = JSON.parse(
-        new TextDecoder().decode(decodedBuffer),
-      );
-
-      return {
-        elements: data.elements || null,
-        appState: data.appState || null,
-      };
+      // Buffer should contain both the IV (fixed length) and encrypted data
+      const iv = buffer.slice(0, IV_LENGTH_BYTES);
+      const encrypted = buffer.slice(IV_LENGTH_BYTES, buffer.byteLength);
+      decrypted = await decryptData(new Uint8Array(iv), encrypted, privateKey);
    } catch (error: any) {
-      console.warn(
-        "error when decoding shareLink data using the new format:",
-        error,
-      );
-      return legacy_decodeFromBackend({ buffer, decryptionKey });
+      // Fixed IV (old format, backward compatibility)
+      const fixedIv = new Uint8Array(IV_LENGTH_BYTES);
+      decrypted = await decryptData(fixedIv, buffer, privateKey);
    }
+
+    // We need to convert the decrypted array buffer to a string
+    const string = new window.TextDecoder("utf-8").decode(
+      new Uint8Array(decrypted),
+    );
+    const data: ImportedDataState = JSON.parse(string);
+
+    return {
+      elements: data.elements || null,
+      appState: data.appState || null,
+    };
  } catch (error: any) {
    window.alert(t("alerts.importBackendFailed"));
    console.error(error);
@@ -224,14 +188,20 @@ export const exportToBackend = async (
  appState: AppState,
  files: BinaryFiles,
 ) => {
-  const encryptionKey = await generateEncryptionKey("string");
+  const json = serializeAsJSON(elements, appState, files, "database");
+  const encoded = new TextEncoder().encode(json);

-  const payload = await compressData(
-    new TextEncoder().encode(
-      serializeAsJSON(elements, appState, files, "database"),
-    ),
-    { encryptionKey },
-  );
+  const cryptoKey = await generateEncryptionKey("cryptoKey");
+
+  const { encryptedBuffer, iv } = await encryptData(cryptoKey, encoded);
+
+  // Concatenate IV with encrypted data (IV does not have to be secret).
+  const payloadBlob = new Blob([iv.buffer, encryptedBuffer]);
+  const payload = await new Response(payloadBlob).arrayBuffer();
+
+  // We use jwk encoding to be able to extract just the base64 encoded key.
+  // We will hardcode the rest of the attributes when importing back the key.
+  const exportedKey = await window.crypto.subtle.exportKey("jwk", cryptoKey);

  try {
    const filesMap = new Map<FileId, BinaryFileData>();
@@ -241,6 +211,8 @@ export const exportToBackend = async (
      }
    }

+    const encryptionKey = exportedKey.k!;
+
    const filesToUpload = await encodeFilesForUpload({
      files: filesMap,
      encryptionKey,
@@ -249,7 +221,7 @@ export const exportToBackend = async (

    const response = await fetch(BACKEND_V2_POST, {
      method: "POST",
-      body: payload.buffer,
+      body: payload,
    });
    const json = await response.json();
    if (json.id) {
@@ -5,8 +5,14 @@ import {
  getDefaultAppState,
 } from "../../appState";
 import { clearElementsForLocalStorage } from "../../element";
-import { updateBrowserStateVersion } from "./tabSync";
-import { STORAGE_KEYS } from "../app_constants";
+import { STORAGE_KEYS as APP_STORAGE_KEYS } from "../../constants";
+
+export const STORAGE_KEYS = {
+  LOCAL_STORAGE_ELEMENTS: "excalidraw",
+  LOCAL_STORAGE_APP_STATE: "excalidraw-state",
+  LOCAL_STORAGE_COLLAB: "excalidraw-collab",
+  LOCAL_STORAGE_KEY_COLLAB_FORCE_FLAG: "collabLinkForceLoadFlag",
+};

 export const saveUsernameToLocalStorage = (username: string) => {
  try {
@@ -47,7 +53,6 @@ export const saveToLocalStorage = (
      STORAGE_KEYS.LOCAL_STORAGE_APP_STATE,
      JSON.stringify(clearAppStateForLocalStorage(appState)),
    );
-    updateBrowserStateVersion(STORAGE_KEYS.VERSION_DATA_STATE);
  } catch (error: any) {
    // Unable to access window.localStorage
    console.error(error);
@@ -108,7 +113,9 @@ export const getTotalStorageSize = () => {
  try {
    const appState = localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_APP_STATE);
    const collab = localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_COLLAB);
-    const library = localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_LIBRARY);
+    const library = localStorage.getItem(
+      APP_STORAGE_KEYS.LOCAL_STORAGE_LIBRARY,
+    );

    const appStateSize = appState?.length || 0;
    const collabSize = collab?.length || 0;
@@ -120,17 +127,3 @@ export const getTotalStorageSize = () => {
    return 0;
  }
 };
-
-export const getLibraryItemsFromStorage = () => {
-  try {
-    const libraryItems =
-      JSON.parse(
-        localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_LIBRARY) as string,
-      ) || [];
-
-    return libraryItems;
-  } catch (e) {
-    console.error(e);
-    return [];
-  }
-};
@@ -1,29 +0,0 @@
-import { STORAGE_KEYS } from "../app_constants";
-
-// in-memory state (this tab's current state) versions. Currently just
-// timestamps of the last time the state was saved to browser storage.
-const LOCAL_STATE_VERSIONS = {
-  [STORAGE_KEYS.VERSION_DATA_STATE]: -1,
-  [STORAGE_KEYS.VERSION_FILES]: -1,
-};
-
-type BrowserStateTypes = keyof typeof LOCAL_STATE_VERSIONS;
-
-export const isBrowserStorageStateNewer = (type: BrowserStateTypes) => {
-  const storageTimestamp = JSON.parse(localStorage.getItem(type) || "-1");
-  return storageTimestamp > LOCAL_STATE_VERSIONS[type];
-};
-
-export const updateBrowserStateVersion = (type: BrowserStateTypes) => {
-  const timestamp = Date.now();
-  localStorage.setItem(type, JSON.stringify(timestamp));
-  LOCAL_STATE_VERSIONS[type] = timestamp;
-};
-
-export const resetBrowserStateVersions = () => {
-  for (const key of Object.keys(LOCAL_STATE_VERSIONS) as BrowserStateTypes[]) {
-    const timestamp = -1;
-    localStorage.setItem(key, JSON.stringify(timestamp));
-    LOCAL_STATE_VERSIONS[key] = timestamp;
-  }
-};
@@ -1,9 +1,4 @@
 .excalidraw {
-  --color-primary-contrast-offset: #625ee0; // to offset Chubb illusion
-
-  &.theme--dark {
-    --color-primary-contrast-offset: #726dff; // to offset Chubb illusion
-  }
  .layer-ui__wrapper__footer-center {
    display: flex;
    justify-content: space-between;
@@ -14,7 +9,7 @@

  .encrypted-icon {
    border-radius: var(--space-factor);
-    color: var(--color-primary);
+    color: var(--icon-green-fill-color);
    margin-top: auto;
    margin-bottom: auto;
    margin-inline-start: auto;
@@ -7,6 +7,7 @@ import { TopErrorBoundary } from "../components/TopErrorBoundary";
 import {
  APP_NAME,
  EVENT,
+  STORAGE_KEYS,
  TITLE_TIMEOUT,
  URL_HASH_KEYS,
  VERSION_TIMEOUT,
@@ -34,7 +35,6 @@ import {
 import {
  debounce,
  getVersion,
-  isTestEnv,
  preventUnload,
  ResolvablePromise,
  resolvablePromise,
@@ -42,8 +42,6 @@ import {
 import {
  FIREBASE_STORAGE_PREFIXES,
  SAVE_TO_LOCAL_STORAGE_TIMEOUT,
-  STORAGE_KEYS,
-  SYNC_BROWSER_TABS_TIMEOUT,
 } from "./app_constants";
 import CollabWrapper, {
  CollabAPI,
@@ -53,9 +51,7 @@ import CollabWrapper, {
 import { LanguageList } from "./components/LanguageList";
 import { exportToBackend, getCollaborationLinkData, loadScene } from "./data";
 import {
-  getLibraryItemsFromStorage,
  importFromLocalStorage,
-  importUsernameFromLocalStorage,
  saveToLocalStorage,
 } from "./data/localStorage";
 import CustomStats from "./CustomStats";
@@ -71,10 +67,6 @@ import { FileManager, updateStaleImageStatuses } from "./data/FileManager";
 import { newElementWith } from "../element/mutateElement";
 import { isInitializedImageElement } from "../element/typeChecks";
 import { loadFilesFromFirebase } from "./data/firebase";
-import {
-  isBrowserStorageStateNewer,
-  updateBrowserStateVersion,
-} from "./data/tabSync";

 const filesStore = createStore("files-db", "files-store");

@@ -112,11 +104,6 @@ const localFileStorage = new FileManager({
    const savedFiles = new Map<FileId, true>();
    const erroredFiles = new Map<FileId, true>();

-    // before we use `storage` event synchronization, let's update the flag
-    // optimistically. Hopefully nothing fails, and an IDB read executed
-    // before an IDB write finishes will read the latest value.
-    updateBrowserStateVersion(STORAGE_KEYS.VERSION_FILES);
-
    await Promise.all(
      [...addedFiles].map(async ([id, fileData]) => {
        try {
@@ -155,6 +142,7 @@ const saveDebounced = debounce(
      elements,
      files,
    });
+
    onFilesSaved();
  },
  SAVE_TO_LOCAL_STORAGE_TIMEOUT,
@@ -274,7 +262,7 @@ const PlusLinkJSX = (
    Introducing Excalidraw+
    <br />
    <a
-      href="https://plus.excalidraw.com/plus?utm_source=excalidraw&utm_medium=banner&utm_campaign=launch"
+      href="https://plus.excalidraw.com/?utm_source=excalidraw&utm_medium=banner&utm_campaign=launch"
      target="_blank"
      rel="noreferrer"
    >
@@ -290,6 +278,7 @@ const ExcalidrawWrapper = () => {
    currentLangCode = currentLangCode[0];
  }
  const [langCode, setLangCode] = useState(currentLangCode);
+
  // initial state
  // ---------------------------------------------------------------------------

@@ -383,7 +372,14 @@ const ExcalidrawWrapper = () => {
        }
      }

-      data.scene.libraryItems = getLibraryItemsFromStorage();
+      try {
+        data.scene.libraryItems =
+          JSON.parse(
+            localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_LIBRARY) as string,
+          ) || [];
+      } catch (error: any) {
+        console.error(error);
+      }
    };

    initializeScene({ collabAPI }).then((data) => {
@@ -419,71 +415,13 @@ const ExcalidrawWrapper = () => {
      () => (document.title = APP_NAME),
      TITLE_TIMEOUT,
    );
-
-    const syncData = debounce(() => {
-      if (isTestEnv()) {
-        return;
-      }
-      if (!document.hidden && !collabAPI.isCollaborating()) {
-        // don't sync if local state is newer or identical to browser state
-        if (isBrowserStorageStateNewer(STORAGE_KEYS.VERSION_DATA_STATE)) {
-          const localDataState = importFromLocalStorage();
-          const username = importUsernameFromLocalStorage();
-          let langCode = languageDetector.detect() || defaultLang.code;
-          if (Array.isArray(langCode)) {
-            langCode = langCode[0];
-          }
-          setLangCode(langCode);
-          excalidrawAPI.updateScene({
-            ...localDataState,
-            libraryItems: getLibraryItemsFromStorage(),
-          });
-          collabAPI.setUsername(username || "");
-        }
-
-        if (isBrowserStorageStateNewer(STORAGE_KEYS.VERSION_FILES)) {
-          const elements = excalidrawAPI.getSceneElementsIncludingDeleted();
-          const currFiles = excalidrawAPI.getFiles();
-          const fileIds =
-            elements?.reduce((acc, element) => {
-              if (
-                isInitializedImageElement(element) &&
-                // only load and update images that aren't already loaded
-                !currFiles[element.fileId]
-              ) {
-                return acc.concat(element.fileId);
-              }
-              return acc;
-            }, [] as FileId[]) || [];
-          if (fileIds.length) {
-            localFileStorage
-              .getFiles(fileIds)
-              .then(({ loadedFiles, erroredFiles }) => {
-                if (loadedFiles.length) {
-                  excalidrawAPI.addFiles(loadedFiles);
-                }
-                updateStaleImageStatuses({
-                  excalidrawAPI,
-                  erroredFiles,
-                  elements: excalidrawAPI.getSceneElementsIncludingDeleted(),
-                });
-              });
-          }
-        }
-      }
-    }, SYNC_BROWSER_TABS_TIMEOUT);
-
    window.addEventListener(EVENT.HASHCHANGE, onHashChange, false);
    window.addEventListener(EVENT.UNLOAD, onBlur, false);
    window.addEventListener(EVENT.BLUR, onBlur, false);
-    document.addEventListener(EVENT.VISIBILITY_CHANGE, syncData, false);
-    window.addEventListener(EVENT.FOCUS, syncData, false);
    return () => {
      window.removeEventListener(EVENT.HASHCHANGE, onHashChange, false);
      window.removeEventListener(EVENT.UNLOAD, onBlur, false);
      window.removeEventListener(EVENT.BLUR, onBlur, false);
-      window.removeEventListener(EVENT.FOCUS, syncData, false);
-      document.removeEventListener(EVENT.VISIBILITY_CHANGE, syncData, false);
      clearTimeout(titleTimeout);
    };
  }, [collabAPI, excalidrawAPI]);
@@ -1,3 +1,5 @@
+// import type {PngChunk} from "./types";
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface Document {
  fonts?: {
@@ -54,8 +56,6 @@ type NonOptional<T> = Exclude<T, undefined>;

 // PNG encoding/decoding
 // -----------------------------------------------------------------------------
-type TEXtChunk = { name: "tEXt"; data: Uint8Array };
-
 declare module "png-chunk-text" {
  function encode(
    name: string,
@@ -64,11 +64,11 @@ declare module "png-chunk-text" {
  function decode(data: Uint8Array): { keyword: string; text: string };
 }
 declare module "png-chunks-encode" {
-  function encode(chunks: TEXtChunk[]): Uint8Array;
+  function encode(chunks: import("./types").PngChunk[]): Uint8Array;
  export = encode;
 }
 declare module "png-chunks-extract" {
-  function extract(buffer: Uint8Array): TEXtChunk[];
+  function extract(buffer: Uint8Array): import("./types").PngChunk[];
  export = extract;
 }
 // -----------------------------------------------------------------------------
@@ -1,13 +1,6 @@
-import {
-  GroupId,
-  ExcalidrawElement,
-  NonDeleted,
-  ExcalidrawTextElementWithContainer,
-} from "./element/types";
+import { GroupId, ExcalidrawElement, NonDeleted } from "./element/types";
 import { AppState } from "./types";
 import { getSelectedElements } from "./scene";
-import { getBoundTextElementId } from "./element/textElement";
-import Scene from "./scene/Scene";

 export const selectGroup = (
  groupId: GroupId,
@@ -165,33 +158,3 @@ export const removeFromSelectedGroups = (
  groupIds: ExcalidrawElement["groupIds"],
  selectedGroupIds: { [groupId: string]: boolean },
 ) => groupIds.filter((groupId) => !selectedGroupIds[groupId]);
-
-export const getMaximumGroups = (
-  elements: ExcalidrawElement[],
-): ExcalidrawElement[][] => {
-  const groups: Map<String, ExcalidrawElement[]> = new Map<
-    String,
-    ExcalidrawElement[]
-  >();
-
-  elements.forEach((element: ExcalidrawElement) => {
-    const groupId =
-      element.groupIds.length === 0
-        ? element.id
-        : element.groupIds[element.groupIds.length - 1];
-
-    const currentGroupMembers = groups.get(groupId) || [];
-
-    // Include bounded text if present when grouping
-    const boundTextElementId = getBoundTextElementId(element);
-    if (boundTextElementId) {
-      const textElement = Scene.getScene(element)!.getElement(
-        boundTextElementId,
-      ) as ExcalidrawTextElementWithContainer;
-      currentGroupMembers.push(textElement);
-    }
-    groups.set(groupId, [...currentGroupMembers, element]);
-  });
-
-  return Array.from(groups.values());
-};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dwelle	75e2d9e359	remove debug	2021-11-22 23:20:40 +01:00
dwelle	6592517122	import lazily	2021-11-22 22:11:10 +01:00
dwelle	bd953a6287	feat: compress non-transparent PNGs as JPGs and allow larger dimensions	2021-11-22 17:39:59 +01:00