Update textWysiwyg.tsx

2025-08-22 01:37:04 +02:00 · 2022-03-14 07:15:21 +01:00 · 2022-03-14 07:11:12 +01:00 · 2022-03-13 23:45:03 +01:00 · 2022-03-13 23:43:03 +01:00 · 2022-03-13 23:38:54 +01:00
190 changed files with 13640 additions and 6646 deletions
--- a/.env.development
+++ b/.env.development
@@ -4,5 +4,9 @@ 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:3000
+REACT_APP_PORTAL_URL=http://localhost:3002
+# Fill to set socket server URL used for collaboration.
+# Meant for forks only: excalidraw.com uses custom REACT_APP_PORTAL_URL flow
+REACT_APP_WS_SERVER_URL=
+
 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"}'
--- a/.env.production
+++ b/.env.production
@@ -4,7 +4,11 @@ REACT_APP_BACKEND_V2_POST_URL=https://json.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=https://oss-collab-us1.excalidraw.com
+REACT_APP_PORTAL_URL=https://portal.excalidraw.com
+# Fill to set socket server URL used for collaboration.
+# Meant for forks only: excalidraw.com uses custom REACT_APP_PORTAL_URL flow
+REACT_APP_WS_SERVER_URL=
+
 REACT_APP_FIREBASE_CONFIG='{"apiKey":"AIzaSyAd15pYlMci_xIp9ko6wkEsDzAAA0Dn0RU","authDomain":"excalidraw-room-persistence.firebaseapp.com","databaseURL":"https://excalidraw-room-persistence.firebaseio.com","projectId":"excalidraw-room-persistence","storageBucket":"excalidraw-room-persistence.appspot.com","messagingSenderId":"654800341332","appId":"1:654800341332:web:4a692de832b55bd57ce0c1"}'

 # production-only vars
--- a/.github/workflows/autorelease-excalidraw.yml
+++ b/.github/workflows/autorelease-excalidraw.yml
@@ -23,4 +23,5 @@ jobs:
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
      - name: Auto release
        run: |
+          yarn add @actions/core
          yarn autorelease
--- a/.github/workflows/autorelease-preview.yml
+++ b/.github/workflows/autorelease-preview.yml
@@ -0,0 +1,55 @@
+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 }}"
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -1,29 +0,0 @@
-name: Build packages
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-
-jobs:
-  packages:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Setup Node.js 14.x
-        uses: actions/setup-node@v2
-        with:
-          node-version: 14.x
-      - name: Install dependencies
-        run: |
-          yarn --frozen-lockfile
-          yarn --cwd src/packages/excalidraw
-          yarn --cwd src/packages/utils
-      - name: Build @excalidraw/excalidraw
-        run: |
-          yarn --cwd src/packages/excalidraw run pack
-      - name: Build @excalidraw/utils
-        run: |
-          yarn --cwd src/packages/utils run pack
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,7 @@ 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
+
--- a/README.md
+++ b/README.md
@@ -32,6 +32,10 @@ Last but not least, we're thankful to these companies for offering their service

 [![Vercel](./.github/assets/vercel.svg)](https://vercel.com) [![Sentry](./.github/assets/sentry.svg)](https://sentry.io) [![Crowdin](./.github/assets/crowdin.svg)](https://crowdin.com)

+## Who's integrating Excalidraw
+
+[Google Cloud](https://googlecloudcheatsheet.withgoogle.com/architecture) • [Meta](https://meta.com/) • [CodeSandbox](https://codesandbox.io/) • [Obsidian Excalidraw](https://github.com/zsviczian/obsidian-excalidraw-plugin) • [Replit](https://replit.com/) • [Slite](https://slite.com/) • [Notion](https://notion.so/) • [HackerRank](https://www.hackerrank.com/) •
+
 ## Documentation

 ### Shortcuts
@@ -118,6 +122,10 @@ 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                       |
--- a/package.json
+++ b/package.json
@@ -21,15 +21,15 @@
  "dependencies": {
    "@sentry/browser": "6.2.5",
    "@sentry/integrations": "6.2.5",
-    "@testing-library/jest-dom": "5.15.1",
+    "@testing-library/jest-dom": "5.16.2",
    "@testing-library/react": "12.1.2",
-    "@tldraw/vec": "1.1.5",
-    "@types/jest": "27.0.3",
+    "@tldraw/vec": "1.4.3",
+    "@types/jest": "27.4.0",
    "@types/pica": "5.1.3",
-    "@types/react": "17.0.37",
+    "@types/react": "17.0.39",
    "@types/react-dom": "17.0.11",
    "@types/socket.io-client": "1.4.36",
-    "browser-fs-access": "0.23.0",
+    "browser-fs-access": "0.24.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.30",
+    "nanoid": "3.1.32",
    "open-color": "1.9.1",
    "pako": "1.0.11",
    "perfect-freehand": "1.0.16",
@@ -50,31 +50,30 @@
    "react-dom": "17.0.2",
    "react-scripts": "4.0.3",
    "roughjs": "4.5.2",
-    "sass": "1.43.5",
+    "sass": "1.49.7",
    "socket.io-client": "2.3.1",
-    "typescript": "4.5.2"
+    "typescript": "4.5.5"
  },
  "devDependencies": {
    "@excalidraw/eslint-config": "1.0.0",
    "@excalidraw/prettier-config": "1.0.2",
-    "@types/chai": "4.2.22",
+    "@types/chai": "4.3.0",
    "@types/lodash.throttle": "4.1.6",
-    "@types/pako": "1.0.2",
+    "@types/pako": "1.0.3",
    "@types/resize-observer-browser": "0.1.6",
-    "chai": "4.3.4",
+    "chai": "4.3.6",
    "dotenv": "10.0.0",
    "eslint-config-prettier": "8.3.0",
    "eslint-plugin-prettier": "3.3.1",
-    "firebase-tools": "9.23.0",
    "husky": "7.0.4",
    "jest-canvas-mock": "2.3.1",
-    "lint-staged": "12.1.2",
+    "lint-staged": "12.3.3",
    "pepjs": "0.5.3",
-    "prettier": "2.5.0",
+    "prettier": "2.5.1",
    "rewire": "5.0.0"
  },
  "resolutions": {
-    "@typescript-eslint/typescript-estree": "5.3.0"
+    "@typescript-eslint/typescript-estree": "5.10.2"
  },
  "engines": {
    "node": ">=14.0.0"
--- a/public/index.html
+++ b/public/index.html
@@ -72,12 +72,6 @@
      crossorigin="anonymous"
    />

-    <link
-      href="%REACT_APP_SOCKET_SERVER_URL%/socket.io"
-      rel="preconnect"
-      crossorigin="anonymous"
-    />
-
    <link
      rel="manifest"
      href="manifest.json"
--- a/scripts/autorelease.js
+++ b/scripts/autorelease.js
@@ -1,5 +1,6 @@
 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`;
@@ -15,18 +16,25 @@ 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/;

@@ -37,16 +45,33 @@ 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";
-  fs.writeFileSync(excalidrawPackage, JSON.stringify(pkg, null, 2), "utf8");
+  let version = `${pkg.version}-${getShortCommitHash()}`;

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

-    // return if the changelog already contains the pr number which would happen for package updates
-    if (existingChangeLog.includes(prNumber)) {
-      return;
+      // 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);
    }
-    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;
 };

--- a/src/actions/actionCanvas.tsx
+++ b/src/actions/actionCanvas.tsx
@@ -9,7 +9,7 @@ import { t } from "../i18n";
 import { CODES, KEYS } from "../keys";
 import { getNormalizedZoom, getSelectedElements } from "../scene";
 import { centerScrollOn } from "../scene/scroll";
-import { getNewZoom } from "../scene/zoom";
+import { getStateForZoom } from "../scene/zoom";
 import { AppState, NormalizedZoomValue } from "../types";
 import { getShortcutKey } from "../utils";
 import { register } from "./register";
@@ -26,7 +26,7 @@ export const actionChangeViewBackgroundColor = register({
      commitToHistory: !!value.viewBackgroundColor,
    };
  },
-  PanelComponent: ({ appState, updateData }) => {
+  PanelComponent: ({ elements, appState, updateData }) => {
    return (
      <div style={{ position: "relative" }}>
        <ColorPicker
@@ -39,6 +39,8 @@ export const actionChangeViewBackgroundColor = register({
            updateData({ openPopup: active ? "canvasColorPicker" : null })
          }
          data-testid="canvas-background-picker"
+          elements={elements}
+          appState={appState}
        />
      </div>
    );
@@ -58,11 +60,15 @@ 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,
    };
@@ -73,17 +79,18 @@ export const actionClearCanvas = register({

 export const actionZoomIn = register({
  name: "zoomIn",
-  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 },
-    );
+  perform: (_elements, appState, _, app) => {
    return {
      appState: {
        ...appState,
-        zoom,
+        ...getStateForZoom(
+          {
+            viewportX: appState.width / 2 + appState.offsetLeft,
+            viewportY: appState.height / 2 + appState.offsetTop,
+            nextZoom: getNormalizedZoom(appState.zoom.value + ZOOM_STEP),
+          },
+          appState,
+        ),
      },
      commitToHistory: false,
    };
@@ -107,18 +114,18 @@ export const actionZoomIn = register({

 export const actionZoomOut = register({
  name: "zoomOut",
-  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 },
-    );
-
+  perform: (_elements, appState, _, app) => {
    return {
      appState: {
        ...appState,
-        zoom,
+        ...getStateForZoom(
+          {
+            viewportX: appState.width / 2 + appState.offsetLeft,
+            viewportY: appState.height / 2 + appState.offsetTop,
+            nextZoom: getNormalizedZoom(appState.zoom.value - ZOOM_STEP),
+          },
+          appState,
+        ),
      },
      commitToHistory: false,
    };
@@ -142,18 +149,17 @@ export const actionZoomOut = register({

 export const actionResetZoom = register({
  name: "resetZoom",
-  perform: (_elements, appState) => {
+  perform: (_elements, appState, _, app) => {
    return {
      appState: {
        ...appState,
-        zoom: getNewZoom(
-          1 as NormalizedZoomValue,
-          appState.zoom,
-          { left: appState.offsetLeft, top: appState.offsetTop },
+        ...getStateForZoom(
          {
-            x: appState.width / 2,
-            y: appState.height / 2,
+            viewportX: appState.width / 2 + appState.offsetLeft,
+            viewportY: appState.height / 2 + appState.offsetTop,
+            nextZoom: getNormalizedZoom(1),
          },
+          appState,
        ),
      },
      commitToHistory: false,
@@ -212,14 +218,12 @@ const zoomToFitElements = (
      ? getCommonBounds(selectedElements)
      : getCommonBounds(nonDeletedElements);

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

  const [x1, y1, x2, y2] = commonBounds;
  const centerX = (x1 + x2) / 2;
--- a/src/actions/actionClipboard.tsx
+++ b/src/actions/actionClipboard.tsx
@@ -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, data, app);
+    return actionDeleteSelected.perform(elements, appState);
  },
  contextItemLabel: "labels.cut",
  keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.code === CODES.X,
--- a/src/actions/actionDistribute.tsx
+++ b/src/actions/actionDistribute.tsx
@@ -7,7 +7,7 @@ import { distributeElements, Distribution } from "../disitrubte";
 import { getNonDeletedElements } from "../element";
 import { ExcalidrawElement } from "../element/types";
 import { t } from "../i18n";
-import { CODES } from "../keys";
+import { CODES, KEYS } from "../keys";
 import { getSelectedElements, isSomeElementSelected } from "../scene";
 import { AppState } from "../types";
 import { arrayToMap, getShortcutKey } from "../utils";
@@ -49,7 +49,8 @@ export const distributeHorizontally = register({
      commitToHistory: true,
    };
  },
-  keyTest: (event) => event.altKey && event.code === CODES.H,
+  keyTest: (event) =>
+    !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.H,
  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
      hidden={!enableActionGroup(elements, appState)}
@@ -77,7 +78,8 @@ export const distributeVertically = register({
      commitToHistory: true,
    };
  },
-  keyTest: (event) => event.altKey && event.code === CODES.V,
+  keyTest: (event) =>
+    !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.V,
  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
      hidden={!enableActionGroup(elements, appState)}
--- a/src/actions/actionFinalize.tsx
+++ b/src/actions/actionFinalize.tsx
@@ -14,60 +14,10 @@ import {
  bindOrUnbindLinearElement,
 } from "../element/binding";
 import { isBindingElement } from "../element/typeChecks";
-import { ExcalidrawImageElement } from "../element/types";
-import { imageFromImageData } from "../element/image";

 export const actionFinalize = register({
  name: "finalize",
-  perform: (
-    elements,
-    appState,
-    _,
-    { canvas, focusContainer, imageCache, addFiles },
-  ) => {
-    if (appState.editingImageElement) {
-      const { elementId, imageData } = appState.editingImageElement;
-      const editingImageElement = elements.find((el) => el.id === elementId) as
-        | ExcalidrawImageElement
-        | undefined;
-      if (editingImageElement?.fileId) {
-        const cachedImageData = imageCache.get(editingImageElement.fileId);
-        if (cachedImageData) {
-          const { image, dataURL } = imageFromImageData(imageData);
-
-          imageCache.set(editingImageElement.fileId, {
-            ...cachedImageData,
-            image,
-          });
-
-          addFiles([
-            {
-              id: editingImageElement.fileId,
-              dataURL,
-              mimeType: cachedImageData.mimeType,
-              created: Date.now(),
-            },
-          ]);
-
-          return {
-            appState: {
-              ...appState,
-              editingImageElement: null,
-            },
-            commitToHistory: false,
-          };
-        }
-      }
-
-      return {
-        appState: {
-          ...appState,
-          editingImageElement: null,
-        },
-        commitToHistory: false,
-      };
-    }
-
+  perform: (elements, appState, _, { canvas, focusContainer }) => {
    if (appState.editingLinearElement) {
      const { elementId, startBindingElement, endBindingElement } =
        appState.editingLinearElement;
@@ -212,7 +162,6 @@ export const actionFinalize = register({
  keyTest: (event, appState) =>
    (event.key === KEYS.ESCAPE &&
      (appState.editingLinearElement !== null ||
-        appState.editingImageElement !== null ||
        (!appState.draggingElement && appState.multiElement === null))) ||
    ((event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) &&
      appState.multiElement !== null),
--- a/src/actions/actionFlip.ts
+++ b/src/actions/actionFlip.ts
@@ -155,7 +155,7 @@ const flipElement = (
    // calculate new x-coord for transformation
    newNCoordsX = usingNWHandle ? element.x + 2 * width : element.x - 2 * width;
    resizeSingleElement(
-      element,
+      new Map().set(element.id, element),
      true,
      element,
      usingNWHandle ? "nw" : "ne",
--- a/src/actions/actionGroup.tsx
+++ b/src/actions/actionGroup.tsx
@@ -17,8 +17,9 @@ import {
 import { getNonDeletedElements } from "../element";
 import { randomId } from "../random";
 import { ToolButton } from "../components/ToolButton";
-import { ExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawTextElement } from "../element/types";
 import { AppState } from "../types";
+import { isBoundToContainer } from "../element/typeChecks";

 const allElementsInSameGroup = (elements: readonly ExcalidrawElement[]) => {
  if (elements.length >= 2) {
@@ -151,7 +152,12 @@ 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,
@@ -163,11 +169,19 @@ 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: selectGroupsForSelectedElements(
-        { ...appState, selectedGroupIds: {} },
-        getNonDeletedElements(nextElements),
-      ),
+      appState: updateAppState,
+
      elements: nextElements,
      commitToHistory: true,
    };
--- a/src/actions/actionImageEditing.tsx
+++ b/src/actions/actionImageEditing.tsx
@@ -1,75 +0,0 @@
-import { getSelectedElements, isSomeElementSelected } from "../scene";
-import { ToolButton } from "../components/ToolButton";
-import { backgroundIcon } from "../components/icons";
-import { register } from "./register";
-import { getNonDeletedElements } from "../element";
-import { isInitializedImageElement } from "../element/typeChecks";
-import Scene from "../scene/Scene";
-
-export const actionEditImageAlpha = register({
-  name: "editImageAlpha",
-  perform: async (elements, appState, _, app) => {
-    if (appState.editingImageElement) {
-      return {
-        appState: {
-          ...appState,
-          editingImageElement: null,
-        },
-        commitToHistory: false,
-      };
-    }
-
-    const selectedElements = getSelectedElements(elements, appState);
-    const selectedElement = selectedElements[0];
-    if (
-      selectedElements.length === 1 &&
-      isInitializedImageElement(selectedElement)
-    ) {
-      const imgData = app.imageCache.get(selectedElement.fileId);
-      if (!imgData) {
-        return false;
-      }
-
-      const image = await imgData.image;
-      const { width, height } = image;
-
-      const canvas = document.createElement("canvas");
-      canvas.height = height;
-      canvas.width = width;
-      const context = canvas.getContext("2d")!;
-
-      context.drawImage(image, 0, 0, width, height);
-
-      const imageData = context.getImageData(0, 0, width, height);
-
-      Scene.mapElementToScene(selectedElement.id, app.scene);
-
-      return {
-        appState: {
-          ...appState,
-          editingImageElement: {
-            editorType: "alpha",
-            elementId: selectedElement.id,
-            origImageData: imageData,
-            imageData,
-            pointerDownState: { screenX: 0, screenY: 0, sampledPixel: null },
-          },
-        },
-        commitToHistory: false,
-      };
-    }
-    return false;
-  },
-  PanelComponent: ({ elements, appState, updateData }) => (
-    <ToolButton
-      type="button"
-      icon={backgroundIcon}
-      label="Edit Image Alpha"
-      className={appState.editingImageElement ? "active" : ""}
-      title={"Edit image alpha"}
-      aria-label={"Edit image alpha"}
-      onClick={() => updateData(null)}
-      visible={isSomeElementSelected(getNonDeletedElements(elements), appState)}
-    />
-  ),
-});
--- a/src/actions/actionProperties.tsx
+++ b/src/actions/actionProperties.tsx
@@ -30,19 +30,31 @@ import {
  TextAlignCenterIcon,
  TextAlignLeftIcon,
  TextAlignRightIcon,
+  TextAlignTopIcon,
+  TextAlignBottomIcon,
+  TextAlignMiddleIcon,
 } from "../components/icons";
 import {
  DEFAULT_FONT_FAMILY,
  DEFAULT_FONT_SIZE,
  FONT_FAMILY,
+  VERTICAL_ALIGN,
 } from "../constants";
 import {
  getNonDeletedElements,
  isTextElement,
  redrawTextBoundingBox,
 } from "../element";
-import { newElementWith } from "../element/mutateElement";
-import { isLinearElement, isLinearElementType } from "../element/typeChecks";
+import { mutateElement, newElementWith } from "../element/mutateElement";
+import {
+  getBoundTextElement,
+  getContainerElement,
+} from "../element/textElement";
+import {
+  isBoundToContainer,
+  isLinearElement,
+  isLinearElementType,
+} from "../element/typeChecks";
 import {
  Arrowhead,
  ExcalidrawElement,
@@ -50,27 +62,37 @@ import {
  ExcalidrawTextElement,
  FontFamilyValues,
  TextAlign,
+  VerticalAlign,
 } 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 (
-      appState.selectedElementIds[element.id] ||
+      selectedElementIds.get(element.id) ||
      element.id === appState.editingElement?.id
    ) {
      return callback(element);
@@ -100,18 +122,97 @@ 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;
-        }),
+        elements: changeProperty(
+          elements,
+          appState,
+          (el) => {
+            return hasStrokeColor(el.type)
+              ? newElementWith(el, {
+                  strokeColor: value.currentItemStrokeColor,
+                })
+              : el;
+          },
+          true,
+        ),
      }),
      appState: {
        ...appState,
@@ -137,6 +238,8 @@ export const actionChangeStrokeColor = register({
        setActive={(active) =>
          updateData({ openPopup: active ? "strokeColorPicker" : null })
        }
+        elements={elements}
+        appState={appState}
      />
    </>
  ),
@@ -177,6 +280,8 @@ export const actionChangeBackgroundColor = register({
        setActive={(active) =>
          updateData({ openPopup: active ? "backgroundColorPicker" : null })
        }
+        elements={elements}
+        appState={appState}
      />
    </>
  ),
@@ -425,24 +530,7 @@ export const actionChangeOpacity = register({
 export const actionChangeFontSize = register({
  name: "changeFontSize",
  perform: (elements, appState, 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,
-    };
+    return changeFontSize(elements, appState, () => value, value);
  },
  PanelComponent: ({ elements, appState, updateData }) => (
    <fieldset>
@@ -454,27 +542,40 @@ 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) => isTextElement(element) && element.fontSize,
+          (element) => {
+            if (isTextElement(element)) {
+              return element.fontSize;
+            }
+            const boundTextElement = getBoundTextElement(element);
+            if (boundTextElement) {
+              return boundTextElement.fontSize;
+            }
+            return null;
+          },
          appState.currentItemFontSize || DEFAULT_FONT_SIZE,
        )}
        onChange={(value) => updateData(value)}
@@ -483,21 +584,71 @@ 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, (el) => {
-        if (isTextElement(el)) {
-          const element: ExcalidrawTextElement = newElementWith(el, {
-            fontFamily: value,
-          });
-          redrawTextBoundingBox(element);
-          return element;
-        }
+      elements: changeProperty(
+        elements,
+        appState,
+        (oldElement) => {
+          if (isTextElement(oldElement)) {
+            const newElement: ExcalidrawTextElement = newElementWith(
+              oldElement,
+              {
+                fontFamily: value,
+              },
+            );
+            redrawTextBoundingBox(
+              newElement,
+              getContainerElement(oldElement),
+              appState,
+            );
+            return newElement;
+          }

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

-        return el;
-      }),
+          return oldElement;
+        },
+        true,
+      ),
      appState: {
        ...appState,
        currentItemTextAlign: value,
@@ -569,38 +739,119 @@ export const actionChangeTextAlign = register({
      commitToHistory: true,
    };
  },
-  PanelComponent: ({ elements, appState, updateData }) => (
-    <fieldset>
-      <legend>{t("labels.textAlign")}</legend>
-      <ButtonIconSelect<TextAlign | false>
-        group="text-align"
-        options={[
-          {
-            value: "left",
-            text: t("labels.left"),
-            icon: <TextAlignLeftIcon theme={appState.theme} />,
-          },
-          {
-            value: "center",
-            text: t("labels.center"),
-            icon: <TextAlignCenterIcon theme={appState.theme} />,
-          },
-          {
-            value: "right",
-            text: t("labels.right"),
-            icon: <TextAlignRightIcon theme={appState.theme} />,
-          },
-        ]}
-        value={getFormValue(
-          elements,
-          appState,
-          (element) => isTextElement(element) && element.textAlign,
-          appState.currentItemTextAlign,
-        )}
-        onChange={(value) => updateData(value)}
-      />
-    </fieldset>
-  ),
+  PanelComponent: ({ elements, appState, updateData }) => {
+    return (
+      <fieldset>
+        <legend>{t("labels.textAlign")}</legend>
+        <ButtonIconSelect<TextAlign | false>
+          group="text-align"
+          options={[
+            {
+              value: "left",
+              text: t("labels.left"),
+              icon: <TextAlignLeftIcon theme={appState.theme} />,
+            },
+            {
+              value: "center",
+              text: t("labels.center"),
+              icon: <TextAlignCenterIcon theme={appState.theme} />,
+            },
+            {
+              value: "right",
+              text: t("labels.right"),
+              icon: <TextAlignRightIcon theme={appState.theme} />,
+            },
+          ]}
+          value={getFormValue(
+            elements,
+            appState,
+            (element) => {
+              if (isTextElement(element)) {
+                return element.textAlign;
+              }
+              const boundTextElement = getBoundTextElement(element);
+              if (boundTextElement) {
+                return boundTextElement.textAlign;
+              }
+              return null;
+            },
+            appState.currentItemTextAlign,
+          )}
+          onChange={(value) => updateData(value)}
+        />
+      </fieldset>
+    );
+  },
+});
+export const actionChangeVerticalAlign = register({
+  name: "changeVerticalAlign",
+  perform: (elements, appState, value) => {
+    return {
+      elements: changeProperty(
+        elements,
+        appState,
+        (oldElement) => {
+          if (isTextElement(oldElement)) {
+            const newElement: ExcalidrawTextElement = newElementWith(
+              oldElement,
+              { verticalAlign: value },
+            );
+
+            redrawTextBoundingBox(
+              newElement,
+              getContainerElement(oldElement),
+              appState,
+            );
+            return newElement;
+          }
+
+          return oldElement;
+        },
+        true,
+      ),
+      appState: {
+        ...appState,
+      },
+      commitToHistory: true,
+    };
+  },
+  PanelComponent: ({ elements, appState, updateData }) => {
+    return (
+      <fieldset>
+        <ButtonIconSelect<VerticalAlign | false>
+          group="text-align"
+          options={[
+            {
+              value: VERTICAL_ALIGN.TOP,
+              text: t("labels.alignTop"),
+              icon: <TextAlignTopIcon theme={appState.theme} />,
+            },
+            {
+              value: VERTICAL_ALIGN.MIDDLE,
+              text: t("labels.centerVertically"),
+              icon: <TextAlignMiddleIcon theme={appState.theme} />,
+            },
+            {
+              value: VERTICAL_ALIGN.BOTTOM,
+              text: t("labels.alignBottom"),
+              icon: <TextAlignBottomIcon theme={appState.theme} />,
+            },
+          ]}
+          value={getFormValue(elements, appState, (element) => {
+            if (isTextElement(element) && element.containerId) {
+              return element.verticalAlign;
+            }
+            const boundTextElement = getBoundTextElement(element);
+            if (boundTextElement) {
+              return boundTextElement.verticalAlign;
+            }
+            return null;
+          })}
+          onChange={(value) => updateData(value)}
+        />
+      </fieldset>
+    );
+  },
 });

 export const actionChangeSharpness = register({
--- a/src/actions/actionStyles.test.tsx
+++ b/src/actions/actionStyles.test.tsx
@@ -0,0 +1,71 @@
+import ExcalidrawApp from "../excalidraw-app";
+import { t } from "../i18n";
+import { CODES } from "../keys";
+import { API } from "../tests/helpers/api";
+import { Keyboard, Pointer, UI } from "../tests/helpers/ui";
+import { fireEvent, render, screen } from "../tests/test-utils";
+import { copiedStyles } from "./actionStyles";
+
+const { h } = window;
+
+const mouse = new Pointer("mouse");
+
+describe("actionStyles", () => {
+  beforeEach(async () => {
+    await render(<ExcalidrawApp />);
+  });
+  it("should copy & paste styles via keyboard", () => {
+    UI.clickTool("rectangle");
+    mouse.down(10, 10);
+    mouse.up(20, 20);
+
+    UI.clickTool("rectangle");
+    mouse.down(10, 10);
+    mouse.up(20, 20);
+
+    // Change some styles of second rectangle
+    UI.clickLabeledElement("Stroke");
+    UI.clickLabeledElement(t("colors.c92a2a"));
+    UI.clickLabeledElement("Background");
+    UI.clickLabeledElement(t("colors.e64980"));
+    // Fill style
+    fireEvent.click(screen.getByTitle("Cross-hatch"));
+    // Stroke width
+    fireEvent.click(screen.getByTitle("Bold"));
+    // Stroke style
+    fireEvent.click(screen.getByTitle("Dotted"));
+    // Roughness
+    fireEvent.click(screen.getByTitle("Cartoonist"));
+    // Opacity
+    fireEvent.change(screen.getByLabelText("Opacity"), {
+      target: { value: "60" },
+    });
+
+    mouse.reset();
+
+    API.setSelectedElements([h.elements[1]]);
+
+    Keyboard.withModifierKeys({ ctrl: true, alt: true }, () => {
+      Keyboard.codeDown(CODES.C);
+    });
+    const secondRect = JSON.parse(copiedStyles);
+    expect(secondRect.id).toBe(h.elements[1].id);
+
+    mouse.reset();
+    // Paste styles to first rectangle
+    API.setSelectedElements([h.elements[0]]);
+    Keyboard.withModifierKeys({ ctrl: true, alt: true }, () => {
+      Keyboard.codeDown(CODES.V);
+    });
+
+    const firstRect = API.getSelectedElement();
+    expect(firstRect.id).toBe(h.elements[0].id);
+    expect(firstRect.strokeColor).toBe("#c92a2a");
+    expect(firstRect.backgroundColor).toBe("#e64980");
+    expect(firstRect.fillStyle).toBe("cross-hatch");
+    expect(firstRect.strokeWidth).toBe(2); // Bold: 2
+    expect(firstRect.strokeStyle).toBe("dotted");
+    expect(firstRect.roughness).toBe(2); // Cartoonist: 2
+    expect(firstRect.opacity).toBe(60);
+  });
+});
--- a/src/actions/actionStyles.ts
+++ b/src/actions/actionStyles.ts
@@ -12,6 +12,7 @@ import {
  DEFAULT_FONT_FAMILY,
  DEFAULT_TEXT_ALIGN,
 } from "../constants";
+import { getContainerElement } from "../element/textElement";

 // `copiedStyles` is exported only for tests.
 export let copiedStyles: string = "{}";
@@ -55,13 +56,18 @@ export const actionPasteStyles = register({
            opacity: pastedElement?.opacity,
            roughness: pastedElement?.roughness,
          });
-          if (isTextElement(newElement)) {
+          if (isTextElement(newElement) && isTextElement(element)) {
            mutateElement(newElement, {
              fontSize: pastedElement?.fontSize || DEFAULT_FONT_SIZE,
              fontFamily: pastedElement?.fontFamily || DEFAULT_FONT_FAMILY,
              textAlign: pastedElement?.textAlign || DEFAULT_TEXT_ALIGN,
            });
-            redrawTextBoundingBox(newElement);
+
+            redrawTextBoundingBox(
+              newElement,
+              getContainerElement(newElement),
+              appState,
+            );
          }
          return newElement;
        }
--- a/src/actions/actionUnbindText.tsx
+++ b/src/actions/actionUnbindText.tsx
@@ -0,0 +1,44 @@
+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,
+    };
+  },
+});
--- a/src/actions/index.ts
+++ b/src/actions/index.ts
@@ -17,6 +17,7 @@ export {
  actionChangeFontSize,
  actionChangeFontFamily,
  actionChangeTextAlign,
+  actionChangeVerticalAlign,
 } from "./actionProperties";

 export {
@@ -80,4 +81,5 @@ export { actionToggleGridMode } from "./actionToggleGridMode";
 export { actionToggleZenMode } from "./actionToggleZenMode";

 export { actionToggleStats } from "./actionToggleStats";
-export { actionEditImageAlpha } from "./actionImageEditing";
+export { actionUnbindText } from "./actionUnbindText";
+export { actionLink } from "../element/Hyperlink";
--- a/src/actions/manager.tsx
+++ b/src/actions/manager.tsx
@@ -10,6 +10,31 @@ import {
 import { ExcalidrawElement } from "../element/types";
 import { AppClassProperties, AppState } from "../types";
 import { MODES } from "../constants";
+import { trackEvent } from "../analytics";
+
+const trackAction = (
+  action: Action,
+  source: "ui" | "keyboard" | "api",
+  value: any,
+) => {
+  if (action.trackEvent !== false) {
+    try {
+      if (action.trackEvent === true) {
+        trackEvent(
+          action.name,
+          source,
+          typeof value === "number" || typeof value === "string"
+            ? String(value)
+            : undefined,
+        );
+      } else {
+        action.trackEvent?.(action, source, value);
+      }
+    } catch (error) {
+      console.error("error while logging action:", error);
+    }
+  }
+};

 export class ActionManager implements ActionsManagerInterface {
  actions = {} as ActionsManagerInterface["actions"];
@@ -65,9 +90,15 @@ export class ActionManager implements ActionsManagerInterface {
          ),
      );

-    if (data.length === 0) {
+    if (data.length !== 1) {
+      if (data.length > 1) {
+        console.warn("Canceling as multiple actions match this shortcut", data);
+      }
      return false;
    }
+
+    const action = data[0];
+
    const { viewModeEnabled } = this.getAppState();
    if (viewModeEnabled) {
      if (!Object.values(MODES).includes(data[0].name)) {
@@ -75,6 +106,8 @@ export class ActionManager implements ActionsManagerInterface {
      }
    }

+    trackAction(action, "keyboard", null);
+
    event.preventDefault();
    this.updater(
      data[0].perform(
@@ -96,6 +129,7 @@ export class ActionManager implements ActionsManagerInterface {
        this.app,
      ),
    );
+    trackAction(action, "api", null);
  }

  /**
@@ -122,6 +156,8 @@ export class ActionManager implements ActionsManagerInterface {
            this.app,
          ),
        );
+
+        trackAction(action, "ui", formState);
      };

      return (
--- a/src/actions/register.ts
+++ b/src/actions/register.ts
@@ -2,7 +2,9 @@ import { Action } from "./types";

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

-export const register = (action: Action): Action => {
+export const register = <T extends Action>(action: T) => {
  actions = actions.concat(action);
-  return action;
+  return action as T & {
+    keyTest?: unknown extends T["keyTest"] ? never : T["keyTest"];
+  };
 };
--- a/src/actions/shortcuts.ts
+++ b/src/actions/shortcuts.ts
@@ -1,8 +1,10 @@
 import { t } from "../i18n";
 import { isDarwin } from "../keys";
 import { getShortcutKey } from "../utils";
+import { ActionName } from "./types";

-export type ShortcutName =
+export type ShortcutName = SubtypeOf<
+  ActionName,
  | "cut"
  | "copy"
  | "paste"
@@ -25,7 +27,9 @@ export type ShortcutName =
  | "addToLibrary"
  | "viewMode"
  | "flipHorizontal"
-  | "flipVertical";
+  | "flipVertical"
+  | "hyperlink"
+>;

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

 export const getShortcutFromShortcutName = (name: ShortcutName) => {
  const shortcuts = shortcutMap[name];
-  // if multiple shortcuts availiable, take the first one
+  // if multiple shortcuts available, take the first one
  return shortcuts && shortcuts.length > 0 ? shortcuts[0] : "";
 };
--- a/src/actions/types.ts
+++ b/src/actions/types.ts
@@ -82,6 +82,7 @@ export type ActionName =
  | "zoomToSelection"
  | "changeFontFamily"
  | "changeTextAlign"
+  | "changeVerticalAlign"
  | "toggleFullScreen"
  | "toggleShortcuts"
  | "group"
@@ -102,7 +103,10 @@ export type ActionName =
  | "viewMode"
  | "exportWithDarkMode"
  | "toggleTheme"
-  | "editImageAlpha";
+  | "increaseFontSize"
+  | "decreaseFontSize"
+  | "unbindText"
+  | "hyperlink";

 export type PanelComponentProps = {
  elements: readonly ExcalidrawElement[];
@@ -122,12 +126,20 @@ export interface Action {
    appState: AppState,
    elements: readonly ExcalidrawElement[],
  ) => boolean;
-  contextItemLabel?: string;
+  contextItemLabel?:
+    | string
+    | ((
+        elements: readonly ExcalidrawElement[],
+        appState: Readonly<AppState>,
+      ) => string);
  contextItemPredicate?: (
    elements: readonly ExcalidrawElement[],
    appState: AppState,
  ) => boolean;
  checked?: (appState: Readonly<AppState>) => boolean;
+  trackEvent?:
+    | boolean
+    | ((action: Action, type: "ui" | "keyboard" | "api", value: any) => void);
 }

 export interface ActionsManagerInterface {
--- a/src/align.ts
+++ b/src/align.ts
@@ -1,6 +1,7 @@
 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";
@@ -30,28 +31,6 @@ 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,
--- a/src/analytics.ts
+++ b/src/analytics.ts
@@ -3,16 +3,16 @@ export const trackEvent =
  process.env?.REACT_APP_GOOGLE_ANALYTICS_ID &&
  typeof window !== "undefined" &&
  window.gtag
-    ? (category: string, name: string, label?: string, value?: number) => {
-        window.gtag("event", name, {
+    ? (category: string, action: string, label?: string, value?: number) => {
+        window.gtag("event", action, {
          event_category: category,
          event_label: label,
          value,
        });
      }
    : typeof process !== "undefined" && process.env?.JEST_WORKER_ID
-    ? (category: string, name: string, label?: string, value?: number) => {}
-    : (category: string, name: string, label?: string, value?: number) => {
+    ? (category: string, action: string, label?: string, value?: number) => {}
+    : (category: string, action: string, label?: string, value?: number) => {
        // Uncomment the next line to track locally
-        // console.info("Track Event", category, name, label, value);
+        // console.info("Track Event", category, action, label, value);
      };
--- a/src/appState.ts
+++ b/src/appState.ts
@@ -41,9 +41,10 @@ export const getDefaultAppState = (): Omit<
    editingElement: null,
    editingGroupId: null,
    editingLinearElement: null,
-    editingImageElement: null,
    elementLocked: false,
    elementType: "selection",
+    penMode: false,
+    penDetected: false,
    errorMessage: null,
    exportBackground: true,
    exportScale: defaultExportScale,
@@ -78,9 +79,12 @@ export const getDefaultAppState = (): Omit<
    toastMessage: null,
    viewBackgroundColor: oc.white,
    zenModeEnabled: false,
-    zoom: { value: 1 as NormalizedZoomValue, translation: { x: 0, y: 0 } },
+    zoom: {
+      value: 1 as NormalizedZoomValue,
+    },
    viewModeEnabled: false,
    pendingImageElement: null,
+    showHyperlinkPopup: false,
  };
 };

@@ -126,9 +130,10 @@ const APP_STATE_STORAGE_CONF = (<
  editingElement: { browser: false, export: false, server: false },
  editingGroupId: { browser: true, export: false, server: false },
  editingLinearElement: { browser: false, export: false, server: false },
-  editingImageElement: { 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 },
@@ -170,6 +175,7 @@ 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 = <
--- a/src/charts.ts
+++ b/src/charts.ts
@@ -1,5 +1,10 @@
 import colors from "./colors";
-import { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, ENV } from "./constants";
+import {
+  DEFAULT_FONT_FAMILY,
+  DEFAULT_FONT_SIZE,
+  ENV,
+  VERTICAL_ALIGN,
+} from "./constants";
 import { newElement, newLinearElement, newTextElement } from "./element";
 import { NonDeletedExcalidrawElement } from "./element/types";
 import { randomId } from "./random";
@@ -103,7 +108,7 @@ const transposeCells = (cells: string[][]) => {
 };

 export const tryParseSpreadsheet = (text: string): ParseSpreadsheetResult => {
-  // Copy/paste from excel, spreadhseets, tsv, csv.
+  // Copy/paste from excel, spreadsheets, tsv, csv.
  // For now we only accept 2 columns with an optional header

  // Check for tab separated values
@@ -161,7 +166,7 @@ const commonProps = {
  strokeSharpness: "sharp",
  strokeStyle: "solid",
  strokeWidth: 1,
-  verticalAlign: "middle",
+  verticalAlign: VERTICAL_ALIGN.MIDDLE,
 } as const;

 const getChartDimentions = (spreadsheet: Spreadsheet) => {
--- a/src/clipboard.ts
+++ b/src/clipboard.ts
@@ -124,7 +124,7 @@ const getSystemClipboard = async (
 };

 /**
- * Attemps to parse clipboard. Prefers system clipboard.
+ * Attempts to parse clipboard. Prefers system clipboard.
 */
 export const parseClipboard = async (
  event: ClipboardEvent | null,
--- a/src/components/Actions.tsx
+++ b/src/components/Actions.tsx
@@ -19,7 +19,7 @@ import { capitalizeString, isTransparent, setCursorForShape } from "../utils";
 import Stack from "./Stack";
 import { ToolButton } from "./ToolButton";
 import { hasStrokeColor } from "../scene/comparisons";
-import { isImageElement } from "../element/typeChecks";
+import { hasBoundTextElement, isBoundToContainer } from "../element/typeChecks";

 export const SelectedShapeActions = ({
  appState,
@@ -36,6 +36,15 @@ export const SelectedShapeActions = ({
    getNonDeletedElements(elements),
    appState,
  );
+
+  let isSingleElementBoundContainer = false;
+  if (
+    targetElements.length === 2 &&
+    (hasBoundTextElement(targetElements[0]) ||
+      hasBoundTextElement(targetElements[1]))
+  ) {
+    isSingleElementBoundContainer = true;
+  }
  const isEditing = Boolean(appState.editingElement);
  const isMobile = useIsMobile();
  const isRTL = document.documentElement.getAttribute("dir") === "rtl";
@@ -101,18 +110,15 @@ export const SelectedShapeActions = ({
        </>
      )}

+      {targetElements.some(
+        (element) =>
+          hasBoundTextElement(element) || isBoundToContainer(element),
+      ) && renderAction("changeVerticalAlign")}
      {(canHaveArrowheads(elementType) ||
        targetElements.some((element) => canHaveArrowheads(element.type))) && (
        <>{renderAction("changeArrowhead")}</>
      )}

-      <fieldset>
-        <div className="buttonList">
-          {targetElements.some((element) => isImageElement(element)) &&
-            renderAction("editImageAlpha")}
-        </div>
-      </fieldset>
-
      {renderAction("changeOpacity")}

      <fieldset>
@@ -125,7 +131,7 @@ export const SelectedShapeActions = ({
        </div>
      </fieldset>

-      {targetElements.length > 1 && (
+      {targetElements.length > 1 && !isSingleElementBoundContainer && (
        <fieldset>
          <legend>{t("labels.align")}</legend>
          <div className="buttonList">
@@ -158,14 +164,15 @@ export const SelectedShapeActions = ({
          </div>
        </fieldset>
      )}
-      {!isMobile && !isEditing && targetElements.length > 0 && (
+      {!isEditing && targetElements.length > 0 && (
        <fieldset>
          <legend>{t("labels.actions")}</legend>
          <div className="buttonList">
-            {renderAction("duplicateSelection")}
-            {renderAction("deleteSelectedElements")}
+            {!isMobile && renderAction("duplicateSelection")}
+            {!isMobile && renderAction("deleteSelectedElements")}
            {renderAction("group")}
            {renderAction("ungroup")}
+            {targetElements.length === 1 && renderAction("hyperlink")}
          </div>
        </fieldset>
      )}
--- a/src/components/App.tsx
+++ b/src/components/App.tsx
--- a/src/components/ButtonIconSelect.tsx
+++ b/src/components/ButtonIconSelect.tsx
@@ -7,7 +7,7 @@ export const ButtonIconSelect = <T extends Object>({
  onChange,
  group,
 }: {
-  options: { value: T; text: string; icon: JSX.Element }[];
+  options: { value: T; text: string; icon: JSX.Element; testId?: string }[];
  value: T | null;
  onChange: (value: T) => void;
  group: string;
@@ -24,6 +24,7 @@ export const ButtonIconSelect = <T extends Object>({
          name={group}
          onChange={() => onChange(option.value)}
          checked={value === option.value}
+          data-testid={option.testId}
        />
        {option.icon}
      </label>
--- a/src/components/ColorPicker.scss
+++ b/src/components/ColorPicker.scss
@@ -46,7 +46,7 @@
    top: -11px;
  }

-  .color-picker-content {
+  .color-picker-content--default {
    padding: 0.5rem;
    display: grid;
    grid-template-columns: repeat(5, auto);
@@ -59,6 +59,26 @@
    }
  }

+  .color-picker-content--canvas {
+    display: flex;
+    flex-direction: column;
+    padding: 0.25rem;
+
+    &-title {
+      color: $oc-gray-6;
+      font-size: 12px;
+      padding: 0 0.25rem;
+    }
+
+    &-colors {
+      padding: 0.5rem 0;
+
+      .color-picker-swatch {
+        margin: 0 0.25rem;
+      }
+    }
+  }
+
  .color-picker-content .color-input-container {
    grid-column: 1 / span 5;
  }
--- a/src/components/ColorPicker.tsx
+++ b/src/components/ColorPicker.tsx
@@ -7,6 +7,53 @@ import { isArrowKey, KEYS } from "../keys";
 import { t, getLanguage } from "../i18n";
 import { isWritableElement } from "../utils";
 import colors from "../colors";
+import { ExcalidrawElement } from "../element/types";
+import { AppState } from "../types";
+
+const MAX_CUSTOM_COLORS = 5;
+const MAX_DEFAULT_COLORS = 15;
+
+export const getCustomColors = (
+  elements: readonly ExcalidrawElement[],
+  type: "elementBackground" | "elementStroke",
+) => {
+  const customColors: string[] = [];
+  const updatedElements = elements
+    .filter((element) => !element.isDeleted)
+    .sort((ele1, ele2) => ele2.updated - ele1.updated);
+
+  let index = 0;
+  const elementColorTypeMap = {
+    elementBackground: "backgroundColor",
+    elementStroke: "strokeColor",
+  };
+  const colorType = elementColorTypeMap[type] as
+    | "backgroundColor"
+    | "strokeColor";
+  while (
+    index < updatedElements.length &&
+    customColors.length < MAX_CUSTOM_COLORS
+  ) {
+    const element = updatedElements[index];
+
+    if (
+      customColors.length < MAX_CUSTOM_COLORS &&
+      isCustomColor(element[colorType], type) &&
+      !customColors.includes(element[colorType])
+    ) {
+      customColors.push(element[colorType]);
+    }
+    index++;
+  }
+  return customColors;
+};
+
+const isCustomColor = (
+  color: string,
+  type: "elementBackground" | "elementStroke",
+) => {
+  return !colors[type].includes(color);
+};

 const isValidColor = (color: string) => {
  const style = new Option().style;
@@ -35,6 +82,7 @@ const keyBindings = [
  ["1", "2", "3", "4", "5"],
  ["q", "w", "e", "r", "t"],
  ["a", "s", "d", "f", "g"],
+  ["z", "x", "c", "v", "b"],
 ].flat();

 const Picker = ({
@@ -45,6 +93,7 @@ const Picker = ({
  label,
  showInput = true,
  type,
+  elements,
 }: {
  colors: string[];
  color: string | null;
@@ -53,12 +102,20 @@ const Picker = ({
  label: string;
  showInput: boolean;
  type: "canvasBackground" | "elementBackground" | "elementStroke";
+  elements: readonly ExcalidrawElement[];
 }) => {
  const firstItem = React.useRef<HTMLButtonElement>();
  const activeItem = React.useRef<HTMLButtonElement>();
  const gallery = React.useRef<HTMLDivElement>();
  const colorInput = React.useRef<HTMLInputElement>();

+  const [customColors] = React.useState(() => {
+    if (type === "canvasBackground") {
+      return [];
+    }
+    return getCustomColors(elements, type);
+  });
+
  React.useEffect(() => {
    // After the component is first mounted focus on first input
    if (activeItem.current) {
@@ -85,23 +142,42 @@ const Picker = ({
    } else if (isArrowKey(event.key)) {
      const { activeElement } = document;
      const isRTL = getLanguage().rtl;
-      const index = Array.prototype.indexOf.call(
-        gallery!.current!.children,
+      let isCustom = false;
+      let index = Array.prototype.indexOf.call(
+        gallery!.current!.querySelector(".color-picker-content--default")!
+          .children,
        activeElement,
      );
+      if (index === -1) {
+        index = Array.prototype.indexOf.call(
+          gallery!.current!.querySelector(
+            ".color-picker-content--canvas-colors",
+          )!.children,
+          activeElement,
+        );
+        if (index !== -1) {
+          isCustom = true;
+        }
+      }
+      const parentSelector = isCustom
+        ? gallery!.current!.querySelector(
+            ".color-picker-content--canvas-colors",
+          )!
+        : gallery!.current!.querySelector(".color-picker-content--default")!;
+
      if (index !== -1) {
-        const length = gallery!.current!.children.length - (showInput ? 1 : 0);
+        const length = parentSelector!.children.length - (showInput ? 1 : 0);
        const nextIndex =
          event.key === (isRTL ? KEYS.ARROW_LEFT : KEYS.ARROW_RIGHT)
            ? (index + 1) % length
            : event.key === (isRTL ? KEYS.ARROW_RIGHT : KEYS.ARROW_LEFT)
            ? (length + index - 1) % length
-            : event.key === KEYS.ARROW_DOWN
+            : !isCustom && event.key === KEYS.ARROW_DOWN
            ? (index + 5) % length
-            : event.key === KEYS.ARROW_UP
+            : !isCustom && event.key === KEYS.ARROW_UP
            ? (length + index - 5) % length
            : index;
-        (gallery!.current!.children![nextIndex] as any).focus();
+        (parentSelector!.children![nextIndex] as HTMLElement)?.focus();
      }
      event.preventDefault();
    } else if (
@@ -109,7 +185,15 @@ const Picker = ({
      !isWritableElement(event.target)
    ) {
      const index = keyBindings.indexOf(event.key.toLowerCase());
-      (gallery!.current!.children![index] as any).focus();
+      const isCustom = index >= MAX_DEFAULT_COLORS;
+      const parentSelector = isCustom
+        ? gallery!.current!.querySelector(
+            ".color-picker-content--canvas-colors",
+          )!
+        : gallery!.current!.querySelector(".color-picker-content--default")!;
+      const actualIndex = isCustom ? index - MAX_DEFAULT_COLORS : index;
+      (parentSelector!.children![actualIndex] as HTMLElement)?.focus();
+
      event.preventDefault();
    } else if (event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) {
      event.preventDefault();
@@ -119,6 +203,50 @@ const Picker = ({
    event.stopPropagation();
  };

+  const renderColors = (colors: Array<string>, custom: boolean = false) => {
+    return colors.map((_color, i) => {
+      const _colorWithoutHash = _color.replace("#", "");
+      const keyBinding = custom
+        ? keyBindings[i + MAX_DEFAULT_COLORS]
+        : keyBindings[i];
+      const label = custom
+        ? _colorWithoutHash
+        : t(`colors.${_colorWithoutHash}`);
+      return (
+        <button
+          className="color-picker-swatch"
+          onClick={(event) => {
+            (event.currentTarget as HTMLButtonElement).focus();
+            onChange(_color);
+          }}
+          title={`${label}${
+            !isTransparent(_color) ? ` (${_color})` : ""
+          } — ${keyBinding.toUpperCase()}`}
+          aria-label={label}
+          aria-keyshortcuts={keyBindings[i]}
+          style={{ color: _color }}
+          key={_color}
+          ref={(el) => {
+            if (!custom && el && i === 0) {
+              firstItem.current = el;
+            }
+            if (el && _color === color) {
+              activeItem.current = el;
+            }
+          }}
+          onFocus={() => {
+            onChange(_color);
+          }}
+        >
+          {isTransparent(_color) ? (
+            <div className="color-picker-transparent"></div>
+          ) : undefined}
+          <span className="color-picker-keybinding">{keyBinding}</span>
+        </button>
+      );
+    });
+  };
+
  return (
    <div
      className={`color-picker color-picker-type-${type}`}
@@ -138,41 +266,20 @@ const Picker = ({
        }}
        tabIndex={0}
      >
-        {colors.map((_color, i) => {
-          const _colorWithoutHash = _color.replace("#", "");
-          return (
-            <button
-              className="color-picker-swatch"
-              onClick={(event) => {
-                (event.currentTarget as HTMLButtonElement).focus();
-                onChange(_color);
-              }}
-              title={`${t(`colors.${_colorWithoutHash}`)}${
-                !isTransparent(_color) ? ` (${_color})` : ""
-              } — ${keyBindings[i].toUpperCase()}`}
-              aria-label={t(`colors.${_colorWithoutHash}`)}
-              aria-keyshortcuts={keyBindings[i]}
-              style={{ color: _color }}
-              key={_color}
-              ref={(el) => {
-                if (el && i === 0) {
-                  firstItem.current = el;
-                }
-                if (el && _color === color) {
-                  activeItem.current = el;
-                }
-              }}
-              onFocus={() => {
-                onChange(_color);
-              }}
-            >
-              {isTransparent(_color) ? (
-                <div className="color-picker-transparent"></div>
-              ) : undefined}
-              <span className="color-picker-keybinding">{keyBindings[i]}</span>
-            </button>
-          );
-        })}
+        <div className="color-picker-content--default">
+          {renderColors(colors)}
+        </div>
+        {!!customColors.length && (
+          <div className="color-picker-content--canvas">
+            <span className="color-picker-content--canvas-title">
+              {t("labels.canvasColors")}
+            </span>
+            <div className="color-picker-content--canvas-colors">
+              {renderColors(customColors, true)}
+            </div>
+          </div>
+        )}
+
        {showInput && (
          <ColorInput
            color={color}
@@ -246,6 +353,8 @@ export const ColorPicker = ({
  label,
  isActive,
  setActive,
+  elements,
+  appState,
 }: {
  type: "canvasBackground" | "elementBackground" | "elementStroke";
  color: string | null;
@@ -253,6 +362,8 @@ export const ColorPicker = ({
  label: string;
  isActive: boolean;
  setActive: (active: boolean) => void;
+  elements: readonly ExcalidrawElement[];
+  appState: AppState;
 }) => {
  const pickerButton = React.useRef<HTMLButtonElement>(null);

@@ -294,6 +405,7 @@ export const ColorPicker = ({
              label={label}
              showInput={false}
              type={type}
+              elements={elements}
            />
          </Popover>
        ) : null}
--- a/src/components/ContextMenu.tsx
+++ b/src/components/ContextMenu.tsx
@@ -11,6 +11,7 @@ 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;

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

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

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

 const handleClose = (container: HTMLElement) => {
@@ -125,6 +138,7 @@ export default {
          onCloseRequest={() => handleClose(params.container)}
          actionManager={params.actionManager}
          appState={params.appState}
+          elements={params.elements}
        />,
        getContextMenuNode(params.container),
      );
--- a/src/components/HelpDialog.tsx
+++ b/src/components/HelpDialog.tsx
@@ -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", "7"]}
+                  shortcuts={["Shift + P", "X", "7"]}
                />
                <Shortcut label={t("toolBar.text")} shortcuts={["T", "8"]} />
                <Shortcut label={t("toolBar.image")} shortcuts={["9"]} />
@@ -205,6 +205,10 @@ 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
@@ -260,6 +264,18 @@ 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={[
@@ -382,6 +398,14 @@ 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>
--- a/src/components/HintViewer.tsx
+++ b/src/components/HintViewer.tsx
@@ -61,6 +61,27 @@ const getHints = ({ appState, elements, isMobile }: HintViewerProps) => {
    return t("hints.rotate");
  }

+  if (selectedElements.length === 1 && isTextElement(selectedElements[0])) {
+    return t("hints.text_selected");
+  }
+
+  if (appState.editingElement && isTextElement(appState.editingElement)) {
+    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) {
@@ -75,18 +96,6 @@ const getHints = ({ appState, elements, isMobile }: HintViewerProps) => {
    }
  }

-  if (selectedElements.length === 1 && isTextElement(selectedElements[0])) {
-    return t("hints.text_selected");
-  }
-
-  if (appState.editingElement && isTextElement(appState.editingElement)) {
-    return t("hints.text_editing");
-  }
-
-  if (elementType === "selection" && !selectedElements.length && !isMobile) {
-    return t("hints.canvasPanning");
-  }
-
  return null;
 };

--- a/src/components/LayerUI.tsx
+++ b/src/components/LayerUI.tsx
@@ -36,6 +36,7 @@ import { LibraryMenu } from "./LibraryMenu";

 import "./LayerUI.scss";
 import "./Toolbar.scss";
+import { PenModeButton } from "./PenModeButton";

 interface LayerUIProps {
  actionManager: ActionManager;
@@ -46,6 +47,7 @@ interface LayerUIProps {
  elements: readonly NonDeletedExcalidrawElement[];
  onCollabButtonClick?: () => void;
  onLockToggle: () => void;
+  onPenModeToggle: () => void;
  onInsertElements: (elements: readonly NonDeletedExcalidrawElement[]) => void;
  zenModeEnabled: boolean;
  showExitZenModeBtn: boolean;
@@ -76,6 +78,7 @@ const LayerUI = ({
  elements,
  onCollabButtonClick,
  onLockToggle,
+  onPenModeToggle,
  onInsertElements,
  zenModeEnabled,
  showExitZenModeBtn,
@@ -235,7 +238,7 @@ const LayerUI = ({
        className={CLASSES.SHAPE_ACTIONS_MENU}
        padding={2}
        style={{
-          // we want to make sure this doesn't overflow so substracting 200
+          // we want to make sure this doesn't overflow so subtracting 200
          // which is approximately height of zoom footer and top left menu items with some buffer
          // if active file name is displayed, subtracting 248 to account for its height
          maxHeight: `${appState.height - (appState.fileHandle ? 248 : 200)}px`,
@@ -313,6 +316,13 @@ const LayerUI = ({
                      "zen-mode": zenModeEnabled,
                    })}
                  >
+                    <PenModeButton
+                      zenModeEnabled={zenModeEnabled}
+                      checked={appState.penMode}
+                      onChange={onPenModeToggle}
+                      title={t("toolBar.penMode")}
+                      penDetected={appState.penDetected}
+                    />
                    <LockButton
                      zenModeEnabled={zenModeEnabled}
                      checked={appState.elementLocked}
@@ -498,6 +508,7 @@ const LayerUI = ({
        setAppState={setAppState}
        onCollabButtonClick={onCollabButtonClick}
        onLockToggle={onLockToggle}
+        onPenModeToggle={onPenModeToggle}
        canvas={canvas}
        isCollaborating={isCollaborating}
        renderCustomFooter={renderCustomFooter}
--- a/src/components/LibraryUnit.scss
+++ b/src/components/LibraryUnit.scss
@@ -27,6 +27,8 @@

  .library-unit__dragger {
    display: flex;
+    align-items: center;
+    justify-content: center;
    height: 100%;
    width: 100%;
  }
--- a/src/components/MobileMenu.tsx
+++ b/src/components/MobileMenu.tsx
@@ -17,6 +17,7 @@ import { LockButton } from "./LockButton";
 import { UserList } from "./UserList";
 import { BackgroundPickerAndDarkModeToggle } from "./BackgroundPickerAndDarkModeToggle";
 import { LibraryButton } from "./LibraryButton";
+import { PenModeButton } from "./PenModeButton";

 type MobileMenuProps = {
  appState: AppState;
@@ -28,6 +29,7 @@ type MobileMenuProps = {
  libraryMenu: JSX.Element | null;
  onCollabButtonClick?: () => void;
  onLockToggle: () => void;
+  onPenModeToggle: () => void;
  canvas: HTMLCanvasElement | null;
  isCollaborating: boolean;
  renderCustomFooter?: (isMobile: boolean, appState: AppState) => JSX.Element;
@@ -50,6 +52,7 @@ export const MobileMenu = ({
  setAppState,
  onCollabButtonClick,
  onLockToggle,
+  onPenModeToggle,
  canvas,
  isCollaborating,
  renderCustomFooter,
@@ -92,6 +95,13 @@ export const MobileMenu = ({
                  setAppState={setAppState}
                  isMobile
                />
+                <PenModeButton
+                  checked={appState.penMode}
+                  onChange={onPenModeToggle}
+                  title={t("toolBar.penMode")}
+                  isMobile
+                  penDetected={appState.penDetected}
+                />
              </Stack.Row>
              {libraryMenu}
            </Stack.Col>
--- a/src/components/PenModeButton.tsx
+++ b/src/components/PenModeButton.tsx
@@ -0,0 +1,91 @@
+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>
+  );
+};
--- a/src/components/Popover.tsx
+++ b/src/components/Popover.tsx
@@ -8,6 +8,10 @@ type Props = {
  children?: React.ReactNode;
  onCloseRequest?(event: PointerEvent): void;
  fitInViewport?: boolean;
+  offsetLeft?: number;
+  offsetTop?: number;
+  viewportWidth?: number;
+  viewportHeight?: number;
 };

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

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

  useEffect(() => {
    if (onCloseRequest) {
--- a/src/components/ToolIcon.scss
+++ b/src/components/ToolIcon.scss
@@ -219,6 +219,10 @@
      margin-inline-end: 0;
      top: 60px;
    }
+    .ToolIcon.ToolIcon__penMode {
+      margin-inline-end: 0;
+      top: 140px;
+    }
  }

  .unlocked-icon {
--- a/src/components/Toolbar.scss
+++ b/src/components/Toolbar.scss
@@ -46,6 +46,12 @@
      }
    }

+    .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 {
@@ -81,8 +87,14 @@

    .ToolIcon {
      &:hover {
-        --icon-fill-color: var(--color-primary-chubb);
-        --keybinding-color: var(--color-primary-chubb);
+        --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};
--- a/src/components/Tooltip.tsx
+++ b/src/components/Tooltip.tsx
@@ -2,7 +2,7 @@ import "./Tooltip.scss";

 import React, { useEffect } from "react";

-const getTooltipDiv = () => {
+export const getTooltipDiv = () => {
  const existingDiv = document.querySelector<HTMLDivElement>(
    ".excalidraw-tooltip",
  );
@@ -15,6 +15,50 @@ 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,
@@ -27,35 +71,8 @@ const updateTooltip = (

  tooltip.textContent = label;

-  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`,
-  });
+  const itemRect = item.getBoundingClientRect();
+  updateTooltipPosition(tooltip, itemRect);
 };

 type TooltipProps = {
@@ -75,7 +92,6 @@ export const Tooltip = ({
    return () =>
      getTooltipDiv().classList.remove("excalidraw-tooltip--visible");
  }, []);
-
  return (
    <div
      className="excalidraw-tooltip-wrapper"
--- a/src/components/icons.tsx
+++ b/src/components/icons.tsx
@@ -89,14 +89,6 @@ export const trash = createIcon(

  { width: 448, height: 512 },
 );
-export const backgroundIcon = createIcon(
-  <path
-    fill="currentColor"
-    d="M512 320s-64 92.65-64 128c0 35.35 28.66 64 64 64s64-28.65 64-64-64-128-64-128zm-9.37-102.94L294.94 9.37C288.69 3.12 280.5 0 272.31 0s-16.38 3.12-22.62 9.37l-81.58 81.58L81.93 4.76c-6.25-6.25-16.38-6.25-22.62 0L36.69 27.38c-6.24 6.25-6.24 16.38 0 22.62l86.19 86.18-94.76 94.76c-37.49 37.48-37.49 98.26 0 135.75l117.19 117.19c18.74 18.74 43.31 28.12 67.87 28.12 24.57 0 49.13-9.37 67.87-28.12l221.57-221.57c12.5-12.5 12.5-32.75.01-45.25zm-116.22 70.97H65.93c1.36-3.84 3.57-7.98 7.43-11.83l13.15-13.15 81.61-81.61 58.6 58.6c12.49 12.49 32.75 12.49 45.24 0s12.49-32.75 0-45.24l-58.6-58.6 58.95-58.95 162.44 162.44-48.34 48.34z"
-  ></path>,
-
-  { width: 576, height: 512 },
-);

 export const palette = createIcon(
  "M204.3 5C104.9 24.4 24.8 104.3 5.2 203.4c-37 187 131.7 326.4 258.8 306.7 41.2-6.4 61.4-54.6 42.5-91.7-23.1-45.4 9.9-98.4 60.9-98.4h79.7c35.8 0 64.8-29.6 64.9-65.3C511.5 97.1 368.1-26.9 204.3 5zM96 320c-17.7 0-32-14.3-32-32s14.3-32 32-32 32 14.3 32 32-14.3 32-32 32zm32-128c-17.7 0-32-14.3-32-32s14.3-32 32-32 32 14.3 32 32-14.3 32-32 32zm128-64c-17.7 0-32-14.3-32-32s14.3-32 32-32 32 14.3 32 32-14.3 32-32 32zm128 64c-17.7 0-32-14.3-32-32s14.3-32 32-32 32 14.3 32 32-14.3 32-32 32z",
@@ -893,6 +885,40 @@ export const TextAlignRightIcon = React.memo(({ theme }: { theme: Theme }) =>
  ),
 );

+export const TextAlignTopIcon = React.memo(({ theme }: { theme: Theme }) =>
+  createIcon(
+    <path
+      d="m16,132l416,0c8.837,0 16,-7.163 16,-16l0,-40c0,-8.837 -7.163,-16 -16,-16l-416,0c-8.837,0 -16,7.163 -16,16l0,40c0,8.837 7.163,16 16,16zm0,160l416,0c8.837,0 16,-7.163 16,-16l0,-40c0,-8.837 -7.163,-16 -16,-16l-416,0c-8.837,0 -16,7.163 -16,16l0,40c0,8.837 7.163,16 16,16z"
+      fill={iconFillColor(theme)}
+      strokeLinecap="round"
+    />,
+    { width: 448, height: 512 },
+  ),
+);
+
+export const TextAlignBottomIcon = React.memo(({ theme }: { theme: Theme }) =>
+  createIcon(
+    <path
+      d="M16,292L432,292C440.837,292 448,284.837 448,276L448,236C448,227.163 440.837,220 432,220L16,220C7.163,220 0,227.163 0,236L0,276C0,284.837 7.163,292 16,292ZM16,452L432,452C440.837,452 448,444.837 448,436L448,396C448,387.163 440.837,380 432,380L16,380C7.163,380 0,387.163 0,396L0,436C0,444.837 7.163,452 16,452Z"
+      fill={iconFillColor(theme)}
+      strokeLinecap="round"
+    />,
+    { width: 448, height: 512 },
+  ),
+);
+
+export const TextAlignMiddleIcon = React.memo(({ theme }: { theme: Theme }) =>
+  createIcon(
+    <path
+      transform="matrix(1,0,0,1,0,80)"
+      d="M16,132L432,132C440.837,132 448,124.837 448,116L448,76C448,67.163 440.837,60 432,60L16,60C7.163,60 0,67.163 0,76L0,116C0,124.837 7.163,132 16,132ZM16,292L432,292C440.837,292 448,284.837 448,276L448,236C448,227.163 440.837,220 432,220L16,220C7.163,220 0,227.163 0,236L0,276C0,284.837 7.163,292 16,292Z"
+      fill={iconFillColor(theme)}
+      strokeLinecap="round"
+    />,
+    { width: 448, height: 512 },
+  ),
+);
+
 export const publishIcon = createIcon(
  <path
    d="M537.6 226.6c4.1-10.7 6.4-22.4 6.4-34.6 0-53-43-96-96-96-19.7 0-38.1 6-53.3 16.2C367 64.2 315.3 32 256 32c-88.4 0-160 71.6-160 160 0 2.7.1 5.4.2 8.1C40.2 219.8 0 273.2 0 336c0 79.5 64.5 144 144 144h368c70.7 0 128-57.3 128-128 0-61.9-44-113.6-102.4-125.4zM393.4 288H328v112c0 8.8-7.2 16-16 16h-48c-8.8 0-16-7.2-16-16V288h-65.4c-14.3 0-21.4-17.2-11.3-27.3l105.4-105.4c6.2-6.2 16.4-6.2 22.6 0l105.4 105.4c10.1 10.1 2.9 27.3-11.3 27.3z"
@@ -900,3 +926,11 @@ 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 },
+);
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -24,7 +24,7 @@ export const POINTER_BUTTON = {
  WHEEL: 1,
  SECONDARY: 2,
  TOUCH: -1,
-};
+} as const;

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

 export const ENV = {
@@ -61,6 +63,8 @@ export const ENV = {

 export const CLASSES = {
  SHAPE_ACTIONS_MENU: "App-menu__left",
+  SHAPE_ACTIONS_MOBILE_MENU: "App-mobile-menu",
+  MOBILE_TOOLBAR: "App-toolbar-content",
 };

 // 1-based in case we ever do `if(element.fontFamily)`
@@ -106,10 +110,6 @@ 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;
@@ -119,6 +119,7 @@ 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;
@@ -182,4 +183,10 @@ export const VERSIONS = {
  excalidrawLibrary: 2,
 } as const;

-export const PADDING = 30;
+export const BOUND_TEXT_PADDING = 5;
+
+export const VERTICAL_ALIGN = {
+  TOP: "top",
+  MIDDLE: "middle",
+  BOTTOM: "bottom",
+};
--- a/src/css/theme.scss
+++ b/src/css/theme.scss
@@ -38,7 +38,6 @@
  --text-primary-color: #{$oc-gray-8};

  --color-primary: #6965db;
-  --color-primary-chubb: #625ee0; // to offset Chubb illusion
  --color-primary-darker: #5b57d1;
  --color-primary-darkest: #4a47b1;
  --color-primary-light: #e2e1fc;
@@ -85,7 +84,6 @@
    --text-primary-color: #{$oc-gray-4};

    --color-primary: #5650f0;
-    --color-primary-chubb: #726dff; // to offset Chubb illusion
    --color-primary-darker: #4b46d8;
    --color-primary-darkest: #3e39be;
    --color-primary-light: #3f3d64;
--- a/src/data/restore.ts
+++ b/src/data/restore.ts
@@ -105,6 +105,7 @@ const restoreElementWithProperties = <
      ? element.boundElementIds.map((id) => ({ type: "arrow", id }))
      : element.boundElements ?? [],
    updated: element.updated ?? getUpdatedTimestamp(),
+    link: element.link ?? null,
  };

  return {
@@ -136,7 +137,7 @@ const restoreElement = (
        textAlign: element.textAlign || DEFAULT_TEXT_ALIGN,
        verticalAlign: element.verticalAlign || DEFAULT_VERTICAL_ALIGN,
        containerId: element.containerId ?? null,
-        originalText: element.originalText ?? "",
+        originalText: element.originalText || element.text,
      });
    case "freedraw": {
      return restoreElementWithProperties(element, {
@@ -261,7 +262,6 @@ export const restoreAppState = (
      typeof appState.zoom === "number"
        ? {
            value: appState.zoom as NormalizedZoomValue,
-            translation: defaultAppState.zoom.translation,
          }
        : appState.zoom || defaultAppState.zoom,
  };
--- a/src/disitrubte.ts
+++ b/src/disitrubte.ts
@@ -1,17 +1,7 @@
 import { ExcalidrawElement } from "./element/types";
 import { newElementWith } from "./element/mutateElement";
-import { getCommonBounds } from "./element";
-
-interface Box {
-  minX: number;
-  minY: number;
-  maxX: number;
-  maxY: number;
-  midX: number;
-  midY: number;
-  width: number;
-  height: number;
-}
+import { getMaximumGroups } from "./groups";
+import { getCommonBoundingBox } from "./element/bounds";

 export interface Distribution {
  space: "between";
@@ -98,39 +88,3 @@ 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,
-  };
-};
--- a/src/element/Hyperlink.scss
+++ b/src/element/Hyperlink.scss
@@ -0,0 +1,74 @@
+@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;
+  }
+}
--- a/src/element/Hyperlink.tsx
+++ b/src/element/Hyperlink.tsx
@@ -0,0 +1,465 @@
+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";
+import { trackEvent } from "../analytics";
+
+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);
+
+    if (!element.link && link) {
+      trackEvent("hyperlink", "create");
+    }
+
+    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(() => {
+    trackEvent("hyperlink", "delete");
+    mutateElement(element, { link: null });
+    if (isEditing) {
+      inputRef.current!.value = "";
+    }
+    setAppState({ showHyperlinkPopup: false });
+  }, [setAppState, element, isEditing]);
+
+  const onEdit = () => {
+    trackEvent("hyperlink", "edit", "popup-ui");
+    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: "hyperlink",
+  perform: (elements, appState) => {
+    if (appState.showHyperlinkPopup === "editor") {
+      return false;
+    }
+
+    return {
+      elements,
+      appState: {
+        ...appState,
+        showHyperlinkPopup: "editor",
+        openMenu: null,
+      },
+      commitToHistory: true,
+    };
+  },
+  trackEvent: (action, source) => {
+    trackEvent("hyperlink", "edit", source);
+  },
+  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",
+  );
+  trackEvent("hyperlink", "tooltip", "link-icon");
+
+  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;
+};
--- a/src/element/bounds.ts
+++ b/src/element/bounds.ts
@@ -185,7 +185,7 @@ const getLinearElementAbsoluteCoords = (
      maxY + element.y,
    ];
  } else {
-    const shape = getShapeForElement(element) as Drawable[];
+    const shape = getShapeForElement(element)!;

    // 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) as Drawable[];
+  const shape = getShapeForElement(element)!;

  // first element is always the curve
  const ops = getCurvePathOps(shape[0]);
@@ -520,11 +520,24 @@ 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 };
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    width: maxX - minX,
+    height: maxY - minY,
+    midX: (minX + maxX) / 2,
+    midY: (minY + maxY) / 2,
+  };
 };
--- a/src/element/collision.ts
+++ b/src/element/collision.ts
@@ -24,6 +24,7 @@ import {
  NonDeleted,
  ExcalidrawFreeDrawElement,
  ExcalidrawImageElement,
+  ExcalidrawLinearElement,
 } from "./types";

 import { getElementAbsoluteCoords, getCurvePathOps, Bounds } from "./bounds";
@@ -46,8 +47,7 @@ const isElementDraggableFromInside = (
    return true;
  }
  const isDraggableFromInside =
-    !isTransparent(element.backgroundColor) ||
-    (isTransparent(element.backgroundColor) && hasBoundTextElement(element));
+    !isTransparent(element.backgroundColor) || hasBoundTextElement(element);
  if (element.type === "line") {
    return isDraggableFromInside && isPathALoop(element.points);
  }
@@ -97,7 +97,6 @@ export const isHittingElementNotConsideringBoundingBox = (
    : isElementDraggableFromInside(element)
    ? isInsideCheck
    : isNearCheck;
-
  return hitTestPointAgainstElement({ element, point, threshold, check });
 };

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

-const isPointHittingElementBoundingBox = (
+export const isPointHittingElementBoundingBox = (
  element: NonDeleted<ExcalidrawElement>,
  [x, y]: Point,
  threshold: number,
@@ -363,6 +362,14 @@ 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;
 };

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

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

  if (args.check === isInsideCheck) {
    const hit = shape.some((subshape) =>
@@ -635,7 +646,7 @@ const getCorners = (

 // Returns intersection of `line` with `segment`, with `segment` moved by
 // `gap` in its polar direction.
-// If intersection conincides with second segment point returns empty array.
+// If intersection coincides with second segment point returns empty array.
 const intersectSegment = (
  line: GA.Line,
  segment: [GA.Point, GA.Point],
@@ -823,7 +834,7 @@ const hitTestCurveInside = (
  sharpness: ExcalidrawElement["strokeSharpness"],
 ) => {
  const ops = getCurvePathOps(drawable);
-  const points: Point[] = [];
+  const points: Mutable<Point>[] = [];
  let odd = false; // select one line out of double lines
  for (const operation of ops) {
    if (operation.op === "move") {
@@ -837,13 +848,17 @@ 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 as any, 10, 5);
+    const polygonPoints = pointsOnBezierCurves(points, 10, 5);
    return isPointInPolygon(polygonPoints, x, y);
  }
  return false;
@@ -898,9 +913,10 @@ const hitTestRoughShape = (
      // position of the previous operation
      return retVal;
    } else if (op === "lineTo") {
-      // TODO: Implement this
+      return hitTestCurveInside(drawable, x, y, "sharp");
    } else if (op === "qcurveTo") {
      // TODO: Implement this
+      console.warn("qcurveTo is not implemented yet");
    }

    return false;
--- a/src/element/dragElements.ts
+++ b/src/element/dragElements.ts
@@ -3,10 +3,10 @@ import { updateBoundElements } from "./binding";
 import { getCommonBounds } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getPerfectElementSize } from "./sizeHelpers";
-import Scene from "../scene/Scene";
 import { NonDeletedExcalidrawElement } from "./types";
-import { PointerDownState } from "../types";
-import { getBoundTextElementId } from "./textElement";
+import { AppState, PointerDownState } from "../types";
+import { getBoundTextElement } from "./textElement";
+import { isSelectedViaGroup } from "../groups";

 export const dragSelectedElements = (
  pointerDownState: PointerDownState,
@@ -16,6 +16,7 @@ export const dragSelectedElements = (
  lockDirection: boolean = false,
  distanceX: number = 0,
  distanceY: number = 0,
+  appState: AppState,
 ) => {
  const [x1, y1] = getCommonBounds(selectedElements);
  const offset = { x: pointerX - x1, y: pointerY - y1 };
@@ -28,17 +29,23 @@ export const dragSelectedElements = (
      element,
      offset,
    );
-    if (!element.groupIds.length) {
-      const boundTextElementId = getBoundTextElementId(element);
-      if (boundTextElementId) {
-        const textElement =
-          Scene.getScene(element)!.getElement(boundTextElementId);
+    // 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 textElement = getBoundTextElement(element);
+      if (textElement) {
        updateElementCoords(
          lockDirection,
          distanceX,
          distanceY,
          pointerDownState,
-          textElement!,
+          textElement,
          offset,
        );
      }
--- a/src/element/image.ts
+++ b/src/element/image.ts
@@ -109,16 +109,3 @@ export const normalizeSVG = async (SVGString: string) => {
    return svg.outerHTML;
  }
 };
-
-export const imageFromImageData = (imagedata: ImageData) => {
-  const canvas = document.createElement("canvas");
-  const ctx = canvas.getContext("2d")!;
-  canvas.width = imagedata.width;
-  canvas.height = imagedata.height;
-  ctx.putImageData(imagedata, 0, 0);
-
-  const image = new Image();
-  const dataURL = canvas.toDataURL() as DataURL;
-  image.src = dataURL;
-  return { image, dataURL };
-};
--- a/src/element/imageEditor.ts
+++ b/src/element/imageEditor.ts
@@ -1,112 +0,0 @@
-import { distance2d } from "../math";
-import Scene from "../scene/Scene";
-import {
-  ExcalidrawImageElement,
-  InitializedExcalidrawImageElement,
-} from "./types";
-
-export type EditingImageElement = {
-  editorType: "alpha";
-  elementId: ExcalidrawImageElement["id"];
-  origImageData: Readonly<ImageData>;
-  imageData: ImageData;
-  pointerDownState: {
-    screenX: number;
-    screenY: number;
-    sampledPixel: readonly [number, number, number, number] | null;
-  };
-};
-
-const getElement = (id: EditingImageElement["elementId"]) => {
-  const element = Scene.getScene(id)?.getNonDeletedElement(id);
-  if (element) {
-    return element as InitializedExcalidrawImageElement;
-  }
-  return null;
-};
-
-export class ImageEditor {
-  static handlePointerDown(
-    editingElement: EditingImageElement,
-    scenePointer: { x: number; y: number },
-  ) {
-    const imageElement = getElement(editingElement.elementId);
-
-    if (imageElement) {
-      if (
-        scenePointer.x >= imageElement.x &&
-        scenePointer.x <= imageElement.x + imageElement.width &&
-        scenePointer.y >= imageElement.y &&
-        scenePointer.y <= imageElement.y + imageElement.height
-      ) {
-        editingElement.pointerDownState.screenX = scenePointer.x;
-        editingElement.pointerDownState.screenY = scenePointer.y;
-
-        const { width, height, data } = editingElement.origImageData;
-
-        const imageOffsetX = Math.round(
-          (scenePointer.x - imageElement.x) * (width / imageElement.width),
-        );
-        const imageOffsetY = Math.round(
-          (scenePointer.y - imageElement.y) * (height / imageElement.height),
-        );
-
-        const sampledPixel = [
-          data[(imageOffsetY * width + imageOffsetX) * 4 + 0],
-          data[(imageOffsetY * width + imageOffsetX) * 4 + 1],
-          data[(imageOffsetY * width + imageOffsetX) * 4 + 2],
-          data[(imageOffsetY * width + imageOffsetX) * 4 + 3],
-        ] as const;
-
-        editingElement.pointerDownState.sampledPixel = sampledPixel;
-      }
-    }
-  }
-
-  static handlePointerMove(
-    editingElement: EditingImageElement,
-    scenePointer: { x: number; y: number },
-  ) {
-    const { sampledPixel } = editingElement.pointerDownState;
-    if (sampledPixel) {
-      const { screenX, screenY } = editingElement.pointerDownState;
-      const distance = distance2d(
-        scenePointer.x,
-        scenePointer.y,
-        screenX,
-        screenY,
-      );
-
-      const { width, height, data } = editingElement.origImageData;
-      const newImageData = new ImageData(width, height);
-
-      for (let x = 0; x < width; ++x) {
-        for (let y = 0; y < height; ++y) {
-          if (
-            Math.abs(sampledPixel[0] - data[(y * width + x) * 4 + 0]) +
-              Math.abs(sampledPixel[1] - data[(y * width + x) * 4 + 1]) +
-              Math.abs(sampledPixel[2] - data[(y * width + x) * 4 + 2]) <
-            distance
-          ) {
-            newImageData.data[(y * width + x) * 4 + 0] = 0;
-            newImageData.data[(y * width + x) * 4 + 1] = 255;
-            newImageData.data[(y * width + x) * 4 + 2] = 0;
-            newImageData.data[(y * width + x) * 4 + 3] = 0;
-          } else {
-            for (let p = 0; p < 4; ++p) {
-              newImageData.data[(y * width + x) * 4 + p] =
-                data[(y * width + x) * 4 + p];
-            }
-          }
-        }
-      }
-
-      return newImageData;
-    }
-  }
-
-  static handlePointerUp(editingElement: EditingImageElement) {
-    editingElement.pointerDownState.sampledPixel = null;
-    editingElement.origImageData = editingElement.imageData;
-  }
-}
--- a/src/element/linearElementEditor.ts
+++ b/src/element/linearElementEditor.ts
@@ -401,7 +401,7 @@ export class LinearElementEditor {
      ret.hitElement = element;
    } else {
      // You might be wandering why we are storing the binding elements on
-      // LinearElementEditor and passing them in, insted of calculating them
+      // LinearElementEditor and passing them in, instead of calculating them
      // from the end points of the `linearElement` - this is to allow disabling
      // binding (which needs to happen at the point the user finishes moving
      // the point).
--- a/src/element/newElement.ts
+++ b/src/element/newElement.ts
@@ -13,7 +13,7 @@ import {
  FontFamilyValues,
  ExcalidrawRectangleElement,
 } from "../element/types";
-import { getFontString, getUpdatedTimestamp } from "../utils";
+import { getFontString, getUpdatedTimestamp, isTestEnv } from "../utils";
 import { randomInteger, randomId } from "../random";
 import { mutateElement, newElementWith } from "./mutateElement";
 import { getNewGroupIdsForDuplication } from "../groups";
@@ -21,10 +21,8 @@ import { AppState } from "../types";
 import { getElementAbsoluteCoords } from ".";
 import { adjustXYWithRotation } from "../math";
 import { getResizedElementAbsoluteCoords } from "./bounds";
-import { measureText } from "./textElement";
-import { isBoundToContainer } from "./typeChecks";
-import Scene from "../scene/Scene";
-import { PADDING } from "../constants";
+import { getContainerElement, measureText, wrapText } from "./textElement";
+import { BOUND_TEXT_PADDING, VERTICAL_ALIGN } from "../constants";

 type ElementConstructorOpts = MarkOptional<
  Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">,
@@ -36,6 +34,7 @@ type ElementConstructorOpts = MarkOptional<
  | "seed"
  | "version"
  | "versionNonce"
+  | "link"
 >;

 const _newElementBase = <T extends ExcalidrawElement>(
@@ -56,6 +55,7 @@ const _newElementBase = <T extends ExcalidrawElement>(
    groupIds = [],
    strokeSharpness,
    boundElements = null,
+    link = null,
    ...rest
  }: ElementConstructorOpts & Omit<Partial<ExcalidrawGenericElement>, "type">,
 ) => {
@@ -82,6 +82,7 @@ const _newElementBase = <T extends ExcalidrawElement>(
    isDeleted: false as false,
    boundElements,
    updated: getUpdatedTimestamp(),
+    link,
  };
  return element;
 };
@@ -158,7 +159,11 @@ const getAdjustedDimensions = (
  height: number;
  baseline: number;
 } => {
-  const maxWidth = element.containerId ? element.width : null;
+  let maxWidth = null;
+  const container = getContainerElement(element);
+  if (container) {
+    maxWidth = container.width - BOUND_TEXT_PADDING * 2;
+  }
  const {
    width: nextWidth,
    height: nextHeight,
@@ -169,7 +174,7 @@ const getAdjustedDimensions = (
  let y: number;
  if (
    textAlign === "center" &&
-    verticalAlign === "middle" &&
+    verticalAlign === VERTICAL_ALIGN.MIDDLE &&
    !element.containerId
  ) {
    const prevMetrics = measureText(
@@ -215,15 +220,14 @@ const getAdjustedDimensions = (

  // make sure container dimensions are set properly when
  // text editor overflows beyond viewport dimensions
-  if (isBoundToContainer(element)) {
-    const container = Scene.getScene(element)!.getElement(element.containerId)!;
+  if (container) {
    let height = container.height;
    let width = container.width;
-    if (nextHeight > height - PADDING * 2) {
-      height = nextHeight + PADDING * 2;
+    if (nextHeight > height - BOUND_TEXT_PADDING * 2) {
+      height = nextHeight + BOUND_TEXT_PADDING * 2;
    }
-    if (nextWidth > width - PADDING * 2) {
-      width = nextWidth + 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 });
@@ -244,13 +248,17 @@ export const updateTextElement = (
    text,
    isDeleted,
    originalText,
-  }: { text: string; isDeleted?: boolean; originalText: string },
-
-  updateDimensions: boolean,
+  }: {
+    text: string;
+    isDeleted?: boolean;
+    originalText: string;
+  },
 ): ExcalidrawTextElement => {
-  const dimensions = updateDimensions
-    ? getAdjustedDimensions(element, text)
-    : undefined;
+  const container = getContainerElement(element);
+  if (container) {
+    text = wrapText(text, getFontString(element), container.width);
+  }
+  const dimensions = getAdjustedDimensions(element, text);
  return newElementWith(element, {
    text,
    originalText,
@@ -369,7 +377,7 @@ export const duplicateElement = <TElement extends Mutable<ExcalidrawElement>>(
  overrides?: Partial<TElement>,
 ): TElement => {
  let copy: TElement = deepCopyElement(element);
-  if (process.env.NODE_ENV === "test") {
+  if (isTestEnv()) {
    copy.id = `${copy.id}_copy`;
    // `window.h` may not be defined in some unit tests
    if (
--- a/src/element/resizeElements.ts
+++ b/src/element/resizeElements.ts
@@ -1,4 +1,4 @@
-import { SHIFT_LOCKING_ANGLE } from "../constants";
+import { BOUND_TEXT_PADDING, SHIFT_LOCKING_ANGLE } from "../constants";
 import { rescalePoints } from "../points";

 import {
@@ -35,7 +35,9 @@ import {
 import { Point, PointerDownState } from "../types";
 import Scene from "../scene/Scene";
 import {
+  getApproxMinLineHeight,
  getApproxMinLineWidth,
+  getBoundTextElement,
  getBoundTextElementId,
  handleBindTextResize,
  measureText,
@@ -104,7 +106,7 @@ export const transformElements = (
      updateBoundElements(element);
    } else if (transformHandleType) {
      resizeSingleElement(
-        pointerDownState.originalElements.get(element.id) as typeof element,
+        pointerDownState.originalElements,
        shouldMaintainAspectRatio,
        element,
        transformHandleType,
@@ -139,7 +141,6 @@ export const transformElements = (
        pointerX,
        pointerY,
      );
-      handleBindTextResize(selectedElements, transformHandleType);
      return true;
    }
  }
@@ -396,7 +397,7 @@ const resizeSingleTextElement = (
 };

 export const resizeSingleElement = (
-  stateAtResizeStart: NonDeletedExcalidrawElement,
+  originalElements: PointerDownState["originalElements"],
  shouldMaintainAspectRatio: boolean,
  element: NonDeletedExcalidrawElement,
  transformHandleDirection: TransformHandleDirection,
@@ -404,6 +405,7 @@ export const resizeSingleElement = (
  pointerX: number,
  pointerY: number,
 ) => {
+  const stateAtResizeStart = originalElements.get(element.id)!;
  // Gets bounds corners
  const [x1, y1, x2, y2] = getResizedElementAbsoluteCoords(
    stateAtResizeStart,
@@ -428,8 +430,6 @@ export const resizeSingleElement = (
    element.height,
  );

-  const boundTextElementId = getBoundTextElementId(element);
-
  const boundsCurrentWidth = esx2 - esx1;
  const boundsCurrentHeight = esy2 - esy1;

@@ -440,6 +440,9 @@ export const resizeSingleElement = (
  let scaleX = atStartBoundsWidth / boundsCurrentWidth;
  let scaleY = atStartBoundsHeight / boundsCurrentHeight;

+  let boundTextFont: { fontSize?: number; baseline?: number } = {};
+  const boundTextElement = getBoundTextElement(element);
+
  if (transformHandleDirection.includes("e")) {
    scaleX = (rotatedPointer[0] - startTopLeft[0]) / boundsCurrentWidth;
  }
@@ -452,6 +455,7 @@ export const resizeSingleElement = (
  if (transformHandleDirection.includes("n")) {
    scaleY = (startBottomRight[1] - rotatedPointer[1]) / boundsCurrentHeight;
  }
+
  // Linear elements dimensions differ from bounds dimensions
  const eleInitialWidth = stateAtResizeStart.width;
  const eleInitialHeight = stateAtResizeStart.height;
@@ -481,6 +485,37 @@ export const resizeSingleElement = (
    }
  }

+  if (boundTextElement) {
+    const stateOfBoundTextElementAtResize = originalElements.get(
+      boundTextElement.id,
+    ) as typeof boundTextElement | undefined;
+    if (stateOfBoundTextElementAtResize) {
+      boundTextFont = {
+        fontSize: stateOfBoundTextElementAtResize.fontSize,
+        baseline: stateOfBoundTextElementAtResize.baseline,
+      };
+    }
+    if (shouldMaintainAspectRatio) {
+      const nextFont = measureFontSizeFromWH(
+        boundTextElement,
+        eleNewWidth - BOUND_TEXT_PADDING * 2,
+        eleNewHeight - BOUND_TEXT_PADDING * 2,
+      );
+      if (nextFont === null) {
+        return;
+      }
+      boundTextFont = {
+        fontSize: nextFont.size,
+        baseline: nextFont.baseline,
+      };
+    } else {
+      const minWidth = getApproxMinLineWidth(getFontString(boundTextElement));
+      const minHeight = getApproxMinLineHeight(getFontString(boundTextElement));
+      eleNewWidth = Math.ceil(Math.max(eleNewWidth, minWidth));
+      eleNewHeight = Math.ceil(Math.max(eleNewHeight, minHeight));
+    }
+  }
+
  const [newBoundsX1, newBoundsY1, newBoundsX2, newBoundsY2] =
    getResizedElementAbsoluteCoords(
      stateAtResizeStart,
@@ -490,11 +525,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)) {
@@ -587,16 +617,9 @@ export const resizeSingleElement = (
      ],
    });
  }
-  let minWidth = 0;
-  if (boundTextElementId) {
-    const boundTextElement = Scene.getScene(element)!.getElement(
-      boundTextElementId,
-    ) as ExcalidrawTextElement;
-    minWidth = getApproxMinLineWidth(getFontString(boundTextElement));
-  }

  if (
-    resizedElement.width > minWidth &&
+    resizedElement.width !== 0 &&
    resizedElement.height !== 0 &&
    Number.isFinite(resizedElement.x) &&
    Number.isFinite(resizedElement.y)
@@ -605,7 +628,10 @@ export const resizeSingleElement = (
      newSize: { width: resizedElement.width, height: resizedElement.height },
    });
    mutateElement(element, resizedElement);
-    handleBindTextResize([element], transformHandleDirection);
+    if (boundTextElement && boundTextFont) {
+      mutateElement(boundTextElement, { fontSize: boundTextFont.fontSize });
+    }
+    handleBindTextResize(element, transformHandleDirection);
  }
 };

@@ -676,7 +702,25 @@ const resizeMultipleElements = (
        }
        const width = element.width * scale;
        const height = element.height * scale;
+        const boundTextElement = getBoundTextElement(element);
        let font: { fontSize?: number; baseline?: number } = {};
+
+        if (boundTextElement) {
+          const nextFont = measureFontSizeFromWH(
+            boundTextElement,
+            width - BOUND_TEXT_PADDING * 2,
+            height - BOUND_TEXT_PADDING * 2,
+          );
+
+          if (nextFont === null) {
+            return null;
+          }
+          font = {
+            fontSize: nextFont.size,
+            baseline: nextFont.baseline,
+          };
+        }
+
        if (isTextElement(element)) {
          const nextFont = measureFontSizeFromWH(element, width, height);
          if (nextFont === null) {
@@ -720,6 +764,15 @@ const resizeMultipleElements = (
    if (updates) {
      elements.forEach((element, index) => {
        mutateElement(element, updates[index]);
+        const boundTextElement = getBoundTextElement(element);
+
+        if (boundTextElement) {
+          mutateElement(boundTextElement, {
+            fontSize: updates[index].fontSize,
+            baseline: updates[index].baseline,
+          });
+          handleBindTextResize(element, transformHandleType);
+        }
      });
    }
  }
--- a/src/element/sizeHelpers.test.ts
+++ b/src/element/sizeHelpers.test.ts
@@ -32,7 +32,7 @@ describe("getPerfectElementSize", () => {
    expect(width).toEqual(135);
    expect(height).toEqual(135);
  });
-  it("should return height:0 and width:0 when width and heigh are 0", () => {
+  it("should return height:0 and width:0 when width and height are 0", () => {
    const { height, width } = getPerfectElementSize("arrow", 0, 0);
    expect(width).toEqual(0);
    expect(height).toEqual(0);
--- a/src/element/textElement.test.ts
+++ b/src/element/textElement.test.ts
@@ -0,0 +1,140 @@
+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);
+      });
+    });
+  });
+});
--- a/src/element/textElement.ts
+++ b/src/element/textElement.ts
@@ -1,20 +1,34 @@
-import { getFontString, arrayToMap } from "../utils";
+import { getFontString, arrayToMap, isTestEnv } from "../utils";
 import {
-  ExcalidrawBindableElement,
  ExcalidrawElement,
  ExcalidrawTextElement,
+  ExcalidrawTextElementWithContainer,
  FontString,
  NonDeletedExcalidrawElement,
 } from "./types";
 import { mutateElement } from "./mutateElement";
-import { PADDING } from "../constants";
+import { BOUND_TEXT_PADDING, VERTICAL_ALIGN } from "../constants";
 import { MaybeTransformHandleType } from "./transformHandles";
 import Scene from "../scene/Scene";
+import { AppState } from "../types";
+import { isTextElement } from ".";

-export const redrawTextBoundingBox = (element: ExcalidrawTextElement) => {
-  let maxWidth;
-  if (element.containerId) {
-    maxWidth = element.width;
+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,
@@ -22,10 +36,32 @@ export const redrawTextBoundingBox = (element: ExcalidrawTextElement) => {
    maxWidth,
  );

+  let coordY = element.y;
+  // Resize container and vertically center align the text
+  if (container) {
+    let nextHeight = container.height;
+
+    if (element.verticalAlign === VERTICAL_ALIGN.TOP) {
+      coordY = container.y + BOUND_TEXT_PADDING;
+    } else if (element.verticalAlign === VERTICAL_ALIGN.BOTTOM) {
+      coordY =
+        container.y + container.height - metrics.height - BOUND_TEXT_PADDING;
+    } else {
+      coordY = container.y + container.height / 2 - metrics.height / 2;
+      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 });
+  }
+
  mutateElement(element, {
    width: metrics.width,
    height: metrics.height,
    baseline: metrics.baseline,
+    y: coordY,
+    text,
  });
 };

@@ -43,99 +79,99 @@ export const bindTextToShapeAfterDuplication = (
    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,
-        },
-      );
+      const newTextElementId = oldIdToDuplicatedId.get(boundTextElementId);
+      if (newTextElementId) {
+        const newContainer = sceneElementMap.get(newElementId);
+        if (newContainer) {
+          mutateElement(newContainer, {
+            boundElements: element.boundElements?.concat({
+              type: "text",
+              id: newTextElementId,
+            }),
+          });
+        }
+        const newTextElement = sceneElementMap.get(newTextElementId);
+        if (newTextElement && isTextElement(newTextElement)) {
+          mutateElement(newTextElement, {
+            containerId: newContainer ? newElementId : null,
+          });
+        }
+      }
    }
  });
 };

 export const handleBindTextResize = (
-  elements: readonly NonDeletedExcalidrawElement[],
+  element: 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") {
-          let minCharWidthTillNow = 0;
-          if (text) {
-            minCharWidthTillNow = getMinCharWidth(getFontString(textElement));
-            // check if the diff has exceeded min char width needed
-            const diff = Math.abs(
-              element.width - textElement.width + PADDING * 2,
-            );
-            if (diff >= minCharWidthTillNow) {
-              text = wrapText(
-                textElement.originalText,
-                getFontString(textElement),
-                element.width,
-              );
-            }
-          }
-
-          const dimensions = measureText(
-            text,
+  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,
          );
-          nextHeight = dimensions.height;
-          nextBaseLine = dimensions.baseline;
-        }
-        // increase height in case text element height exceeds
-        if (nextHeight > element.height - PADDING * 2) {
-          containerHeight = nextHeight + 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, {
+        const dimensions = measureText(
          text,
-          // preserve padding and set width correctly
-          width: element.width - PADDING * 2,
-          height: nextHeight,
-          x: element.x + PADDING,
+          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,
-          baseline: nextBaseLine,
        });
      }
+
+      let updatedY;
+      if (textElement.verticalAlign === VERTICAL_ALIGN.TOP) {
+        updatedY = element.y + BOUND_TEXT_PADDING;
+      } else if (textElement.verticalAlign === VERTICAL_ALIGN.BOTTOM) {
+        updatedY = element.y + element.height - nextHeight - BOUND_TEXT_PADDING;
+      } else {
+        updatedY = element.y + element.height / 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
@@ -155,7 +191,6 @@ export const measureText = (
  container.style.whiteSpace = "pre";
  container.style.font = font;
  container.style.minHeight = "1em";
-
  if (maxWidth) {
    const lineHeight = getApproxLineHeight(font);
    container.style.width = `${String(maxWidth)}px`;
@@ -185,8 +220,14 @@ export const measureText = (
 };

 const DUMMY_TEXT = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toLocaleUpperCase();
+const cacheApproxLineHeight: { [key: FontString]: number } = {};
+
 export const getApproxLineHeight = (font: FontString) => {
-  return measureText(DUMMY_TEXT, font, null).height;
+  if (cacheApproxLineHeight[font]) {
+    return cacheApproxLineHeight[font];
+  }
+  cacheApproxLineHeight[font] = measureText(DUMMY_TEXT, font, null).height;
+  return cacheApproxLineHeight[font];
 };

 let canvas: HTMLCanvasElement | undefined;
@@ -198,6 +239,12 @@ const getTextWidth = (text: string, font: FontString) => {
  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;
 };
@@ -207,7 +254,7 @@ export const wrapText = (
  font: FontString,
  containerWidth: number,
 ) => {
-  const maxWidth = containerWidth - PADDING * 2;
+  const maxWidth = containerWidth - BOUND_TEXT_PADDING * 2;

  const lines: Array<string> = [];
  const originalLines = text.split("\n");
@@ -226,7 +273,7 @@ export const wrapText = (
        const currentWordWidth = getTextWidth(words[index], font);

        // Start breaking longer words exceeding max width
-        if (currentWordWidth > maxWidth) {
+        if (currentWordWidth >= maxWidth) {
          // push current line since the current word exceeds the max width
          // so will be appended in next line
          if (currentLine) {
@@ -257,7 +304,7 @@ export const wrapText = (
            }
          }
          // push current line if appending space exceeds max width
-          if (currentLineWidthTillNow + spaceWidth > maxWidth) {
+          if (currentLineWidthTillNow + spaceWidth >= maxWidth) {
            lines.push(currentLine);
            currentLine = "";
            currentLineWidthTillNow = 0;
@@ -285,8 +332,15 @@ export const wrapText = (
            }
            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;
@@ -317,37 +371,31 @@ export const charWidth = (() => {
      const width = getTextWidth(char, font);
      cachedCharWidth[font][ascii] = width;
    }
+
    return cachedCharWidth[font][ascii];
  };

-  const updateCache = (char: string, font: FontString) => {
-    const ascii = char.charCodeAt(0);
-
-    if (!cachedCharWidth[font][ascii]) {
-      cachedCharWidth[font][ascii] = calculate(char, font);
-    }
-  };
-
-  const clearCacheforFont = (font: FontString) => {
-    cachedCharWidth[font] = [];
-  };
-
  const getCache = (font: FontString) => {
    return cachedCharWidth[font];
  };
  return {
    calculate,
-    updateCache,
-    clearCacheforFont,
    getCache,
  };
 })();
 export const getApproxMinLineWidth = (font: FontString) => {
-  return measureText(DUMMY_TEXT.split("").join("\n"), font).width + PADDING * 2;
+  const maxCharWidth = getMaxCharWidth(font);
+  if (maxCharWidth === 0) {
+    return (
+      measureText(DUMMY_TEXT.split("").join("\n"), font).width +
+      BOUND_TEXT_PADDING * 2
+    );
+  }
+  return maxCharWidth + BOUND_TEXT_PADDING * 2;
 };

 export const getApproxMinLineHeight = (font: FontString) => {
-  return getApproxLineHeight(font) + PADDING * 2;
+  return getApproxLineHeight(font) + BOUND_TEXT_PADDING * 2;
 };

 export const getMinCharWidth = (font: FontString) => {
@@ -360,6 +408,15 @@ export const getMinCharWidth = (font: FontString) => {
  return Math.min(...cacheWithOutEmpty);
 };

+export const getMaxCharWidth = (font: FontString) => {
+  const cache = charWidth.getCache(font);
+  if (!cache) {
+    return 0;
+  }
+  const cacheWithOutEmpty = cache.filter((val) => val !== undefined);
+  return Math.max(...cacheWithOutEmpty);
+};
+
 export const getApproxCharsToFitInWidth = (font: FontString, width: number) => {
  // Generally lower case is used so converting to lower case
  const dummyText = DUMMY_TEXT.toLocaleLowerCase();
@@ -385,5 +442,37 @@ export const getApproxCharsToFitInWidth = (font: FontString, width: number) => {
 };

 export const getBoundTextElementId = (container: ExcalidrawElement | null) => {
-  return container?.boundElements?.filter((ele) => ele.type === "text")[0]?.id;
+  return container?.boundElements?.length
+    ? container?.boundElements?.filter((ele) => ele.type === "text")[0]?.id ||
+        null
+    : null;
+};
+
+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;
 };
--- a/src/element/textWysiwyg.test.tsx
+++ b/src/element/textWysiwyg.test.tsx
@@ -1,169 +1,749 @@
 import ReactDOM from "react-dom";
 import ExcalidrawApp from "../excalidraw-app";
-import { render } from "../tests/test-utils";
-import { Pointer, UI } from "../tests/helpers/ui";
-import { KEYS } from "../keys";
+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 { BOUND_TEXT_PADDING, FONT_FAMILY } from "../constants";
+import {
+  ExcalidrawTextElement,
+  ExcalidrawTextElementWithContainer,
+} from "./types";
+import * as textElementUtils from "./textElement";
+import { API } from "../tests/helpers/api";
+import { mutateElement } from "./mutateElement";
 // Unmount ReactDOM from root
 ReactDOM.unmountComponentAtNode(document.getElementById("root")!);

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

 describe("textWysiwyg", () => {
-  let textarea: HTMLTextAreaElement;
-  beforeEach(async () => {
-    await render(<ExcalidrawApp />);
-
-    const element = UI.createElement("text");
-
-    new Pointer("mouse").clickOn(element);
-    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,
+  describe("start text editing", () => {
+    const { h } = window;
+    beforeEach(async () => {
+      await render(<ExcalidrawApp />);
+      h.elements = [];
    });
-    textarea.value = `${tab}Line#1\nLine#2`;
-    // cursor: "|    Line#1\nLine#2"
-    textarea.selectionStart = 0;
-    textarea.selectionEnd = 0;

-    textarea.dispatchEvent(event);
+    it("should prefer editing selected text element (non-bindable container present)", async () => {
+      const line = API.createElement({
+        type: "line",
+        width: 100,
+        height: 0,
+        points: [
+          [0, 0],
+          [100, 0],
+        ],
+      });
+      const textSize = 20;
+      const text = API.createElement({
+        type: "text",
+        text: "ola",
+        x: line.width / 2 - textSize / 2,
+        y: -textSize / 2,
+        width: textSize,
+        height: textSize,
+      });
+      h.elements = [text, line];

-    expect(textarea.value).toEqual(`Line#1\nLine#2`);
+      API.setSelectedElements([text]);

-    // cursor: "|Line#1\nLine#2"
-    expect(textarea.selectionStart).toEqual(0);
-    expect(textarea.selectionEnd).toEqual(0);
+      Keyboard.keyPress(KEYS.ENTER);
+
+      expect(h.state.editingElement?.id).toBe(text.id);
+      expect(
+        (h.state.editingElement as ExcalidrawTextElement).containerId,
+      ).toBe(null);
+    });
+
+    it("should prefer editing selected text element (bindable container present)", async () => {
+      const container = API.createElement({
+        type: "rectangle",
+        width: 100,
+        boundElements: [],
+      });
+      const textSize = 20;
+
+      const boundText = API.createElement({
+        type: "text",
+        text: "ola",
+        x: container.width / 2 - textSize / 2,
+        y: container.height / 2 - textSize / 2,
+        width: textSize,
+        height: textSize,
+        containerId: container.id,
+      });
+
+      const boundText2 = API.createElement({
+        type: "text",
+        text: "ola",
+        x: container.width / 2 - textSize / 2,
+        y: container.height / 2 - textSize / 2,
+        width: textSize,
+        height: textSize,
+        containerId: container.id,
+      });
+
+      h.elements = [container, boundText, boundText2];
+
+      mutateElement(container, {
+        boundElements: [{ type: "text", id: boundText.id }],
+      });
+
+      API.setSelectedElements([boundText2]);
+
+      Keyboard.keyPress(KEYS.ENTER);
+
+      expect(h.state.editingElement?.id).toBe(boundText2.id);
+    });
+
+    it("should not create bound text on ENTER if text exists at container center", () => {
+      const container = API.createElement({
+        type: "rectangle",
+        width: 100,
+      });
+      const textSize = 20;
+      const text = API.createElement({
+        type: "text",
+        text: "ola",
+        x: container.width / 2 - textSize / 2,
+        y: container.height / 2 - textSize / 2,
+        width: textSize,
+        height: textSize,
+        containerId: container.id,
+      });
+
+      h.elements = [container, text];
+
+      API.setSelectedElements([container]);
+
+      Keyboard.keyPress(KEYS.ENTER);
+
+      expect(h.state.editingElement?.id).toBe(text.id);
+    });
+
+    it("should edit existing bound text on ENTER even if higher z-index unbound text exists at container center", () => {
+      const container = API.createElement({
+        type: "rectangle",
+        width: 100,
+        boundElements: [],
+      });
+      const textSize = 20;
+
+      const boundText = API.createElement({
+        type: "text",
+        text: "ola",
+        x: container.width / 2 - textSize / 2,
+        y: container.height / 2 - textSize / 2,
+        width: textSize,
+        height: textSize,
+        containerId: container.id,
+      });
+
+      const boundText2 = API.createElement({
+        type: "text",
+        text: "ola",
+        x: container.width / 2 - textSize / 2,
+        y: container.height / 2 - textSize / 2,
+        width: textSize,
+        height: textSize,
+        containerId: container.id,
+      });
+
+      h.elements = [container, boundText, boundText2];
+
+      mutateElement(container, {
+        boundElements: [{ type: "text", id: boundText.id }],
+      });
+
+      API.setSelectedElements([container]);
+
+      Keyboard.keyPress(KEYS.ENTER);
+
+      expect(h.state.editingElement?.id).toBe(boundText.id);
+    });
+
+    it("should edit text under cursor when clicked with text tool", () => {
+      const text = API.createElement({
+        type: "text",
+        text: "ola",
+        x: 60,
+        y: 0,
+        width: 100,
+        height: 100,
+      });
+
+      h.elements = [text];
+      UI.clickTool("text");
+
+      mouse.clickAt(text.x + 50, text.y + 50);
+
+      const editor = document.querySelector(
+        ".excalidraw-textEditorContainer > textarea",
+      ) as HTMLTextAreaElement;
+
+      expect(editor).not.toBe(null);
+      expect(h.state.editingElement?.id).toBe(text.id);
+      expect(h.elements.length).toBe(1);
+    });
+
+    it("should edit text under cursor when double-clicked with selection tool", () => {
+      const text = API.createElement({
+        type: "text",
+        text: "ola",
+        x: 60,
+        y: 0,
+        width: 100,
+        height: 100,
+      });
+
+      h.elements = [text];
+      UI.clickTool("selection");
+
+      mouse.doubleClickAt(text.x + 50, text.y + 50);
+
+      const editor = document.querySelector(
+        ".excalidraw-textEditorContainer > textarea",
+      ) as HTMLTextAreaElement;
+
+      expect(editor).not.toBe(null);
+      expect(h.state.editingElement?.id).toBe(text.id);
+      expect(h.elements.length).toBe(1);
+    });
  });

-  it("should remove a tab at the start of the second line", () => {
-    const event = new KeyboardEvent("keydown", {
-      key: KEYS.TAB,
-      shiftKey: true,
+  describe("Test container-unbound text", () => {
+    const { h } = window;
+
+    let textarea: HTMLTextAreaElement;
+    let textElement: ExcalidrawTextElement;
+    beforeEach(async () => {
+      await render(<ExcalidrawApp />);
+
+      textElement = UI.createElement("text");
+
+      mouse.clickOn(textElement);
+      textarea = document.querySelector(
+        ".excalidraw-textEditorContainer > textarea",
+      )!;
    });
-    // cursor: "Line#1\n    Lin|e#2"
-    textarea.value = `Line#1\n${tab}Line#2`;
-    textarea.selectionStart = 15;
-    textarea.selectionEnd = 15;

-    textarea.dispatchEvent(event);
+    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(`Line#1\nLine#2`);
-    // cursor: "Line#1\nLin|e#2"
-    expect(textarea.selectionStart).toEqual(11);
-    expect(textarea.selectionEnd).toEqual(11);
+      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);
+    });
  });

-  it("should remove a tab at the start of the first and second line", () => {
-    const event = new KeyboardEvent("keydown", {
-      key: KEYS.TAB,
-      shiftKey: true,
+  describe("Test container-bound text", () => {
+    let rectangle: any;
+    const { h } = window;
+
+    const DUMMY_HEIGHT = 240;
+    const DUMMY_WIDTH = 160;
+    const APPROX_LINE_HEIGHT = 25;
+    const INITIAL_WIDTH = 10;
+
+    beforeAll(() => {
+      jest
+        .spyOn(textElementUtils, "getApproxLineHeight")
+        .mockReturnValue(APPROX_LINE_HEIGHT);
    });
-    // 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);
+    beforeEach(async () => {
+      await render(<ExcalidrawApp />);
+      h.elements = [];

-    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,
+      rectangle = UI.createElement("rectangle", {
+        x: 10,
+        y: 20,
+        width: 90,
+        height: 75,
+      });
    });
-    // 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 bind text to container when double clicked on center", async () => {
+      expect(h.elements.length).toBe(1);
+      expect(h.elements[0].id).toBe(rectangle.id);

-  it("should remove partial tabs", () => {
-    const event = new KeyboardEvent("keydown", {
-      key: KEYS.TAB,
-      shiftKey: true,
+      mouse.doubleClickAt(
+        rectangle.x + rectangle.width / 2,
+        rectangle.y + rectangle.height / 2,
+      );
+      expect(h.elements.length).toBe(2);
+
+      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" },
+      ]);
    });
-    // 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 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);

-  it("should remove nothing", () => {
-    const event = new KeyboardEvent("keydown", {
-      key: KEYS.TAB,
-      shiftKey: true,
+      Keyboard.withModifierKeys({}, () => {
+        Keyboard.keyPress(KEYS.ENTER);
+      });
+
+      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" },
+      ]);
    });
-    // 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("shouldn't bind to non-text-bindable containers", async () => {
+      const line = API.createElement({
+        type: "line",
+        width: 100,
+        height: 0,
+        points: [
+          [0, 0],
+          [100, 0],
+        ],
+      });
+      h.elements = [line];
+
+      UI.clickTool("text");
+
+      mouse.clickAt(line.x + line.width / 2, line.y + line.height / 2);
+
+      const editor = document.querySelector(
+        ".excalidraw-textEditorContainer > textarea",
+      ) as HTMLTextAreaElement;
+
+      fireEvent.change(editor, {
+        target: {
+          value: "Hello World!",
+        },
+      });
+      fireEvent.keyDown(editor, { key: KEYS.ESCAPE });
+      editor.dispatchEvent(new Event("input"));
+
+      expect(line.boundElements).toBe(null);
+      expect(h.elements[1].type).toBe("text");
+      expect((h.elements[1] as ExcalidrawTextElement).containerId).toBe(null);
+    });
+
+    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);
+
+      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 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(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 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,
+      );
+    });
  });
 });
--- a/src/element/textWysiwyg.tsx
+++ b/src/element/textWysiwyg.tsx
@@ -2,24 +2,31 @@ import { CODES, KEYS } from "../keys";
 import {
  isWritableElement,
  getFontString,
-  viewportCoordsToSceneCoords,
  getFontFamilyString,
+  isTestEnv,
 } from "../utils";
 import Scene from "../scene/Scene";
 import { isBoundToContainer, isTextElement } from "./typeChecks";
-import { CLASSES, PADDING } from "../constants";
+import { CLASSES, BOUND_TEXT_PADDING, VERTICAL_ALIGN } from "../constants";
 import {
-  ExcalidrawBindableElement,
  ExcalidrawElement,
  ExcalidrawTextElement,
+  ExcalidrawLinearElement,
 } 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 (
@@ -37,31 +44,32 @@ const getTransform = (
  angle: number,
  appState: AppState,
  maxWidth: number,
+  maxHeight: number,
 ) => {
-  const { zoom, offsetTop, offsetLeft } = appState;
+  const { zoom } = appState;
  const degree = (180 * angle) / Math.PI;
-  // 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;
+  let translateX = (width * (zoom.value - 1)) / 2;
+  let translateY = (height * (zoom.value - 1)) / 2;
  if (width > maxWidth && zoom.value !== 1) {
-    translateX = (maxWidth / 2) * (zoom.value - 1);
+    translateX = (maxWidth * (zoom.value - 1)) / 2;
+  }
+  if (height > maxHeight && zoom.value !== 1) {
+    translateY = (maxHeight * (zoom.value - 1)) / 2;
  }
  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;
@@ -69,15 +77,16 @@ export const textWysiwyg = ({
    originalText: string;
  }) => void;
  getViewportCoords: (x: number, y: number) => [number, number];
-  element: ExcalidrawElement;
+  element: ExcalidrawTextElement;
  canvas: HTMLCanvasElement | null;
  excalidrawContainer: HTMLDivElement | null;
+  app: App;
 }) => {
  const textPropertiesUpdated = (
    updatedElement: ExcalidrawTextElement,
    editable: HTMLTextAreaElement,
  ) => {
-    const currentFont = editable.style.fontFamily.replaceAll('"', "");
+    const currentFont = editable.style.fontFamily.replace(/"/g, "");
    if (
      getFontFamilyString({ fontFamily: updatedElement.fontFamily }) !==
      currentFont
@@ -90,128 +99,139 @@ export const textWysiwyg = ({
    return false;
  };
  let originalContainerHeight: number;
-  let approxLineHeight = isTextElement(element)
-    ? getApproxLineHeight(getFontString(element))
-    : 0;

  const updateWysiwygStyle = () => {
-    const updatedElement = Scene.getScene(element)?.getElement(id);
+    const appState = app.state;
+    const updatedElement = Scene.getScene(element)?.getElement(
+      id,
+    ) as ExcalidrawTextElement;
+    const { textAlign, verticalAlign } = updatedElement;
+
+    const approxLineHeight = getApproxLineHeight(getFontString(updatedElement));
    if (updatedElement && isTextElement(updatedElement)) {
      let coordX = updatedElement.x;
      let coordY = updatedElement.y;
-      let container = updatedElement?.containerId
-        ? Scene.getScene(updatedElement)!.getElement(updatedElement.containerId)
-        : null;
+      const container = getContainerElement(updatedElement);
      let maxWidth = updatedElement.width;

      let maxHeight = updatedElement.height;
      let width = updatedElement.width;
+      // Set to element height by default since that's
+      // what is going to be used for unbounded text
      let height = updatedElement.height;
      if (container && updatedElement.containerId) {
        const propertiesUpdated = textPropertiesUpdated(
          updatedElement,
          editable,
        );
+        // 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) {
-          const currentContainer = Scene.getScene(updatedElement)?.getElement(
-            updatedElement.containerId,
-          ) as ExcalidrawBindableElement;
-          approxLineHeight = isTextElement(updatedElement)
-            ? getApproxLineHeight(getFontString(updatedElement))
-            : 0;
-          if (updatedElement.height > currentContainer.height - PADDING * 2) {
-            const nextHeight = updatedElement.height + PADDING * 2;
-            originalContainerHeight = nextHeight;
-            mutateElement(container, { height: nextHeight });
-            container = { ...container, height: nextHeight };
-          }
-          editable.style.height = `${updatedElement.height}px`;
+          originalContainerHeight = container.height;
+
+          // update height of the editor after properties updated
+          height = updatedElement.height;
        }
        if (!originalContainerHeight) {
          originalContainerHeight = container.height;
        }
-        maxWidth = container.width - PADDING * 2;
-        maxHeight = container.height - PADDING * 2;
+        maxWidth = container.width - BOUND_TEXT_PADDING * 2;
+        maxHeight = container.height - BOUND_TEXT_PADDING * 2;
        width = maxWidth;
-        height = Math.min(height, maxHeight);
        // The coordinates of text box set a distance of
-        // 30px to preserve padding
-        coordX = container.x + PADDING;
-
+        // 5px to preserve padding
+        coordX = container.x + BOUND_TEXT_PADDING;
        // autogrow container height if text exceeds
-        if (editable.clientHeight > maxHeight) {
-          const diff = Math.min(
-            editable.clientHeight - maxHeight,
-            approxLineHeight,
-          );
+        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 &&
-          editable.clientHeight < maxHeight
+          height < maxHeight
        ) {
-          const diff = Math.min(
-            maxHeight - editable.clientHeight,
-            approxLineHeight,
-          );
+          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 {
-          const lines = editable.clientHeight / approxLineHeight;
-          // For some reason the scrollHeight gets set to twice the lineHeight
-          // when you start typing for first time  and thus line count is 2
-          // hence this check
-          if (lines > 2 || propertiesUpdated) {
-            // vertically center align the text
+          // vertically center align the text
+          if (verticalAlign === VERTICAL_ALIGN.MIDDLE) {
+            coordY = container.y + container.height / 2 - height / 2;
+          }
+          if (verticalAlign === VERTICAL_ALIGN.BOTTOM) {
            coordY =
-              container.y + container.height / 2 - editable.clientHeight / 2;
+              container.y + container.height - height - BOUND_TEXT_PADDING;
          }
        }
      }
-
      const [viewportX, viewportY] = getViewportCoords(coordX, coordY);
-      const { textAlign, angle } = updatedElement;
+      const initialSelectionStart = editable.selectionStart;
+      const initialSelectionEnd = editable.selectionEnd;
+      const initialLength = editable.value.length;
+      editable.value = updatedElement.originalText;
+
+      // restore cursor position after value updated so it doesn't
+      // go to the end of text when container auto expanded
+      if (
+        initialSelectionStart === initialSelectionEnd &&
+        initialSelectionEnd !== initialLength
+      ) {
+        // get diff between length and selection end and shift
+        // the cursor by "diff" times to position correctly
+        const diff = initialLength - initialSelectionEnd;
+        editable.selectionStart = editable.value.length - diff;
+        editable.selectionEnd = editable.value.length - diff;
+      }

-      editable.value = updatedElement.originalText || updatedElement.text;
      const lines = updatedElement.originalText.split("\n");
      const lineHeight = updatedElement.containerId
        ? approxLineHeight
        : updatedElement.height / lines.length;
      if (!container) {
-        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),
-          );
+        maxWidth = (appState.width - 8 - viewportX) / appState.zoom.value;
      }
+
      // Make sure text editor height doesn't go beyond viewport
      const editorMaxHeight =
-        (appState.offsetTop + appState.height - viewportY) /
-        appState.zoom.value;
+        (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: `${Math.max(editable.clientHeight, updatedElement.height)}px`,
+        height: `${height}px`,
        left: `${viewportX}px`,
        top: `${viewportY}px`,
-        transform: getTransform(width, height, angle, appState, maxWidth),
+        transform: getTransform(
+          width,
+          height,
+          angle,
+          appState,
+          maxWidth,
+          editorMaxHeight,
+        ),
        textAlign,
+        verticalAlign,
        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 });
    }
  };

@@ -254,8 +274,39 @@ export const textWysiwyg = ({

  if (onChange) {
    editable.oninput = () => {
-      if (isBoundToContainer(element)) {
-        editable.style.height = "auto";
+      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 aligns 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));
@@ -264,7 +315,20 @@ export const textWysiwyg = ({

  editable.onkeydown = (event) => {
    event.stopPropagation();
-    if (event.key === KEYS.ESCAPE) {
+
+    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) {
      event.preventDefault();
      submittedViaKeyboard = true;
      handleSubmit();
@@ -358,7 +422,7 @@ export const textWysiwyg = ({
  };

  /**
-   * @returns indeces of start positions of selected lines, in reverse order
+   * @returns indices of start positions of selected lines, in reverse order
   */
  const getSelectedLinesStartIndices = () => {
    let { selectionStart, selectionEnd, value } = editable;
@@ -400,61 +464,41 @@ 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);
+    const updateElement = Scene.getScene(element)?.getElement(
+      element.id,
+    ) as ExcalidrawTextElement;
    if (!updateElement) {
      return;
    }
-    let wrappedText = "";
-    if (isTextElement(updateElement) && updateElement?.containerId) {
-      const container = Scene.getScene(updateElement)!.getElement(
-        updateElement.containerId,
-      ) as ExcalidrawBindableElement;
+    let text = editable.value;
+    const container = getContainerElement(updateElement);

-      if (container) {
-        wrappedText = wrapText(
-          editable.value,
-          getFontString(updateElement),
-          container.width,
-        );
-        const { x, y } = viewportCoordsToSceneCoords(
-          {
-            clientX: Number(editable.style.left.slice(0, -2)),
-            clientY: Number(editable.style.top.slice(0, -2)),
-          },
-          appState,
-        );
-        if (isTextElement(updateElement) && updateElement.containerId) {
-          if (editable.value) {
-            mutateElement(updateElement, {
-              y: y + appState.offsetTop,
-              height: Number(editable.style.height.slice(0, -2)),
-              width: Number(editable.style.width.slice(0, -2)),
-              x: x + appState.offsetLeft,
-            });
-            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) => ele.type !== "text",
-              ),
-            });
-          }
+    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,
+              ),
+          ),
+        });
      }
-    } else {
-      wrappedText = editable.value;
    }

    onSubmit({
-      text: normalizeText(wrappedText),
+      text,
      viaKeyboard: submittedViaKeyboard,
      originalText: editable.value,
    });
@@ -498,9 +542,29 @@ export const textWysiwyg = ({
      target.closest(".color-picker-input") &&
      isWritableElement(target);

+    const isShapeActionsPanel =
+      (target instanceof HTMLElement || target instanceof SVGElement) &&
+      (target.closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) ||
+        target.closest(`.${CLASSES.SHAPE_ACTIONS_MOBILE_MENU}`) ||
+        target.closest(`.${CLASSES.MOBILE_TOOLBAR}`));
+
    setTimeout(() => {
-      editable.onblur = handleSubmit;
-      if (target && isTargetColorPicker) {
+      editable.onblur = () => {
+        app.setState({
+          toastMessage:
+            target instanceof HTMLElement
+              ? target.tagName ?? "no tagName"
+              : "not an HTMLElement",
+        });
+        if (isShapeActionsPanel) {
+          return;
+        }
+        app.setState({
+          toastMessage: "debug: onblur",
+        });
+        handleSubmit();
+      };
+      if (target && (isTargetColorPicker || isShapeActionsPanel)) {
        target.onblur = () => {
          editable.focus();
        };
@@ -518,13 +582,22 @@ export const textWysiwyg = ({
      event.target instanceof HTMLInputElement &&
      event.target.closest(".color-picker-input") &&
      isWritableElement(event.target);
+    const isShapeActionsPanel =
+      (event.target instanceof HTMLElement ||
+        event.target instanceof SVGElement) &&
+      (event.target.closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) ||
+        event.target.closest(`.${CLASSES.SHAPE_ACTIONS_MOBILE_MENU}`) ||
+        event.target.closest(`.${CLASSES.MOBILE_TOOLBAR}`));
    if (
      ((event.target instanceof HTMLElement ||
        event.target instanceof SVGElement) &&
-        event.target.closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) &&
+        isShapeActionsPanel &&
        !isWritableElement(event.target)) ||
      isTargetColorPicker
    ) {
+      app.setState({
+        toastMessage: "debug: onPointerDown",
+      });
      editable.onblur = null;
      window.addEventListener("pointerup", bindBlurEvent);
      // handle edge-case where pointerup doesn't fire e.g. due to user
--- a/src/element/typeChecks.ts
+++ b/src/element/typeChecks.ts
@@ -8,6 +8,7 @@ import {
  InitializedExcalidrawImageElement,
  ExcalidrawImageElement,
  ExcalidrawTextElementWithContainer,
+  ExcalidrawTextContainer,
 } from "./types";

 export const isGenericElement = (
@@ -91,7 +92,9 @@ export const isBindableElement = (
  );
 };

-export const isTextBindableContainer = (element: ExcalidrawElement | null) => {
+export const isTextBindableContainer = (
+  element: ExcalidrawElement | null,
+): element is ExcalidrawTextContainer => {
  return (
    element != null &&
    (element.type === "rectangle" ||
--- a/src/element/types.ts
+++ b/src/element/types.ts
@@ -1,5 +1,5 @@
 import { Point } from "../types";
-import { FONT_FAMILY, THEME } from "../constants";
+import { FONT_FAMILY, THEME, VERTICAL_ALIGN } from "../constants";

 export type ChartType = "bar" | "line";
 export type FillStyle = "hachure" | "cross-hatch" | "solid";
@@ -12,7 +12,9 @@ export type PointerType = "mouse" | "pen" | "touch";
 export type StrokeSharpness = "round" | "sharp";
 export type StrokeStyle = "solid" | "dashed" | "dotted";
 export type TextAlign = "left" | "center" | "right";
-export type VerticalAlign = "top" | "middle";
+
+type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
+export type VerticalAlign = typeof VERTICAL_ALIGN[VerticalAlignKeys];

 type _ExcalidrawElementBase = Readonly<{
  id: string;
@@ -52,6 +54,7 @@ type _ExcalidrawElementBase = Readonly<{
    | null;
  /** epoch (ms) timestamp of last element update */
  updated: number;
+  link: string | null;
 }>;

 export type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
@@ -132,8 +135,14 @@ export type ExcalidrawBindableElement =
  | ExcalidrawTextElement
  | ExcalidrawImageElement;

+export type ExcalidrawTextContainer =
+  | ExcalidrawRectangleElement
+  | ExcalidrawDiamondElement
+  | ExcalidrawEllipseElement
+  | ExcalidrawImageElement;
+
 export type ExcalidrawTextElementWithContainer = {
-  containerId: ExcalidrawGenericElement["id"];
+  containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;

 export type PointBinding = {
--- a/src/excalidraw-app/app_constants.ts
+++ b/src/excalidraw-app/app_constants.ts
@@ -4,6 +4,8 @@ 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 CURSOR_SYNC_TIMEOUT = 33; // ~30fps

 export const FILE_UPLOAD_MAX_BYTES = 3 * 1024 * 1024; // 3 MiB
 // 1 year (https://stackoverflow.com/a/25201898/927631)
@@ -25,3 +27,13 @@ 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;
--- a/src/excalidraw-app/collab/CollabWrapper.tsx
+++ b/src/excalidraw-app/collab/CollabWrapper.tsx
@@ -16,18 +16,20 @@ import {
  withBatchedUpdates,
 } from "../../utils";
 import {
+  CURSOR_SYNC_TIMEOUT,
  FILE_UPLOAD_MAX_BYTES,
  FIREBASE_STORAGE_PREFIXES,
  INITIAL_SCENE_UPDATE_TIMEOUT,
  LOAD_IMAGES_TIMEOUT,
  SCENE,
+  STORAGE_KEYS,
  SYNC_FULL_SCENE_INTERVAL_MS,
 } from "../app_constants";
 import {
  generateCollaborationLinkData,
  getCollaborationLink,
+  getCollabServer,
  SocketUpdateDataSource,
-  SOCKET_SERVER,
 } from "../data";
 import {
  isSavedToFirebase,
@@ -39,7 +41,6 @@ import {
 import {
  importUsernameFromLocalStorage,
  saveUsernameToLocalStorage,
-  STORAGE_KEYS,
 } from "../data/localStorage";
 import Portal from "./Portal";
 import RoomDialog from "./RoomDialog";
@@ -65,6 +66,7 @@ import {
  reconcileElements as _reconcileElements,
 } from "./reconciliation";
 import { decryptData } from "../../data/encryption";
+import { resetBrowserStateVersions } from "../data/tabSync";

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

 interface Props {
@@ -246,6 +249,10 @@ 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");
@@ -347,32 +354,29 @@ class CollabWrapper extends PureComponent<Props, CollabState> {

    this.isCollaborating = true;

-    const { default: socketIOClient }: any = await import(
+    const { default: socketIOClient } = await import(
      /* webpackChunkName: "socketIoClient" */ "socket.io-client"
    );

-    this.portal.open(socketIOClient(SOCKET_SERVER), roomId, roomKey);
+    try {
+      const socketServerData = await getCollabServer();

-    if (existingRoomLinkData) {
-      this.excalidrawAPI.resetScene();
+      this.portal.socket = this.portal.open(
+        socketIOClient(socketServerData.url, {
+          transports: socketServerData.polling
+            ? ["websocket", "polling"]
+            : ["websocket"],
+        }),
+        roomId,
+        roomKey,
+      );
+    } catch (error: any) {
+      console.error(error);
+      this.setState({ errorMessage: error.message });
+      return null;
+    }

-      try {
-        const elements = await loadFromFirebase(
-          roomId,
-          roomKey,
-          this.portal.socket,
-        );
-        if (elements) {
-          scenePromise.resolve({
-            elements,
-            scrollToContent: true,
-          });
-        }
-      } catch (error: any) {
-        // log the error and move on. other peers will sync us the scene.
-        console.error(error);
-      }
-    } else {
+    if (!existingRoomLinkData) {
      const elements = this.excalidrawAPI.getSceneElements().map((element) => {
        if (isImageElement(element) && element.status === "saved") {
          return newElementWith(element, { status: "pending" });
@@ -396,14 +400,17 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
    }

    // fallback in case you're not alone in the room but still don't receive
-    // initial SCENE_UPDATE message
+    // initial SCENE_INIT message
    this.socketInitializationTimer = window.setTimeout(() => {
-      this.initializeSocket();
+      this.initializeRoom({
+        roomLinkData: existingRoomLinkData,
+        fetchScene: true,
+      });
      scenePromise.resolve(null);
    }, INITIAL_SCENE_UPDATE_TIMEOUT);

    // All socket listeners are moving to Portal
-    this.portal.socket!.on(
+    this.portal.socket.on(
      "client-broadcast",
      async (encryptedData: ArrayBuffer, iv: Uint8Array) => {
        if (!this.portal.roomKey) {
@@ -421,7 +428,7 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
            return;
          case SCENE.INIT: {
            if (!this.portal.socketInitialized) {
-              this.initializeSocket();
+              this.initializeRoom({ fetchScene: false });
              const remoteElements = decryptedData.payload.elements;
              const reconciledElements = this.reconcileElements(remoteElements);
              this.handleRemoteSceneUpdate(reconciledElements, {
@@ -475,12 +482,15 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
      },
    );

-    this.portal.socket!.on("first-in-room", () => {
+    this.portal.socket.on("first-in-room", async () => {
      if (this.portal.socket) {
        this.portal.socket.off("first-in-room");
      }
-      this.initializeSocket();
-      scenePromise.resolve(null);
+      const sceneData = await this.initializeRoom({
+        fetchScene: true,
+        roomLinkData: existingRoomLinkData,
+      });
+      scenePromise.resolve(sceneData);
    });

    this.initializeIdleDetector();
@@ -492,9 +502,45 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
    return scenePromise;
  };

-  private initializeSocket = () => {
-    this.portal.socketInitialized = true;
+  private initializeRoom = async ({
+    fetchScene,
+    roomLinkData,
+  }:
+    | {
+        fetchScene: true;
+        roomLinkData: { roomId: string; roomKey: string } | null;
+      }
+    | { fetchScene: false; roomLinkData?: null }) => {
    clearTimeout(this.socketInitializationTimer!);
+    if (fetchScene && roomLinkData && this.portal.socket) {
+      this.excalidrawAPI.resetScene();
+
+      try {
+        const elements = await loadFromFirebase(
+          roomLinkData.roomId,
+          roomLinkData.roomKey,
+          this.portal.socket,
+        );
+        if (elements) {
+          this.setLastBroadcastedOrReceivedSceneVersion(
+            getSceneVersion(elements),
+          );
+
+          return {
+            elements,
+            scrollToContent: true,
+          };
+        }
+      } catch (error: any) {
+        // log the error and move on. other peers will sync us the scene.
+        console.error(error);
+      } finally {
+        this.portal.socketInitialized = true;
+      }
+    } else {
+      this.portal.socketInitialized = true;
+    }
+    return null;
  };

  private reconcileElements = (
@@ -558,7 +604,9 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
      window.clearTimeout(this.idleTimeoutId);
      this.idleTimeoutId = null;
    }
+
    this.idleTimeoutId = window.setTimeout(this.reportIdle, IDLE_THRESHOLD);
+
    if (!this.activeIntervalId) {
      this.activeIntervalId = window.setInterval(
        this.reportActive,
@@ -633,15 +681,18 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
    return this.excalidrawAPI.getSceneElementsIncludingDeleted();
  };

-  onPointerUpdate = (payload: {
-    pointer: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["pointer"];
-    button: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["button"];
-    pointersMap: Gesture["pointers"];
-  }) => {
-    payload.pointersMap.size < 2 &&
-      this.portal.socket &&
-      this.portal.broadcastMouseLocation(payload);
-  };
+  onPointerUpdate = throttle(
+    (payload: {
+      pointer: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["pointer"];
+      button: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["button"];
+      pointersMap: Gesture["pointers"];
+    }) => {
+      payload.pointersMap.size < 2 &&
+        this.portal.socket &&
+        this.portal.broadcastMouseLocation(payload);
+    },
+    CURSOR_SYNC_TIMEOUT,
+  );

  onIdleStateChange = (userState: UserIdleState) => {
    this.setState({ userState });
@@ -677,8 +728,12 @@ class CollabWrapper extends PureComponent<Props, CollabState> {
    this.setState({ modalIsShown: false });
  };

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

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

--- a/src/excalidraw-app/collab/Portal.tsx
+++ b/src/excalidraw-app/collab/Portal.tsx
@@ -45,6 +45,8 @@ class Portal {
    this.socket.on("room-user-change", (clients: string[]) => {
      this.collab.setCollaborators(clients);
    });
+
+    return socket;
  }

  close() {
--- a/src/excalidraw-app/data/index.ts
+++ b/src/excalidraw-app/data/index.ts
@@ -30,7 +30,34 @@ const generateRoomId = async () => {
  return bytesToHexString(buffer);
 };

-export const SOCKET_SERVER = process.env.REACT_APP_SOCKET_SERVER_URL;
+/**
+ * Right now the reason why we resolve connection params (url, polling...)
+ * from upstream is to allow changing the params immediately when needed without
+ * having to wait for clients to update the SW.
+ *
+ * If REACT_APP_WS_SERVER_URL env is set, we use that instead (useful for forks)
+ */
+export const getCollabServer = async (): Promise<{
+  url: string;
+  polling: boolean;
+}> => {
+  if (process.env.REACT_APP_WS_SERVER_URL) {
+    return {
+      url: process.env.REACT_APP_WS_SERVER_URL,
+      polling: true,
+    };
+  }
+
+  try {
+    const resp = await fetch(
+      `${process.env.REACT_APP_PORTAL_URL}/collab-server`,
+    );
+    return await resp.json();
+  } catch (error) {
+    console.error(error);
+    throw new Error(t("errors.cannotResolveCollabServer"));
+  }
+};

 export type EncryptedData = {
  data: ArrayBuffer;
--- a/src/excalidraw-app/data/localStorage.ts
+++ b/src/excalidraw-app/data/localStorage.ts
@@ -5,14 +5,8 @@ import {
  getDefaultAppState,
 } from "../../appState";
 import { clearElementsForLocalStorage } from "../../element";
-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",
-};
+import { updateBrowserStateVersion } from "./tabSync";
+import { STORAGE_KEYS } from "../app_constants";

 export const saveUsernameToLocalStorage = (username: string) => {
  try {
@@ -53,6 +47,7 @@ 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);
@@ -113,9 +108,7 @@ 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(
-      APP_STORAGE_KEYS.LOCAL_STORAGE_LIBRARY,
-    );
+    const library = localStorage.getItem(STORAGE_KEYS.LOCAL_STORAGE_LIBRARY);

    const appStateSize = appState?.length || 0;
    const collabSize = collab?.length || 0;
@@ -127,3 +120,17 @@ 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 [];
+  }
+};
--- a/src/excalidraw-app/data/tabSync.ts
+++ b/src/excalidraw-app/data/tabSync.ts
@@ -0,0 +1,29 @@
+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;
+  }
+};
--- a/src/excalidraw-app/index.scss
+++ b/src/excalidraw-app/index.scss
@@ -1,4 +1,9 @@
 .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;
--- a/src/excalidraw-app/index.tsx
+++ b/src/excalidraw-app/index.tsx
@@ -7,7 +7,6 @@ import { TopErrorBoundary } from "../components/TopErrorBoundary";
 import {
  APP_NAME,
  EVENT,
-  STORAGE_KEYS,
  TITLE_TIMEOUT,
  URL_HASH_KEYS,
  VERSION_TIMEOUT,
@@ -35,6 +34,7 @@ import {
 import {
  debounce,
  getVersion,
+  isTestEnv,
  preventUnload,
  ResolvablePromise,
  resolvablePromise,
@@ -42,6 +42,8 @@ import {
 import {
  FIREBASE_STORAGE_PREFIXES,
  SAVE_TO_LOCAL_STORAGE_TIMEOUT,
+  STORAGE_KEYS,
+  SYNC_BROWSER_TABS_TIMEOUT,
 } from "./app_constants";
 import CollabWrapper, {
  CollabAPI,
@@ -51,7 +53,9 @@ 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";
@@ -67,6 +71,10 @@ 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");

@@ -104,6 +112,11 @@ 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 {
@@ -142,7 +155,6 @@ const saveDebounced = debounce(
      elements,
      files,
    });
-
    onFilesSaved();
  },
  SAVE_TO_LOCAL_STORAGE_TIMEOUT,
@@ -262,7 +274,7 @@ const PlusLinkJSX = (
    Introducing Excalidraw+
    <br />
    <a
-      href="https://plus.excalidraw.com/?utm_source=excalidraw&utm_medium=banner&utm_campaign=launch"
+      href="https://plus.excalidraw.com/plus?utm_source=excalidraw&utm_medium=banner&utm_campaign=launch"
      target="_blank"
      rel="noreferrer"
    >
@@ -278,7 +290,6 @@ const ExcalidrawWrapper = () => {
    currentLangCode = currentLangCode[0];
  }
  const [langCode, setLangCode] = useState(currentLangCode);
-
  // initial state
  // ---------------------------------------------------------------------------

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

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

    initializeScene({ collabAPI }).then((data) => {
@@ -415,13 +419,71 @@ 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]);
--- a/src/ga.ts
+++ b/src/ga.ts
@@ -62,7 +62,7 @@ const NVECTOR_BASE = ["1", "e0", "e1", "e2", "e01", "e20", "e12", "e012"];
 export const nvector = (value: number = 0, index: number = 0): NVector => {
  const result = [0, 0, 0, 0, 0, 0, 0, 0];
  if (index < 0 || index > 7) {
-    throw new Error(`Expected \`index\` betwen 0 and 7, got \`${index}\``);
+    throw new Error(`Expected \`index\` between 0 and 7, got \`${index}\``);
  }
  if (value !== 0) {
    result[index] = value;
--- a/src/galines.ts
+++ b/src/galines.ts
@@ -7,7 +7,7 @@ import { Line, Point } from "./ga";
 *
 * This maps to a standard formula `a * x + b * y + c`.
 *
- * `(-b, a)` correponds to a 2D vector parallel to the line. The lines
+ * `(-b, a)` corresponds to a 2D vector parallel to the line. The lines
 * have a natural orientation, corresponding to that vector.
 *
 * The magnitude ("norm") of the line is `sqrt(a ^ 2 + b ^ 2)`.
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -21,7 +21,7 @@ declare namespace NodeJS {
  interface ProcessEnv {
    readonly REACT_APP_BACKEND_V2_GET_URL: string;
    readonly REACT_APP_BACKEND_V2_POST_URL: string;
-    readonly REACT_APP_SOCKET_SERVER_URL: string;
+    readonly REACT_APP_PORTAL_URL: string;
    readonly REACT_APP_FIREBASE_CONFIG: string;
  }
 }
@@ -34,6 +34,10 @@ type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
 };

+/** utility type to assert that the second type is a subtype of the first type.
+ * Returns the subtype. */
+type SubtypeOf<Supertype, Subtype extends Supertype> = Subtype;
+
 type ResolutionType<T extends (...args: any) => any> = T extends (
  ...args: any
 ) => Promise<infer R>
--- a/src/groups.ts
+++ b/src/groups.ts
@@ -1,6 +1,7 @@
 import { GroupId, ExcalidrawElement, NonDeleted } from "./element/types";
 import { AppState } from "./types";
 import { getSelectedElements } from "./scene";
+import { getBoundTextElement } from "./element/textElement";

 export const selectGroup = (
  groupId: GroupId,
@@ -158,3 +159,30 @@ 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 bound text if present when grouping
+    const boundTextElement = getBoundTextElement(element);
+    if (boundTextElement) {
+      currentGroupMembers.push(boundTextElement);
+    }
+    groups.set(groupId, [...currentGroupMembers, element]);
+  });
+
+  return Array.from(groups.values());
+};
--- a/src/i18n.ts
+++ b/src/i18n.ts
@@ -16,9 +16,11 @@ const allLanguages: Language[] = [
  { code: "ar-SA", label: "العربية", rtl: true },
  { code: "bg-BG", label: "Български" },
  { code: "ca-ES", label: "Català" },
+  { code: "cs-CZ", label: "Česky" },
  { code: "de-DE", label: "Deutsch" },
  { code: "el-GR", label: "Ελληνικά" },
  { code: "es-ES", label: "Español" },
+  { code: "eu-ES", label: "Euskara" },
  { code: "fa-IR", label: "فارسی", rtl: true },
  { code: "fi-FI", label: "Suomi" },
  { code: "fr-FR", label: "Français" },
@@ -29,7 +31,10 @@ const allLanguages: Language[] = [
  { code: "it-IT", label: "Italiano" },
  { code: "ja-JP", label: "日本語" },
  { code: "kab-KAB", label: "Taqbaylit" },
+  { code: "kk-KZ", label: "Қазақ тілі" },
  { code: "ko-KR", label: "한국어" },
+  { code: "lt-LT", label: "Lietuvių" },
+  { code: "lv-LV", label: "Latviešu" },
  { code: "my-MM", label: "Burmese" },
  { code: "nb-NO", label: "Norsk bokmål" },
  { code: "nl-NL", label: "Nederlands" },
@@ -47,9 +52,6 @@ const allLanguages: Language[] = [
  { code: "uk-UA", label: "Українська" },
  { code: "zh-CN", label: "简体中文" },
  { code: "zh-TW", label: "繁體中文" },
-  { code: "lv-LV", label: "Latviešu" },
-  { code: "cs-CZ", label: "Česky" },
-  { code: "kk-KZ", label: "Қазақ тілі" },
 ].concat([defaultLang]);

 export const languages: Language[] = allLanguages
--- a/src/keys.ts
+++ b/src/keys.ts
@@ -1,5 +1,6 @@
 export const isDarwin = /Mac|iPod|iPhone|iPad/.test(window.navigator.platform);
 export const isWindows = /^Win/.test(window.navigator.platform);
+export const isAndroid = /\b(android)\b/i.test(navigator.userAgent);

 export const CODES = {
  EQUAL: "Equal",
@@ -40,6 +41,10 @@ export const KEYS = {
  QUESTION_MARK: "?",
  SPACE: " ",
  TAB: "Tab",
+  CHEVRON_LEFT: "<",
+  CHEVRON_RIGHT: ">",
+  PERIOD: ".",
+  COMMA: ",",

  A: "a",
  D: "d",
@@ -57,6 +62,7 @@ export const KEYS = {
  X: "x",
  Y: "y",
  Z: "z",
+  K: "k",
 } as const;

 export type Key = keyof typeof KEYS;
--- a/src/locales/ar-SA.json
+++ b/src/locales/ar-SA.json
@@ -64,6 +64,7 @@
    "cartoonist": "كرتوني",
    "fileTitle": "إسم الملف",
    "colorPicker": "منتقي اللون",
+    "canvasColors": "",
    "canvasBackground": "خلفية اللوحة",
    "drawingCanvas": "لوحة الرسم",
    "layers": "الطبقات",
@@ -101,8 +102,16 @@
    "showStroke": "إظهار منتقي لون الخط",
    "showBackground": "إظهار منتقي لون الخلفية",
    "toggleTheme": "غير النمط",
-    "personalLib": "",
-    "excalidrawLib": ""
+    "personalLib": "المكتبة الشخصية",
+    "excalidrawLib": "مكتبتنا",
+    "decreaseFontSize": "تصغير حجم الخط",
+    "increaseFontSize": "تكبير حجم الخط",
+    "unbindText": "",
+    "link": {
+      "edit": "تعديل الرابط",
+      "create": "إنشاء رابط",
+      "label": "رابط"
+    }
  },
  "buttons": {
    "clearReset": "إعادة تعيين اللوحة",
@@ -138,10 +147,10 @@
    "exitZenMode": "إلغاء الوضع الليلى",
    "cancel": "إلغاء",
    "clear": "مسح",
-    "remove": "",
-    "publishLibrary": "",
-    "submit": "",
-    "confirm": ""
+    "remove": "إزالة",
+    "publishLibrary": "انشر",
+    "submit": "أرسل",
+    "confirm": "تأكيد"
  },
  "alerts": {
    "clearReset": "هذا سيُزيل كامل اللوحة. هل أنت متأكد؟",
@@ -159,7 +168,7 @@
    "errorAddingToLibrary": "تعذر إضافة العنصر للمكتبة",
    "errorRemovingFromLibrary": "تعذر إزالة العنصر من المكتبة",
    "confirmAddLibrary": "هذا سيضيف {{numShapes}} شكل إلى مكتبتك. هل أنت متأكد؟",
-    "imageDoesNotContainScene": "",
+    "imageDoesNotContainScene": "يبدو أن هذه الصورة لا تحتوي على أي بيانات مشهد. هل قمت بتمكين تضمين المشهد أثناء التصدير؟",
    "cannotRestoreFromImage": "تعذر استعادة المشهد من ملف الصورة",
    "invalidSceneUrl": "تعذر استيراد المشهد من عنوان URL المتوفر. إما أنها مشوهة، أو لا تحتوي على بيانات Excalidraw JSON صالحة.",
    "resetLibrary": "هذا سوف يمسح مكتبتك. هل أنت متأكد؟",
@@ -171,7 +180,8 @@
    "imageInsertError": "تعذر إدراج الصورة. حاول مرة أخرى لاحقاً...",
    "fileTooBig": "الملف كبير جداً. الحد الأقصى المسموح به للحجم هو {{maxSize}}.",
    "svgImageInsertError": "تعذر إدراج صورة SVG. يبدو أن ترميز SVG غير صحيح.",
-    "invalidSVGString": ""
+    "invalidSVGString": "SVG غير صالح.",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "تحديد",
@@ -184,7 +194,9 @@
    "freedraw": "رسم",
    "text": "نص",
    "library": "مكتبة",
-    "lock": "الحفاظ على أداة التحديد نشطة بعد الرسم"
+    "lock": "الحفاظ على أداة التحديد نشطة بعد الرسم",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "إجراءات اللوحة",
@@ -192,7 +204,7 @@
    "shapes": "الأشكال"
  },
  "hints": {
-    "canvasPanning": "",
+    "canvasPanning": "لتحريك لوحة الرسم ، استمر في الضغط على عجلة الماوس أو مفتاح المسافة أثناء السحب",
    "linearElement": "انقر لبدء نقاط متعددة، اسحب لخط واحد",
    "freeDraw": "انقر واسحب، افرج عند الانتهاء",
    "text": "نصيحة: يمكنك أيضًا إضافة نص بالنقر المزدوج في أي مكان بأداة الاختيار",
@@ -204,10 +216,12 @@
    "resizeImage": "يمكنك تغيير الحجم بحرية بالضغط بأستمرار على SHIFT،\nاضغط بأستمرار على ALT أيضا لتغيير الحجم من المركز",
    "rotate": "يمكنك تقييد الزوايا من خلال الضغط على SHIFT أثناء الدوران",
    "lineEditor_info": "انقر نقراً مزدوجاً أو اضغط Enter لتعديل النقاط",
-    "lineEditor_pointSelected": "اضغط على حذف لإزالة النقطة، Ctrl Or Cmd+D للتكرار، أو اسحب للانتقال",
-    "lineEditor_nothingSelected": "حدد نقطة لتحريك أو إزالتها، أو اضغط Alt ثم انقر لإضافة نقاط جديدة",
+    "lineEditor_pointSelected": "",
+    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "نشر مكتبتك",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "تعذر عرض المعاينة",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "اقرأ مدونتنا",
    "click": "انقر",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "سهم مائل",
    "curvedLine": "خط مائل",
    "documentation": "دليل الاستخدام",
@@ -275,55 +291,55 @@
    "zoomToSelection": "تكبير للعنصر المحدد"
  },
  "clearCanvasDialog": {
-    "title": ""
+    "title": "مسح اللوحة"
  },
  "publishDialog": {
-    "title": "",
-    "itemName": "",
-    "authorName": "",
-    "githubUsername": "",
-    "twitterUsername": "",
-    "libraryName": "",
-    "libraryDesc": "",
-    "website": "",
+    "title": "نشر المكتبة",
+    "itemName": "إسم العنصر",
+    "authorName": "إسم المؤلف",
+    "githubUsername": "اسم المستخدم في جيت هب",
+    "twitterUsername": "اسم المستخدم في تويتر",
+    "libraryName": "اسم المكتبة",
+    "libraryDesc": "وصف المكتبة",
+    "website": "الموقع",
    "placeholder": {
-      "authorName": "",
-      "libraryName": "",
-      "libraryDesc": "",
+      "authorName": "اسمك أو اسم المستخدم",
+      "libraryName": "اسم مكتبتك",
+      "libraryDesc": "وصف مكتبتك لمساعدة الناس على فهم استخدامها",
      "githubHandle": "",
      "twitterHandle": "",
      "website": ""
    },
    "errors": {
-      "required": "",
-      "website": ""
+      "required": "مطلوب",
+      "website": "أدخل عنوان URL صالح"
    },
    "noteDescription": {
      "pre": "",
-      "link": "",
-      "post": ""
+      "link": "مستودع المكتبة العامة",
+      "post": "ليستخدمها الآخرون في رسوماتهم."
    },
    "noteGuidelines": {
-      "pre": "",
-      "link": "",
+      "pre": "يجب الموافقة على المكتبة يدويًا أولاً. يرجى قراءة ",
+      "link": "الإرشادات",
      "post": ""
    },
    "noteLicense": {
      "pre": "",
-      "link": "",
-      "post": ""
+      "link": "رخصة إم أي تي ",
+      "post": "وهو ما يعني باختصار أنه يمكن لأي شخص استخدامها دون قيود."
    },
-    "noteItems": "",
-    "atleastOneLibItem": ""
+    "noteItems": "يجب أن يكون لكل عنصر مكتبة اسمه الخاص حتى يكون قابلاً للتصفية. سيتم تضمين عناصر المكتبة التالية:",
+    "atleastOneLibItem": "يرجى تحديد عنصر مكتبة واحد على الأقل للبدء"
  },
  "publishSuccessDialog": {
-    "title": "",
-    "content": "",
-    "link": ""
+    "title": "تم إرسال المكتبة",
+    "content": "شكرا لك {{authorName}}. لقد تم إرسال مكتبتك للمراجعة. يمكنك تتبع الحالة",
+    "link": "هنا"
  },
  "confirmDialog": {
-    "resetLibrary": "",
-    "removeItemsFromLib": ""
+    "resetLibrary": "إعادة ضبط المكتبة",
+    "removeItemsFromLib": "إزالة العناصر المحددة من المكتبة"
  },
  "encrypted": {
    "tooltip": "رسوماتك مشفرة من النهاية إلى النهاية حتى أن خوادم Excalidraw لن تراها أبدا.",
@@ -345,7 +361,7 @@
    "width": "العرض"
  },
  "toast": {
-    "addedToLibrary": "",
+    "addedToLibrary": "تمت الاضافة الى المكتبة!",
    "copyStyles": "نسخت الانماط.",
    "copyToClipboard": "نسخ إلى الحافظة.",
    "copyToClipboardAsPng": "تم نسخ {{exportSelection}} إلى الحافظة بصيغة PNG\n({{exportColorScheme}})",
--- a/src/locales/bg-BG.json
+++ b/src/locales/bg-BG.json
@@ -35,11 +35,11 @@
    "arrowhead_arrow": "Стрелка",
    "arrowhead_bar": "Връх на стрелката",
    "arrowhead_dot": "Точка",
-    "arrowhead_triangle": "",
+    "arrowhead_triangle": "Триъгълник",
    "fontSize": "Размер на шрифта",
    "fontFamily": "Семейство шрифтове",
    "onlySelected": "Само избраното",
-    "withBackground": "",
+    "withBackground": "Фон",
    "exportEmbedScene": "",
    "exportEmbedScene_details": "Данните от сцената ще бъдат екпортирани в PNG/SVG файл, за да може сцената да бъде възстановена от него.\nТова ще увеличи размера на файла.",
    "addWatermark": "Добави \"Направено с Excalidraw\"",
@@ -62,8 +62,9 @@
    "architect": "Архитект",
    "artist": "Художник",
    "cartoonist": "Карикатурист",
-    "fileTitle": "",
+    "fileTitle": "Име на файл",
    "colorPicker": "Избор на цвят",
+    "canvasColors": "",
    "canvasBackground": "Фон на платно",
    "drawingCanvas": "Платно за рисуване",
    "layers": "Слоеве",
@@ -93,21 +94,29 @@
    "centerHorizontally": "Центрирай хоризонтално",
    "distributeHorizontally": "Разпредели хоризонтално",
    "distributeVertically": "Разпредели вертикално",
-    "flipHorizontal": "",
-    "flipVertical": "",
+    "flipHorizontal": "Хоризонтално обръщане",
+    "flipVertical": "Вертикално обръщане",
    "viewMode": "Изглед",
    "toggleExportColorScheme": "",
-    "share": "",
+    "share": "Сподели",
    "showStroke": "",
    "showBackground": "",
    "toggleTheme": "",
    "personalLib": "",
-    "excalidrawLib": ""
+    "excalidrawLib": "",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "Нулиране на платно",
    "exportJSON": "",
-    "exportImage": "",
+    "exportImage": "Запиши като изображение",
    "export": "Експортиране",
    "exportToPng": "Изнасяне в PNG",
    "exportToSvg": "Изнасяне в SVG",
@@ -129,19 +138,19 @@
    "edit": "Редактиране",
    "undo": "Отмяна",
    "redo": "Повтори",
-    "resetLibrary": "",
+    "resetLibrary": "Нулиране на библиотеката",
    "createNewRoom": "Създай нова стая",
    "fullScreen": "На цял екран",
    "darkMode": "Тъмен режим",
    "lightMode": "Светъл режим",
    "zenMode": "Режим Zen",
    "exitZenMode": "Спиране на Zen режим",
-    "cancel": "",
-    "clear": "",
-    "remove": "",
-    "publishLibrary": "",
-    "submit": "",
-    "confirm": ""
+    "cancel": "Отмени",
+    "clear": "Изчисти",
+    "remove": "Премахване",
+    "publishLibrary": "Публикувай",
+    "submit": "Изпрати",
+    "confirm": "Потвърждаване"
  },
  "alerts": {
    "clearReset": "Това ще изчисти цялото платно. Сигурни ли сте?",
@@ -167,24 +176,27 @@
    "invalidEncryptionKey": ""
  },
  "errors": {
-    "unsupportedFileType": "",
+    "unsupportedFileType": "Този файлов формат не се поддържа.",
    "imageInsertError": "",
    "fileTooBig": "",
    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "invalidSVGString": "",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Селекция",
-    "image": "",
+    "image": "Вмъкване на изображение",
    "rectangle": "Правоъгълник",
    "diamond": "Диамант",
    "ellipse": "Елипс",
    "arrow": "Стрелка",
    "line": "Линия",
-    "freedraw": "",
+    "freedraw": "Рисуване",
    "text": "Текст",
    "library": "Библиотека",
-    "lock": "Поддържайте избрания инструмент активен след рисуване"
+    "lock": "Поддържайте избрания инструмент активен след рисуване",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "Действия по платното",
@@ -204,10 +216,12 @@
    "resizeImage": "",
    "rotate": "Можете да ограничите ъглите, като държите SHIFT, докато се въртите",
    "lineEditor_info": "Кликнете два пъти или натиснете Enter за да промените точките",
-    "lineEditor_pointSelected": "Натиснете Delete за да изтриете точка, CtrlOrCmd+D за дуплициране, или извлачете за да преместите",
-    "lineEditor_nothingSelected": "Изберете точка за местене или изтриване, или пък задръжте Alt и натиснете за да добавите нови точки",
+    "lineEditor_pointSelected": "Натиснете Delete за да изтриете точка(и), CtrlOrCmd+D за дуплициране, или извлачете за да преместите",
+    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "",
+    "bindTextToElement": "Натиснете Enter, за да добавите",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "Невъзможност за показване на preview",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Прочетете нашия блог",
    "click": "клик",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "Извита стрелка",
    "curvedLine": "Извита линия",
    "documentation": "Документация",
--- a/src/locales/bn-BD.json
+++ b/src/locales/bn-BD.json
@@ -64,6 +64,7 @@
    "cartoonist": "",
    "fileTitle": "",
    "colorPicker": "",
+    "canvasColors": "",
    "canvasBackground": "",
    "drawingCanvas": "",
    "layers": "",
@@ -102,7 +103,15 @@
    "showBackground": "",
    "toggleTheme": "",
    "personalLib": "",
-    "excalidrawLib": ""
+    "excalidrawLib": "",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "",
@@ -171,7 +180,8 @@
    "imageInsertError": "",
    "fileTooBig": "",
    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "invalidSVGString": "",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "",
@@ -184,7 +194,9 @@
    "freedraw": "",
    "text": "",
    "library": "",
-    "lock": ""
+    "lock": "",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "",
@@ -207,7 +219,9 @@
    "lineEditor_pointSelected": "",
    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "",
    "click": "",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "",
    "curvedLine": "",
    "documentation": "",
--- a/src/locales/ca-ES.json
+++ b/src/locales/ca-ES.json
@@ -35,7 +35,7 @@
    "arrowhead_arrow": "Fletxa",
    "arrowhead_bar": "Barra",
    "arrowhead_dot": "Punt",
-    "arrowhead_triangle": "",
+    "arrowhead_triangle": "Triangle",
    "fontSize": "Mida de lletra",
    "fontFamily": "Tipus de lletra",
    "onlySelected": "Només seleccionats",
@@ -64,6 +64,7 @@
    "cartoonist": "Dibuixant",
    "fileTitle": "Nom del fitxer",
    "colorPicker": "Selector de colors",
+    "canvasColors": "Usat al llenç",
    "canvasBackground": "Fons del llenç",
    "drawingCanvas": "Llenç de dibuix",
    "layers": "Capes",
@@ -101,8 +102,16 @@
    "showStroke": "Mostra el selector de color del traç",
    "showBackground": "Mostra el selector de color de fons",
    "toggleTheme": "Activa o desactiva el tema",
-    "personalLib": "",
-    "excalidrawLib": ""
+    "personalLib": "Biblioteca personal",
+    "excalidrawLib": "Biblioteca d'Excalidraw",
+    "decreaseFontSize": "Redueix la mida de la lletra",
+    "increaseFontSize": "Augmenta la mida de la lletra",
+    "unbindText": "Desvincular el text",
+    "link": {
+      "edit": "Edita l'enllaç",
+      "create": "Crea un enllaç",
+      "label": "Enllaç"
+    }
  },
  "buttons": {
    "clearReset": "Neteja el llenç",
@@ -136,12 +145,12 @@
    "lightMode": "Mode clar",
    "zenMode": "Mode zen",
    "exitZenMode": "Surt de mode zen",
-    "cancel": "",
-    "clear": "",
-    "remove": "",
-    "publishLibrary": "",
-    "submit": "",
-    "confirm": ""
+    "cancel": "Cancel·la",
+    "clear": "Neteja",
+    "remove": "Suprimeix",
+    "publishLibrary": "Publica",
+    "submit": "Envia",
+    "confirm": "Confirma"
  },
  "alerts": {
    "clearReset": "S'esborrarà tot el llenç. N'esteu segur?",
@@ -159,23 +168,24 @@
    "errorAddingToLibrary": "No s'ha pogut afegir l'element a la biblioteca",
    "errorRemovingFromLibrary": "No s'ha pogut eliminar l'element de la biblioteca",
    "confirmAddLibrary": "Això afegirà {{numShapes}} forma(es) a la vostra biblioteca. Estàs segur?",
-    "imageDoesNotContainScene": "",
+    "imageDoesNotContainScene": "Aquesta imatge no sembla contenir cap dada d'escena. Heu activat l'incrustació de l'escena durant l'exportació?",
    "cannotRestoreFromImage": "L’escena no s’ha pogut restaurar des d’aquest fitxer d’imatge",
    "invalidSceneUrl": "No s'ha pogut importar l'escena des de l'adreça URL proporcionada. Està malformada o no conté dades Excalidraw JSON vàlides.",
    "resetLibrary": "Això buidarà la biblioteca. N'esteu segur?",
-    "removeItemsFromsLibrary": "",
-    "invalidEncryptionKey": ""
+    "removeItemsFromsLibrary": "Suprimir {{count}} element(s) de la biblioteca?",
+    "invalidEncryptionKey": "La clau d'encriptació ha de tenir 22 caràcters. La col·laboració en directe està desactivada."
  },
  "errors": {
-    "unsupportedFileType": "",
-    "imageInsertError": "",
-    "fileTooBig": "",
-    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "unsupportedFileType": "Tipus de fitxer no suportat.",
+    "imageInsertError": "No s'ha pogut insertar la imatge, torneu-ho a provar més tard...",
+    "fileTooBig": "El fitxer és massa gros. La mida màxima permesa és {{maxSize}}.",
+    "svgImageInsertError": "No ha estat possible inserir la imatge SVG. Les marques SVG semblen invàlides.",
+    "invalidSVGString": "SVG no vàlid.",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Selecció",
-    "image": "",
+    "image": "Insereix imatge",
    "rectangle": "Rectangle",
    "diamond": "Rombe",
    "ellipse": "El·lipse",
@@ -184,7 +194,9 @@
    "freedraw": "Dibuix",
    "text": "Text",
    "library": "Biblioteca",
-    "lock": "Mantenir activa l'eina seleccionada desprès de dibuixar"
+    "lock": "Mantenir activa l'eina seleccionada desprès de dibuixar",
+    "penMode": "Evita el zoom i accepta solament el dibuix lliure amb bolígraf",
+    "link": "Afegeix / actualitza l'enllaç per a la forma seleccionada"
  },
  "headings": {
    "canvasActions": "Accions del llenç",
@@ -192,7 +204,7 @@
    "shapes": "Formes"
  },
  "hints": {
-    "canvasPanning": "",
+    "canvasPanning": "Per a moure el llenç, mantingueu premuda la roda del ratolí o la tecla espai mentre l'arrossegueu",
    "linearElement": "Feu clic per a dibuixar múltiples punts; arrossegueu per a una sola línia",
    "freeDraw": "Feu clic i arrossegueu, deixeu anar per a finalitzar",
    "text": "Consell: també podeu afegir text fent doble clic en qualsevol lloc amb l'eina de selecció",
@@ -201,13 +213,15 @@
    "linearElementMulti": "Feu clic a l'ultim punt, o pitgeu Esc o Retorn per a finalitzar",
    "lockAngle": "Per restringir els angles, mantenir premut el majúscul (SHIFT)",
    "resize": "Per restringir les proporcions mentres es canvia la mida, mantenir premut el majúscul (SHIFT); per canviar la mida des del centre, mantenir premut ALT",
-    "resizeImage": "",
+    "resizeImage": "Podeu redimensionar lliurement prement MAJÚSCULA;\nper a redimensionar des del centre, premeu ALT",
    "rotate": "Per restringir els angles mentre gira, mantenir premut el majúscul (SHIFT)",
    "lineEditor_info": "Fes doble clic o premi Enter per editar punts",
-    "lineEditor_pointSelected": "Premeu Suprimir per a eliminar el punt, CtrlOrCmd+D per a duplicar-lo, o arrossegueu-lo per a moure'l",
-    "lineEditor_nothingSelected": "Selecciona un punt per moure o eliminar, o manté premut Alt i fes clic per afegir punts nous",
-    "placeImage": "",
-    "publishLibrary": ""
+    "lineEditor_pointSelected": "Premeu Suprimir per a eliminar el(s) punt(s), CtrlOrCmd+D per a duplicar-lo, o arrossegueu-lo per a moure'l",
+    "lineEditor_nothingSelected": "Seleccioneu un punt per a editar-lo (premeu SHIFT si voleu\nselecció múltiple), o manteniu Alt i feu clic per a afegir més punts",
+    "placeImage": "Feu clic per a col·locar la imatge o clic i arrossegar per a establir-ne la mida manualment",
+    "publishLibrary": "Publiqueu la vostra pròpia llibreria",
+    "bindTextToElement": "Premeu enter per a afegir-hi text",
+    "deepBoxSelect": "Manteniu CtrlOrCmd per a selecció profunda, i per a evitar l'arrossegament"
  },
  "canvasError": {
    "cannotShowPreview": "No es pot mostrar la previsualització",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Llegiu el nostre blog",
    "click": "clic",
+    "deepSelect": "Selecció profunda",
+    "deepBoxSelect": "",
    "curvedArrow": "Fletxa corba",
    "curvedLine": "Línia corba",
    "documentation": "Documentació",
@@ -275,55 +291,55 @@
    "zoomToSelection": "Zoom per veure la selecció"
  },
  "clearCanvasDialog": {
-    "title": ""
+    "title": "Neteja el llenç"
  },
  "publishDialog": {
-    "title": "",
-    "itemName": "",
-    "authorName": "",
-    "githubUsername": "",
-    "twitterUsername": "",
-    "libraryName": "",
-    "libraryDesc": "",
-    "website": "",
+    "title": "Publica la biblioteca",
+    "itemName": "Nom de l'element",
+    "authorName": "Nom de l'autor/a",
+    "githubUsername": "Nom d'usuari de GitHub",
+    "twitterUsername": "Nom d'usuari de Twitter",
+    "libraryName": "Nom de la biblioteca",
+    "libraryDesc": "Descripció de la biblioteca",
+    "website": "Lloc web",
    "placeholder": {
-      "authorName": "",
-      "libraryName": "",
-      "libraryDesc": "",
+      "authorName": "Nom o usuari",
+      "libraryName": "Nom de la vostra biblioteca",
+      "libraryDesc": "Descripció de la biblioteca per a ajudar a la gent a entendre'n el funcionament",
      "githubHandle": "",
-      "twitterHandle": "",
-      "website": ""
+      "twitterHandle": "Usuari de twitter (opcional), per tal que puguem donar-vos crèdit quan fem la promoció a Twitter",
+      "website": "Enllaç al vostre lloc web personal o a qualsevol altre (opcional)"
    },
    "errors": {
-      "required": "",
-      "website": ""
+      "required": "Requerit",
+      "website": "Introduïu una URL vàlida"
    },
    "noteDescription": {
-      "pre": "",
-      "link": "",
-      "post": ""
+      "pre": "Envieu la vostra biblioteca perquè sigui inclosa al ",
+      "link": "repositori públic",
+      "post": "per tal que altres persones puguin fer-ne ús en els seus dibuixos."
    },
    "noteGuidelines": {
-      "pre": "",
-      "link": "",
-      "post": ""
+      "pre": "La biblioteca ha de ser aprovada manualment. Si us plau, llegiu les ",
+      "link": "directrius",
+      "post": " abans d'enviar-hi res. Necessitareu un compte de GitHub per a comunicar i fer-hi canvis si cal, però no és requisit imprescindible."
    },
    "noteLicense": {
-      "pre": "",
-      "link": "",
-      "post": ""
+      "pre": "Quan l'envieu, accepteu que la biblioteca sigui publicada sota la ",
+      "link": "llicència MIT, ",
+      "post": "que, en resum, vol dir que qualsevol persona pot fer-ne ús sense restriccions."
    },
-    "noteItems": "",
-    "atleastOneLibItem": ""
+    "noteItems": "Cada element de la biblioteca ha de tenir el seu propi nom per tal que sigui filtrable. S'hi inclouran els elements següents:",
+    "atleastOneLibItem": "Si us plau, seleccioneu si més no un element de la biblioteca per a començar"
  },
  "publishSuccessDialog": {
-    "title": "",
-    "content": "",
-    "link": ""
+    "title": "Biblioteca enviada",
+    "content": "Gràcies, {{authorName}}. La vostra biblioteca ha estat enviada per a ser revisada. Podeu comprovar-ne l'estat",
+    "link": "aquí"
  },
  "confirmDialog": {
-    "resetLibrary": "",
-    "removeItemsFromLib": ""
+    "resetLibrary": "Restableix la biblioteca",
+    "removeItemsFromLib": "Suprimeix els elements seleccionats de la llibreria"
  },
  "encrypted": {
    "tooltip": "Els vostres dibuixos estan xifrats de punta a punta de manera que els servidors d’Excalidraw no els veuran mai.",
@@ -345,7 +361,7 @@
    "width": "Amplada"
  },
  "toast": {
-    "addedToLibrary": "",
+    "addedToLibrary": "Afegit a la biblioteca",
    "copyStyles": "S'han copiat els estils.",
    "copyToClipboard": "S'ha copiat al porta-retalls.",
    "copyToClipboardAsPng": "S'ha copiat {{exportSelection}} al porta-retalls en format PNG\n({{exportColorScheme}})",
@@ -360,29 +376,29 @@
    "f1f3f5": "Gris 1",
    "fff5f5": "Vermell 0",
    "fff0f6": "Rosa 0",
-    "f8f0fc": "",
-    "f3f0ff": "",
-    "edf2ff": "",
+    "f8f0fc": "Malva 0",
+    "f3f0ff": "Violat 0",
+    "edf2ff": "Indi 0",
    "e7f5ff": "Blau 0",
-    "e3fafc": "",
-    "e6fcf5": "",
+    "e3fafc": "Cian 0",
+    "e6fcf5": "Xarxet 0",
    "ebfbee": "Verd 0",
-    "f4fce3": "",
+    "f4fce3": "Llima 0",
    "fff9db": "Groc 0",
-    "fff4e6": "",
+    "fff4e6": "Taronja 0",
    "transparent": "Transparent",
    "ced4da": "Gris 4",
    "868e96": "Gris 6",
    "fa5252": "Vermell 6",
    "e64980": "Rosa 6",
-    "be4bdb": "",
-    "7950f2": "",
-    "4c6ef5": "",
+    "be4bdb": "Malva 6",
+    "7950f2": "Violat 6",
+    "4c6ef5": "Indi 6",
    "228be6": "Blau 6",
-    "15aabf": "",
-    "12b886": "",
+    "15aabf": "Cian 6",
+    "12b886": "Xarxet 6",
    "40c057": "Verd 6",
-    "82c91e": "",
+    "82c91e": "Llima 6",
    "fab005": "Groc 6",
    "fd7e14": "Taronja 6",
    "000000": "Negre",
@@ -390,14 +406,14 @@
    "495057": "Gris 7",
    "c92a2a": "Vermell 9",
    "a61e4d": "Rosa 9",
-    "862e9c": "",
-    "5f3dc4": "",
-    "364fc7": "",
+    "862e9c": "Malva 9",
+    "5f3dc4": "Violat 9",
+    "364fc7": "Indi 9",
    "1864ab": "Blau 9",
-    "0b7285": "",
-    "087f5b": "",
+    "0b7285": "Cian 9",
+    "087f5b": "Xarxet 9",
    "2b8a3e": "Verd 9",
-    "5c940d": "",
+    "5c940d": "Llima 9",
    "e67700": "Groc 9",
    "d9480f": "Taronja 9"
  }
--- a/src/locales/cs-CZ.json
+++ b/src/locales/cs-CZ.json
@@ -64,6 +64,7 @@
    "cartoonist": "",
    "fileTitle": "",
    "colorPicker": "",
+    "canvasColors": "",
    "canvasBackground": "Pozadí plátna",
    "drawingCanvas": "",
    "layers": "",
@@ -102,7 +103,15 @@
    "showBackground": "",
    "toggleTheme": "Přepnout tmavý řežim",
    "personalLib": "",
-    "excalidrawLib": ""
+    "excalidrawLib": "",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "",
@@ -171,7 +180,8 @@
    "imageInsertError": "",
    "fileTooBig": "",
    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "invalidSVGString": "",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Výběr",
@@ -184,7 +194,9 @@
    "freedraw": "Kreslení",
    "text": "Text",
    "library": "",
-    "lock": ""
+    "lock": "",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "",
@@ -207,7 +219,9 @@
    "lineEditor_pointSelected": "",
    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "",
    "click": "kliknutí",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "",
    "curvedLine": "",
    "documentation": "",
--- a/src/locales/da-DK.json
+++ b/src/locales/da-DK.json
@@ -5,7 +5,7 @@
    "selectAll": "Marker alle",
    "multiSelect": "",
    "moveCanvas": "",
-    "cut": "",
+    "cut": "Klip",
    "copy": "Kopier",
    "copyAsPng": "Kopier til klippebord som PNG",
    "copyAsSvg": "Kopier til klippebord som SVG",
@@ -64,6 +64,7 @@
    "cartoonist": "",
    "fileTitle": "Filnavn",
    "colorPicker": "Farvevælger",
+    "canvasColors": "Brugt på lærred",
    "canvasBackground": "",
    "drawingCanvas": "",
    "layers": "",
@@ -102,7 +103,15 @@
    "showBackground": "",
    "toggleTheme": "",
    "personalLib": "",
-    "excalidrawLib": ""
+    "excalidrawLib": "",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "",
@@ -171,7 +180,8 @@
    "imageInsertError": "",
    "fileTooBig": "",
    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "invalidSVGString": "",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "",
@@ -184,7 +194,9 @@
    "freedraw": "",
    "text": "",
    "library": "",
-    "lock": ""
+    "lock": "",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "",
@@ -207,7 +219,9 @@
    "lineEditor_pointSelected": "",
    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Læs vores blog",
    "click": "",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "",
    "curvedLine": "",
    "documentation": "",
--- a/src/locales/de-DE.json
+++ b/src/locales/de-DE.json
@@ -64,6 +64,7 @@
    "cartoonist": "Karikaturist",
    "fileTitle": "Dateiname",
    "colorPicker": "Farbauswähler",
+    "canvasColors": "Auf Leinwand verwendet",
    "canvasBackground": "Zeichenflächenhintergrund",
    "drawingCanvas": "Leinwand",
    "layers": "Ebenen",
@@ -100,9 +101,17 @@
    "share": "Teilen",
    "showStroke": "Auswahl für Strichfarbe anzeigen",
    "showBackground": "Hintergrundfarbe auswählen",
-    "toggleTheme": "Design umschalten",
+    "toggleTheme": "Thema umschalten",
    "personalLib": "Persönliche Bibliothek",
-    "excalidrawLib": "Excalidraw-Bibliothek"
+    "excalidrawLib": "Excalidraw-Bibliothek",
+    "decreaseFontSize": "Schrift verkleinern",
+    "increaseFontSize": "Schrift vergrößern",
+    "unbindText": "Text lösen",
+    "link": {
+      "edit": "Link bearbeiten",
+      "create": "Link erstellen",
+      "label": "Link"
+    }
  },
  "buttons": {
    "clearReset": "Zeichenfläche löschen & Hintergrundfarbe zurücksetzen",
@@ -171,7 +180,8 @@
    "imageInsertError": "Das Bild konnte nicht eingefügt werden. Versuche es später erneut...",
    "fileTooBig": "Die Datei ist zu groß. Die maximal zulässige Größe ist {{maxSize}}.",
    "svgImageInsertError": "SVG-Bild konnte nicht eingefügt werden. Das SVG-Markup sieht ungültig aus.",
-    "invalidSVGString": "Ungültige SVG."
+    "invalidSVGString": "Ungültige SVG.",
+    "cannotResolveCollabServer": "Konnte keine Verbindung zum Collab-Server herstellen. Bitte lade die Seite neu und versuche es erneut."
  },
  "toolBar": {
    "selection": "Auswahl",
@@ -184,7 +194,9 @@
    "freedraw": "Zeichnen",
    "text": "Text",
    "library": "Bibliothek",
-    "lock": "Ausgewähltes Werkzeug nach Zeichnen aktiv lassen"
+    "lock": "Ausgewähltes Werkzeug nach Zeichnen aktiv lassen",
+    "penMode": "",
+    "link": "Link für ausgewählte Form hinzufügen / aktualisieren"
  },
  "headings": {
    "canvasActions": "Aktionen für Zeichenfläche",
@@ -197,17 +209,19 @@
    "freeDraw": "Klicke und ziehe. Lass los, wenn du fertig bist",
    "text": "Tipp: Du kannst auch Text hinzufügen, indem du mit dem Auswahlwerkzeug auf eine beliebige Stelle doppelklickst",
    "text_selected": "Doppelklicken oder Eingabetaste drücken, um Text zu bearbeiten",
-    "text_editing": "Drücke Escape oder Strg/Cmd+Eingabetaste, um die Bearbeitung abzuschließen",
+    "text_editing": "Drücke Escape oder CtrlOrCmd+Eingabetaste, um die Bearbeitung abzuschließen",
    "linearElementMulti": "Zum Beenden auf den letzten Punkt klicken oder Escape oder Eingabe drücken",
    "lockAngle": "Du kannst Winkel einschränken, indem du SHIFT gedrückt hältst",
    "resize": "Du kannst die Proportionen einschränken, indem du SHIFT während der Größenänderung gedrückt hältst. Halte ALT gedrückt, um die Größe vom Zentrum aus zu ändern",
    "resizeImage": "Du kannst die Größe frei ändern, indem du SHIFT gedrückt hältst; halte ALT, um die Größe vom Zentrum aus zu ändern",
    "rotate": "Du kannst Winkel einschränken, indem du SHIFT während der Drehung gedrückt hältst",
    "lineEditor_info": "Doppelklicken oder Eingabetaste drücken, um Punkte zu bearbeiten",
-    "lineEditor_pointSelected": "Drücke Löschen, um Punkt zu entfernen, Strg+D oder Cmd+D zum Duplizieren oder ziehe zum Verschieben",
-    "lineEditor_nothingSelected": "Wähle einen Punkt zum Verschieben oder Löschen oder halte die Alt-Taste gedrückt und klicke, um neue Punkte hinzuzufügen",
+    "lineEditor_pointSelected": "Drücke Löschen, um Punkt(e) zu entfernen, CtrlOrCmd+D zum Duplizieren oder ziehe zum Verschieben",
+    "lineEditor_nothingSelected": "Wähle einen zu bearbeitenden Punkt (halte SHIFT gedrückt um mehrere Punkte auszuwählen),\noder halte Alt gedrückt und klicke um neue Punkte hinzuzufügen",
    "placeImage": "Klicken, um das Bild zu platzieren oder klicken und ziehen um seine Größe manuell zu setzen",
-    "publishLibrary": "Veröffentliche deine eigene Bibliothek"
+    "publishLibrary": "Veröffentliche deine eigene Bibliothek",
+    "bindTextToElement": "Zum Hinzufügen Eingabetaste drücken",
+    "deepBoxSelect": "Halte CtrlOrCmd gedrückt, um innerhalb der Gruppe auszuwählen, und um Ziehen zu vermeiden"
  },
  "canvasError": {
    "cannotShowPreview": "Vorschau kann nicht angezeigt werden",
@@ -243,7 +257,7 @@
  "exportDialog": {
    "disk_title": "Auf Festplatte speichern",
    "disk_details": "Exportiere die Zeichnungsdaten in eine Datei, die Du später importieren kannst.",
-    "disk_button": "In Datei speichern",
+    "disk_button": "Als Datei speichern",
    "link_title": "Teilbarer Link",
    "link_details": "Als schreibgeschützten Link exportieren.",
    "link_button": "Als Link exportieren",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Lies unseren Blog",
    "click": "klicken",
+    "deepSelect": "Auswahl innerhalb der Gruppe",
+    "deepBoxSelect": "Auswahl innerhalb der Gruppe, und Ziehen vermeiden",
    "curvedArrow": "Gebogener Pfeil",
    "curvedLine": "Gebogene Linie",
    "documentation": "Dokumentation",
--- a/src/locales/el-GR.json
+++ b/src/locales/el-GR.json
@@ -64,6 +64,7 @@
    "cartoonist": "Σκιτσογράφος",
    "fileTitle": "Όνομα αρχείου",
    "colorPicker": "Επιλογή Χρώματος",
+    "canvasColors": "",
    "canvasBackground": "Φόντο καμβά",
    "drawingCanvas": "Σχεδίαση καμβά",
    "layers": "Στρώματα",
@@ -101,8 +102,16 @@
    "showStroke": "Εμφάνιση επιλογέα χρωμάτων πινελιάς",
    "showBackground": "Εμφάνιση επιλογέα χρώματος φόντου",
    "toggleTheme": "Εναλλαγή θέματος",
-    "personalLib": "",
-    "excalidrawLib": ""
+    "personalLib": "Προσωπική Βιβλιοθήκη",
+    "excalidrawLib": "Βιβλιοθήκη Excalidraw",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "Επαναφορά του καμβά",
@@ -171,7 +180,8 @@
    "imageInsertError": "Αδυναμία εισαγωγής εικόνας. Προσπαθήστε ξανά αργότερα...",
    "fileTooBig": "Το αρχείο είναι πολύ μεγάλο. Το μέγιστο επιτρεπόμενο μέγεθος είναι {{maxSize}}.",
    "svgImageInsertError": "",
-    "invalidSVGString": "Μη έγκυρο SVG."
+    "invalidSVGString": "Μη έγκυρο SVG.",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Επιλογή",
@@ -184,7 +194,9 @@
    "freedraw": "Σχεδίαση",
    "text": "Κείμενο",
    "library": "Βιβλιοθήκη",
-    "lock": "Κράτησε επιλεγμένο το εργαλείο μετά το σχέδιο"
+    "lock": "Κράτησε επιλεγμένο το εργαλείο μετά το σχέδιο",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "Ενέργειες καμβά",
@@ -204,10 +216,12 @@
    "resizeImage": "",
    "rotate": "Μπορείς να περιορίσεις τις γωνίες κρατώντας πατημένο το πλήκτρο SHIFT κατά την περιστροφή",
    "lineEditor_info": "Διπλό-κλικ ή πιέστε Enter για να επεξεργαστείτε τα σημεία",
-    "lineEditor_pointSelected": "Πιέστε Διαγραφή για να αφαιρέσετε το σημείου, CtrlOrCmd+D για να το αντιγράψετε ή σύρτε το για να το μετακινήσετε",
-    "lineEditor_nothingSelected": "Επιλέξτε ένα σημείο για μετακίνηση ή αφαίρεση, ή κρατήστε παρατεταμένα το Alt και κάντε κλικ για να προσθέσετε νέα σημεία",
+    "lineEditor_pointSelected": "",
+    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": "Δημοσιεύστε τη δική σας βιβλιοθήκη"
+    "publishLibrary": "Δημοσιεύστε τη δική σας βιβλιοθήκη",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "Αδυναμία εμφάνισης προεπισκόπησης",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Διαβάστε το Blog μας",
    "click": "κλικ",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "Κυρτό βέλος",
    "curvedLine": "Κυρτή γραμμή",
    "documentation": "Εγχειρίδιο",
@@ -295,7 +311,7 @@
      "website": ""
    },
    "errors": {
-      "required": "",
+      "required": "Απαιτείται",
      "website": "Εισάγετε μια έγκυρη διεύθυνση URL"
    },
    "noteDescription": {
@@ -305,7 +321,7 @@
    },
    "noteGuidelines": {
      "pre": "",
-      "link": "",
+      "link": "οδηγίες",
      "post": ""
    },
    "noteLicense": {
@@ -319,11 +335,11 @@
  "publishSuccessDialog": {
    "title": "",
    "content": "",
-    "link": ""
+    "link": "εδώ"
  },
  "confirmDialog": {
-    "resetLibrary": "",
-    "removeItemsFromLib": ""
+    "resetLibrary": "Καθαρισμός βιβλιοθήκης",
+    "removeItemsFromLib": "Αφαίρεση επιλεγμένων αντικειμένων από τη βιβλιοθήκη"
  },
  "encrypted": {
    "tooltip": "Τα σχέδιά σου είναι κρυπτογραφημένα από άκρο σε άκρο, έτσι δεν θα είναι ποτέ ορατά μέσα από τους διακομιστές του Excalidraw.",
@@ -345,7 +361,7 @@
    "width": "Πλάτος"
  },
  "toast": {
-    "addedToLibrary": "",
+    "addedToLibrary": "Προστέθηκε στη βιβλιοθήκη",
    "copyStyles": "Αντιγράφηκαν στυλ.",
    "copyToClipboard": "Αντιγράφηκε στο πρόχειρο.",
    "copyToClipboardAsPng": "Αντιγράφηκε {{exportSelection}} στο πρόχειρο ως PNG\n({{exportColorScheme}})",
--- a/src/locales/en.json
+++ b/src/locales/en.json
@@ -64,6 +64,7 @@
    "cartoonist": "Cartoonist",
    "fileTitle": "File name",
    "colorPicker": "Color picker",
+    "canvasColors": "Used on canvas",
    "canvasBackground": "Canvas background",
    "drawingCanvas": "Drawing canvas",
    "layers": "Layers",
@@ -102,7 +103,15 @@
    "showBackground": "Show background color picker",
    "toggleTheme": "Toggle theme",
    "personalLib": "Personal Library",
-    "excalidrawLib": "Excalidraw Library"
+    "excalidrawLib": "Excalidraw Library",
+    "decreaseFontSize": "Decrease font size",
+    "increaseFontSize": "Increase font size",
+    "unbindText": "Unbind text",
+    "link": {
+      "edit": "Edit link",
+      "create": "Create link",
+      "label": "Link"
+    }
  },
  "buttons": {
    "clearReset": "Reset the canvas",
@@ -171,7 +180,8 @@
    "imageInsertError": "Couldn't insert image. Try again later...",
    "fileTooBig": "File is too big. Maximum allowed size is {{maxSize}}.",
    "svgImageInsertError": "Couldn't insert SVG image. The SVG markup looks invalid.",
-    "invalidSVGString": "Invalid SVG."
+    "invalidSVGString": "Invalid SVG.",
+    "cannotResolveCollabServer": "Couldn't connect to the collab server. Please reload the page and try again."
  },
  "toolBar": {
    "selection": "Selection",
@@ -184,7 +194,9 @@
    "freedraw": "Draw",
    "text": "Text",
    "library": "Library",
-    "lock": "Keep selected tool active after drawing"
+    "lock": "Keep selected tool active after drawing",
+    "penMode": "Prevent pinch-zoom and accept freedraw input only from pen",
+    "link": "Add/ Update link for a selected shape"
  },
  "headings": {
    "canvasActions": "Canvas actions",
@@ -208,7 +220,8 @@
    "lineEditor_nothingSelected": "Select a point to edit (hold SHIFT to select multiple),\nor hold Alt and click to add new points",
    "placeImage": "Click to place the image, or click and drag to set its size manually",
    "publishLibrary": "Publish your own library",
-    "bindTextToElement": "Press enter to add text"
+    "bindTextToElement": "Press enter to add text",
+    "deepBoxSelect": "Hold CtrlOrCmd to deep select, and to prevent dragging"
  },
  "canvasError": {
    "cannotShowPreview": "Cannot show preview",
@@ -255,6 +268,8 @@
  "helpDialog": {
    "blog": "Read our blog",
    "click": "click",
+    "deepSelect": "Deep select",
+    "deepBoxSelect": "Deep select within box, and prevent dragging",
    "curvedArrow": "Curved arrow",
    "curvedLine": "Curved line",
    "documentation": "Documentation",
--- a/src/locales/es-ES.json
+++ b/src/locales/es-ES.json
@@ -64,6 +64,7 @@
    "cartoonist": "Caricatura",
    "fileTitle": "Nombre del archivo",
    "colorPicker": "Selector de color",
+    "canvasColors": "Usado en lienzo",
    "canvasBackground": "Fondo del lienzo",
    "drawingCanvas": "Lienzo de dibujo",
    "layers": "Capas",
@@ -101,8 +102,16 @@
    "showStroke": "Mostrar selector de color de trazo",
    "showBackground": "Mostrar el selector de color de fondo",
    "toggleTheme": "Alternar tema",
-    "personalLib": "",
-    "excalidrawLib": ""
+    "personalLib": "Biblioteca personal",
+    "excalidrawLib": "Biblioteca Excalidraw",
+    "decreaseFontSize": "Disminuir tamaño de letra",
+    "increaseFontSize": "Aumentar el tamaño de letra",
+    "unbindText": "Desvincular texto",
+    "link": {
+      "edit": "Editar enlace",
+      "create": "Crear enlace",
+      "label": "Enlace"
+    }
  },
  "buttons": {
    "clearReset": "Limpiar lienzo y reiniciar el color de fondo",
@@ -138,10 +147,10 @@
    "exitZenMode": "Salir del modo Zen",
    "cancel": "Cancelar",
    "clear": "Borrar",
-    "remove": "",
-    "publishLibrary": "",
-    "submit": "",
-    "confirm": ""
+    "remove": "Eliminar",
+    "publishLibrary": "Publicar",
+    "submit": "Enviar",
+    "confirm": "Confirmar"
  },
  "alerts": {
    "clearReset": "Esto limpiará todo el lienzo. Estás seguro?",
@@ -163,7 +172,7 @@
    "cannotRestoreFromImage": "No se pudo restaurar la escena desde este archivo de imagen",
    "invalidSceneUrl": "No se ha podido importar la escena desde la URL proporcionada. Está mal formada, o no contiene datos de Excalidraw JSON válidos.",
    "resetLibrary": "Esto borrará tu biblioteca. ¿Estás seguro?",
-    "removeItemsFromsLibrary": "",
+    "removeItemsFromsLibrary": "¿Eliminar {{count}} elemento(s) de la biblioteca?",
    "invalidEncryptionKey": "La clave de cifrado debe tener 22 caracteres. La colaboración en vivo está deshabilitada."
  },
  "errors": {
@@ -171,7 +180,8 @@
    "imageInsertError": "No se pudo insertar la imagen. Inténtelo de nuevo más tarde...",
    "fileTooBig": "Archivo demasiado grande. El tamaño máximo permitido es {{maxSize}}.",
    "svgImageInsertError": "No se pudo insertar la imagen SVG. El código SVG parece inválido.",
-    "invalidSVGString": "SVG no válido."
+    "invalidSVGString": "SVG no válido.",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Selección",
@@ -184,7 +194,9 @@
    "freedraw": "Dibujar",
    "text": "Texto",
    "library": "Biblioteca",
-    "lock": "Mantener la herramienta seleccionada activa después de dibujar"
+    "lock": "Mantener la herramienta seleccionada activa después de dibujar",
+    "penMode": "Evitar el zoom de pellizco y aceptar la entrada libre sólo desde el lápiz",
+    "link": "Añadir/Actualizar enlace para una forma seleccionada"
  },
  "headings": {
    "canvasActions": "Acciones del lienzo",
@@ -192,7 +204,7 @@
    "shapes": "Formas"
  },
  "hints": {
-    "canvasPanning": "Para mover lienzo, mantenga la rueda del ratón o la barra espaciadora mientras arrastra",
+    "canvasPanning": "Para mover el lienzo, mantenga la rueda del ratón o la barra de espacio mientras arrastra",
    "linearElement": "Haz clic para dibujar múltiples puntos, arrastrar para solo una línea",
    "freeDraw": "Haz clic y arrastra, suelta al terminar",
    "text": "Consejo: también puedes añadir texto haciendo doble clic en cualquier lugar con la herramienta de selección",
@@ -204,10 +216,12 @@
    "resizeImage": "Puede redimensionar libremente pulsando SHIFT,\npulse ALT para redimensionar desde el centro",
    "rotate": "Puedes restringir los ángulos manteniendo presionado SHIFT mientras giras",
    "lineEditor_info": "Doble clic o pulse Enter para editar puntos",
-    "lineEditor_pointSelected": "Presione Suprimir para eliminar el punto, CtrlOrCmd+D para duplicarlo, o arrástrelo para moverlo",
-    "lineEditor_nothingSelected": "Selecciona un punto sea para mover o eliminar, o mantén pulsado Alt y haz clic para añadir nuevos puntos",
+    "lineEditor_pointSelected": "Presione Suprimir para eliminar el/los punto(s), CtrlOrCmd+D para duplicarlo, o arrástrelo para moverlo",
+    "lineEditor_nothingSelected": "Seleccione un punto a editar (mantenga MAYÚSCULAS para seleccionar múltiples),\no mantenga pulsado Alt y haga clic para añadir nuevos puntos",
    "placeImage": "Haga clic para colocar la imagen o haga clic y arrastre para establecer su tamaño manualmente",
-    "publishLibrary": ""
+    "publishLibrary": "Publica tu propia biblioteca",
+    "bindTextToElement": "Presione Entrar para agregar",
+    "deepBoxSelect": "Mantén CtrlOrCmd para seleccionar en profundidad, y para evitar arrastrar"
  },
  "canvasError": {
    "cannotShowPreview": "No se puede mostrar la vista previa",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Lea nuestro blog",
    "click": "clic",
+    "deepSelect": "Selección profunda",
+    "deepBoxSelect": "Seleccione en profundidad dentro de la caja, y evite arrastrar",
    "curvedArrow": "Flecha curva",
    "curvedLine": "Línea curva",
    "documentation": "Documentación",
@@ -278,52 +294,52 @@
    "title": "Borrar lienzo"
  },
  "publishDialog": {
-    "title": "",
-    "itemName": "",
-    "authorName": "",
-    "githubUsername": "",
-    "twitterUsername": "",
-    "libraryName": "",
-    "libraryDesc": "",
-    "website": "",
+    "title": "Publicar biblioteca",
+    "itemName": "Nombre del artículo",
+    "authorName": "Nombre del autor",
+    "githubUsername": "Nombre de usuario de Github",
+    "twitterUsername": "Nombre de usuario de Twitter",
+    "libraryName": "Nombre de la librería",
+    "libraryDesc": "Descripción de la biblioteca",
+    "website": "Sitio Web",
    "placeholder": {
-      "authorName": "",
-      "libraryName": "",
-      "libraryDesc": "",
-      "githubHandle": "",
-      "twitterHandle": "",
-      "website": ""
+      "authorName": "Nombre o nombre de usuario",
+      "libraryName": "Nombre de tu biblioteca",
+      "libraryDesc": "Descripción de su biblioteca para ayudar a la gente a entender su uso",
+      "githubHandle": "GitHub maneja (opcional), así que puede editar la biblioteca una vez enviada para su revisión",
+      "twitterHandle": "Nombre de usuario de Twitter (opcional), así que sabemos a quién acreditar cuando se promociona en Twitter",
+      "website": "Enlace a su sitio web personal o en cualquier otro lugar (opcional)"
    },
    "errors": {
-      "required": "",
-      "website": ""
+      "required": "Requerido",
+      "website": "Introduce una URL válida"
    },
    "noteDescription": {
-      "pre": "",
-      "link": "",
-      "post": ""
+      "pre": "Envía tu biblioteca para ser incluida en el ",
+      "link": "repositorio de librería pública",
+      "post": "para que otras personas utilicen en sus dibujos."
    },
    "noteGuidelines": {
-      "pre": "",
-      "link": "",
-      "post": ""
+      "pre": "La biblioteca debe ser aprobada manualmente primero. Por favor, lea la ",
+      "link": "pautas",
+      "post": " antes de enviar. Necesitará una cuenta de GitHub para comunicarse y hacer cambios si se solicita, pero no es estrictamente necesario."
    },
    "noteLicense": {
-      "pre": "",
-      "link": "",
-      "post": ""
+      "pre": "Al enviar, usted acepta que la biblioteca se publicará bajo el ",
+      "link": "Licencia MIT ",
+      "post": "que en breve significa que cualquiera puede utilizarlos sin restricciones."
    },
-    "noteItems": "",
-    "atleastOneLibItem": ""
+    "noteItems": "Cada elemento de la biblioteca debe tener su propio nombre para que sea filtrable. Los siguientes elementos de la biblioteca serán incluidos:",
+    "atleastOneLibItem": "Por favor, seleccione al menos un elemento de la biblioteca para empezar"
  },
  "publishSuccessDialog": {
-    "title": "",
-    "content": "",
-    "link": ""
+    "title": "Biblioteca enviada",
+    "content": "Gracias {{authorName}}. Su biblioteca ha sido enviada para ser revisada. Puede seguir el estado",
+    "link": "aquí"
  },
  "confirmDialog": {
-    "resetLibrary": "",
-    "removeItemsFromLib": ""
+    "resetLibrary": "Reiniciar biblioteca",
+    "removeItemsFromLib": "Eliminar elementos seleccionados de la biblioteca"
  },
  "encrypted": {
    "tooltip": "Tus dibujos están cifrados de punto a punto, por lo que los servidores de Excalidraw nunca los verán.",
@@ -345,7 +361,7 @@
    "width": "Ancho"
  },
  "toast": {
-    "addedToLibrary": "",
+    "addedToLibrary": "Añadido a la biblioteca",
    "copyStyles": "Estilos copiados.",
    "copyToClipboard": "Copiado en el portapapeles.",
    "copyToClipboardAsPng": "Copiado {{exportSelection}} al portapapeles como PNG\n({{exportColorScheme}})",
--- a/src/locales/eu-ES.json
+++ b/src/locales/eu-ES.json
@@ -0,0 +1,420 @@
+{
+  "labels": {
+    "paste": "Itsatsi",
+    "pasteCharts": "Itsatsi grafikoak",
+    "selectAll": "Hautatu dena",
+    "multiSelect": "Gehitu elementua hautapenera",
+    "moveCanvas": "Mugitu oihala",
+    "cut": "Ebaki",
+    "copy": "Kopiatu",
+    "copyAsPng": "Kopiatu arbelera PNG gisa",
+    "copyAsSvg": "Kopiatu arbelera SVG gisa",
+    "bringForward": "Ekarri aurrerago",
+    "sendToBack": "Eraman atzera",
+    "bringToFront": "Ekarri aurrera",
+    "sendBackward": "Eraman atzerago",
+    "delete": "Ezabatu",
+    "copyStyles": "Kopiatu estiloak",
+    "pasteStyles": "Itsatsi estiloak",
+    "stroke": "Marra",
+    "background": "Atzeko planoa",
+    "fill": "Bete",
+    "strokeWidth": "Marraren zabalera",
+    "strokeStyle": "Marraren estiloa",
+    "strokeStyle_solid": "Solidoa",
+    "strokeStyle_dashed": "Marratua",
+    "strokeStyle_dotted": "Puntukatua",
+    "sloppiness": "Marraren trazoa",
+    "opacity": "Opakotasuna",
+    "textAlign": "Testuaren lerrokapena",
+    "edges": "Ertzak",
+    "sharp": "Ertz bizia",
+    "round": "Borobildua",
+    "arrowheads": "Gezi-puntak",
+    "arrowhead_none": "Bat ere ez",
+    "arrowhead_arrow": "Gezia",
+    "arrowhead_bar": "Barra",
+    "arrowhead_dot": "Puntua",
+    "arrowhead_triangle": "Hirukia",
+    "fontSize": "Letra-tamaina",
+    "fontFamily": "Letra-tipoa",
+    "onlySelected": "Hautapena soilik",
+    "withBackground": "Atzeko planoa",
+    "exportEmbedScene": "Txertatu eszena",
+    "exportEmbedScene_details": "Eszenaren datuak esportatutako PNG/SVG fitxategian gordeko dira, eszena bertatik berrezartzeko.\nEsportatutako fitxategien tamaina handituko da.",
+    "addWatermark": "Gehitu \"Excalidraw bidez egina\"",
+    "handDrawn": "Eskuz marraztua",
+    "normal": "Normala",
+    "code": "Kodea",
+    "small": "Txikia",
+    "medium": "Ertaina",
+    "large": "Handia",
+    "veryLarge": "Oso handia",
+    "solid": "Solidoa",
+    "hachure": "Itzalduna",
+    "crossHatch": "Marraduna",
+    "thin": "Mehea",
+    "bold": "Lodia",
+    "left": "Ezkerrean",
+    "center": "Erdian",
+    "right": "Eskuinean",
+    "extraBold": "Oso lodia",
+    "architect": "Arkitektoa",
+    "artist": "Artista",
+    "cartoonist": "Marrazkilaria",
+    "fileTitle": "Fitxategi izena",
+    "colorPicker": "Kolore-hautatzailea",
+    "canvasColors": "",
+    "canvasBackground": "Oihalaren atzeko planoa",
+    "drawingCanvas": "Marrazteko oihala",
+    "layers": "Geruzak",
+    "actions": "Ekintzak",
+    "language": "Hizkuntza",
+    "liveCollaboration": "Zuzeneko elkarlana",
+    "duplicateSelection": "Bikoiztu",
+    "untitled": "Izengabea",
+    "name": "Izena",
+    "yourName": "Zure izena",
+    "madeWithExcalidraw": "Excalidraw bidez egina",
+    "group": "Hautapena taldea bihurtu",
+    "ungroup": "Desegin hautapenaren taldea",
+    "collaborators": "Kolaboratzaileak",
+    "showGrid": "Erakutsi sareta",
+    "addToLibrary": "Gehitu liburutegira",
+    "removeFromLibrary": "Kendu liburutegitik",
+    "libraryLoadingMessage": "Liburutegia kargatzen…",
+    "libraries": "Arakatu liburutegiak",
+    "loadingScene": "Eszena kargatzen…",
+    "align": "Lerrokatu",
+    "alignTop": "Lerrokatu goian",
+    "alignBottom": "Lerrokatu behean",
+    "alignLeft": "Lerrokatu ezkerrean",
+    "alignRight": "Lerrokatu eskuinean",
+    "centerVertically": "Erdiratu bertikalki",
+    "centerHorizontally": "Erdiratu horizontalki",
+    "distributeHorizontally": "Banandu horizontalki",
+    "distributeVertically": "Banandu bertikalki",
+    "flipHorizontal": "Irauli horizontalki",
+    "flipVertical": "Irauli bertikalki",
+    "viewMode": "Ikuspegia",
+    "toggleExportColorScheme": "Aldatu esportatzeko kolorearen eszena",
+    "share": "Partekatu",
+    "showStroke": "Erakutsi marraren kolore-hautatzailea",
+    "showBackground": "Erakutsi atzeko planoaren kolore-hautatzailea",
+    "toggleTheme": "Aldatu gaia",
+    "personalLib": "Liburutegi pertsonala",
+    "excalidrawLib": "Excalidraw liburutegia",
+    "decreaseFontSize": "Txikitu letra tamaina",
+    "increaseFontSize": "Handitu letra tamaina",
+    "unbindText": "Askatu testua",
+    "link": {
+      "edit": "Editatu esteka",
+      "create": "Sortu esteka",
+      "label": "Esteka"
+    }
+  },
+  "buttons": {
+    "clearReset": "Garbitu oihala",
+    "exportJSON": "Esportatu fitxategira",
+    "exportImage": "Gorde irudi gisa",
+    "export": "Esportatu",
+    "exportToPng": "Esportatu PNG gisa",
+    "exportToSvg": "Esportatu SVG gisa",
+    "copyToClipboard": "Kopiatu arbelera",
+    "copyPngToClipboard": "Kopiatu PNG arbelera",
+    "scale": "Eskala",
+    "save": "Gorde uneko fitxategian",
+    "saveAs": "Gorde honela",
+    "load": "Kargatu",
+    "getShareableLink": "Lortu partekatzeko esteka",
+    "close": "Itxi",
+    "selectLanguage": "Hautatu hizkuntza",
+    "scrollBackToContent": "Joan atzera edukira",
+    "zoomIn": "Handiagotu",
+    "zoomOut": "Txikiagotu",
+    "resetZoom": "Leheneratu zooma",
+    "menu": "Menua",
+    "done": "Egina",
+    "edit": "Editatu",
+    "undo": "Desegin",
+    "redo": "Berregin",
+    "resetLibrary": "Leheneratu liburutegia",
+    "createNewRoom": "Sortu gela berria",
+    "fullScreen": "Pantaila osoa",
+    "darkMode": "Modu iluna",
+    "lightMode": "Modu argia",
+    "zenMode": "Zen modua",
+    "exitZenMode": "Irten Zen modutik",
+    "cancel": "Utzi",
+    "clear": "Garbitu",
+    "remove": "Kendu",
+    "publishLibrary": "Argitaratu",
+    "submit": "Bidali",
+    "confirm": "Bai"
+  },
+  "alerts": {
+    "clearReset": "Honek oihal osoa garbituko du. Ziur zaude?",
+    "couldNotCreateShareableLink": "Ezin izan da partekatzeko estekarik sortu.",
+    "couldNotCreateShareableLinkTooBig": "Ezin izan da partekatzeko estekarik sortu: eszena handiegia da",
+    "couldNotLoadInvalidFile": "Ezin izan da kargatu, fitxategiak ez du balio",
+    "importBackendFailed": "Inportazioak huts egin du.",
+    "cannotExportEmptyCanvas": "Ezin izan da oihal hutsa esportatu.",
+    "couldNotCopyToClipboard": "Ezin izan da arbelean kopiatu.",
+    "decryptFailed": "Ezin izan da deszifratu.",
+    "uploadedSecurly": "Kargatzea muturretik muturrerako zifratze bidez ziurtatu da, hau da, Excalidraw zerbitzariak eta hirugarrenek ezin dutela edukia irakurri.",
+    "loadSceneOverridePrompt": "Kanpoko marrazkia kargatzeak lehendik duzun edukia ordezkatuko du. Jarraitu nahi duzu?",
+    "collabStopOverridePrompt": "Saioa gelditzeak lokalean gordetako zure aurreko marrazkia gainidatziko du. Ziur zaude?\n\n(Zure marrazki lokala mantendu nahi baduzu, itxi arakatzailearen fitxa.)",
+    "errorLoadingLibrary": "Errore bat gertatu da hirugarrenen liburutegia kargatzean.",
+    "errorAddingToLibrary": "Ezin izan da elementua liburutegian gehitu",
+    "errorRemovingFromLibrary": "Ezin izan da elementua liburutegitik kendu",
+    "confirmAddLibrary": "Honek {{numShapes}} forma gehituko ditu zure liburutegian. Ziur zaude?",
+    "imageDoesNotContainScene": "Irudi honek ez dirudi eszena daturik duenik. Eszena kapsulatzea gaitu al duzu esportazioan?",
+    "cannotRestoreFromImage": "Ezin izan da eszena leheneratu irudi fitxategi honetatik",
+    "invalidSceneUrl": "Ezin izan da eszena inportatu emandako URLtik. Gaizki eratuta dago edo ez du baliozko Excalidraw JSON daturik.",
+    "resetLibrary": "Honek zure liburutegia garbituko du. Ziur zaude?",
+    "removeItemsFromsLibrary": "Liburutegitik {{count}} elementu ezabatu?",
+    "invalidEncryptionKey": "Enkriptazio-gakoak 22 karaktere izan behar ditu. Zuzeneko lankidetza desgaituta dago."
+  },
+  "errors": {
+    "unsupportedFileType": "Onartu gabeko fitxategi mota.",
+    "imageInsertError": "Ezin izan da irudia txertatu. Saiatu berriro geroago...",
+    "fileTooBig": "Fitxategia handiegia da. Onartutako gehienezko tamaina {{maxSize}} da.",
+    "svgImageInsertError": "Ezin izan da SVG irudia txertatu. SVG markak baliogabea dirudi.",
+    "invalidSVGString": "SVG baliogabea.",
+    "cannotResolveCollabServer": ""
+  },
+  "toolBar": {
+    "selection": "Hautapena",
+    "image": "Txertatu irudia",
+    "rectangle": "Laukizuzena",
+    "diamond": "Diamantea",
+    "ellipse": "Elipsea",
+    "arrow": "Gezia",
+    "line": "Lerroa",
+    "freedraw": "Marraztu",
+    "text": "Testua",
+    "library": "Liburutegia",
+    "lock": "Mantendu aktibo hautatutako tresna marraztu ondoren",
+    "penMode": "Saihestu txikiagotzea eta onartu marrazte libreko idazketa solik arkatza bidez",
+    "link": "Gehitu / Eguneratu esteka hautatutako forma baterako"
+  },
+  "headings": {
+    "canvasActions": "Canvas ekintzak",
+    "selectedShapeActions": "Hautatutako formaren ekintzak",
+    "shapes": "Formak"
+  },
+  "hints": {
+    "canvasPanning": "Oihala mugitzeko, sakatu saguaren gurpila edo zuriune-barra arrastatzean",
+    "linearElement": "Egin klik hainbat puntu hasteko, arrastatu lerro bakarrerako",
+    "freeDraw": "Egin klik eta arrastatu, askatu amaitutakoan",
+    "text": "Aholkua: testua gehitu dezakezu edozein lekutan klik bikoitza eginez hautapen tresnarekin",
+    "text_selected": "Egin klik bikoitza edo sakatu SARTU testua editatzeko",
+    "text_editing": "Sakatu Esc edo Ctrl+SARTU editatzen amaitzeko",
+    "linearElementMulti": "Egin klik azken puntuan edo sakatu Esc edo Sartu amaitzeko",
+    "lockAngle": "SHIFT sakatuta angelua mantendu dezakezu",
+    "resize": "Proportzioak mantendu ditzakezu SHIFT sakatuta tamaina aldatzen duzun bitartean.\nsakatu ALT erditik tamaina aldatzeko",
+    "resizeImage": "Tamaina libreki alda dezakezu SHIFT sakatuta,\nsakatu ALT erditik tamaina aldatzeko",
+    "rotate": "Angeluak mantendu ditzakezu SHIFT sakatuta biratzen duzun bitartean",
+    "lineEditor_info": "Egin klik bikoitza edo sakatu Sartu puntuak editatzeko",
+    "lineEditor_pointSelected": "Sakatu Ezabatu puntuak kentzeko,\nKtrl+D bikoizteko, edo arrastatu mugitzeko",
+    "lineEditor_nothingSelected": "Hautatu editatzeko puntu bat (SHIFT sakatuta anitz hautatzeko),\nedo eduki Alt sakatuta eta egin klik puntu berriak gehitzeko",
+    "placeImage": "Egin klik irudia kokatzeko, edo egin klik eta arrastatu bere tamaina eskuz ezartzeko",
+    "publishLibrary": "Argitaratu zure liburutegia",
+    "bindTextToElement": "Sakatu Sartu testua gehitzeko",
+    "deepBoxSelect": "Eutsi Ctrl edo Cmd sakatuta aukeraketa sakona egiteko eta arrastatzea saihesteko"
+  },
+  "canvasError": {
+    "cannotShowPreview": "Ezin da oihala aurreikusi",
+    "canvasTooBig": "Agian oihala handiegia da.",
+    "canvasTooBigTip": "Aholkua: saiatu urrunen dauden elementuak pixka bat hurbiltzen."
+  },
+  "errorSplash": {
+    "headingMain_pre": "Errore bat aurkitu da. Saiatu ",
+    "headingMain_button": "orria birkargatzen.",
+    "clearCanvasMessage": "Birkargatzea ez bada burutzen, saiatu ",
+    "clearCanvasMessage_button": "oihala garbitzen.",
+    "clearCanvasCaveat": " Honen ondorioz lana galduko da ",
+    "trackedToSentry_pre": "Identifikatzailearen errorea ",
+    "trackedToSentry_post": " gure sistemak behatu du.",
+    "openIssueMessage_pre": "Oso kontuz ibili gara zure eszenaren informazioa errorean ez sartzeko. Zure eszena pribatua ez bada, kontuan hartu gure ",
+    "openIssueMessage_button": "erroreen jarraipena egitea.",
+    "openIssueMessage_post": " Sartu beheko informazioa kopiatu eta itsatsi bidez GitHub issue-n.",
+    "sceneContent": "Eszenaren edukia:"
+  },
+  "roomDialog": {
+    "desc_intro": "Jendea zure uneko eszenara gonbida dezakezu zurekin elkarlanean aritzeko.",
+    "desc_privacy": "Ez kezkatu, saioak muturretik muturrerako enkriptatzea erabiltzen du, beraz, marrazten duzuna pribatua izango da. Gure zerbitzariak ere ezingo du ikusi zer egiten duzun.",
+    "button_startSession": "Hasi saioa",
+    "button_stopSession": "Itxi saioa",
+    "desc_inProgressIntro": "Zuzeneko lankidetza saioa abian da.",
+    "desc_shareLink": "Partekatu esteka hau elkarlanean aritu nahi duzun edonorekin:",
+    "desc_exitSession": "Saioa ixteak aretotik deskonektatuko zaitu, baina eszenarekin lanean jarraitu ahal izango duzu lokalean. Kontuan izan honek ez diela beste pertsonei eragingo, eta euren bertsioan elkarlanean aritu ahal izango dira.",
+    "shareTitle": "Sartu Excalidraw-en zuzeneko lankidetza-saio batean"
+  },
+  "errorDialog": {
+    "title": "Errorea"
+  },
+  "exportDialog": {
+    "disk_title": "Gorde diskoan",
+    "disk_details": "Esportatu eszenaren datuak geroago inportatu ahal izango duzun fitxategi batan.",
+    "disk_button": "Gorde fitxategian",
+    "link_title": "Partekatzeko esteka",
+    "link_details": "Esportatu irakurtzeko soilik moduko esteka.",
+    "link_button": "Esportatu esteka",
+    "excalidrawplus_description": "Gorde eszena zure Excalidraw+ laneko areara.",
+    "excalidrawplus_button": "Esportatu",
+    "excalidrawplus_exportError": "Une honetan ezin izan da esportatu Excalidraw+era..."
+  },
+  "helpDialog": {
+    "blog": "Irakurri gure bloga",
+    "click": "sakatu",
+    "deepSelect": "Hautapen sakona",
+    "deepBoxSelect": "Hautapen sakona egin laukizuzen bidez, eta saihestu arrastatzea",
+    "curvedArrow": "Gezi kurbatua",
+    "curvedLine": "Lerro kurbatua",
+    "documentation": "Dokumentazioa",
+    "doubleClick": "klik bikoitza",
+    "drag": "arrastatu",
+    "editor": "Editorea",
+    "editSelectedShape": "Editatu hautatutako forma (testua/gezia/lerroa)",
+    "github": "Arazorik izan al duzu? Eman horren berri",
+    "howto": "Jarraitu gure gidak",
+    "or": "edo",
+    "preventBinding": "Saihestu gezien gainjartzea",
+    "shapes": "Formak",
+    "shortcuts": "Laster-teklak",
+    "textFinish": "Bukatu edizioa (testu editorea)",
+    "textNewLine": "Gehitu lerro berri bat (testu editorea)",
+    "title": "Laguntza",
+    "view": "Bistaratu",
+    "zoomToFit": "Egin zoom elementu guztiak ikusteko",
+    "zoomToSelection": "Zooma hautapenera"
+  },
+  "clearCanvasDialog": {
+    "title": "Garbitu oihala"
+  },
+  "publishDialog": {
+    "title": "Argitaratu liburutegia",
+    "itemName": "Elementuaren izena",
+    "authorName": "Egilearen izena",
+    "githubUsername": "GitHub-eko erabiltzaile-izena",
+    "twitterUsername": "Twitter-eko erabiltzaile-izena",
+    "libraryName": "Liburutegiaren izena",
+    "libraryDesc": "Liburutegiaren deskripzioa",
+    "website": "Webgunea",
+    "placeholder": {
+      "authorName": "Zure izena edo erabiltzaile-izena",
+      "libraryName": "Zure liburutegiaren izena",
+      "libraryDesc": "Zure liburutegiaren deskripzioa laguntzeko jendeari ulertzen haren erabilpena",
+      "githubHandle": "GitHub heldulekua (aukerakoa), liburutegia editatu ahal izateko berrikustera bidalitakoan",
+      "twitterHandle": "Twitter-eko erabiltzaile-izena (aukerakoa), badakigu nori kreditatu behar dugun Twitter bidez sustatzeko",
+      "website": "Estekatu zure webgunera edo nahi duzun tokira (aukerakoa)"
+    },
+    "errors": {
+      "required": "Beharrezkoa",
+      "website": "Sartu baliozko URL bat"
+    },
+    "noteDescription": {
+      "pre": "Bidali zure liburutegira sartu ahal izateko ",
+      "link": "zure liburutegiko biltegian",
+      "post": "beste jendeak bere marrazkietan erabili ahal izateko."
+    },
+    "noteGuidelines": {
+      "pre": "Liburutegia eskuz onartu behar da. Irakurri ",
+      "link": "gidalerroak",
+      "post": " bidali aurretik. GitHub kontu bat edukitzea komeni da komunikatzeko eta aldaketak egin ahal izateko, baina ez da guztiz beharrezkoa."
+    },
+    "noteLicense": {
+      "pre": "Bidaltzen baduzu, onartzen duzu liburutegia ",
+      "link": "MIT lizentziarekin argitaratuko dela, ",
+      "post": "zeinak, laburbilduz, esan nahi du edozeinek erabiltzen ahal duela murrizketarik gabe."
+    },
+    "noteItems": "Liburutegiko elementu bakoitzak bere izena eduki behar du iragazi ahal izateko. Liburutegiko hurrengo elementuak barne daude:",
+    "atleastOneLibItem": "Hautatu gutxienez liburutegiko elementu bat gutxienez hasi ahal izateko"
+  },
+  "publishSuccessDialog": {
+    "title": "Liburutegia bidali da",
+    "content": "Eskerrik asko {{authorName}}. Zure liburutegia bidali da berrikustera. Jarraitu dezakezu haren egoera",
+    "link": "hemen"
+  },
+  "confirmDialog": {
+    "resetLibrary": "Leheneratu liburutegia",
+    "removeItemsFromLib": "Kendu hautatutako elementuak liburutegitik"
+  },
+  "encrypted": {
+    "tooltip": "Zure marrazkiak muturretik muturrera enkriptatu dira, beraz Excalidraw-ren zerbitzariek ezingo dituzte ikusi.",
+    "link": "Excalidraw-ren muturretik muturrerako enkriptatzearen gaineko mezua blogean"
+  },
+  "stats": {
+    "angle": "Angelua",
+    "element": "Elementua",
+    "elements": "Elementuak",
+    "height": "Altuera",
+    "scene": "Eszena",
+    "selected": "Hautatua",
+    "storage": "Biltegia",
+    "title": "Datuak",
+    "total": "Guztira",
+    "version": "Bertsioa",
+    "versionCopy": "Klikatu kopiatzeko",
+    "versionNotAvailable": "Bertsio ez eskuragarria",
+    "width": "Zabalera"
+  },
+  "toast": {
+    "addedToLibrary": "Liburutegira gehitu da",
+    "copyStyles": "Estiloak kopiatu dira.",
+    "copyToClipboard": "Arbelean kopiatu da.",
+    "copyToClipboardAsPng": "{{exportSelection}} kopiatu da arbelean PNG gisa\n({{exportColorScheme}})",
+    "fileSaved": "Fitxategia gorde da.",
+    "fileSavedToFilename": "{filename}-n gorde da",
+    "canvas": "oihala",
+    "selection": "hautapena"
+  },
+  "colors": {
+    "ffffff": "Zuria",
+    "f8f9fa": "Grisa 0",
+    "f1f3f5": "Grisa 1",
+    "fff5f5": "Gorria 0",
+    "fff0f6": "Arrosa 0",
+    "f8f0fc": "Mahats kolorea 0",
+    "f3f0ff": "Bioleta 0",
+    "edf2ff": "Indigoa 0",
+    "e7f5ff": "Urdina 0",
+    "e3fafc": "Ziana 0",
+    "e6fcf5": "Berde urdinxka 0",
+    "ebfbee": "Berdea 0",
+    "f4fce3": "Lima 0",
+    "fff9db": "Horia 0",
+    "fff4e6": "Laranja 0",
+    "transparent": "Gardena",
+    "ced4da": "Grisa 4",
+    "868e96": "Grisa 6",
+    "fa5252": "Gorria 6",
+    "e64980": "Arrosa 6",
+    "be4bdb": "Mahats kolorea 6",
+    "7950f2": "Bioleta 6",
+    "4c6ef5": "Indigoa 6",
+    "228be6": "Urdina 6",
+    "15aabf": "Ziana 6",
+    "12b886": "Berde urdinxka 6",
+    "40c057": "Berdea 6",
+    "82c91e": "Lima 6",
+    "fab005": "Horia 6",
+    "fd7e14": "Laranja 6",
+    "000000": "Beltza",
+    "343a40": "Grisa 8",
+    "495057": "Grisa 7",
+    "c92a2a": "Gorria 9",
+    "a61e4d": "Arrosa 9",
+    "862e9c": "Mahats kolorea 9",
+    "5f3dc4": "Bioleta 9",
+    "364fc7": "Indigoa 9",
+    "1864ab": "Urdina 9",
+    "0b7285": "Ziana 9",
+    "087f5b": "Berde urdinxka 9",
+    "2b8a3e": "Berdea 9",
+    "5c940d": "Lima 9",
+    "e67700": "Horia 9",
+    "d9480f": "Laranja 9"
+  }
+}
--- a/src/locales/fa-IR.json
+++ b/src/locales/fa-IR.json
@@ -64,6 +64,7 @@
    "cartoonist": "کارتونیست",
    "fileTitle": "نام فایل",
    "colorPicker": "انتخابگر رنگ",
+    "canvasColors": "",
    "canvasBackground": "بوم",
    "drawingCanvas": "بوم نقاشی",
    "layers": "لایه ها",
@@ -102,7 +103,15 @@
    "showBackground": "نمایش انتخاب کننده رنگ پس زمینه",
    "toggleTheme": "تغییر تم",
    "personalLib": "",
-    "excalidrawLib": ""
+    "excalidrawLib": "",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "پاکسازی بوم نقاشی",
@@ -171,7 +180,8 @@
    "imageInsertError": "",
    "fileTooBig": "",
    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "invalidSVGString": "",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "گزینش",
@@ -184,7 +194,9 @@
    "freedraw": "کشیدن",
    "text": "متن",
    "library": "کتابخانه",
-    "lock": "ابزار انتخاب شده را بعد از کشیدن نگه دار"
+    "lock": "ابزار انتخاب شده را بعد از کشیدن نگه دار",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "عملیات روی بوم",
@@ -204,10 +216,12 @@
    "resizeImage": "",
    "rotate": "با نگه داشتن SHIFT هنگام چرخش می توانید زاویه ها را محدود کنید",
    "lineEditor_info": "دوبار کلیک کنید یا Enter را فشار دهید تا نقاط را ویرایش کنید",
-    "lineEditor_pointSelected": "برای حذف نقطه Delete برای کپی زدن Ctrl یا Cmd+D را بزنید و یا برای جابجایی بکشید.",
-    "lineEditor_nothingSelected": "یک نقطه را برای جابجایی یا حذف انتخاب کنید یا کلید Alt بگیرید و کلیک کنید تا بتوانید یک نقطه جدید اضافه کنید",
+    "lineEditor_pointSelected": "",
+    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "پیش نمایش نشان داده نمی شود",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "بلاگ ما را بخوانید",
    "click": "کلیک",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "فلش خمیده",
    "curvedLine": "منحنی",
    "documentation": "مستندات",
--- a/src/locales/fi-FI.json
+++ b/src/locales/fi-FI.json
@@ -64,6 +64,7 @@
    "cartoonist": "Sarjakuva",
    "fileTitle": "Tiedostonimi",
    "colorPicker": "Värin valinta",
+    "canvasColors": "",
    "canvasBackground": "Piirtoalueen tausta",
    "drawingCanvas": "Piirtoalue",
    "layers": "Tasot",
@@ -102,7 +103,15 @@
    "showBackground": "Näytä taustavärin valitsin",
    "toggleTheme": "Vaihda teema",
    "personalLib": "Oma kirjasto",
-    "excalidrawLib": "Excalidraw kirjasto"
+    "excalidrawLib": "Excalidraw kirjasto",
+    "decreaseFontSize": "Pienennä kirjasinkokoa",
+    "increaseFontSize": "Kasvata kirjasinkokoa",
+    "unbindText": "",
+    "link": {
+      "edit": "Muokkaa linkkiä",
+      "create": "Luo linkki",
+      "label": "Linkki"
+    }
  },
  "buttons": {
    "clearReset": "Tyhjennä piirtoalue",
@@ -171,7 +180,8 @@
    "imageInsertError": "Kuvan lisääminen epäonnistui. Yritä myöhemmin uudelleen...",
    "fileTooBig": "Tiedosto on liian suuri. Suurin sallittu koko on {{maxSize}}.",
    "svgImageInsertError": "SVG- kuvaa ei voitu lisätä. Tiedoston SVG-sisältö näyttää virheelliseltä.",
-    "invalidSVGString": "Virheellinen SVG."
+    "invalidSVGString": "Virheellinen SVG.",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Valinta",
@@ -184,7 +194,9 @@
    "freedraw": "Piirrä",
    "text": "Teksti",
    "library": "Kirjasto",
-    "lock": "Pidä valittu työkalu aktiivisena piirron jälkeen"
+    "lock": "Pidä valittu työkalu aktiivisena piirron jälkeen",
+    "penMode": "Estä nipistyszoomaus ja vastaanota ainoastaan kynällä piirretty",
+    "link": "Lisää/päivitä linkki valitulle muodolle"
  },
  "headings": {
    "canvasActions": "Piirtoalueen toiminnot",
@@ -204,10 +216,12 @@
    "resizeImage": "Voit muuttaa kokoa vapaasti pitämällä SHIFTiä pohjassa, pidä ALT pohjassa muuttaaksesi kokoa keskipisteen ympäri",
    "rotate": "Voit rajoittaa kulman pitämällä SHIFT pohjassa pyörittäessäsi",
    "lineEditor_info": "Kaksoisnapauta tai paina Enter muokataksesi pisteitä",
-    "lineEditor_pointSelected": "Paina Delete poistaaksesi pisteen, Ctrl tai Cmd+D monistaaksesi, tai raahaa liikuttaaksesi",
-    "lineEditor_nothingSelected": "Valitse liikutettava tai poistettava piste, tai pidä ALT-näppäintä alaspainettuna ja napsauta lisätäksesi uusia pisteitä",
+    "lineEditor_pointSelected": "Poista piste(et) painamalla delete, monista painamalla CtrlOrCmd+D, tai liikuta raahaamalla",
+    "lineEditor_nothingSelected": "Valitse muokattava piste (monivalinta pitämällä SHIFT pohjassa), tai paina Alt ja klikkaa lisätäksesi uusia pisteitä",
    "placeImage": "Klikkaa asettaaksesi kuvan, tai klikkaa ja raahaa asettaaksesi sen koon manuaalisesti",
-    "publishLibrary": "Julkaise oma kirjasto"
+    "publishLibrary": "Julkaise oma kirjasto",
+    "bindTextToElement": "Lisää tekstiä painamalla enter",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "Esikatselua ei voitu näyttää",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Lue blogiamme",
    "click": "klikkaa",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "Kaareva nuoli",
    "curvedLine": "Kaareva viiva",
    "documentation": "Käyttöohjeet",
--- a/src/locales/fr-FR.json
+++ b/src/locales/fr-FR.json
@@ -64,6 +64,7 @@
    "cartoonist": "Caricaturiste",
    "fileTitle": "Nom du fichier",
    "colorPicker": "Sélecteur de couleur",
+    "canvasColors": "",
    "canvasBackground": "Arrière-plan du canevas",
    "drawingCanvas": "Zone de dessin",
    "layers": "Calques",
@@ -102,7 +103,15 @@
    "showBackground": "Afficher le sélecteur de couleur d'arrière-plan",
    "toggleTheme": "Changer le thème",
    "personalLib": "Bibliothèque personnelle",
-    "excalidrawLib": "Bibliothèque Excalidraw"
+    "excalidrawLib": "Bibliothèque Excalidraw",
+    "decreaseFontSize": "Réduire la taille de police",
+    "increaseFontSize": "Augmenter la taille de police",
+    "unbindText": "Délier le texte",
+    "link": {
+      "edit": "Modifier le lien",
+      "create": "Créer un lien",
+      "label": "Lien"
+    }
  },
  "buttons": {
    "clearReset": "Réinitialiser le canevas",
@@ -171,7 +180,8 @@
    "imageInsertError": "Impossible d'insérer l'image. Réessayez plus tard...",
    "fileTooBig": "Le fichier est trop volumineux. La taille maximale autorisée est de {{maxSize}}.",
    "svgImageInsertError": "Impossible d'insérer l'image SVG. Le balisage SVG semble invalide.",
-    "invalidSVGString": "SVG invalide."
+    "invalidSVGString": "SVG invalide.",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "Sélection",
@@ -184,7 +194,9 @@
    "freedraw": "Dessiner",
    "text": "Texte",
    "library": "Bibliothèque",
-    "lock": "Garder l'outil sélectionné actif après le dessin"
+    "lock": "Garder l'outil sélectionné actif après le dessin",
+    "penMode": "Empêcher le zoom tactile et accepter la saisie libre uniquement à partir du stylet",
+    "link": "Ajouter/mettre à jour le lien pour une forme sélectionnée"
  },
  "headings": {
    "canvasActions": "Actions du canevas",
@@ -204,10 +216,12 @@
    "resizeImage": "Vous pouvez redimensionner librement en maintenant SHIFT,\nmaintenez ALT pour redimensionner depuis le centre",
    "rotate": "Vous pouvez restreindre les angles en maintenant MAJ pendant la rotation",
    "lineEditor_info": "Double-cliquez ou appuyez sur Entrée pour éditer les points",
-    "lineEditor_pointSelected": "Appuyez sur Supprimer pour supprimer le point, Ctrl ou Cmd+D pour le dupliquer, ou faites-le glisser pour le déplacer",
-    "lineEditor_nothingSelected": "Sélectionnez un point à déplacer ou supprimer, ou maintenez Alt et cliquez pour ajouter de nouveaux points",
+    "lineEditor_pointSelected": "Appuyer sur Suppr. pour supprimer des points, Ctrl ou Cmd+D pour dupliquer, ou faire glisser pour déplacer",
+    "lineEditor_nothingSelected": "Sélectionner un point pour éditer (maintenir la touche MAJ pour en sélectionner plusieurs),\nou maintenir la touche Alt enfoncée et cliquer pour ajouter de nouveaux points",
    "placeImage": "Cliquez pour placer l'image, ou cliquez et faites glisser pour définir sa taille manuellement",
-    "publishLibrary": "Publier votre propre bibliothèque"
+    "publishLibrary": "Publier votre propre bibliothèque",
+    "bindTextToElement": "Appuyer sur Entrée pour ajouter du texte",
+    "deepBoxSelect": "Maintenir CtrlOuCmd pour sélectionner dans les groupes, et empêcher le déplacement"
  },
  "canvasError": {
    "cannotShowPreview": "Impossible d’afficher l’aperçu",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "Lire notre blog",
    "click": "clic",
+    "deepSelect": "Sélection dans les groupes",
+    "deepBoxSelect": "Sélectionner dans les groupes, et empêcher le déplacement",
    "curvedArrow": "Flèche courbée",
    "curvedLine": "Ligne courbée",
    "documentation": "Documentation",
--- a/src/locales/he-IL.json
+++ b/src/locales/he-IL.json
@@ -64,6 +64,7 @@
    "cartoonist": "קריקטוריסט",
    "fileTitle": "שם קובץ",
    "colorPicker": "בחירת צבע",
+    "canvasColors": "",
    "canvasBackground": "רקע הלוח",
    "drawingCanvas": "לוח ציור",
    "layers": "שכבות",
@@ -102,7 +103,15 @@
    "showBackground": "הצג צבעי רקע",
    "toggleTheme": "שינוי ערכת העיצוב",
    "personalLib": "",
-    "excalidrawLib": ""
+    "excalidrawLib": "",
+    "decreaseFontSize": "",
+    "increaseFontSize": "",
+    "unbindText": "",
+    "link": {
+      "edit": "",
+      "create": "",
+      "label": ""
+    }
  },
  "buttons": {
    "clearReset": "אפס את הלוח",
@@ -171,7 +180,8 @@
    "imageInsertError": "",
    "fileTooBig": "",
    "svgImageInsertError": "",
-    "invalidSVGString": ""
+    "invalidSVGString": "",
+    "cannotResolveCollabServer": ""
  },
  "toolBar": {
    "selection": "בחירה",
@@ -184,7 +194,9 @@
    "freedraw": "צייר",
    "text": "טקסט",
    "library": "ספריה",
-    "lock": "השאר את הכלי הנבחר פעיל גם לאחר סיום הציור"
+    "lock": "השאר את הכלי הנבחר פעיל גם לאחר סיום הציור",
+    "penMode": "",
+    "link": ""
  },
  "headings": {
    "canvasActions": "פעולות הלוח",
@@ -204,10 +216,12 @@
    "resizeImage": "",
    "rotate": "ניתן להגביל זוויות על ידי לחיצה על SHIFT תוך כדי סיבוב",
    "lineEditor_info": "לחץ לחיצה כפולה או אנטר לעריכת הנקודות",
-    "lineEditor_pointSelected": "לחץ על Delete להסרת נקודה, CtrlOrCmd+D לשכפל, או גרור להזזה",
-    "lineEditor_nothingSelected": "בחר נקודה להזזה או הסרה, או החזק את כפתור Alt והקלק להוספת נקודות חדשות",
+    "lineEditor_pointSelected": "",
+    "lineEditor_nothingSelected": "",
    "placeImage": "",
-    "publishLibrary": ""
+    "publishLibrary": "",
+    "bindTextToElement": "",
+    "deepBoxSelect": ""
  },
  "canvasError": {
    "cannotShowPreview": "לא הצלחנו להציג את התצוגה המקדימה",
@@ -254,6 +268,8 @@
  "helpDialog": {
    "blog": "קרא את הבלוג שלנו",
    "click": "קליק",
+    "deepSelect": "",
+    "deepBoxSelect": "",
    "curvedArrow": "חץ מעוגל",
    "curvedLine": "קו מעוגל",
    "documentation": "תיעוד",
--- a/Show More
+++ b/Show More