feat: update eye-dropper icon

2023-07-07 12:22:52 +02:00
191 changed files with 14709 additions and 14256 deletions
--- a/.codesandbox/Dockerfile
+++ b/.codesandbox/Dockerfile
@ -1,5 +0,0 @@
-FROM node:18-bullseye
-
-# Vite wants to open the browser using `open`, so we
-# need to install those utils.
-RUN apt update -y && apt install -y xdg-utils
--- a/.codesandbox/tasks.json
+++ b/.codesandbox/tasks.json
@ -27,10 +27,7 @@
    "start": {
      "name": "Start Excalidraw",
      "command": "yarn start",
-      "runAtStart": true,
-      "preview": {
-        "port": 3000
-      }
+      "runAtStart": true
    },
    "test": {
      "name": "Run Tests",
@ -40,11 +37,7 @@
    "install-deps": {
      "name": "Install Dependencies",
      "command": "yarn install",
-      "restartOn": {
-        "files": ["yarn.lock"],
-        "branch": false,
-        "resume": false
-      }
+      "restartOn": { "files": ["yarn.lock"] }
    }
  }
 }
--- a/.env.development
+++ b/.env.development
@ -1,39 +1,30 @@
-VITE_APP_BACKEND_V2_GET_URL=https://json-dev.excalidraw.com/api/v2/
-VITE_APP_BACKEND_V2_POST_URL=https://json-dev.excalidraw.com/api/v2/post/
+REACT_APP_BACKEND_V2_GET_URL=https://json-dev.excalidraw.com/api/v2/
+REACT_APP_BACKEND_V2_POST_URL=https://json-dev.excalidraw.com/api/v2/post/

-VITE_APP_LIBRARY_URL=https://libraries.excalidraw.com
-VITE_APP_LIBRARY_BACKEND=https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries
+REACT_APP_LIBRARY_URL=https://libraries.excalidraw.com
+REACT_APP_LIBRARY_BACKEND=https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries

 # collaboration WebSocket server (https://github.com/excalidraw/excalidraw-room)
-VITE_APP_WS_SERVER_URL=http://localhost:3002
+REACT_APP_WS_SERVER_URL=http://localhost:3002

 # set this only if using the collaboration workflow we use on excalidraw.com
-VITE_APP_PORTAL_URL=
+REACT_APP_PORTAL_URL=

-VITE_APP_FIREBASE_CONFIG='{"apiKey":"AIzaSyCMkxA60XIW8KbqMYL7edC4qT5l4qHX2h8","authDomain":"excalidraw-oss-dev.firebaseapp.com","projectId":"excalidraw-oss-dev","storageBucket":"excalidraw-oss-dev.appspot.com","messagingSenderId":"664559512677","appId":"1:664559512677:web:a385181f2928d328a7aa8c"}'
+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"}'

 # put these in your .env.local, or make sure you don't commit!
 # must be lowercase `true` when turned on
 #
 # whether to enable Service Workers in development
-VITE_APP_DEV_ENABLE_SW=
+REACT_APP_DEV_ENABLE_SW=
 # whether to disable live reload / HMR. Usuaully what you want to do when
 # debugging Service Workers.
-VITE_APP_DEV_DISABLE_LIVE_RELOAD=
-VITE_APP_DISABLE_TRACKING=true
+REACT_APP_DEV_DISABLE_LIVE_RELOAD=
+REACT_APP_DISABLE_TRACKING=true

 FAST_REFRESH=false

-# The port the run the dev server
-VITE_APP_PORT=3000
-
 #Debug flags

 # To enable bounding box for text containers
-VITE_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX=
-
-# Set this flag to false if you want to open the overlay by default
-VITE_APP_COLLAPSE_OVERLAY=true
-
-# Set this flag to false to disable eslint
-VITE_APP_ENABLE_ESLINT=true
+REACT_APP_DEBUG_ENABLE_TEXT_CONTAINER_BOUNDING_BOX=
--- a/.env.production
+++ b/.env.production
@ -1,15 +1,15 @@
-VITE_APP_BACKEND_V2_GET_URL=https://json.excalidraw.com/api/v2/
-VITE_APP_BACKEND_V2_POST_URL=https://json.excalidraw.com/api/v2/post/
+REACT_APP_BACKEND_V2_GET_URL=https://json.excalidraw.com/api/v2/
+REACT_APP_BACKEND_V2_POST_URL=https://json.excalidraw.com/api/v2/post/

-VITE_APP_LIBRARY_URL=https://libraries.excalidraw.com
-VITE_APP_LIBRARY_BACKEND=https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries
+REACT_APP_LIBRARY_URL=https://libraries.excalidraw.com
+REACT_APP_LIBRARY_BACKEND=https://us-central1-excalidraw-room-persistence.cloudfunctions.net/libraries

-VITE_APP_PORTAL_URL=https://portal.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 VITE_APP_PORTAL_URL flow
-VITE_APP_WS_SERVER_URL=
+# Meant for forks only: excalidraw.com uses custom REACT_APP_PORTAL_URL flow
+REACT_APP_WS_SERVER_URL=

-VITE_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"}'
+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"}'

-VITE_APP_PLUS_APP=https://app.excalidraw.com
-VITE_APP_DISABLE_TRACKING=
+REACT_APP_PLUS_APP=https://app.excalidraw.com
+REACT_APP_DISABLE_TRACKING=
--- a/.github/workflows/autorelease-excalidraw.yml
+++ b/.github/workflows/autorelease-excalidraw.yml
@ -12,10 +12,10 @@ jobs:
      - uses: actions/checkout@v2
        with:
          fetch-depth: 2
-      - name: Setup Node.js 18.x
+      - name: Setup Node.js 14.x
        uses: actions/setup-node@v2
        with:
-          node-version: 18.x
+          node-version: 14.x
      - name: Set up publish access
        run: |
          npm config set //registry.npmjs.org/:_authToken ${NPM_TOKEN}
--- a/.github/workflows/autorelease-preview.yml
+++ b/.github/workflows/autorelease-preview.yml
@ -32,10 +32,10 @@ jobs:
        with:
          ref: ${{ steps.sha.outputs.result }}
          fetch-depth: 2
-      - name: Setup Node.js 18.x
+      - name: Setup Node.js 14.x
        uses: actions/setup-node@v2
        with:
-          node-version: 18.x
+          node-version: 14.x
      - name: Set up publish access
        run: |
          npm config set //registry.npmjs.org/:_authToken ${NPM_TOKEN}
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@ -9,10 +9,10 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: Setup Node.js 18.x
+      - name: Setup Node.js 14.x
        uses: actions/setup-node@v2
        with:
-          node-version: 18.x
+          node-version: 14.x

      - name: Install and lint
        run: |
--- a/.github/workflows/locales-coverage.yml
+++ b/.github/workflows/locales-coverage.yml
@ -14,10 +14,10 @@ jobs:
        with:
          token: ${{ secrets.PUSH_TRANSLATIONS_COVERAGE_PAT }}

-      - name: Setup Node.js 18.x
+      - name: Setup Node.js 14.x
        uses: actions/setup-node@v2
        with:
-          node-version: 18.x
+          node-version: 14.x

      - name: Create report file
        run: |
--- a/.github/workflows/semantic-pr-title.yml
+++ b/.github/workflows/semantic-pr-title.yml
@ -1,7 +1,7 @@
 name: Semantic PR title

 on:
-  pull_request:
+  pull_request_target:
    types:
      - opened
      - edited
--- a/.github/workflows/sentry-production.yml
+++ b/.github/workflows/sentry-production.yml
@ -10,10 +10,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      - name: Setup Node.js 18.x
+      - name: Setup Node.js 14.x
        uses: actions/setup-node@v2
        with:
-          node-version: 18.x
+          node-version: 14.x
      - name: Install and build
        run: |
          yarn --frozen-lockfile
--- a/.github/workflows/size-limit.yml
+++ b/.github/workflows/size-limit.yml
@ -1,30 +0,0 @@
-name: "Bundle Size check @excalidraw/excalidraw"
-on:
-  pull_request:
-    branches:
-      - master
-jobs:
-  size:
-    runs-on: ubuntu-latest
-    env:
-      CI_JOB_NUMBER: 1
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-      - name: Setup Node.js 18.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18.x
-      - name: Install
-        run: yarn --frozen-lockfile
-      - name: Install in src/packages/excalidraw
-        run: yarn --frozen-lockfile
-        working-directory: src/packages/excalidraw
-        env:
-          CI: true
-      - uses: andresz1/size-limit-action@v1
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          build_script: build:umd
-          skip_step: install
-          directory: src/packages/excalidraw
--- a/.github/workflows/test-coverage-pr.yml
+++ b/.github/workflows/test-coverage-pr.yml
@ -1,26 +0,0 @@
-name: Test Coverage PR
-on:
-  pull_request:
-
-jobs:
-  coverage:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: "Install Node"
-        uses: actions/setup-node@v2
-        with:
-          node-version: "18.x"
-      - name: "Install Deps"
-        run: yarn --frozen-lockfile
-      - name: "Test Coverage"
-        run: yarn test:coverage
-      - name: "Report Coverage"
-        if: always() # Also generate the report if tests are failing
-        uses: davelosert/vitest-coverage-report-action@v2
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@ -7,10 +7,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      - name: Setup Node.js 18.x
+      - name: Setup Node.js 14.x
        uses: actions/setup-node@v2
        with:
-          node-version: 18.x
+          node-version: 14.x
      - name: Install and test
        run: |
          yarn --frozen-lockfile
--- a/.gitignore
+++ b/.gitignore
@ -26,5 +26,3 @@ src/packages/excalidraw/example/public/bundle.js
 src/packages/excalidraw/example/public/excalidraw-assets-dev
 src/packages/excalidraw/example/public/excalidraw.development.js
 coverage
-dev-dist
-html
--- a/.nvmrc
+++ b/.nvmrc
@ -1 +1 @@
-18
+14
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-FROM node:18 AS build
+FROM node:14-alpine AS build

 WORKDIR /opt/node_app

--- a/dev-docs/docs/@excalidraw/excalidraw/api/props/props.mdx
+++ b/dev-docs/docs/@excalidraw/excalidraw/api/props/props.mdx
@ -29,8 +29,6 @@ All `props` are *optional*.
 | [`handleKeyboardGlobally`](#handlekeyboardglobally) | `boolean` | `false` | Indicates whether to bind the keyboard events to document. |
 | [`autoFocus`](#autofocus) | `boolean` | `false` | indicates whether to focus the Excalidraw component on page load |
 | [`generateIdForFile`](#generateidforfile) | `function` | _ | Allows you to override `id` generation for files added on canvas |
-| [`validateEmbeddable`](#validateEmbeddable) | string[] | `boolean | RegExp | RegExp[] | ((link: string) => boolean | undefined)` | \_ | use for custom src url validation |
-| [`renderEmbeddable`](/docs/@excalidraw/excalidraw/api/props/render-props#renderEmbeddable) | `function` | \_ | Render function that can override the built-in `<iframe>` |

 ### Storing custom data on Excalidraw elements

@ -217,6 +215,7 @@ Indicates whether to bind keyboard events to `document`. Disabled by default, me

 Enable this if you want Excalidraw to handle keyboard even if the component isn't focused (e.g. a user is interacting with the navbar, sidebar, or similar).

+
 ### autoFocus

 This prop indicates whether to `focus` the Excalidraw component on page load. Defaults to false.
@ -229,12 +228,3 @@ Allows you to override `id` generation for files added on canvas (images). By de
 (file: File) => string | Promise<string>
 ```

-### validateEmbeddable
-
-```tsx
-validateEmbeddable?: boolean | string[] | RegExp | RegExp[] | ((link: string) => boolean | undefined)
-```
-
-This is an optional property. By default we support a handful of well-known sites. You may allow additional sites or disallow the default ones by supplying a custom validator. If you pass `true`, all URLs will be allowed. You can also supply a list of hostnames, RegExp (or list of RegExp objects), or a function. If the function returns `undefined`, the built-in validator will be used.
-
-Supplying a list of hostnames (with or without `www.`) is the preferred way to allow a specific list of domains.
--- a/dev-docs/docs/@excalidraw/excalidraw/api/props/render-props.mdx
+++ b/dev-docs/docs/@excalidraw/excalidraw/api/props/render-props.mdx
@ -121,16 +121,3 @@ function App() {
  );
 }
 ```
-
-## renderEmbeddable
-
-<pre>
-  (element: NonDeleted&lt;ExcalidrawEmbeddableElement&gt;, appState: <a href="https://github.com/excalidraw/excalidraw/blob/master/src/types.ts#L95">AppState</a>) => JSX.Element | null
-</pre>
-
-Allows you to replace the renderer for embeddable elements (which renders `<iframe>` elements).
-
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `element` | `NonDeleted<ExcalidrawEmbeddableElement>` | The embeddable element to be rendered. |
-| `appState` | `AppState` | The current state of the UI. |
--- a/dev-docs/docs/introduction/contributing.mdx
+++ b/dev-docs/docs/introduction/contributing.mdx
@ -69,10 +69,6 @@ It's also a good idea to consider if your change should include additional tests

 Finally - always manually test your changes using the convenient staging environment deployed for each pull request. As much as local development attempts to replicate production, there can still be subtle differences in behavior. For larger features consider testing your change in multiple browsers as well.

-:::note
-Some checks, such as the `lint` and `test`, require approval from the maintainers to run. 
-They will appear as `Expected — Waiting for status to be reported` in the PR checks when they are waiting for approval.
-:::

 ## Translating

--- a/dev-docs/yarn.lock
+++ b/dev-docs/yarn.lock
@ -6611,19 +6611,19 @@ semver@7.0.0:
  integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==

 semver@^5.4.1:
-  version "5.7.2"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
-  integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
+  version "5.7.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
+  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==

 semver@^6.0.0, semver@^6.1.1, semver@^6.1.2, semver@^6.2.0, semver@^6.3.0:
-  version "6.3.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
-  integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
+  version "6.3.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
+  integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==

 semver@^7.3.2, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7:
-  version "7.5.4"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
-  integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
+  version "7.3.7"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f"
+  integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==
  dependencies:
    lru-cache "^6.0.0"

--- a/package.json
+++ b/package.json
@ -32,7 +32,6 @@
    "canvas-roundrect-polyfill": "0.0.1",
    "clsx": "1.1.1",
    "cross-env": "7.0.3",
-    "eslint-plugin-react": "7.32.2",
    "fake-indexeddb": "3.1.7",
    "firebase": "8.3.3",
    "i18next-browser-languagedetector": "6.1.4",
@ -52,13 +51,26 @@
    "pwacompat": "2.0.17",
    "react": "18.2.0",
    "react-dom": "18.2.0",
+    "react-scripts": "5.0.1",
    "roughjs": "4.5.2",
    "sass": "1.51.0",
    "socket.io-client": "2.3.1",
-    "tunnel-rat": "0.1.2"
+    "tunnel-rat": "0.1.2",
+    "workbox-background-sync": "^6.5.4",
+    "workbox-broadcast-update": "^6.5.4",
+    "workbox-cacheable-response": "^6.5.4",
+    "workbox-core": "^6.5.4",
+    "workbox-expiration": "^6.5.4",
+    "workbox-google-analytics": "^6.5.4",
+    "workbox-navigation-preload": "^6.5.4",
+    "workbox-precaching": "^6.5.4",
+    "workbox-range-requests": "^6.5.4",
+    "workbox-routing": "^6.5.4",
+    "workbox-strategies": "^6.5.4",
+    "workbox-streams": "^6.5.4"
  },
  "devDependencies": {
-    "@excalidraw/eslint-config": "1.0.3",
+    "@excalidraw/eslint-config": "1.0.0",
    "@excalidraw/prettier-config": "1.0.2",
    "@types/chai": "4.3.0",
    "@types/jest": "27.4.0",
@ -69,43 +81,48 @@
    "@types/react-dom": "18.0.6",
    "@types/resize-observer-browser": "0.1.7",
    "@types/socket.io-client": "1.4.36",
-    "@vitejs/plugin-react": "3.1.0",
-    "@vitest/coverage-v8": "0.33.0",
-    "@vitest/ui": "0.32.2",
    "chai": "4.3.6",
    "dotenv": "16.0.1",
    "eslint-config-prettier": "8.5.0",
-    "eslint-config-react-app": "7.0.1",
    "eslint-plugin-prettier": "3.3.1",
    "http-server": "14.1.1",
    "husky": "7.0.4",
-    "jsdom": "22.1.0",
+    "jest-canvas-mock": "2.4.0",
    "lint-staged": "12.3.7",
    "pepjs": "0.5.3",
    "prettier": "2.6.2",
    "rewire": "6.0.0",
-    "typescript": "4.9.4",
-    "vite": "4.4.2",
-    "vite-plugin-checker": "0.6.1",
-    "vite-plugin-ejs": "1.6.4",
-    "vite-plugin-pwa": "0.16.4",
-    "vite-plugin-svgr": "2.4.0",
-    "vitest": "0.32.2",
-    "vitest-canvas-mock": "0.3.2"
+    "typescript": "4.9.4"
  },
  "engines": {
-    "node": ">=18.0.0"
+    "node": ">=14.0.0"
  },
  "homepage": ".",
+  "jest": {
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}"
+    ],
+    "coveragePathIgnorePatterns": [
+      "<rootDir>/locales",
+      "<rootDir>/src/packages/excalidraw/dist/",
+      "<rootDir>/src/packages/excalidraw/types",
+      "<rootDir>/src/packages/excalidraw/example"
+    ],
+    "transformIgnorePatterns": [
+      "node_modules/(?!(roughjs|points-on-curve|path-data-parser|points-on-path|browser-fs-access|canvas-roundrect-polyfill)/)"
+    ],
+    "resetMocks": false
+  },
  "name": "excalidraw",
  "prettier": "@excalidraw/prettier-config",
  "private": true,
  "scripts": {
    "build-node": "node ./scripts/build-node.js",
-    "build:app:docker": "cross-env VITE_APP_DISABLE_SENTRY=true VITE_APP_DISABLE_TRACKING=true vite build",
-    "build:app": "cross-env VITE_APP_GIT_SHA=$VERCEL_GIT_COMMIT_SHA vite build",
+    "build:app:docker": "cross-env REACT_APP_DISABLE_SENTRY=true REACT_APP_DISABLE_TRACKING=true react-scripts build",
+    "build:app": "cross-env REACT_APP_GIT_SHA=$VERCEL_GIT_COMMIT_SHA react-scripts build",
    "build:version": "node ./scripts/build-version.js",
    "build": "yarn build:app && yarn build:version",
+    "eject": "react-scripts eject",
    "fix:code": "yarn test:code --fix",
    "fix:other": "yarn prettier --write",
    "fix": "yarn fix:other && yarn fix:code",
@ -113,21 +130,19 @@
    "locales-coverage:description": "node scripts/locales-coverage-description.js",
    "prepare": "husky install",
    "prettier": "prettier \"**/*.{css,scss,json,md,html,yml}\" --ignore-path=.eslintignore",
-    "start": "vite",
+    "start": "react-scripts start",
    "start:production": "npm run build && npx http-server build -a localhost -p 5001 -o",
-    "test:all": "yarn test:typecheck && yarn test:code && yarn test:other && yarn test:app --watch=false",
-    "test:app": "vitest --config vitest.config.ts",
+    "test:all": "yarn test:typecheck && yarn test:code && yarn test:other && yarn test:app --watchAll=false",
+    "test:app": "react-scripts test --passWithNoTests",
    "test:code": "eslint --max-warnings=0 --ext .js,.ts,.tsx .",
+    "test:debug": "react-scripts --inspect-brk test --runInBand --no-cache",
    "test:other": "yarn prettier --list-different",
    "test:typecheck": "tsc",
-    "test:update": "yarn test:app --update --watch=false",
+    "test:update": "yarn test:app --updateSnapshot --watchAll=false",
    "test": "yarn test:app",
-    "test:coverage": "vitest --coverage",
-    "test:coverage:watch": "vitest --coverage --watch",
-    "test:ui": "yarn test --ui",
+    "test:coverage": "react-scripts test --passWithNoTests --coverage --watchAll",
    "autorelease": "node scripts/autorelease.js",
    "prerelease": "node scripts/prerelease.js",
-    "build:preview": "yarn build && vite preview --port 5000",
    "release": "node scripts/release.js"
  }
 }
--- a/public/index.html
+++ b/public/index.html
@ -78,7 +78,8 @@
      }
    </style>
    <!------------------------------------------------------------------------->
-    <% if ("%PROD%" === "true") { %>
+
+    <% if (process.env.NODE_ENV === "production") { %>
    <script>
      // Redirect Excalidraw+ users which have auto-redirect enabled.
      //
@ -99,35 +100,41 @@
    </script>
    <% } %>

-    <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
+    <link rel="shortcut icon" href="favicon.ico" type="image/x-icon" />

    <!-- Excalidraw version -->
    <meta name="version" content="{version}" />

    <link
      rel="preload"
-      href="/Virgil.woff2"
+      href="Virgil.woff2"
      as="font"
      type="font/woff2"
      crossorigin="anonymous"
    />
    <link
      rel="preload"
-      href="/Cascadia.woff2"
+      href="Cascadia.woff2"
      as="font"
      type="font/woff2"
      crossorigin="anonymous"
    />

-    <link rel="stylesheet" href="/fonts.css" type="text/css" />
-    <% if ("%VITE_APP_DEV_DISABLE_LIVE_RELOAD%"==="true" ) { %>
+    <link
+      rel="manifest"
+      href="manifest.json"
+      style="--pwacompat-splash-font: 24px Virgil"
+    />
+
+    <link rel="stylesheet" href="fonts.css" type="text/css" />
+    <% if (process.env.REACT_APP_DEV_DISABLE_LIVE_RELOAD==="true" ) { %>
    <script>
      {
        const _WebSocket = window.WebSocket;
        window.WebSocket = function (url) {
          if (/ws:\/\/localhost:.+?\/sockjs-node/.test(url)) {
            console.info(
-              "[!!!] Live reload is disabled via VITE_APP_DEV_DISABLE_LIVE_RELOAD [!!!]",
+              "[!!!] Live reload is disabled via process.env.REACT_APP_DEV_DISABLE_LIVE_RELOAD [!!!]",
            );
          } else {
            return new _WebSocket(url);
@ -193,8 +200,7 @@
      <h1 class="visually-hidden">Excalidraw</h1>
    </header>
    <div id="root"></div>
-    <script type="module" src="/src/index.tsx"></script>
-    <% if ("%VITE_APP_DEV_DISABLE_LIVE_RELOAD%" !== 'true') { %>
+    <% if (process.env.REACT_APP_DISABLE_TRACKING !== 'true') { %>
    <!-- 100% privacy friendly analytics -->
    <script>
      // need to load this script dynamically bcs. of iframe embed tracking
--- a/public/service-worker.js
+++ b/public/service-worker.js
@ -1,20 +0,0 @@
-// Since we migrated to Vite, the service worker strategy changed, in CRA it was a custom service worker named service-worker.js and in Vite its sw.js handled by vite-plugin-pwa
-// Due to this the existing CRA users were not able to migrate to Vite or any new changes post Vite unless browser is hard refreshed
-// Hence adding a self destroying worker so all CRA service workers are destroyed and migrated to Vite
-// We should remove this code after sometime when we are confident that
-// all users have migrated to Vite
-
-self.addEventListener("install", () => {
-  self.skipWaiting();
-});
-
-self.addEventListener("activate", () => {
-  self.registration
-    .unregister()
-    .then(() => {
-      return self.clients.matchAll();
-    })
-    .then((clients) => {
-      clients.forEach((client) => client.navigate(client.url));
-    });
-});
--- a/public/workbox/workbox-background-sync.prod.js
+++ b/public/workbox/workbox-background-sync.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.backgroundSync=function(t,e,s){"use strict";try{self["workbox:background-sync:4.3.1"]&&_()}catch(t){}const i=3,n="workbox-background-sync",a="requests",r="queueName";class c{constructor(t){this.t=t,this.s=new s.DBWrapper(n,i,{onupgradeneeded:this.i})}async pushEntry(t){delete t.id,t.queueName=this.t,await this.s.add(a,t)}async unshiftEntry(t){const[e]=await this.s.getAllMatching(a,{count:1});e?t.id=e.id-1:delete t.id,t.queueName=this.t,await this.s.add(a,t)}async popEntry(){return this.h({direction:"prev"})}async shiftEntry(){return this.h({direction:"next"})}async getAll(){return await this.s.getAllMatching(a,{index:r,query:IDBKeyRange.only(this.t)})}async deleteEntry(t){await this.s.delete(a,t)}async h({direction:t}){const[e]=await this.s.getAllMatching(a,{direction:t,index:r,query:IDBKeyRange.only(this.t),count:1});if(e)return await this.deleteEntry(e.id),e}i(t){const e=t.target.result;t.oldVersion>0&&t.oldVersion<i&&e.objectStoreNames.contains(a)&&e.deleteObjectStore(a),e.createObjectStore(a,{autoIncrement:!0,keyPath:"id"}).createIndex(r,r,{unique:!1})}}const h=["method","referrer","referrerPolicy","mode","credentials","cache","redirect","integrity","keepalive"];class o{static async fromRequest(t){const e={url:t.url,headers:{}};"GET"!==t.method&&(e.body=await t.clone().arrayBuffer());for(const[s,i]of t.headers.entries())e.headers[s]=i;for(const s of h)void 0!==t[s]&&(e[s]=t[s]);return new o(e)}constructor(t){"navigate"===t.mode&&(t.mode="same-origin"),this.o=t}toObject(){const t=Object.assign({},this.o);return t.headers=Object.assign({},this.o.headers),t.body&&(t.body=t.body.slice(0)),t}toRequest(){return new Request(this.o.url,this.o)}clone(){return new o(this.toObject())}}const u="workbox-background-sync",y=10080,w=new Set;class d{constructor(t,{onSync:s,maxRetentionTime:i}={}){if(w.has(t))throw new e.WorkboxError("duplicate-queue-name",{name:t});w.add(t),this.u=t,this.l=s||this.replayRequests,this.q=i||y,this.m=new c(this.u),this.p()}get name(){return this.u}async pushRequest(t){await this.g(t,"push")}async unshiftRequest(t){await this.g(t,"unshift")}async popRequest(){return this.R("pop")}async shiftRequest(){return this.R("shift")}async getAll(){const t=await this.m.getAll(),e=Date.now(),s=[];for(const i of t){const t=60*this.q*1e3;e-i.timestamp>t?await this.m.deleteEntry(i.id):s.push(f(i))}return s}async g({request:t,metadata:e,timestamp:s=Date.now()},i){const n={requestData:(await o.fromRequest(t.clone())).toObject(),timestamp:s};e&&(n.metadata=e),await this.m[`${i}Entry`](n),this.k?this.D=!0:await this.registerSync()}async R(t){const e=Date.now(),s=await this.m[`${t}Entry`]();if(s){const i=60*this.q*1e3;return e-s.timestamp>i?this.R(t):f(s)}}async replayRequests(){let t;for(;t=await this.shiftRequest();)try{await fetch(t.request.clone())}catch(s){throw await this.unshiftRequest(t),new e.WorkboxError("queue-replay-failed",{name:this.u})}}async registerSync(){if("sync"in registration)try{await registration.sync.register(`${u}:${this.u}`)}catch(t){}}p(){"sync"in registration?self.addEventListener("sync",t=>{if(t.tag===`${u}:${this.u}`){const e=async()=>{let e;this.k=!0;try{await this.l({queue:this})}catch(t){throw e=t}finally{!this.D||e&&!t.lastChance||await this.registerSync(),this.k=!1,this.D=!1}};t.waitUntil(e())}}):this.l({queue:this})}static get _(){return w}}const f=t=>{const e={request:new o(t.requestData).toRequest(),timestamp:t.timestamp};return t.metadata&&(e.metadata=t.metadata),e};return t.Queue=d,t.Plugin=class{constructor(...t){this.v=new d(...t),this.fetchDidFail=this.fetchDidFail.bind(this)}async fetchDidFail({request:t}){await this.v.pushRequest({request:t})}},t}({},workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-background-sync.prod.js.map
--- a/public/workbox/workbox-broadcast-update.prod.js
+++ b/public/workbox/workbox-broadcast-update.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.broadcastUpdate=function(e,t){"use strict";try{self["workbox:broadcast-update:4.3.1"]&&_()}catch(e){}const s=(e,t,s)=>{return!s.some(s=>e.headers.has(s)&&t.headers.has(s))||s.every(s=>{const n=e.headers.has(s)===t.headers.has(s),a=e.headers.get(s)===t.headers.get(s);return n&&a})},n="workbox",a=1e4,i=["content-length","etag","last-modified"],o=async({channel:e,cacheName:t,url:s})=>{const n={type:"CACHE_UPDATED",meta:"workbox-broadcast-update",payload:{cacheName:t,updatedURL:s}};if(e)e.postMessage(n);else{const e=await clients.matchAll({type:"window"});for(const t of e)t.postMessage(n)}};class c{constructor({headersToCheck:e,channelName:t,deferNoticationTimeout:s}={}){this.t=e||i,this.s=t||n,this.i=s||a,this.o()}notifyIfUpdated({oldResponse:e,newResponse:t,url:n,cacheName:a,event:i}){if(!s(e,t,this.t)){const e=(async()=>{i&&i.request&&"navigate"===i.request.mode&&await this.h(i),await this.l({channel:this.u(),cacheName:a,url:n})})();if(i)try{i.waitUntil(e)}catch(e){}return e}}async l(e){await o(e)}u(){return"BroadcastChannel"in self&&!this.p&&(this.p=new BroadcastChannel(this.s)),this.p}h(e){if(!this.m.has(e)){const s=new t.Deferred;this.m.set(e,s);const n=setTimeout(()=>{s.resolve()},this.i);s.promise.then(()=>clearTimeout(n))}return this.m.get(e).promise}o(){this.m=new Map,self.addEventListener("message",e=>{if("WINDOW_READY"===e.data.type&&"workbox-window"===e.data.meta&&this.m.size>0){for(const e of this.m.values())e.resolve();this.m.clear()}})}}return e.BroadcastCacheUpdate=c,e.Plugin=class{constructor(e){this.l=new c(e)}cacheDidUpdate({cacheName:e,oldResponse:t,newResponse:s,request:n,event:a}){t&&this.l.notifyIfUpdated({cacheName:e,oldResponse:t,newResponse:s,event:a,url:n.url})}},e.broadcastUpdate=o,e.responsesAreSame=s,e}({},workbox.core._private);
+//# sourceMappingURL=workbox-broadcast-update.prod.js.map
--- a/public/workbox/workbox-cacheable-response.prod.js
+++ b/public/workbox/workbox-cacheable-response.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.cacheableResponse=function(t){"use strict";try{self["workbox:cacheable-response:4.3.1"]&&_()}catch(t){}class s{constructor(t={}){this.t=t.statuses,this.s=t.headers}isResponseCacheable(t){let s=!0;return this.t&&(s=this.t.includes(t.status)),this.s&&s&&(s=Object.keys(this.s).some(s=>t.headers.get(s)===this.s[s])),s}}return t.CacheableResponse=s,t.Plugin=class{constructor(t){this.i=new s(t)}cacheWillUpdate({response:t}){return this.i.isResponseCacheable(t)?t:null}},t}({});
+//# sourceMappingURL=workbox-cacheable-response.prod.js.map
--- a/public/workbox/workbox-core.prod.js
+++ b/public/workbox/workbox-core.prod.js
--- a/public/workbox/workbox-expiration.prod.js
+++ b/public/workbox/workbox-expiration.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.expiration=function(t,e,s,i,a,n){"use strict";try{self["workbox:expiration:4.3.1"]&&_()}catch(t){}const h="workbox-expiration",c="cache-entries",r=t=>{const e=new URL(t,location);return e.hash="",e.href};class o{constructor(t){this.t=t,this.s=new e.DBWrapper(h,1,{onupgradeneeded:t=>this.i(t)})}i(t){const e=t.target.result.createObjectStore(c,{keyPath:"id"});e.createIndex("cacheName","cacheName",{unique:!1}),e.createIndex("timestamp","timestamp",{unique:!1}),s.deleteDatabase(this.t)}async setTimestamp(t,e){t=r(t),await this.s.put(c,{url:t,timestamp:e,cacheName:this.t,id:this.h(t)})}async getTimestamp(t){return(await this.s.get(c,this.h(t))).timestamp}async expireEntries(t,e){const s=await this.s.transaction(c,"readwrite",(s,i)=>{const a=s.objectStore(c),n=[];let h=0;a.index("timestamp").openCursor(null,"prev").onsuccess=(({target:s})=>{const a=s.result;if(a){const s=a.value;s.cacheName===this.t&&(t&&s.timestamp<t||e&&h>=e?n.push(a.value):h++),a.continue()}else i(n)})}),i=[];for(const t of s)await this.s.delete(c,t.id),i.push(t.url);return i}h(t){return this.t+"|"+r(t)}}class u{constructor(t,e={}){this.o=!1,this.u=!1,this.l=e.maxEntries,this.p=e.maxAgeSeconds,this.t=t,this.m=new o(t)}async expireEntries(){if(this.o)return void(this.u=!0);this.o=!0;const t=this.p?Date.now()-1e3*this.p:void 0,e=await this.m.expireEntries(t,this.l),s=await caches.open(this.t);for(const t of e)await s.delete(t);this.o=!1,this.u&&(this.u=!1,this.expireEntries())}async updateTimestamp(t){await this.m.setTimestamp(t,Date.now())}async isURLExpired(t){return await this.m.getTimestamp(t)<Date.now()-1e3*this.p}async delete(){this.u=!1,await this.m.expireEntries(1/0)}}return t.CacheExpiration=u,t.Plugin=class{constructor(t={}){this.D=t,this.p=t.maxAgeSeconds,this.g=new Map,t.purgeOnQuotaError&&n.registerQuotaErrorCallback(()=>this.deleteCacheAndMetadata())}k(t){if(t===a.cacheNames.getRuntimeName())throw new i.WorkboxError("expire-custom-caches-only");let e=this.g.get(t);return e||(e=new u(t,this.D),this.g.set(t,e)),e}cachedResponseWillBeUsed({event:t,request:e,cacheName:s,cachedResponse:i}){if(!i)return null;let a=this.N(i);const n=this.k(s);n.expireEntries();const h=n.updateTimestamp(e.url);if(t)try{t.waitUntil(h)}catch(t){}return a?i:null}N(t){if(!this.p)return!0;const e=this._(t);return null===e||e>=Date.now()-1e3*this.p}_(t){if(!t.headers.has("date"))return null;const e=t.headers.get("date"),s=new Date(e).getTime();return isNaN(s)?null:s}async cacheDidUpdate({cacheName:t,request:e}){const s=this.k(t);await s.updateTimestamp(e.url),await s.expireEntries()}async deleteCacheAndMetadata(){for(const[t,e]of this.g)await caches.delete(t),await e.delete();this.g=new Map}},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core);
+//# sourceMappingURL=workbox-expiration.prod.js.map
--- a/public/workbox/workbox-navigation-preload.prod.js
+++ b/public/workbox/workbox-navigation-preload.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.navigationPreload=function(t){"use strict";try{self["workbox:navigation-preload:4.3.1"]&&_()}catch(t){}function e(){return Boolean(self.registration&&self.registration.navigationPreload)}return t.disable=function(){e()&&self.addEventListener("activate",t=>{t.waitUntil(self.registration.navigationPreload.disable().then(()=>{}))})},t.enable=function(t){e()&&self.addEventListener("activate",e=>{e.waitUntil(self.registration.navigationPreload.enable().then(()=>{t&&self.registration.navigationPreload.setHeaderValue(t)}))})},t.isSupported=e,t}({});
+//# sourceMappingURL=workbox-navigation-preload.prod.js.map
--- a/public/workbox/workbox-offline-ga.prod.js
+++ b/public/workbox/workbox-offline-ga.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.googleAnalytics=function(e,t,o,n,a,c,w){"use strict";try{self["workbox:google-analytics:4.3.1"]&&_()}catch(e){}const r=/^\/(\w+\/)?collect/,s=e=>async({queue:t})=>{let o;for(;o=await t.shiftRequest();){const{request:n,timestamp:a}=o,c=new URL(n.url);try{const w="POST"===n.method?new URLSearchParams(await n.clone().text()):c.searchParams,r=a-(Number(w.get("qt"))||0),s=Date.now()-r;if(w.set("qt",s),e.parameterOverrides)for(const t of Object.keys(e.parameterOverrides)){const o=e.parameterOverrides[t];w.set(t,o)}"function"==typeof e.hitFilter&&e.hitFilter.call(null,w),await fetch(new Request(c.origin+c.pathname,{body:w.toString(),method:"POST",mode:"cors",credentials:"omit",headers:{"Content-Type":"text/plain"}}))}catch(e){throw await t.unshiftRequest(o),e}}},i=e=>{const t=({url:e})=>"www.google-analytics.com"===e.hostname&&r.test(e.pathname),o=new w.NetworkOnly({plugins:[e]});return[new n.Route(t,o,"GET"),new n.Route(t,o,"POST")]},l=e=>{const t=new c.NetworkFirst({cacheName:e});return new n.Route(({url:e})=>"www.google-analytics.com"===e.hostname&&"/analytics.js"===e.pathname,t,"GET")},m=e=>{const t=new c.NetworkFirst({cacheName:e});return new n.Route(({url:e})=>"www.googletagmanager.com"===e.hostname&&"/gtag/js"===e.pathname,t,"GET")},u=e=>{const t=new c.NetworkFirst({cacheName:e});return new n.Route(({url:e})=>"www.googletagmanager.com"===e.hostname&&"/gtm.js"===e.pathname,t,"GET")};return e.initialize=((e={})=>{const n=o.cacheNames.getGoogleAnalyticsName(e.cacheName),c=new t.Plugin("workbox-google-analytics",{maxRetentionTime:2880,onSync:s(e)}),w=[u(n),l(n),m(n),...i(c)],r=new a.Router;for(const e of w)r.registerRoute(e);r.addFetchListener()}),e}({},workbox.backgroundSync,workbox.core._private,workbox.routing,workbox.routing,workbox.strategies,workbox.strategies);
+//# sourceMappingURL=workbox-offline-ga.prod.js.map
--- a/public/workbox/workbox-precaching.prod.js
+++ b/public/workbox/workbox-precaching.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.precaching=function(t,e,n,s,c){"use strict";try{self["workbox:precaching:4.3.1"]&&_()}catch(t){}const o=[],i={get:()=>o,add(t){o.push(...t)}};const a="__WB_REVISION__";function r(t){if(!t)throw new c.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if("string"==typeof t){const e=new URL(t,location);return{cacheKey:e.href,url:e.href}}const{revision:e,url:n}=t;if(!n)throw new c.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if(!e){const t=new URL(n,location);return{cacheKey:t.href,url:t.href}}const s=new URL(n,location),o=new URL(n,location);return o.searchParams.set(a,e),{cacheKey:o.href,url:s.href}}class l{constructor(t){this.t=e.cacheNames.getPrecacheName(t),this.s=new Map}addToCacheList(t){for(const e of t){const{cacheKey:t,url:n}=r(e);if(this.s.has(n)&&this.s.get(n)!==t)throw new c.WorkboxError("add-to-cache-list-conflicting-entries",{firstEntry:this.s.get(n),secondEntry:t});this.s.set(n,t)}}async install({event:t,plugins:e}={}){const n=[],s=[],c=await caches.open(this.t),o=await c.keys(),i=new Set(o.map(t=>t.url));for(const t of this.s.values())i.has(t)?s.push(t):n.push(t);const a=n.map(n=>this.o({event:t,plugins:e,url:n}));return await Promise.all(a),{updatedURLs:n,notUpdatedURLs:s}}async activate(){const t=await caches.open(this.t),e=await t.keys(),n=new Set(this.s.values()),s=[];for(const c of e)n.has(c.url)||(await t.delete(c),s.push(c.url));return{deletedURLs:s}}async o({url:t,event:e,plugins:o}){const i=new Request(t,{credentials:"same-origin"});let a,r=await s.fetchWrapper.fetch({event:e,plugins:o,request:i});for(const t of o||[])"cacheWillUpdate"in t&&(a=t.cacheWillUpdate.bind(t));if(!(a?a({event:e,request:i,response:r}):r.status<400))throw new c.WorkboxError("bad-precaching-response",{url:t,status:r.status});r.redirected&&(r=await async function(t){const e=t.clone(),n="body"in e?Promise.resolve(e.body):e.blob(),s=await n;return new Response(s,{headers:e.headers,status:e.status,statusText:e.statusText})}(r)),await n.cacheWrapper.put({event:e,plugins:o,request:i,response:r,cacheName:this.t,matchOptions:{ignoreSearch:!0}})}getURLsToCacheKeys(){return this.s}getCachedURLs(){return[...this.s.keys()]}getCacheKeyForURL(t){const e=new URL(t,location);return this.s.get(e.href)}}let u;const h=()=>(u||(u=new l),u);const d=(t,e)=>{const n=h().getURLsToCacheKeys();for(const s of function*(t,{ignoreURLParametersMatching:e,directoryIndex:n,cleanURLs:s,urlManipulation:c}={}){const o=new URL(t,location);o.hash="",yield o.href;const i=function(t,e){for(const n of[...t.searchParams.keys()])e.some(t=>t.test(n))&&t.searchParams.delete(n);return t}(o,e);if(yield i.href,n&&i.pathname.endsWith("/")){const t=new URL(i);t.pathname+=n,yield t.href}if(s){const t=new URL(i);t.pathname+=".html",yield t.href}if(c){const t=c({url:o});for(const e of t)yield e.href}}(t,e)){const t=n.get(s);if(t)return t}};let w=!1;const f=t=>{w||((({ignoreURLParametersMatching:t=[/^utm_/],directoryIndex:n="index.html",cleanURLs:s=!0,urlManipulation:c=null}={})=>{const o=e.cacheNames.getPrecacheName();addEventListener("fetch",e=>{const i=d(e.request.url,{cleanURLs:s,directoryIndex:n,ignoreURLParametersMatching:t,urlManipulation:c});if(!i)return;let a=caches.open(o).then(t=>t.match(i)).then(t=>t||fetch(i));e.respondWith(a)})})(t),w=!0)},y=t=>{const e=h(),n=i.get();t.waitUntil(e.install({event:t,plugins:n}).catch(t=>{throw t}))},p=t=>{const e=h(),n=i.get();t.waitUntil(e.activate({event:t,plugins:n}))},L=t=>{h().addToCacheList(t),t.length>0&&(addEventListener("install",y),addEventListener("activate",p))};return t.addPlugins=(t=>{i.add(t)}),t.addRoute=f,t.cleanupOutdatedCaches=(()=>{addEventListener("activate",t=>{const n=e.cacheNames.getPrecacheName();t.waitUntil((async(t,e="-precache-")=>{const n=(await caches.keys()).filter(n=>n.includes(e)&&n.includes(self.registration.scope)&&n!==t);return await Promise.all(n.map(t=>caches.delete(t))),n})(n).then(t=>{}))})}),t.getCacheKeyForURL=(t=>{return h().getCacheKeyForURL(t)}),t.precache=L,t.precacheAndRoute=((t,e)=>{L(t),f(e)}),t.PrecacheController=l,t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-precaching.prod.js.map
--- a/public/workbox/workbox-range-requests.prod.js
+++ b/public/workbox/workbox-range-requests.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.rangeRequests=function(e,n){"use strict";try{self["workbox:range-requests:4.3.1"]&&_()}catch(e){}async function t(e,t){try{if(206===t.status)return t;const s=e.headers.get("range");if(!s)throw new n.WorkboxError("no-range-header");const a=function(e){const t=e.trim().toLowerCase();if(!t.startsWith("bytes="))throw new n.WorkboxError("unit-must-be-bytes",{normalizedRangeHeader:t});if(t.includes(","))throw new n.WorkboxError("single-range-only",{normalizedRangeHeader:t});const s=/(\d*)-(\d*)/.exec(t);if(null===s||!s[1]&&!s[2])throw new n.WorkboxError("invalid-range-values",{normalizedRangeHeader:t});return{start:""===s[1]?null:Number(s[1]),end:""===s[2]?null:Number(s[2])}}(s),r=await t.blob(),i=function(e,t,s){const a=e.size;if(s>a||t<0)throw new n.WorkboxError("range-not-satisfiable",{size:a,end:s,start:t});let r,i;return null===t?(r=a-s,i=a):null===s?(r=t,i=a):(r=t,i=s+1),{start:r,end:i}}(r,a.start,a.end),o=r.slice(i.start,i.end),u=o.size,l=new Response(o,{status:206,statusText:"Partial Content",headers:t.headers});return l.headers.set("Content-Length",u),l.headers.set("Content-Range",`bytes ${i.start}-${i.end-1}/`+r.size),l}catch(e){return new Response("",{status:416,statusText:"Range Not Satisfiable"})}}return e.createPartialResponse=t,e.Plugin=class{async cachedResponseWillBeUsed({request:e,cachedResponse:n}){return n&&e.headers.has("range")?await t(e,n):n}},e}({},workbox.core._private);
+//# sourceMappingURL=workbox-range-requests.prod.js.map
--- a/public/workbox/workbox-routing.prod.js
+++ b/public/workbox/workbox-routing.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.routing=function(t,e,r){"use strict";try{self["workbox:routing:4.3.1"]&&_()}catch(t){}const s="GET",n=t=>t&&"object"==typeof t?t:{handle:t};class o{constructor(t,e,r){this.handler=n(e),this.match=t,this.method=r||s}}class i extends o{constructor(t,{whitelist:e=[/./],blacklist:r=[]}={}){super(t=>this.t(t),t),this.s=e,this.o=r}t({url:t,request:e}){if("navigate"!==e.mode)return!1;const r=t.pathname+t.search;for(const t of this.o)if(t.test(r))return!1;return!!this.s.some(t=>t.test(r))}}class u extends o{constructor(t,e,r){super(({url:e})=>{const r=t.exec(e.href);return r?e.origin!==location.origin&&0!==r.index?null:r.slice(1):null},e,r)}}class c{constructor(){this.i=new Map}get routes(){return this.i}addFetchListener(){self.addEventListener("fetch",t=>{const{request:e}=t,r=this.handleRequest({request:e,event:t});r&&t.respondWith(r)})}addCacheListener(){self.addEventListener("message",async t=>{if(t.data&&"CACHE_URLS"===t.data.type){const{payload:e}=t.data,r=Promise.all(e.urlsToCache.map(t=>{"string"==typeof t&&(t=[t]);const e=new Request(...t);return this.handleRequest({request:e})}));t.waitUntil(r),t.ports&&t.ports[0]&&(await r,t.ports[0].postMessage(!0))}})}handleRequest({request:t,event:e}){const r=new URL(t.url,location);if(!r.protocol.startsWith("http"))return;let s,{params:n,route:o}=this.findMatchingRoute({url:r,request:t,event:e}),i=o&&o.handler;if(!i&&this.u&&(i=this.u),i){try{s=i.handle({url:r,request:t,event:e,params:n})}catch(t){s=Promise.reject(t)}return s&&this.h&&(s=s.catch(t=>this.h.handle({url:r,event:e,err:t}))),s}}findMatchingRoute({url:t,request:e,event:r}){const s=this.i.get(e.method)||[];for(const n of s){let s,o=n.match({url:t,request:e,event:r});if(o)return Array.isArray(o)&&o.length>0?s=o:o.constructor===Object&&Object.keys(o).length>0&&(s=o),{route:n,params:s}}return{}}setDefaultHandler(t){this.u=n(t)}setCatchHandler(t){this.h=n(t)}registerRoute(t){this.i.has(t.method)||this.i.set(t.method,[]),this.i.get(t.method).push(t)}unregisterRoute(t){if(!this.i.has(t.method))throw new r.WorkboxError("unregister-route-but-not-found-with-method",{method:t.method});const e=this.i.get(t.method).indexOf(t);if(!(e>-1))throw new r.WorkboxError("unregister-route-route-not-registered");this.i.get(t.method).splice(e,1)}}let a;const h=()=>(a||((a=new c).addFetchListener(),a.addCacheListener()),a);return t.NavigationRoute=i,t.RegExpRoute=u,t.registerNavigationRoute=((t,r={})=>{const s=e.cacheNames.getPrecacheName(r.cacheName),n=new i(async()=>{try{const e=await caches.match(t,{cacheName:s});if(e)return e;throw new Error(`The cache ${s} did not have an entry for `+`${t}.`)}catch(e){return fetch(t)}},{whitelist:r.whitelist,blacklist:r.blacklist});return h().registerRoute(n),n}),t.registerRoute=((t,e,s="GET")=>{let n;if("string"==typeof t){const r=new URL(t,location);n=new o(({url:t})=>t.href===r.href,e,s)}else if(t instanceof RegExp)n=new u(t,e,s);else if("function"==typeof t)n=new o(t,e,s);else{if(!(t instanceof o))throw new r.WorkboxError("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});n=t}return h().registerRoute(n),n}),t.Route=o,t.Router=c,t.setCatchHandler=(t=>{h().setCatchHandler(t)}),t.setDefaultHandler=(t=>{h().setDefaultHandler(t)}),t}({},workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-routing.prod.js.map
--- a/public/workbox/workbox-strategies.prod.js
+++ b/public/workbox/workbox-strategies.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.strategies=function(e,t,s,n,r){"use strict";try{self["workbox:strategies:4.3.1"]&&_()}catch(e){}class i{constructor(e={}){this.t=t.cacheNames.getRuntimeName(e.cacheName),this.s=e.plugins||[],this.i=e.fetchOptions||null,this.h=e.matchOptions||null}async handle({event:e,request:t}){return this.makeRequest({event:e,request:t||e.request})}async makeRequest({event:e,request:t}){"string"==typeof t&&(t=new Request(t));let n,i=await s.cacheWrapper.match({cacheName:this.t,request:t,event:e,matchOptions:this.h,plugins:this.s});if(!i)try{i=await this.u(t,e)}catch(e){n=e}if(!i)throw new r.WorkboxError("no-response",{url:t.url,error:n});return i}async u(e,t){const r=await n.fetchWrapper.fetch({request:e,event:t,fetchOptions:this.i,plugins:this.s}),i=r.clone(),h=s.cacheWrapper.put({cacheName:this.t,request:e,response:i,event:t,plugins:this.s});if(t)try{t.waitUntil(h)}catch(e){}return r}}class h{constructor(e={}){this.t=t.cacheNames.getRuntimeName(e.cacheName),this.s=e.plugins||[],this.h=e.matchOptions||null}async handle({event:e,request:t}){return this.makeRequest({event:e,request:t||e.request})}async makeRequest({event:e,request:t}){"string"==typeof t&&(t=new Request(t));const n=await s.cacheWrapper.match({cacheName:this.t,request:t,event:e,matchOptions:this.h,plugins:this.s});if(!n)throw new r.WorkboxError("no-response",{url:t.url});return n}}const u={cacheWillUpdate:({response:e})=>200===e.status||0===e.status?e:null};class a{constructor(e={}){if(this.t=t.cacheNames.getRuntimeName(e.cacheName),e.plugins){let t=e.plugins.some(e=>!!e.cacheWillUpdate);this.s=t?e.plugins:[u,...e.plugins]}else this.s=[u];this.o=e.networkTimeoutSeconds,this.i=e.fetchOptions||null,this.h=e.matchOptions||null}async handle({event:e,request:t}){return this.makeRequest({event:e,request:t||e.request})}async makeRequest({event:e,request:t}){const s=[];"string"==typeof t&&(t=new Request(t));const n=[];let i;if(this.o){const{id:r,promise:h}=this.l({request:t,event:e,logs:s});i=r,n.push(h)}const h=this.q({timeoutId:i,request:t,event:e,logs:s});n.push(h);let u=await Promise.race(n);if(u||(u=await h),!u)throw new r.WorkboxError("no-response",{url:t.url});return u}l({request:e,logs:t,event:s}){let n;return{promise:new Promise(t=>{n=setTimeout(async()=>{t(await this.p({request:e,event:s}))},1e3*this.o)}),id:n}}async q({timeoutId:e,request:t,logs:r,event:i}){let h,u;try{u=await n.fetchWrapper.fetch({request:t,event:i,fetchOptions:this.i,plugins:this.s})}catch(e){h=e}if(e&&clearTimeout(e),h||!u)u=await this.p({request:t,event:i});else{const e=u.clone(),n=s.cacheWrapper.put({cacheName:this.t,request:t,response:e,event:i,plugins:this.s});if(i)try{i.waitUntil(n)}catch(e){}}return u}p({event:e,request:t}){return s.cacheWrapper.match({cacheName:this.t,request:t,event:e,matchOptions:this.h,plugins:this.s})}}class c{constructor(e={}){this.t=t.cacheNames.getRuntimeName(e.cacheName),this.s=e.plugins||[],this.i=e.fetchOptions||null}async handle({event:e,request:t}){return this.makeRequest({event:e,request:t||e.request})}async makeRequest({event:e,request:t}){let s,i;"string"==typeof t&&(t=new Request(t));try{i=await n.fetchWrapper.fetch({request:t,event:e,fetchOptions:this.i,plugins:this.s})}catch(e){s=e}if(!i)throw new r.WorkboxError("no-response",{url:t.url,error:s});return i}}class o{constructor(e={}){if(this.t=t.cacheNames.getRuntimeName(e.cacheName),this.s=e.plugins||[],e.plugins){let t=e.plugins.some(e=>!!e.cacheWillUpdate);this.s=t?e.plugins:[u,...e.plugins]}else this.s=[u];this.i=e.fetchOptions||null,this.h=e.matchOptions||null}async handle({event:e,request:t}){return this.makeRequest({event:e,request:t||e.request})}async makeRequest({event:e,request:t}){"string"==typeof t&&(t=new Request(t));const n=this.u({request:t,event:e});let i,h=await s.cacheWrapper.match({cacheName:this.t,request:t,event:e,matchOptions:this.h,plugins:this.s});if(h){if(e)try{e.waitUntil(n)}catch(i){}}else try{h=await n}catch(e){i=e}if(!h)throw new r.WorkboxError("no-response",{url:t.url,error:i});return h}async u({request:e,event:t}){const r=await n.fetchWrapper.fetch({request:e,event:t,fetchOptions:this.i,plugins:this.s}),i=s.cacheWrapper.put({cacheName:this.t,request:e,response:r.clone(),event:t,plugins:this.s});if(t)try{t.waitUntil(i)}catch(e){}return r}}const l={cacheFirst:i,cacheOnly:h,networkFirst:a,networkOnly:c,staleWhileRevalidate:o},q=e=>{const t=l[e];return e=>new t(e)},w=q("cacheFirst"),p=q("cacheOnly"),v=q("networkFirst"),y=q("networkOnly"),m=q("staleWhileRevalidate");return e.CacheFirst=i,e.CacheOnly=h,e.NetworkFirst=a,e.NetworkOnly=c,e.StaleWhileRevalidate=o,e.cacheFirst=w,e.cacheOnly=p,e.networkFirst=v,e.networkOnly=y,e.staleWhileRevalidate=m,e}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private);
+//# sourceMappingURL=workbox-strategies.prod.js.map
--- a/public/workbox/workbox-streams.prod.js
+++ b/public/workbox/workbox-streams.prod.js
@ -0,0 +1,2 @@
+this.workbox=this.workbox||{},this.workbox.streams=function(e){"use strict";try{self["workbox:streams:4.3.1"]&&_()}catch(e){}function n(e){const n=e.map(e=>Promise.resolve(e).then(e=>(function(e){return e.body&&e.body.getReader?e.body.getReader():e.getReader?e.getReader():new Response(e).body.getReader()})(e)));let t,r;const s=new Promise((e,n)=>{t=e,r=n});let o=0;return{done:s,stream:new ReadableStream({pull(e){return n[o].then(e=>e.read()).then(r=>{if(r.done)return++o>=n.length?(e.close(),void t()):this.pull(e);e.enqueue(r.value)}).catch(e=>{throw r(e),e})},cancel(){t()}})}}function t(e={}){const n=new Headers(e);return n.has("content-type")||n.set("content-type","text/html"),n}function r(e,r){const{done:s,stream:o}=n(e),a=t(r);return{done:s,response:new Response(o,{headers:a})}}let s=void 0;function o(){if(void 0===s)try{new ReadableStream({start(){}}),s=!0}catch(e){s=!1}return s}return e.concatenate=n,e.concatenateToResponse=r,e.isSupported=o,e.strategy=function(e,n){return async({event:s,url:a,params:c})=>{if(o()){const{done:t,response:o}=r(e.map(e=>e({event:s,url:a,params:c})),n);return s.waitUntil(t),o}const i=await Promise.all(e.map(e=>e({event:s,url:a,params:c})).map(async e=>{const n=await e;return n instanceof Response?n.blob():n})),u=t(n);return new Response(new Blob(i),{headers:u})}},e}({});
+//# sourceMappingURL=workbox-streams.prod.js.map
--- a/public/workbox/workbox-sw.js
+++ b/public/workbox/workbox-sw.js
@ -0,0 +1,2 @@
+!function(){"use strict";try{self["workbox:sw:4.3.1"]&&_()}catch(t){}const t="https://storage.googleapis.com/workbox-cdn/releases/4.3.1",e={backgroundSync:"background-sync",broadcastUpdate:"broadcast-update",cacheableResponse:"cacheable-response",core:"core",expiration:"expiration",googleAnalytics:"offline-ga",navigationPreload:"navigation-preload",precaching:"precaching",rangeRequests:"range-requests",routing:"routing",strategies:"strategies",streams:"streams"};self.workbox=new class{constructor(){return this.v={},this.t={debug:"localhost"===self.location.hostname,modulePathPrefix:null,modulePathCb:null},this.s=this.t.debug?"dev":"prod",this.o=!1,new Proxy(this,{get(t,s){if(t[s])return t[s];const o=e[s];return o&&t.loadModule(`workbox-${o}`),t[s]}})}setConfig(t={}){if(this.o)throw new Error("Config must be set before accessing workbox.* modules");Object.assign(this.t,t),this.s=this.t.debug?"dev":"prod"}loadModule(t){const e=this.i(t);try{importScripts(e),this.o=!0}catch(s){throw console.error(`Unable to import module '${t}' from '${e}'.`),s}}i(e){if(this.t.modulePathCb)return this.t.modulePathCb(e,this.t.debug);let s=[t];const o=`${e}.${this.s}.js`,r=this.t.modulePathPrefix;return r&&""===(s=r.split("/"))[s.length-1]&&s.splice(s.length-1,1),s.push(o),s.join("/")}}}();
+//# sourceMappingURL=workbox-sw.js.map
--- a/public/workbox/workbox-window.prod.es5.mjs
+++ b/public/workbox/workbox-window.prod.es5.mjs
@ -0,0 +1,2 @@
+try{self["workbox:window:4.3.1"]&&_()}catch(n){}var n=function(n,t){return new Promise(function(i){var e=new MessageChannel;e.port1.onmessage=function(n){return i(n.data)},n.postMessage(t,[e.port2])})};function t(n,t){for(var i=0;i<t.length;i++){var e=t[i];e.enumerable=e.enumerable||!1,e.configurable=!0,"value"in e&&(e.writable=!0),Object.defineProperty(n,e.key,e)}}function i(n){if(void 0===n)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return n}try{self["workbox:core:4.3.1"]&&_()}catch(n){}var e=function(){var n=this;this.promise=new Promise(function(t,i){n.resolve=t,n.reject=i})},r=function(n,t){return new URL(n,location).href===new URL(t,location).href},o=function(n,t){Object.assign(this,t,{type:n})};function u(n){return function(){for(var t=[],i=0;i<arguments.length;i++)t[i]=arguments[i];try{return Promise.resolve(n.apply(this,t))}catch(n){return Promise.reject(n)}}}function a(n,t,i){return i?t?t(n):n:(n&&n.then||(n=Promise.resolve(n)),t?n.then(t):n)}function s(){}var c=function(c){var f,h;function v(n,t){var r;return void 0===t&&(t={}),(r=c.call(this)||this).t=n,r.i=t,r.o=0,r.u=new e,r.s=new e,r.h=new e,r.v=r.v.bind(i(i(r))),r.l=r.l.bind(i(i(r))),r.g=r.g.bind(i(i(r))),r.m=r.m.bind(i(i(r))),r}h=c,(f=v).prototype=Object.create(h.prototype),f.prototype.constructor=f,f.__proto__=h;var l,w,g,d=v.prototype;return d.register=u(function(n){var t,i,e=this,u=(void 0===n?{}:n).immediate,c=void 0!==u&&u;return t=function(){return e.p=Boolean(navigator.serviceWorker.controller),e.P=e.R(),a(e.k(),function(n){e.B=n,e.P&&(e.O=e.P,e.s.resolve(e.P),e.h.resolve(e.P),e.j(e.P),e.P.addEventListener("statechange",e.l,{once:!0}));var t=e.B.waiting;return t&&r(t.scriptURL,e.t)&&(e.O=t,Promise.resolve().then(function(){e.dispatchEvent(new o("waiting",{sw:t,wasWaitingBeforeRegister:!0}))})),e.O&&e.u.resolve(e.O),e.B.addEventListener("updatefound",e.g),navigator.serviceWorker.addEventListener("controllerchange",e.m,{once:!0}),"BroadcastChannel"in self&&(e.C=new BroadcastChannel("workbox"),e.C.addEventListener("message",e.v)),navigator.serviceWorker.addEventListener("message",e.v),e.B})},(i=function(){if(!c&&"complete"!==document.readyState)return function(n,t){if(!t)return n&&n.then?n.then(s):Promise.resolve()}(new Promise(function(n){return addEventListener("load",n)}))}())&&i.then?i.then(t):t(i)}),d.getSW=u(function(){return this.O||this.u.promise}),d.messageSW=u(function(t){return a(this.getSW(),function(i){return n(i,t)})}),d.R=function(){var n=navigator.serviceWorker.controller;if(n&&r(n.scriptURL,this.t))return n},d.k=u(function(){var n=this;return function(n,t){try{var i=n()}catch(n){return t(n)}return i&&i.then?i.then(void 0,t):i}(function(){return a(navigator.serviceWorker.register(n.t,n.i),function(t){return n.L=performance.now(),t})},function(n){throw n})}),d.j=function(t){n(t,{type:"WINDOW_READY",meta:"workbox-window"})},d.g=function(){var n=this.B.installing;this.o>0||!r(n.scriptURL,this.t)||performance.now()>this.L+6e4?(this.W=n,this.B.removeEventListener("updatefound",this.g)):(this.O=n,this.u.resolve(n)),++this.o,n.addEventListener("statechange",this.l)},d.l=function(n){var t=this,i=n.target,e=i.state,r=i===this.W,u=r?"external":"",a={sw:i,originalEvent:n};!r&&this.p&&(a.isUpdate=!0),this.dispatchEvent(new o(u+e,a)),"installed"===e?this._=setTimeout(function(){"installed"===e&&t.B.waiting===i&&t.dispatchEvent(new o(u+"waiting",a))},200):"activating"===e&&(clearTimeout(this._),r||this.s.resolve(i))},d.m=function(n){var t=this.O;t===navigator.serviceWorker.controller&&(this.dispatchEvent(new o("controlling",{sw:t,originalEvent:n})),this.h.resolve(t))},d.v=function(n){var t=n.data;this.dispatchEvent(new o("message",{data:t,originalEvent:n}))},l=v,(w=[{key:"active",get:function(){return this.s.promise}},{key:"controlling",get:function(){return this.h.promise}}])&&t(l.prototype,w),g&&t(l,g),v}(function(){function n(){this.D={}}var t=n.prototype;return t.addEventListener=function(n,t){this.T(n).add(t)},t.removeEventListener=function(n,t){this.T(n).delete(t)},t.dispatchEvent=function(n){n.target=this,this.T(n.type).forEach(function(t){return t(n)})},t.T=function(n){return this.D[n]=this.D[n]||new Set},n}());export{c as Workbox,n as messageSW};
+//# sourceMappingURL=workbox-window.prod.es5.mjs.map
--- a/public/workbox/workbox-window.prod.mjs
+++ b/public/workbox/workbox-window.prod.mjs
@ -0,0 +1,2 @@
+try{self["workbox:window:4.3.1"]&&_()}catch(t){}const t=(t,s)=>new Promise(i=>{let e=new MessageChannel;e.port1.onmessage=(t=>i(t.data)),t.postMessage(s,[e.port2])});try{self["workbox:core:4.3.1"]&&_()}catch(t){}class s{constructor(){this.promise=new Promise((t,s)=>{this.resolve=t,this.reject=s})}}class i{constructor(){this.t={}}addEventListener(t,s){this.s(t).add(s)}removeEventListener(t,s){this.s(t).delete(s)}dispatchEvent(t){t.target=this,this.s(t.type).forEach(s=>s(t))}s(t){return this.t[t]=this.t[t]||new Set}}const e=(t,s)=>new URL(t,location).href===new URL(s,location).href;class n{constructor(t,s){Object.assign(this,s,{type:t})}}const h=200,a=6e4;class o extends i{constructor(t,i={}){super(),this.i=t,this.h=i,this.o=0,this.l=new s,this.g=new s,this.u=new s,this.m=this.m.bind(this),this.v=this.v.bind(this),this.p=this.p.bind(this),this._=this._.bind(this)}async register({immediate:t=!1}={}){t||"complete"===document.readyState||await new Promise(t=>addEventListener("load",t)),this.C=Boolean(navigator.serviceWorker.controller),this.W=this.L(),this.S=await this.B(),this.W&&(this.R=this.W,this.g.resolve(this.W),this.u.resolve(this.W),this.P(this.W),this.W.addEventListener("statechange",this.v,{once:!0}));const s=this.S.waiting;return s&&e(s.scriptURL,this.i)&&(this.R=s,Promise.resolve().then(()=>{this.dispatchEvent(new n("waiting",{sw:s,wasWaitingBeforeRegister:!0}))})),this.R&&this.l.resolve(this.R),this.S.addEventListener("updatefound",this.p),navigator.serviceWorker.addEventListener("controllerchange",this._,{once:!0}),"BroadcastChannel"in self&&(this.T=new BroadcastChannel("workbox"),this.T.addEventListener("message",this.m)),navigator.serviceWorker.addEventListener("message",this.m),this.S}get active(){return this.g.promise}get controlling(){return this.u.promise}async getSW(){return this.R||this.l.promise}async messageSW(s){const i=await this.getSW();return t(i,s)}L(){const t=navigator.serviceWorker.controller;if(t&&e(t.scriptURL,this.i))return t}async B(){try{const t=await navigator.serviceWorker.register(this.i,this.h);return this.U=performance.now(),t}catch(t){throw t}}P(s){t(s,{type:"WINDOW_READY",meta:"workbox-window"})}p(){const t=this.S.installing;this.o>0||!e(t.scriptURL,this.i)||performance.now()>this.U+a?(this.k=t,this.S.removeEventListener("updatefound",this.p)):(this.R=t,this.l.resolve(t)),++this.o,t.addEventListener("statechange",this.v)}v(t){const s=t.target,{state:i}=s,e=s===this.k,a=e?"external":"",o={sw:s,originalEvent:t};!e&&this.C&&(o.isUpdate=!0),this.dispatchEvent(new n(a+i,o)),"installed"===i?this.D=setTimeout(()=>{"installed"===i&&this.S.waiting===s&&this.dispatchEvent(new n(a+"waiting",o))},h):"activating"===i&&(clearTimeout(this.D),e||this.g.resolve(s))}_(t){const s=this.R;s===navigator.serviceWorker.controller&&(this.dispatchEvent(new n("controlling",{sw:s,originalEvent:t})),this.u.resolve(s))}m(t){const{data:s}=t;this.dispatchEvent(new n("message",{data:s,originalEvent:t}))}}export{o as Workbox,t as messageSW};
+//# sourceMappingURL=workbox-window.prod.mjs.map
--- a/public/workbox/workbox-window.prod.umd.js
+++ b/public/workbox/workbox-window.prod.umd.js
@ -0,0 +1,2 @@
+!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n=n||self).workbox={})}(this,function(n){"use strict";try{self["workbox:window:4.3.1"]&&_()}catch(n){}var t=function(n,t){return new Promise(function(i){var e=new MessageChannel;e.port1.onmessage=function(n){return i(n.data)},n.postMessage(t,[e.port2])})};function i(n,t){for(var i=0;i<t.length;i++){var e=t[i];e.enumerable=e.enumerable||!1,e.configurable=!0,"value"in e&&(e.writable=!0),Object.defineProperty(n,e.key,e)}}function e(n){if(void 0===n)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return n}try{self["workbox:core:4.3.1"]&&_()}catch(n){}var r=function(){var n=this;this.promise=new Promise(function(t,i){n.resolve=t,n.reject=i})},o=function(n,t){return new URL(n,location).href===new URL(t,location).href},u=function(n,t){Object.assign(this,t,{type:n})};function s(n){return function(){for(var t=[],i=0;i<arguments.length;i++)t[i]=arguments[i];try{return Promise.resolve(n.apply(this,t))}catch(n){return Promise.reject(n)}}}function a(n,t,i){return i?t?t(n):n:(n&&n.then||(n=Promise.resolve(n)),t?n.then(t):n)}function c(){}var f=function(n){var f,h;function v(t,i){var o;return void 0===i&&(i={}),(o=n.call(this)||this).t=t,o.i=i,o.o=0,o.u=new r,o.s=new r,o.h=new r,o.v=o.v.bind(e(e(o))),o.l=o.l.bind(e(e(o))),o.g=o.g.bind(e(e(o))),o.m=o.m.bind(e(e(o))),o}h=n,(f=v).prototype=Object.create(h.prototype),f.prototype.constructor=f,f.__proto__=h;var l,w,d,g=v.prototype;return g.register=s(function(n){var t,i,e=this,r=(void 0===n?{}:n).immediate,s=void 0!==r&&r;return t=function(){return e.p=Boolean(navigator.serviceWorker.controller),e.P=e.j(),a(e.O(),function(n){e.R=n,e.P&&(e._=e.P,e.s.resolve(e.P),e.h.resolve(e.P),e.k(e.P),e.P.addEventListener("statechange",e.l,{once:!0}));var t=e.R.waiting;return t&&o(t.scriptURL,e.t)&&(e._=t,Promise.resolve().then(function(){e.dispatchEvent(new u("waiting",{sw:t,wasWaitingBeforeRegister:!0}))})),e._&&e.u.resolve(e._),e.R.addEventListener("updatefound",e.g),navigator.serviceWorker.addEventListener("controllerchange",e.m,{once:!0}),"BroadcastChannel"in self&&(e.B=new BroadcastChannel("workbox"),e.B.addEventListener("message",e.v)),navigator.serviceWorker.addEventListener("message",e.v),e.R})},(i=function(){if(!s&&"complete"!==document.readyState)return function(n,t){if(!t)return n&&n.then?n.then(c):Promise.resolve()}(new Promise(function(n){return addEventListener("load",n)}))}())&&i.then?i.then(t):t(i)}),g.getSW=s(function(){return this._||this.u.promise}),g.messageSW=s(function(n){return a(this.getSW(),function(i){return t(i,n)})}),g.j=function(){var n=navigator.serviceWorker.controller;if(n&&o(n.scriptURL,this.t))return n},g.O=s(function(){var n=this;return function(n,t){try{var i=n()}catch(n){return t(n)}return i&&i.then?i.then(void 0,t):i}(function(){return a(navigator.serviceWorker.register(n.t,n.i),function(t){return n.C=performance.now(),t})},function(n){throw n})}),g.k=function(n){t(n,{type:"WINDOW_READY",meta:"workbox-window"})},g.g=function(){var n=this.R.installing;this.o>0||!o(n.scriptURL,this.t)||performance.now()>this.C+6e4?(this.L=n,this.R.removeEventListener("updatefound",this.g)):(this._=n,this.u.resolve(n)),++this.o,n.addEventListener("statechange",this.l)},g.l=function(n){var t=this,i=n.target,e=i.state,r=i===this.L,o=r?"external":"",s={sw:i,originalEvent:n};!r&&this.p&&(s.isUpdate=!0),this.dispatchEvent(new u(o+e,s)),"installed"===e?this.W=setTimeout(function(){"installed"===e&&t.R.waiting===i&&t.dispatchEvent(new u(o+"waiting",s))},200):"activating"===e&&(clearTimeout(this.W),r||this.s.resolve(i))},g.m=function(n){var t=this._;t===navigator.serviceWorker.controller&&(this.dispatchEvent(new u("controlling",{sw:t,originalEvent:n})),this.h.resolve(t))},g.v=function(n){var t=n.data;this.dispatchEvent(new u("message",{data:t,originalEvent:n}))},l=v,(w=[{key:"active",get:function(){return this.s.promise}},{key:"controlling",get:function(){return this.h.promise}}])&&i(l.prototype,w),d&&i(l,d),v}(function(){function n(){this.D={}}var t=n.prototype;return t.addEventListener=function(n,t){this.M(n).add(t)},t.removeEventListener=function(n,t){this.M(n).delete(t)},t.dispatchEvent=function(n){n.target=this,this.M(n.type).forEach(function(t){return t(n)})},t.M=function(n){return this.D[n]=this.D[n]||new Set},n}());n.Workbox=f,n.messageSW=t,Object.defineProperty(n,"__esModule",{value:!0})});
+//# sourceMappingURL=workbox-window.prod.umd.js.map
--- a/src/actions/actionAddToLibrary.ts
+++ b/src/actions/actionAddToLibrary.ts
@ -1,30 +1,31 @@
 import { register } from "./register";
+import { getSelectedElements } from "../scene";
+import { getNonDeletedElements } from "../element";
 import { deepCopyElement } from "../element/newElement";
 import { randomId } from "../random";
 import { t } from "../i18n";
-import { LIBRARY_DISABLED_TYPES } from "../constants";

 export const actionAddToLibrary = register({
  name: "addToLibrary",
  trackEvent: { category: "element" },
  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
        includeElementsInFrames: true,
-    });
-
-    for (const type of LIBRARY_DISABLED_TYPES) {
-      if (selectedElements.some((element) => element.type === type)) {
+      },
+    );
+    if (selectedElements.some((element) => element.type === "image")) {
      return {
        commitToHistory: false,
        appState: {
          ...appState,
-            errorMessage: t(`errors.libraryElementTypeError.${type}`),
+          errorMessage: "Support for adding images to the library coming soon!",
        },
      };
    }
-    }

    return app.library
      .getLatestLibrary()
--- a/src/actions/actionAlign.tsx
+++ b/src/actions/actionAlign.tsx
@ -13,18 +13,19 @@ import { ExcalidrawElement } from "../element/types";
 import { updateFrameMembershipOfSelectedElements } from "../frame";
 import { t } from "../i18n";
 import { KEYS } from "../keys";
-import { isSomeElementSelected } from "../scene";
-import { AppClassProperties, AppState } from "../types";
+import { getSelectedElements, isSomeElementSelected } from "../scene";
+import { AppState } from "../types";
 import { arrayToMap, getShortcutKey } from "../utils";
 import { register } from "./register";

 const alignActionsPredicate = (
  elements: readonly ExcalidrawElement[],
  appState: AppState,
-  _: unknown,
-  app: AppClassProperties,
 ) => {
-  const selectedElements = app.scene.getSelectedElements(appState);
+  const selectedElements = getSelectedElements(
+    getNonDeletedElements(elements),
+    appState,
+  );
  return (
    selectedElements.length > 1 &&
    // TODO enable aligning frames when implemented properly
@ -35,10 +36,12 @@ const alignActionsPredicate = (
 const alignSelectedElements = (
  elements: readonly ExcalidrawElement[],
  appState: Readonly<AppState>,
-  app: AppClassProperties,
  alignment: Alignment,
 ) => {
-  const selectedElements = app.scene.getSelectedElements(appState);
+  const selectedElements = getSelectedElements(
+    getNonDeletedElements(elements),
+    appState,
+  );

  const updatedElements = alignElements(selectedElements, alignment);

@ -47,7 +50,6 @@ const alignSelectedElements = (
  return updateFrameMembershipOfSelectedElements(
    elements.map((element) => updatedElementsMap.get(element.id) || element),
    appState,
-    app,
  );
 };

@ -55,10 +57,10 @@ export const actionAlignTop = register({
  name: "alignTop",
  trackEvent: { category: "element" },
  predicate: alignActionsPredicate,
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: alignSelectedElements(elements, appState, app, {
+      elements: alignSelectedElements(elements, appState, {
        position: "start",
        axis: "y",
      }),
@ -67,9 +69,9 @@ export const actionAlignTop = register({
  },
  keyTest: (event) =>
    event[KEYS.CTRL_OR_CMD] && event.shiftKey && event.key === KEYS.ARROW_UP,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!alignActionsPredicate(elements, appState, null, app)}
+      hidden={!alignActionsPredicate(elements, appState)}
      type="button"
      icon={AlignTopIcon}
      onClick={() => updateData(null)}
@ -86,10 +88,10 @@ export const actionAlignBottom = register({
  name: "alignBottom",
  trackEvent: { category: "element" },
  predicate: alignActionsPredicate,
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: alignSelectedElements(elements, appState, app, {
+      elements: alignSelectedElements(elements, appState, {
        position: "end",
        axis: "y",
      }),
@ -98,9 +100,9 @@ export const actionAlignBottom = register({
  },
  keyTest: (event) =>
    event[KEYS.CTRL_OR_CMD] && event.shiftKey && event.key === KEYS.ARROW_DOWN,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!alignActionsPredicate(elements, appState, null, app)}
+      hidden={!alignActionsPredicate(elements, appState)}
      type="button"
      icon={AlignBottomIcon}
      onClick={() => updateData(null)}
@ -117,10 +119,10 @@ export const actionAlignLeft = register({
  name: "alignLeft",
  trackEvent: { category: "element" },
  predicate: alignActionsPredicate,
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: alignSelectedElements(elements, appState, app, {
+      elements: alignSelectedElements(elements, appState, {
        position: "start",
        axis: "x",
      }),
@ -129,9 +131,9 @@ export const actionAlignLeft = register({
  },
  keyTest: (event) =>
    event[KEYS.CTRL_OR_CMD] && event.shiftKey && event.key === KEYS.ARROW_LEFT,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!alignActionsPredicate(elements, appState, null, app)}
+      hidden={!alignActionsPredicate(elements, appState)}
      type="button"
      icon={AlignLeftIcon}
      onClick={() => updateData(null)}
@ -148,10 +150,10 @@ export const actionAlignRight = register({
  name: "alignRight",
  trackEvent: { category: "element" },
  predicate: alignActionsPredicate,
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: alignSelectedElements(elements, appState, app, {
+      elements: alignSelectedElements(elements, appState, {
        position: "end",
        axis: "x",
      }),
@ -160,9 +162,9 @@ export const actionAlignRight = register({
  },
  keyTest: (event) =>
    event[KEYS.CTRL_OR_CMD] && event.shiftKey && event.key === KEYS.ARROW_RIGHT,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!alignActionsPredicate(elements, appState, null, app)}
+      hidden={!alignActionsPredicate(elements, appState)}
      type="button"
      icon={AlignRightIcon}
      onClick={() => updateData(null)}
@ -179,19 +181,19 @@ export const actionAlignVerticallyCentered = register({
  name: "alignVerticallyCentered",
  trackEvent: { category: "element" },
  predicate: alignActionsPredicate,
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: alignSelectedElements(elements, appState, app, {
+      elements: alignSelectedElements(elements, appState, {
        position: "center",
        axis: "y",
      }),
      commitToHistory: true,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!alignActionsPredicate(elements, appState, null, app)}
+      hidden={!alignActionsPredicate(elements, appState)}
      type="button"
      icon={CenterVerticallyIcon}
      onClick={() => updateData(null)}
@ -206,19 +208,19 @@ export const actionAlignHorizontallyCentered = register({
  name: "alignHorizontallyCentered",
  trackEvent: { category: "element" },
  predicate: alignActionsPredicate,
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: alignSelectedElements(elements, appState, app, {
+      elements: alignSelectedElements(elements, appState, {
        position: "center",
        axis: "x",
      }),
      commitToHistory: true,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!alignActionsPredicate(elements, appState, null, app)}
+      hidden={!alignActionsPredicate(elements, appState)}
      type="button"
      icon={CenterHorizontallyIcon}
      onClick={() => updateData(null)}
--- a/src/actions/actionBoundText.tsx
+++ b/src/actions/actionBoundText.tsx
@ -4,7 +4,7 @@ import {
  VERTICAL_ALIGN,
  TEXT_ALIGN,
 } from "../constants";
-import { isTextElement, newElement } from "../element";
+import { getNonDeletedElements, isTextElement, newElement } from "../element";
 import { mutateElement } from "../element/mutateElement";
 import {
  computeBoundTextPosition,
@ -29,8 +29,8 @@ import {
  ExcalidrawTextContainer,
  ExcalidrawTextElement,
 } from "../element/types";
+import { getSelectedElements } from "../scene";
 import { AppState } from "../types";
-import { Mutable } from "../utility-types";
 import { getFontString } from "../utils";
 import { register } from "./register";

@ -38,13 +38,16 @@ export const actionUnbindText = register({
  name: "unbindText",
  contextItemLabel: "labels.unbindText",
  trackEvent: { category: "element" },
-  predicate: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  predicate: (elements, appState) => {
+    const selectedElements = getSelectedElements(elements, appState);

    return selectedElements.some((element) => hasBoundTextElement(element));
  },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    );
    selectedElements.forEach((element) => {
      const boundTextElement = getBoundTextElement(element);
      if (boundTextElement) {
@ -89,8 +92,8 @@ export const actionBindText = register({
  name: "bindText",
  contextItemLabel: "labels.bindText",
  trackEvent: { category: "element" },
-  predicate: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  predicate: (elements, appState) => {
+    const selectedElements = getSelectedElements(elements, appState);

    if (selectedElements.length === 2) {
      const textElement =
@ -113,8 +116,11 @@ export const actionBindText = register({
    }
    return false;
  },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    );

    let textElement: ExcalidrawTextElement;
    let container: ExcalidrawTextContainer;
@ -194,15 +200,18 @@ export const actionWrapTextInContainer = register({
  name: "wrapTextInContainer",
  contextItemLabel: "labels.createContainerFromText",
  trackEvent: { category: "element" },
-  predicate: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  predicate: (elements, appState) => {
+    const selectedElements = getSelectedElements(elements, appState);
    const areTextElements = selectedElements.every((el) => isTextElement(el));
    return selectedElements.length > 0 && areTextElements;
  },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    );
    let updatedElements: readonly ExcalidrawElement[] = elements.slice();
-    const containerIds: Mutable<AppState["selectedElementIds"]> = {};
+    const containerIds: AppState["selectedElementIds"] = {};

    for (const textElement of selectedElements) {
      if (isTextElement(textElement)) {
--- a/src/actions/actionCanvas.tsx
+++ b/src/actions/actionCanvas.tsx
@ -6,7 +6,7 @@ import { getCommonBounds, getNonDeletedElements } from "../element";
 import { ExcalidrawElement } from "../element/types";
 import { t } from "../i18n";
 import { CODES, KEYS } from "../keys";
-import { getNormalizedZoom } from "../scene";
+import { getNormalizedZoom, getSelectedElements } from "../scene";
 import { centerScrollOn } from "../scene/scroll";
 import { getStateForZoom } from "../scene/zoom";
 import { AppState, NormalizedZoomValue } from "../types";
@ -302,8 +302,11 @@ export const zoomToFit = ({
 export const actionZoomToFitSelectionInViewport = register({
  name: "zoomToFitSelectionInViewport",
  trackEvent: { category: "canvas" },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    );
    return zoomToFit({
      targetElements: selectedElements.length ? selectedElements : elements,
      appState,
@ -322,8 +325,11 @@ export const actionZoomToFitSelectionInViewport = register({
 export const actionZoomToFitSelection = register({
  name: "zoomToFitSelection",
  trackEvent: { category: "canvas" },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    );
    return zoomToFit({
      targetElements: selectedElements.length ? selectedElements : elements,
      appState,
@ -396,7 +402,6 @@ export const actionToggleEraserTool = register({
        ...appState,
        selectedElementIds: {},
        selectedGroupIds: {},
-        activeEmbeddable: null,
        activeTool,
      },
      commitToHistory: true,
@ -431,7 +436,6 @@ export const actionToggleHandTool = register({
        ...appState,
        selectedElementIds: {},
        selectedGroupIds: {},
-        activeEmbeddable: null,
        activeTool,
      },
      commitToHistory: true,
--- a/src/actions/actionClipboard.tsx
+++ b/src/actions/actionClipboard.tsx
@ -7,6 +7,7 @@ import {
  probablySupportsClipboardWriteText,
 } from "../clipboard";
 import { actionDeleteSelected } from "./actionDeleteSelected";
+import { getSelectedElements } from "../scene/selection";
 import { exportCanvas } from "../data/index";
 import { getNonDeletedElements, isTextElement } from "../element";
 import { t } from "../i18n";
@ -15,8 +16,7 @@ export const actionCopy = register({
  name: "copy",
  trackEvent: { category: "element" },
  perform: (elements, appState, _, app) => {
-    const elementsToCopy = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+    const elementsToCopy = getSelectedElements(elements, appState, {
      includeBoundTextElement: true,
      includeElementsInFrames: true,
    });
@ -75,11 +75,14 @@ export const actionCopyAsSvg = register({
        commitToHistory: false,
      };
    }
-    const selectedElements = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
        includeElementsInFrames: true,
-    });
+      },
+    );
    try {
      await exportCanvas(
        "clipboard-svg",
@ -119,11 +122,14 @@ export const actionCopyAsPng = register({
        commitToHistory: false,
      };
    }
-    const selectedElements = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
        includeElementsInFrames: true,
-    });
+      },
+    );
    try {
      await exportCanvas(
        "clipboard",
@ -171,11 +177,14 @@ export const actionCopyAsPng = register({
 export const copyText = register({
  name: "copyText",
  trackEvent: { category: "element" },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
-    });
+      },
+    );

    const text = selectedElements
      .reduce((acc: string[], element) => {
@ -190,15 +199,12 @@ export const copyText = register({
      commitToHistory: false,
    };
  },
-  predicate: (elements, appState, _, app) => {
+  predicate: (elements, appState) => {
    return (
      probablySupportsClipboardWriteText &&
-      app.scene
-        .getSelectedElements({
-          selectedElementIds: appState.selectedElementIds,
+      getSelectedElements(elements, appState, {
        includeBoundTextElement: true,
-        })
-        .some(isTextElement)
+      }).some(isTextElement)
    );
  },
  contextItemLabel: "labels.copyText",
--- a/src/actions/actionDeleteSelected.tsx
+++ b/src/actions/actionDeleteSelected.tsx
@ -158,7 +158,6 @@ export const actionDeleteSelected = register({
        ...nextAppState,
        activeTool: updateActiveTool(appState, { type: "selection" }),
        multiElement: null,
-        activeEmbeddable: null,
      },
      commitToHistory: isSomeElementSelected(
        getNonDeletedElements(elements),
--- a/src/actions/actionDistribute.tsx
+++ b/src/actions/actionDistribute.tsx
@ -9,13 +9,19 @@ import { ExcalidrawElement } from "../element/types";
 import { updateFrameMembershipOfSelectedElements } from "../frame";
 import { t } from "../i18n";
 import { CODES, KEYS } from "../keys";
-import { isSomeElementSelected } from "../scene";
-import { AppClassProperties, AppState } from "../types";
+import { getSelectedElements, isSomeElementSelected } from "../scene";
+import { AppState } from "../types";
 import { arrayToMap, getShortcutKey } from "../utils";
 import { register } from "./register";

-const enableActionGroup = (appState: AppState, app: AppClassProperties) => {
-  const selectedElements = app.scene.getSelectedElements(appState);
+const enableActionGroup = (
+  elements: readonly ExcalidrawElement[],
+  appState: AppState,
+) => {
+  const selectedElements = getSelectedElements(
+    getNonDeletedElements(elements),
+    appState,
+  );
  return (
    selectedElements.length > 1 &&
    // TODO enable distributing frames when implemented properly
@ -26,10 +32,12 @@ const enableActionGroup = (appState: AppState, app: AppClassProperties) => {
 const distributeSelectedElements = (
  elements: readonly ExcalidrawElement[],
  appState: Readonly<AppState>,
-  app: AppClassProperties,
  distribution: Distribution,
 ) => {
-  const selectedElements = app.scene.getSelectedElements(appState);
+  const selectedElements = getSelectedElements(
+    getNonDeletedElements(elements),
+    appState,
+  );

  const updatedElements = distributeElements(selectedElements, distribution);

@ -38,17 +46,16 @@ const distributeSelectedElements = (
  return updateFrameMembershipOfSelectedElements(
    elements.map((element) => updatedElementsMap.get(element.id) || element),
    appState,
-    app,
  );
 };

 export const distributeHorizontally = register({
  name: "distributeHorizontally",
  trackEvent: { category: "element" },
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: distributeSelectedElements(elements, appState, app, {
+      elements: distributeSelectedElements(elements, appState, {
        space: "between",
        axis: "x",
      }),
@ -57,9 +64,9 @@ export const distributeHorizontally = register({
  },
  keyTest: (event) =>
    !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.H,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!enableActionGroup(appState, app)}
+      hidden={!enableActionGroup(elements, appState)}
      type="button"
      icon={DistributeHorizontallyIcon}
      onClick={() => updateData(null)}
@ -75,10 +82,10 @@ export const distributeHorizontally = register({
 export const distributeVertically = register({
  name: "distributeVertically",
  trackEvent: { category: "element" },
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      appState,
-      elements: distributeSelectedElements(elements, appState, app, {
+      elements: distributeSelectedElements(elements, appState, {
        space: "between",
        axis: "y",
      }),
@ -87,9 +94,9 @@ export const distributeVertically = register({
  },
  keyTest: (event) =>
    !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.V,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!enableActionGroup(appState, app)}
+      hidden={!enableActionGroup(elements, appState)}
      type="button"
      icon={DistributeVerticallyIcon}
      onClick={() => updateData(null)}
--- a/src/actions/actionDuplicateSelection.tsx
+++ b/src/actions/actionDuplicateSelection.tsx
@ -274,8 +274,6 @@ const duplicateElements = (
        ),
      },
      getNonDeletedElements(finalElements),
-      appState,
-      null,
    ),
  };
 };
--- a/src/actions/actionElementLock.ts
+++ b/src/actions/actionElementLock.ts
@ -1,6 +1,7 @@
 import { newElementWith } from "../element/mutateElement";
 import { ExcalidrawElement } from "../element/types";
 import { KEYS } from "../keys";
+import { getSelectedElements } from "../scene";
 import { arrayToMap } from "../utils";
 import { register } from "./register";

@ -10,15 +11,14 @@ const shouldLock = (elements: readonly ExcalidrawElement[]) =>
 export const actionToggleElementLock = register({
  name: "toggleElementLock",
  trackEvent: { category: "element" },
-  predicate: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  predicate: (elements, appState) => {
+    const selectedElements = getSelectedElements(elements, appState);
    return !selectedElements.some(
      (element) => element.locked && element.frameId,
    );
  },
-  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+  perform: (elements, appState) => {
+    const selectedElements = getSelectedElements(elements, appState, {
      includeBoundTextElement: true,
      includeElementsInFrames: true,
    });
@ -46,9 +46,8 @@ export const actionToggleElementLock = register({
      commitToHistory: true,
    };
  },
-  contextItemLabel: (elements, appState, app) => {
-    const selected = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+  contextItemLabel: (elements, appState) => {
+    const selected = getSelectedElements(elements, appState, {
      includeBoundTextElement: false,
    });
    if (selected.length === 1 && selected[0].type !== "frame") {
@ -61,13 +60,12 @@ export const actionToggleElementLock = register({
      ? "labels.elementLock.lockAll"
      : "labels.elementLock.unlockAll";
  },
-  keyTest: (event, appState, elements, app) => {
+  keyTest: (event, appState, elements) => {
    return (
      event.key.toLocaleLowerCase() === KEYS.L &&
      event[KEYS.CTRL_OR_CMD] &&
      event.shiftKey &&
-      app.scene.getSelectedElements({
-        selectedElementIds: appState.selectedElementIds,
+      getSelectedElements(elements, appState, {
        includeBoundTextElement: false,
      }).length > 0
    );
--- a/src/actions/actionExport.tsx
+++ b/src/actions/actionExport.tsx
@ -65,7 +65,7 @@ export const actionChangeExportScale = register({
          );

          const scaleButtonTitle = `${t(
-            "imageExportDialog.label.scale",
+            "buttons.scale",
          )} ${s}x (${width}x${height})`;

          return (
@ -102,7 +102,7 @@ export const actionChangeExportBackground = register({
      checked={appState.exportBackground}
      onChange={(checked) => updateData(checked)}
    >
-      {t("imageExportDialog.label.withBackground")}
+      {t("labels.withBackground")}
    </CheckboxItem>
  ),
 });
@ -121,8 +121,8 @@ export const actionChangeExportEmbedScene = register({
      checked={appState.exportEmbedScene}
      onChange={(checked) => updateData(checked)}
    >
-      {t("imageExportDialog.label.embedScene")}
-      <Tooltip label={t("imageExportDialog.tooltip.embedScene")} long={true}>
+      {t("labels.exportEmbedScene")}
+      <Tooltip label={t("labels.exportEmbedScene_details")} long={true}>
        <div className="excalidraw-tooltip-icon">{questionCircle}</div>
      </Tooltip>
    </CheckboxItem>
@ -277,7 +277,7 @@ export const actionExportWithDarkMode = register({
        onChange={(theme: Theme) => {
          updateData(theme === THEME.DARK);
        }}
-        title={t("imageExportDialog.label.darkMode")}
+        title={t("labels.toggleExportColorScheme")}
      />
    </div>
  ),
--- a/src/actions/actionFinalize.tsx
+++ b/src/actions/actionFinalize.tsx
@ -125,6 +125,13 @@ export const actionFinalize = register({
          { x, y },
        );
      }
+
+      if (
+        !appState.activeTool.locked &&
+        appState.activeTool.type !== "freedraw"
+      ) {
+        appState.selectedElementIds[multiPointElement.id] = true;
+      }
    }

    if (
@ -160,7 +167,6 @@ export const actionFinalize = register({
          multiPointElement
            ? appState.activeTool
            : activeTool,
-        activeEmbeddable: null,
        draggingElement: null,
        multiElement: null,
        editingElement: null,
--- a/src/actions/actionFlip.ts
+++ b/src/actions/actionFlip.ts
@ -17,12 +17,11 @@ import { updateFrameMembershipOfSelectedElements } from "../frame";
 export const actionFlipHorizontal = register({
  name: "flipHorizontal",
  trackEvent: { category: "element" },
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      elements: updateFrameMembershipOfSelectedElements(
        flipSelectedElements(elements, appState, "horizontal"),
        appState,
-        app,
      ),
      appState,
      commitToHistory: true,
@ -35,12 +34,11 @@ export const actionFlipHorizontal = register({
 export const actionFlipVertical = register({
  name: "flipVertical",
  trackEvent: { category: "element" },
-  perform: (elements, appState, _, app) => {
+  perform: (elements, appState) => {
    return {
      elements: updateFrameMembershipOfSelectedElements(
        flipSelectedElements(elements, appState, "vertical"),
        appState,
-        app,
      ),
      appState,
      commitToHistory: true,
--- a/src/actions/actionFrame.ts
+++ b/src/actions/actionFrame.ts
@ -3,12 +3,19 @@ import { ExcalidrawElement } from "../element/types";
 import { removeAllElementsFromFrame } from "../frame";
 import { getFrameElements } from "../frame";
 import { KEYS } from "../keys";
-import { AppClassProperties, AppState } from "../types";
+import { getSelectedElements } from "../scene";
+import { AppState } from "../types";
 import { setCursorForShape, updateActiveTool } from "../utils";
 import { register } from "./register";

-const isSingleFrameSelected = (appState: AppState, app: AppClassProperties) => {
-  const selectedElements = app.scene.getSelectedElements(appState);
+const isSingleFrameSelected = (
+  elements: readonly ExcalidrawElement[],
+  appState: AppState,
+) => {
+  const selectedElements = getSelectedElements(
+    getNonDeletedElements(elements),
+    appState,
+  );

  return selectedElements.length === 1 && selectedElements[0].type === "frame";
 };
@ -16,8 +23,11 @@ const isSingleFrameSelected = (appState: AppState, app: AppClassProperties) => {
 export const actionSelectAllElementsInFrame = register({
  name: "selectAllElementsInFrame",
  trackEvent: { category: "canvas" },
-  perform: (elements, appState, _, app) => {
-    const selectedFrame = app.scene.getSelectedElements(appState)[0];
+  perform: (elements, appState) => {
+    const selectedFrame = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    )[0];

    if (selectedFrame && selectedFrame.type === "frame") {
      const elementsInFrame = getFrameElements(
@ -45,15 +55,17 @@ export const actionSelectAllElementsInFrame = register({
    };
  },
  contextItemLabel: "labels.selectAllElementsInFrame",
-  predicate: (elements, appState, _, app) =>
-    isSingleFrameSelected(appState, app),
+  predicate: (elements, appState) => isSingleFrameSelected(elements, appState),
 });

 export const actionRemoveAllElementsFromFrame = register({
  name: "removeAllElementsFromFrame",
  trackEvent: { category: "history" },
-  perform: (elements, appState, _, app) => {
-    const selectedFrame = app.scene.getSelectedElements(appState)[0];
+  perform: (elements, appState) => {
+    const selectedFrame = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+    )[0];

    if (selectedFrame && selectedFrame.type === "frame") {
      return {
@ -75,12 +87,11 @@ export const actionRemoveAllElementsFromFrame = register({
    };
  },
  contextItemLabel: "labels.removeAllElementsFromFrame",
-  predicate: (elements, appState, _, app) =>
-    isSingleFrameSelected(appState, app),
+  predicate: (elements, appState) => isSingleFrameSelected(elements, appState),
 });

-export const actionupdateFrameRendering = register({
-  name: "updateFrameRendering",
+export const actionToggleFrameRendering = register({
+  name: "toggleFrameRendering",
  viewMode: true,
  trackEvent: { category: "canvas" },
  perform: (elements, appState) => {
@ -88,16 +99,13 @@ export const actionupdateFrameRendering = register({
      elements,
      appState: {
        ...appState,
-        frameRendering: {
-          ...appState.frameRendering,
-          enabled: !appState.frameRendering.enabled,
-        },
+        shouldRenderFrames: !appState.shouldRenderFrames,
      },
      commitToHistory: false,
    };
  },
-  contextItemLabel: "labels.updateFrameRendering",
-  checked: (appState: AppState) => appState.frameRendering.enabled,
+  contextItemLabel: "labels.toggleFrameRendering",
+  checked: (appState: AppState) => appState.shouldRenderFrames,
 });

 export const actionSetFrameAsActiveTool = register({
--- a/src/actions/actionGroup.tsx
+++ b/src/actions/actionGroup.tsx
@ -4,7 +4,7 @@ import { arrayToMap, getShortcutKey } from "../utils";
 import { register } from "./register";
 import { UngroupIcon, GroupIcon } from "../components/icons";
 import { newElementWith } from "../element/mutateElement";
-import { isSomeElementSelected } from "../scene";
+import { getSelectedElements, isSomeElementSelected } from "../scene";
 import {
  getSelectedGroupIds,
  selectGroup,
@ -22,7 +22,7 @@ import {
  ExcalidrawFrameElement,
  ExcalidrawTextElement,
 } from "../element/types";
-import { AppClassProperties, AppState } from "../types";
+import { AppState } from "../types";
 import { isBoundToContainer } from "../element/typeChecks";
 import {
  getElementsInResizingFrame,
@ -51,12 +51,14 @@ const allElementsInSameGroup = (elements: readonly ExcalidrawElement[]) => {
 const enableActionGroup = (
  elements: readonly ExcalidrawElement[],
  appState: AppState,
-  app: AppClassProperties,
 ) => {
-  const selectedElements = app.scene.getSelectedElements({
-    selectedElementIds: appState.selectedElementIds,
+  const selectedElements = getSelectedElements(
+    getNonDeletedElements(elements),
+    appState,
+    {
      includeBoundTextElement: true,
-  });
+    },
+  );
  return (
    selectedElements.length >= 2 && !allElementsInSameGroup(selectedElements)
  );
@ -66,10 +68,13 @@ export const actionGroup = register({
  name: "group",
  trackEvent: { category: "element" },
  perform: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+    const selectedElements = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
-    });
+      },
+    );
    if (selectedElements.length < 2) {
      // nothing to group
      return { appState, elements, commitToHistory: false };
@ -159,13 +164,12 @@ export const actionGroup = register({
    };
  },
  contextItemLabel: "labels.group",
-  predicate: (elements, appState, _, app) =>
-    enableActionGroup(elements, appState, app),
+  predicate: (elements, appState) => enableActionGroup(elements, appState),
  keyTest: (event) =>
    !event.shiftKey && event[KEYS.CTRL_OR_CMD] && event.key === KEYS.G,
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData }) => (
    <ToolButton
-      hidden={!enableActionGroup(elements, appState, app)}
+      hidden={!enableActionGroup(elements, appState)}
      type="button"
      icon={<GroupIcon theme={appState.theme} />}
      onClick={() => updateData(null)}
@ -187,7 +191,7 @@ export const actionUngroup = register({

    let nextElements = [...elements];

-    const selectedElements = app.scene.getSelectedElements(appState);
+    const selectedElements = getSelectedElements(nextElements, appState);
    const frames = selectedElements
      .filter((element) => element.frameId)
      .map((element) =>
@ -214,8 +218,6 @@ export const actionUngroup = register({
    const updateAppState = selectGroupsForSelectedElements(
      { ...appState, selectedGroupIds: {} },
      getNonDeletedElements(nextElements),
-      appState,
-      null,
    );

    frames.forEach((frame) => {
@ -230,18 +232,9 @@ export const actionUngroup = register({
    });

    // remove binded text elements from selection
-    updateAppState.selectedElementIds = Object.entries(
-      updateAppState.selectedElementIds,
-    ).reduce(
-      (acc: { [key: ExcalidrawElement["id"]]: true }, [id, selected]) => {
-        if (selected && !boundTextElementIds.includes(id)) {
-          acc[id] = true;
-        }
-        return acc;
-      },
-      {},
+    boundTextElementIds.forEach(
+      (id) => (updateAppState.selectedElementIds[id] = false),
    );
-
    return {
      appState: updateAppState,
      elements: nextElements,
--- a/src/actions/actionLinearEditor.ts
+++ b/src/actions/actionLinearEditor.ts
@ -1,6 +1,8 @@
+import { getNonDeletedElements } from "../element";
 import { LinearElementEditor } from "../element/linearElementEditor";
 import { isLinearElement } from "../element/typeChecks";
 import { ExcalidrawLinearElement } from "../element/types";
+import { getSelectedElements } from "../scene";
 import { register } from "./register";

 export const actionToggleLinearEditor = register({
@ -8,18 +10,21 @@ export const actionToggleLinearEditor = register({
  trackEvent: {
    category: "element",
  },
-  predicate: (elements, appState, _, app) => {
-    const selectedElements = app.scene.getSelectedElements(appState);
+  predicate: (elements, appState) => {
+    const selectedElements = getSelectedElements(elements, appState);
    if (selectedElements.length === 1 && isLinearElement(selectedElements[0])) {
      return true;
    }
    return false;
  },
  perform(elements, appState, _, app) {
-    const selectedElement = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+    const selectedElement = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
-    })[0] as ExcalidrawLinearElement;
+      },
+    )[0] as ExcalidrawLinearElement;

    const editingLinearElement =
      appState.editingLinearElement?.elementId === selectedElement.id
@ -33,11 +38,14 @@ export const actionToggleLinearEditor = register({
      commitToHistory: false,
    };
  },
-  contextItemLabel: (elements, appState, app) => {
-    const selectedElement = app.scene.getSelectedElements({
-      selectedElementIds: appState.selectedElementIds,
+  contextItemLabel: (elements, appState) => {
+    const selectedElement = getSelectedElements(
+      getNonDeletedElements(elements),
+      appState,
+      {
        includeBoundTextElement: true,
-    })[0] as ExcalidrawLinearElement;
+      },
+    )[0] as ExcalidrawLinearElement;
    return appState.editingLinearElement?.elementId === selectedElement.id
      ? "labels.lineEditor.exit"
      : "labels.lineEditor.edit";
--- a/src/actions/actionSelectAll.ts
+++ b/src/actions/actionSelectAll.ts
@ -41,8 +41,6 @@ export const actionSelectAll = register({
          selectedElementIds,
        },
        getNonDeletedElements(elements),
-        appState,
-        app,
      ),
      commitToHistory: true,
    };
--- a/src/actions/manager.tsx
+++ b/src/actions/manager.tsx
@ -90,7 +90,6 @@ export class ActionManager {
            event,
            this.getAppState(),
            this.getElementsIncludingDeleted(),
-            this.app,
          ),
      );

@ -169,7 +168,6 @@ export class ActionManager {
          appState={this.getAppState()}
          updateData={updateData}
          appProps={this.app.props}
-          app={this.app}
          data={data}
        />
      );
--- a/src/actions/types.ts
+++ b/src/actions/types.ts
@ -119,9 +119,8 @@ export type ActionName =
  | "toggleHandTool"
  | "selectAllElementsInFrame"
  | "removeAllElementsFromFrame"
-  | "updateFrameRendering"
+  | "toggleFrameRendering"
  | "setFrameAsActiveTool"
-  | "setEmbeddableAsActiveTool"
  | "createContainerFromText"
  | "wrapTextInContainer";

@ -131,7 +130,6 @@ export type PanelComponentProps = {
  updateData: (formData?: any) => void;
  appProps: ExcalidrawProps;
  data?: Record<string, any>;
-  app: AppClassProperties;
 };

 export interface Action {
@ -143,14 +141,12 @@ export interface Action {
    event: React.KeyboardEvent | KeyboardEvent,
    appState: AppState,
    elements: readonly ExcalidrawElement[],
-    app: AppClassProperties,
  ) => boolean;
  contextItemLabel?:
    | string
    | ((
        elements: readonly ExcalidrawElement[],
        appState: Readonly<AppState>,
-        app: AppClassProperties,
      ) => string);
  predicate?: (
    elements: readonly ExcalidrawElement[],
--- a/src/analytics.ts
+++ b/src/analytics.ts
@ -11,7 +11,7 @@ export const trackEvent = (
    // Uncomment the next line to track locally
    // console.log("Track Event", { category, action, label, value });

-    if (typeof window === "undefined" || import.meta.env.VITE_WORKER_ID) {
+    if (typeof window === "undefined" || process.env.JEST_WORKER_ID) {
      return;
    }

--- a/src/appState.ts
+++ b/src/appState.ts
@ -38,7 +38,6 @@ export const getDefaultAppState = (): Omit<
    currentItemStrokeWidth: DEFAULT_ELEMENT_PROPS.strokeWidth,
    currentItemTextAlign: DEFAULT_TEXT_ALIGN,
    cursorButton: "up",
-    activeEmbeddable: null,
    draggingElement: null,
    editingElement: null,
    editingGroupId: null,
@ -85,7 +84,7 @@ export const getDefaultAppState = (): Omit<
    showStats: false,
    startBoundElement: null,
    suggestedBindings: [],
-    frameRendering: { enabled: true, clip: true, name: true, outline: true },
+    shouldRenderFrames: true,
    frameToHighlight: null,
    editingFrame: null,
    elementsToHighlight: null,
@ -140,7 +139,6 @@ const APP_STATE_STORAGE_CONF = (<
  currentItemStrokeWidth: { browser: true, export: false, server: false },
  currentItemTextAlign: { browser: true, export: false, server: false },
  cursorButton: { browser: true, export: false, server: false },
-  activeEmbeddable: { browser: false, export: false, server: false },
  draggingElement: { browser: false, export: false, server: false },
  editingElement: { browser: false, export: false, server: false },
  editingGroupId: { browser: true, export: false, server: false },
@ -193,7 +191,7 @@ const APP_STATE_STORAGE_CONF = (<
  showStats: { browser: true, export: false, server: false },
  startBoundElement: { browser: false, export: false, server: false },
  suggestedBindings: { browser: false, export: false, server: false },
-  frameRendering: { browser: false, export: false, server: false },
+  shouldRenderFrames: { browser: false, export: false, server: false },
  frameToHighlight: { browser: false, export: false, server: false },
  editingFrame: { browser: false, export: false, server: false },
  elementsToHighlight: { browser: false, export: false, server: false },
--- a/src/charts.ts
+++ b/src/charts.ts
@ -6,6 +6,7 @@ import {
 import {
  DEFAULT_FONT_FAMILY,
  DEFAULT_FONT_SIZE,
+  ENV,
  VERTICAL_ALIGN,
 } from "./constants";
 import { newElement, newLinearElement, newTextElement } from "./element";
@ -383,7 +384,7 @@ const chartTypeBar = (
      y,
      groupId,
      backgroundColor,
-      import.meta.env.DEV,
+      process.env.NODE_ENV === ENV.DEVELOPMENT,
    ),
  ];
 };
@ -472,7 +473,7 @@ const chartTypeLine = (
      y,
      groupId,
      backgroundColor,
-      import.meta.env.DEV,
+      process.env.NODE_ENV === ENV.DEVELOPMENT,
    ),
    line,
    ...lines,
--- a/src/clipboard.ts
+++ b/src/clipboard.ts
@ -24,7 +24,6 @@ export interface ClipboardData {
  files?: BinaryFiles;
  text?: string;
  errorMessage?: string;
-  programmaticAPI?: boolean;
 }

 let CLIPBOARD = "";
@ -49,7 +48,6 @@ const clipboardContainsElements = (
    [
      EXPORT_DATA_TYPES.excalidraw,
      EXPORT_DATA_TYPES.excalidrawClipboard,
-      EXPORT_DATA_TYPES.excalidrawClipboardWithAPI,
    ].includes(contents?.type) &&
    Array.isArray(contents.elements)
  ) {
@ -193,8 +191,6 @@ export const parseClipboard = async (

  try {
    const systemClipboardData = JSON.parse(systemClipboard);
-    const programmaticAPI =
-      systemClipboardData.type === EXPORT_DATA_TYPES.excalidrawClipboardWithAPI;
    if (clipboardContainsElements(systemClipboardData)) {
      return {
        elements: systemClipboardData.elements,
@ -202,7 +198,6 @@ export const parseClipboard = async (
        text: isPlainPaste
          ? JSON.stringify(systemClipboardData.elements, null, 2)
          : undefined,
-        programmaticAPI,
      };
    }
  } catch (e) {}
--- a/src/colors.ts
+++ b/src/colors.ts
@ -21,7 +21,7 @@ export type ColorPickerColor =
 export type ColorTuple = readonly [string, string, string, string, string];
 export type ColorPalette = Merge<
  Record<ColorPickerColor, ColorTuple>,
-  { black: "#1e1e1e"; white: "#ffffff"; transparent: "transparent" }
+  { black: string; white: string; transparent: string }
 >;

 // used general type instead of specific type (ColorPalette) to support custom colors
--- a/src/components/Actions.tsx
+++ b/src/components/Actions.tsx
@ -36,7 +36,7 @@ import {

 import "./Actions.scss";
 import DropdownMenu from "./dropdownMenu/DropdownMenu";
-import { EmbedIcon, extraToolsIcon, frameToolIcon } from "./icons";
+import { extraToolsIcon, frameToolIcon } from "./icons";
 import { KEYS } from "../keys";

 export const SelectedShapeActions = ({
@ -266,7 +266,6 @@ export const ShapesSwitcher = ({
              });
              setAppState({
                activeTool: nextActiveTool,
-                activeEmbeddable: null,
                multiElement: null,
                selectedElementIds: {},
              });
@ -284,7 +283,6 @@ export const ShapesSwitcher = ({
      <div className="App-toolbar__divider" />
      {/* TEMP HACK because dropdown doesn't work well inside mobile toolbar */}
      {device.isMobile ? (
-        <>
        <ToolButton
          className={clsx("Shape", { fillable: false })}
          type="radio"
@ -315,41 +313,9 @@ export const ShapesSwitcher = ({
              activeTool: nextActiveTool,
              multiElement: null,
              selectedElementIds: {},
-                activeEmbeddable: null,
            });
          }}
        />
-          <ToolButton
-            className={clsx("Shape", { fillable: false })}
-            type="radio"
-            icon={EmbedIcon}
-            checked={activeTool.type === "embeddable"}
-            name="editor-current-shape"
-            title={capitalizeString(t("toolBar.embeddable"))}
-            aria-label={capitalizeString(t("toolBar.embeddable"))}
-            data-testid={`toolbar-embeddable`}
-            onPointerDown={({ pointerType }) => {
-              if (!appState.penDetected && pointerType === "pen") {
-                setAppState({
-                  penDetected: true,
-                  penMode: true,
-                });
-              }
-            }}
-            onChange={({ pointerType }) => {
-              trackEvent("toolbar", "embeddable", "ui");
-              const nextActiveTool = updateActiveTool(appState, {
-                type: "embeddable",
-              });
-              setAppState({
-                activeTool: nextActiveTool,
-                multiElement: null,
-                selectedElementIds: {},
-                activeEmbeddable: null,
-              });
-            }}
-          />
-        </>
      ) : (
        <DropdownMenu open={isExtraToolsMenuOpen}>
          <DropdownMenu.Trigger
@ -381,22 +347,6 @@ export const ShapesSwitcher = ({
            >
              {t("toolBar.frame")}
            </DropdownMenu.Item>
-            <DropdownMenu.Item
-              onSelect={() => {
-                const nextActiveTool = updateActiveTool(appState, {
-                  type: "embeddable",
-                });
-                setAppState({
-                  activeTool: nextActiveTool,
-                  multiElement: null,
-                  selectedElementIds: {},
-                });
-              }}
-              icon={EmbedIcon}
-              data-testid="toolbar-embeddable"
-            >
-              {t("toolBar.embeddable")}
-            </DropdownMenu.Item>
          </DropdownMenu.Content>
        </DropdownMenu>
      )}
--- a/src/components/App.test.tsx
+++ b/src/components/App.test.tsx
@ -4,9 +4,8 @@ import { reseed } from "../random";
 import { render, queryByTestId } from "../tests/test-utils";

 import ExcalidrawApp from "../excalidraw-app";
-import { vi } from "vitest";

-const renderScene = vi.spyOn(Renderer, "renderScene");
+const renderScene = jest.spyOn(Renderer, "renderScene");

 describe("Test <App/>", () => {
  beforeEach(async () => {
--- a/src/components/App.tsx
+++ b/src/components/App.tsx
--- a/src/components/ColorPicker/PickerColorList.tsx
+++ b/src/components/ColorPicker/PickerColorList.tsx
@ -8,7 +8,7 @@ import {
 } from "./colorPickerUtils";
 import HotkeyLabel from "./HotkeyLabel";
 import { ColorPaletteCustom } from "../../colors";
-import { TranslationKeys, t } from "../../i18n";
+import { t } from "../../i18n";

 interface PickerColorListProps {
  palette: ColorPaletteCustom;
@ -48,11 +48,7 @@ const PickerColorList = ({
          (Array.isArray(value) ? value[activeShade] : value) || "transparent";

        const keybinding = colorPickerHotkeyBindings[index];
-        const label = t(
-          `colors.${key.replace(/\d+/, "")}` as unknown as TranslationKeys,
-          null,
-          "",
-        );
+        const label = t(`colors.${key.replace(/\d+/, "")}`, null, "");

        return (
          <button
--- a/src/components/ContextMenu.tsx
+++ b/src/components/ContextMenu.tsx
@ -1,6 +1,6 @@
 import clsx from "clsx";
 import { Popover } from "./Popover";
-import { t, TranslationKeys } from "../i18n";
+import { t } from "../i18n";

 import "./ContextMenu.scss";
 import {
@ -82,15 +82,9 @@ export const ContextMenu = React.memo(
            let label = "";
            if (item.contextItemLabel) {
              if (typeof item.contextItemLabel === "function") {
-                label = t(
-                  item.contextItemLabel(
-                    elements,
-                    appState,
-                    actionManager.app,
-                  ) as unknown as TranslationKeys,
-                );
+                label = t(item.contextItemLabel(elements, appState));
              } else {
-                label = t(item.contextItemLabel as unknown as TranslationKeys);
+                label = t(item.contextItemLabel);
              }
            }

--- a/src/components/EyeDropper.tsx
+++ b/src/components/EyeDropper.tsx
@ -58,7 +58,7 @@ export const EyeDropper: React.FC<{
      return;
    }

-    let currentColor: string = COLOR_PALETTE.black;
+    let currentColor = COLOR_PALETTE.black;
    let isHoldingPointerDown = false;

    const ctx = app.canvas.getContext("2d")!;
@ -77,8 +77,8 @@ export const EyeDropper: React.FC<{
      colorPreviewDiv.style.left = `${clientX + 20}px`;

      const pixel = ctx.getImageData(
-        (clientX - appState.offsetLeft) * window.devicePixelRatio,
-        (clientY - appState.offsetTop) * window.devicePixelRatio,
+        clientX * window.devicePixelRatio - appState.offsetLeft,
+        clientY * window.devicePixelRatio - appState.offsetTop,
        1,
        1,
      ).data;
--- a/src/components/HintViewer.tsx
+++ b/src/components/HintViewer.tsx
@ -1,5 +1,7 @@
 import { t } from "../i18n";
-import { AppClassProperties, Device, UIAppState } from "../types";
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { getSelectedElements } from "../scene";
+import { Device, UIAppState } from "../types";
 import {
  isImageElement,
  isLinearElement,
@ -13,12 +15,17 @@ import "./HintViewer.scss";

 interface HintViewerProps {
  appState: UIAppState;
+  elements: readonly NonDeletedExcalidrawElement[];
  isMobile: boolean;
  device: Device;
-  app: AppClassProperties;
 }

-const getHints = ({ appState, isMobile, device, app }: HintViewerProps) => {
+const getHints = ({
+  appState,
+  elements,
+  isMobile,
+  device,
+}: HintViewerProps) => {
  const { activeTool, isResizing, isRotating, lastPointerDownWith } = appState;
  const multiMode = appState.multiElement !== null;

@ -44,15 +51,11 @@ const getHints = ({ appState, isMobile, device, app }: HintViewerProps) => {
    return t("hints.text");
  }

-  if (activeTool.type === "embeddable") {
-    return t("hints.embeddable");
-  }
-
  if (appState.activeTool.type === "image" && appState.pendingImageElementId) {
    return t("hints.placeImage");
  }

-  const selectedElements = app.scene.getSelectedElements(appState);
+  const selectedElements = getSelectedElements(elements, appState);

  if (
    isResizing &&
@ -112,15 +115,15 @@ const getHints = ({ appState, isMobile, device, app }: HintViewerProps) => {

 export const HintViewer = ({
  appState,
+  elements,
  isMobile,
  device,
-  app,
 }: HintViewerProps) => {
  let hint = getHints({
    appState,
+    elements,
    isMobile,
    device,
-    app,
  });
  if (!hint) {
    return null;
--- a/src/components/LayerUI.tsx
+++ b/src/components/LayerUI.tsx
@ -72,7 +72,6 @@ interface LayerUIProps {
  onExportImage: AppClassProperties["onExportImage"];
  renderWelcomeScreen: boolean;
  children?: React.ReactNode;
-  app: AppClassProperties;
 }

 const DefaultMainMenu: React.FC<{
@ -128,7 +127,6 @@ const LayerUI = ({
  onExportImage,
  renderWelcomeScreen,
  children,
-  app,
 }: LayerUIProps) => {
  const device = useDevice();
  const tunnels = useInitializeTunnels();
@ -242,9 +240,9 @@ const LayerUI = ({
                      >
                        <HintViewer
                          appState={appState}
+                          elements={elements}
                          isMobile={device.isMobile}
                          device={device}
-                          app={app}
                        />
                        {heading}
                        <Stack.Row gap={1}>
@ -403,7 +401,6 @@ const LayerUI = ({
      )}
      {device.isMobile && (
        <MobileMenu
-          app={app}
          appState={appState}
          elements={elements}
          actionManager={actionManager}
--- a/src/components/LibraryMenu.tsx
+++ b/src/components/LibraryMenu.tsx
@ -29,7 +29,6 @@ import "./LibraryMenu.scss";
 import { LibraryMenuControlButtons } from "./LibraryMenuControlButtons";
 import { isShallowEqual } from "../utils";
 import { NonDeletedExcalidrawElement } from "../element/types";
-import { LIBRARY_DISABLED_TYPES } from "../constants";

 export const isLibraryMenuOpenAtom = atom(false);

@ -69,13 +68,12 @@ export const LibraryMenuContent = ({
        libraryItems: LibraryItems,
      ) => {
        trackEvent("element", "addToLibrary", "ui");
-        for (const type of LIBRARY_DISABLED_TYPES) {
-          if (processedElements.some((element) => element.type === type)) {
+        if (processedElements.some((element) => element.type === "image")) {
          return setAppState({
-              errorMessage: t(`errors.libraryElementTypeError.${type}`),
+            errorMessage:
+              "Support for adding images to the library coming soon!",
          });
        }
-        }
        const nextItems: LibraryItems = [
          {
            status: "unpublished",
@ -199,7 +197,6 @@ export const LibraryMenu = () => {
    setAppState({
      selectedElementIds: {},
      selectedGroupIds: {},
-      activeEmbeddable: null,
    });
  }, [setAppState]);

--- a/src/components/LibraryMenuBrowseButton.tsx
+++ b/src/components/LibraryMenuBrowseButton.tsx
@ -16,7 +16,7 @@ const LibraryMenuBrowseButton = ({
  return (
    <a
      className="library-menu-browse-button"
-      href={`${import.meta.env.VITE_APP_LIBRARY_URL}?target=${
+      href={`${process.env.REACT_APP_LIBRARY_URL}?target=${
        window.name || "_blank"
      }&referrer=${referrer}&useHash=true&token=${id}&theme=${theme}&version=${
        VERSIONS.excalidrawLibrary
--- a/src/components/LibraryUnit.scss
+++ b/src/components/LibraryUnit.scss
@ -12,11 +12,6 @@
    box-sizing: border-box;
    border-radius: var(--border-radius-lg);

-    svg {
-      // to prevent clicks on links and such
-      pointer-events: none;
-    }
-
    &--hover {
      border-color: var(--color-primary);
    }
--- a/src/components/MobileMenu.tsx
+++ b/src/components/MobileMenu.tsx
@ -1,11 +1,5 @@
 import React from "react";
-import {
-  AppClassProperties,
-  AppState,
-  Device,
-  ExcalidrawProps,
-  UIAppState,
-} from "../types";
+import { AppState, Device, ExcalidrawProps, UIAppState } from "../types";
 import { ActionManager } from "../actions/manager";
 import { t } from "../i18n";
 import Stack from "./Stack";
@ -47,7 +41,6 @@ type MobileMenuProps = {
  renderSidebars: () => JSX.Element | null;
  device: Device;
  renderWelcomeScreen: boolean;
-  app: AppClassProperties;
 };

 export const MobileMenu = ({
@ -65,7 +58,6 @@ export const MobileMenu = ({
  renderSidebars,
  device,
  renderWelcomeScreen,
-  app,
 }: MobileMenuProps) => {
  const {
    WelcomeScreenCenterTunnel,
@ -127,9 +119,9 @@ export const MobileMenu = ({
        </Section>
        <HintViewer
          appState={appState}
+          elements={elements}
          isMobile={true}
          device={device}
-          app={app}
        />
      </FixedSideContainer>
    );
--- a/src/components/PublishLibrary.tsx
+++ b/src/components/PublishLibrary.tsx
@ -319,7 +319,7 @@ const PublishLibrary = ({
    formData.append("twitterHandle", libraryData.twitterHandle);
    formData.append("website", libraryData.website);

-    fetch(`${import.meta.env.VITE_APP_LIBRARY_BACKEND}/submit`, {
+    fetch(`${process.env.REACT_APP_LIBRARY_BACKEND}/submit`, {
      method: "post",
      body: formData,
    })
--- a/src/components/Section.tsx
+++ b/src/components/Section.tsx
@ -3,7 +3,7 @@ import { t } from "../i18n";
 import { useExcalidrawContainer } from "./App";

 export const Section: React.FC<{
-  heading: "canvasActions" | "selectedShapeActions" | "shapes";
+  heading: string;
  children?: React.ReactNode | ((heading: React.ReactNode) => React.ReactNode);
  className?: string;
 }> = ({ heading, children, ...props }) => {
--- a/src/components/Sidebar/Sidebar.test.tsx
+++ b/src/components/Sidebar/Sidebar.test.tsx
@ -10,7 +10,6 @@ import {
  waitFor,
  withExcalidrawDimensions,
 } from "../../tests/test-utils";
-import { vi } from "vitest";

 export const assertSidebarDockButton = async <T extends boolean>(
  hasDockButton: T,
@ -206,7 +205,7 @@ describe("Sidebar", () => {
    });

    it("<Sidebar.Header> should render close button", async () => {
-      const onStateChange = vi.fn();
+      const onStateChange = jest.fn();
      const CustomExcalidraw = () => {
        return (
          <Excalidraw
--- a/src/components/Sidebar/Sidebar.tsx
+++ b/src/components/Sidebar/Sidebar.tsx
@ -53,7 +53,7 @@ export const SidebarInner = forwardRef(
    }: SidebarProps & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">,
    ref: React.ForwardedRef<HTMLDivElement>,
  ) => {
-    if (import.meta.env.DEV && onDock && docked == null) {
+    if (process.env.NODE_ENV === "development" && onDock && docked == null) {
      console.warn(
        "Sidebar: `docked` must be set when `onDock` is supplied for the sidebar to be user-dockable. To hide this message, either pass `docked` or remove `onDock`",
      );
--- a/src/components/Trans.test.tsx
+++ b/src/components/Trans.test.tsx
@ -3,7 +3,6 @@ import { render } from "@testing-library/react";
 import fallbackLangData from "../locales/en.json";

 import Trans from "./Trans";
-import { TranslationKeys } from "../i18n";

 describe("Test <Trans/>", () => {
  it("should translate the the strings correctly", () => {
@ -19,27 +18,24 @@ describe("Test <Trans/>", () => {
    const { getByTestId } = render(
      <>
        <div data-testid="test1">
-          <Trans
-            i18nKey={"transTest.key1" as unknown as TranslationKeys}
-            audience="world"
-          />
+          <Trans i18nKey="transTest.key1" audience="world" />
        </div>
        <div data-testid="test2">
          <Trans
-            i18nKey={"transTest.key2" as unknown as TranslationKeys}
+            i18nKey="transTest.key2"
            link={(el) => <a href="https://example.com">{el}</a>}
          />
        </div>
        <div data-testid="test3">
          <Trans
-            i18nKey={"transTest.key3" as unknown as TranslationKeys}
+            i18nKey="transTest.key3"
            link={(el) => <a href="https://example.com">{el}</a>}
            location="the button"
          />
        </div>
        <div data-testid="test4">
          <Trans
-            i18nKey={"transTest.key4" as unknown as TranslationKeys}
+            i18nKey="transTest.key4"
            link={(el) => <a href="https://example.com">{el}</a>}
            location="the button"
            bold={(el) => <strong>{el}</strong>}
@ -47,7 +43,7 @@ describe("Test <Trans/>", () => {
        </div>
        <div data-testid="test5">
          <Trans
-            i18nKey={"transTest.key5" as unknown as TranslationKeys}
+            i18nKey="transTest.key5"
            connect-link={(el) => <a href="https://example.com">{el}</a>}
          />
        </div>
--- a/src/components/Trans.tsx
+++ b/src/components/Trans.tsx
@ -1,6 +1,6 @@
 import React from "react";

-import { TranslationKeys, useI18n } from "../i18n";
+import { useI18n } from "../i18n";

 // Used for splitting i18nKey into tokens in Trans component
 // Example:
@ -153,7 +153,7 @@ const Trans = ({
  children,
  ...props
 }: {
-  i18nKey: TranslationKeys;
+  i18nKey: string;
  [key: string]: React.ReactNode | ((el: React.ReactNode) => React.ReactNode);
 }) => {
  const { t } = useI18n();
--- a/src/components/snapshots/App.test.tsx.snap
+++ b/src/components/snapshots/App.test.tsx.snap
@ -1,6 +1,6 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+// Jest Snapshot v1, https://goo.gl/fbAQLP

-exports[`Test <App/> > should show error modal when using brave and measureText API is not working 1`] = `
+exports[`Test <App/> should show error modal when using brave and measureText API is not working 1`] = `
 <div
  data-testid="brave-measure-text-error"
 >
--- a/src/components/icons.tsx
+++ b/src/components/icons.tsx
@ -396,14 +396,6 @@ export const TrashIcon = createIcon(
  modifiedTablerIconProps,
 );

-export const EmbedIcon = createIcon(
-  <g strokeWidth="1.25">
-    <polyline points="12 16 18 10 12 4" />
-    <polyline points="8 4 2 10 8 16" />
-  </g>,
-  modifiedTablerIconProps,
-);
-
 export const DuplicateIcon = createIcon(
  <g strokeWidth="1.25">
    <path d="M14.375 6.458H8.958a2.5 2.5 0 0 0-2.5 2.5v5.417a2.5 2.5 0 0 0 2.5 2.5h5.417a2.5 2.5 0 0 0 2.5-2.5V8.958a2.5 2.5 0 0 0-2.5-2.5Z" />
@ -1628,11 +1620,18 @@ export const alertTriangleIcon = createIcon(

 export const eyeDropperIcon = createIcon(
  <g strokeWidth={1.25}>
-    <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
-    <path d="M11 7l6 6"></path>
-    <path d="M4 16l11.7 -11.7a1 1 0 0 1 1.4 0l2.6 2.6a1 1 0 0 1 0 1.4l-11.7 11.7h-4v-4z"></path>
+    <path d="m9.168 5.833 5 5M9.999 6.667l-6.667 6.666v3.334h3.333L13.332 10M9.999 6.667l3.083-3.084a.833.833 0 0 1 1.167 0l2.166 2.167a.833.833 0 0 1 0 1.167L13.332 10M9.999 6.667 13.332 10" />
+    <rect
+      x="13.684"
+      y="2.976"
+      width="4.751"
+      height="5.106"
+      rx="1"
+      transform="rotate(45 13.684 2.976)"
+      fill="currentColor"
+    />
  </g>,
-  tablerIconProps,
+  modifiedTablerIconProps,
 );

 export const extraToolsIcon = createIcon(
--- a/src/components/main-menu/DefaultItems.tsx
+++ b/src/components/main-menu/DefaultItems.tsx
@ -4,7 +4,6 @@ import {
  useExcalidrawSetAppState,
  useExcalidrawActionManager,
  useExcalidrawElements,
-  useAppProps,
 } from "../App";
 import {
  ExportIcon,
@ -199,20 +198,13 @@ export const ChangeCanvasBackground = () => {
  const { t } = useI18n();
  const appState = useUIAppState();
  const actionManager = useExcalidrawActionManager();
-  const appProps = useAppProps();

-  if (
-    appState.viewModeEnabled ||
-    !appProps.UIOptions.canvasActions.changeViewBackgroundColor
-  ) {
+  if (appState.viewModeEnabled) {
    return null;
  }
  return (
    <div style={{ marginTop: "0.5rem" }}>
-      <div
-        data-testid="canvas-background-label"
-        style={{ fontSize: ".75rem", marginBottom: ".5rem" }}
-      >
+      <div style={{ fontSize: ".75rem", marginBottom: ".5rem" }}>
        {t("labels.canvasBackground")}
      </div>
      <div style={{ padding: "0 0.625rem" }}>
--- a/src/constants.ts
+++ b/src/constants.ts
@ -71,18 +71,8 @@ export enum EVENT {
  // custom events
  EXCALIDRAW_LINK = "excalidraw-link",
  MENU_ITEM_SELECT = "menu.itemSelect",
-  MESSAGE = "message",
 }

-export const YOUTUBE_STATES = {
-  UNSTARTED: -1,
-  ENDED: 0,
-  PLAYING: 1,
-  PAUSED: 2,
-  BUFFERING: 3,
-  CUED: 5,
-} as const;
-
 export const ENV = {
  TEST: "test",
  DEVELOPMENT: "development",
@ -102,7 +92,7 @@ export const FONT_FAMILY = {
 export const THEME = {
  LIGHT: "light",
  DARK: "dark",
-} as const;
+};

 export const FRAME_STYLE = {
  strokeColor: "#bbb" as ExcalidrawElement["strokeColor"],
@ -117,7 +107,6 @@ export const FRAME_STYLE = {

 export const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";

-export const MIN_FONT_SIZE = 1;
 export const DEFAULT_FONT_SIZE = 20;
 export const DEFAULT_FONT_FAMILY: FontFamilyValues = FONT_FAMILY.Virgil;
 export const DEFAULT_TEXT_ALIGN = "left";
@ -164,7 +153,6 @@ export const EXPORT_DATA_TYPES = {
  excalidraw: "excalidraw",
  excalidrawClipboard: "excalidraw/clipboard",
  excalidrawLibrary: "excalidrawlib",
-  excalidrawClipboardWithAPI: "excalidraw-api/clipboard",
 } as const;

 export const EXPORT_SOURCE =
@ -241,8 +229,6 @@ export const VERSIONS = {
 } as const;

 export const BOUND_TEXT_PADDING = 5;
-export const ARROW_LABEL_WIDTH_FRACTION = 0.7;
-export const ARROW_LABEL_FONT_SIZE_TO_MIN_WIDTH_RATIO = 11;

 export const VERTICAL_ALIGN = {
  TOP: "top",
@ -314,5 +300,3 @@ export const DEFAULT_SIDEBAR = {
  name: "default",
  defaultTab: LIBRARY_SIDEBAR_TAB,
 } as const;
-
-export const LIBRARY_DISABLED_TYPES = new Set(["embeddable", "image"] as const);
--- a/src/css/styles.scss
+++ b/src/css/styles.scss
@ -77,19 +77,6 @@
    position: absolute;
  }

-  &__embeddable {
-    width: 100%;
-    height: 100%;
-    border: 0;
-  }
-
-  &__embeddable-container {
-    position: absolute;
-    z-index: 2;
-    transform-origin: top left;
-    pointer-events: none;
-  }
-
  &.theme--dark {
    // The percentage is inspired by
    // https://material.io/design/color/dark-theme.html#properties, which
@ -674,33 +661,3 @@
    }
  }
 }
-
-.excalidraw__embeddable-container {
-  .excalidraw__embeddable-container__inner {
-    overflow: hidden;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    border-radius: var(--embeddable-radius);
-  }
-
-  .excalidraw__embeddable__outer {
-    width: 100%;
-    height: 100%;
-    & > * {
-      border-radius: var(--embeddable-radius);
-    }
-  }
-
-  .excalidraw__embeddable-hint {
-    position: absolute;
-    z-index: 1;
-    background: rgba(0, 0, 0, 0.5);
-    padding: 1rem 1.6rem;
-    border-radius: 12px;
-    color: #fff;
-    font-weight: bold;
-    letter-spacing: 0.6px;
-    font-family: "Assistant";
-  }
-}
--- a/src/data/snapshots/transform.test.ts.snap
+++ b/src/data/snapshots/transform.test.ts.snap
--- a/src/data/restore.ts
+++ b/src/data/restore.ts
@ -3,7 +3,6 @@ import {
  ExcalidrawSelectionElement,
  ExcalidrawTextElement,
  FontFamilyValues,
-  PointBinding,
  StrokeRoundness,
 } from "../element/types";
 import {
@ -29,7 +28,6 @@ import {
  FONT_FAMILY,
  ROUNDNESS,
  DEFAULT_SIDEBAR,
-  DEFAULT_ELEMENT_PROPS,
 } from "../constants";
 import { getDefaultAppState } from "../appState";
 import { LinearElementEditor } from "../element/linearElementEditor";
@ -42,6 +40,7 @@ import {
  getDefaultLineHeight,
  measureBaseline,
 } from "../element/textElement";
+import { COLOR_PALETTE } from "../colors";
 import { normalizeLink } from "./url";

 type RestoredAppState = Omit<
@ -65,7 +64,6 @@ export const AllowedExcalidrawActiveTools: Record<
  eraser: false,
  custom: true,
  frame: true,
-  embeddable: true,
  hand: true,
 };

@ -84,13 +82,6 @@ const getFontFamilyByName = (fontFamilyName: string): FontFamilyValues => {
  return DEFAULT_FONT_FAMILY;
 };

-const repairBinding = (binding: PointBinding | null) => {
-  if (!binding) {
-    return null;
-  }
-  return { ...binding, focus: binding.focus || 0 };
-};
-
 const restoreElementWithProperties = <
  T extends Required<Omit<ExcalidrawElement, "customData">> & {
    customData?: ExcalidrawElement["customData"];
@ -122,18 +113,16 @@ const restoreElementWithProperties = <
    versionNonce: element.versionNonce ?? 0,
    isDeleted: element.isDeleted ?? false,
    id: element.id || randomId(),
-    fillStyle: element.fillStyle || DEFAULT_ELEMENT_PROPS.fillStyle,
-    strokeWidth: element.strokeWidth || DEFAULT_ELEMENT_PROPS.strokeWidth,
-    strokeStyle: element.strokeStyle ?? DEFAULT_ELEMENT_PROPS.strokeStyle,
-    roughness: element.roughness ?? DEFAULT_ELEMENT_PROPS.roughness,
-    opacity:
-      element.opacity == null ? DEFAULT_ELEMENT_PROPS.opacity : element.opacity,
+    fillStyle: element.fillStyle || "hachure",
+    strokeWidth: element.strokeWidth || 1,
+    strokeStyle: element.strokeStyle ?? "solid",
+    roughness: element.roughness ?? 1,
+    opacity: element.opacity == null ? 100 : element.opacity,
    angle: element.angle || 0,
    x: extra.x ?? element.x ?? 0,
    y: extra.y ?? element.y ?? 0,
-    strokeColor: element.strokeColor || DEFAULT_ELEMENT_PROPS.strokeColor,
-    backgroundColor:
-      element.backgroundColor || DEFAULT_ELEMENT_PROPS.backgroundColor,
+    strokeColor: element.strokeColor || COLOR_PALETTE.black,
+    backgroundColor: element.backgroundColor || COLOR_PALETTE.transparent,
    width: element.width || 0,
    height: element.height || 0,
    seed: element.seed ?? 1,
@ -248,6 +237,7 @@ const restoreElement = (
        startArrowhead = null,
        endArrowhead = element.type === "arrow" ? "arrow" : null,
      } = element;
+
      let x = element.x;
      let y = element.y;
      let points = // migrate old arrow model to new one
@ -267,8 +257,8 @@ const restoreElement = (
          (element.type as ExcalidrawElement["type"] | "draw") === "draw"
            ? "line"
            : element.type,
-        startBinding: repairBinding(element.startBinding),
-        endBinding: repairBinding(element.endBinding),
+        startBinding: element.startBinding,
+        endBinding: element.endBinding,
        lastCommittedPoint: null,
        startArrowhead,
        endArrowhead,
@ -285,10 +275,6 @@ const restoreElement = (
      return restoreElementWithProperties(element, {});
    case "diamond":
      return restoreElementWithProperties(element, {});
-    case "embeddable":
-      return restoreElementWithProperties(element, {
-        validated: null,
-      });
    case "frame":
      return restoreElementWithProperties(element, {
        name: element.name ?? null,
@ -411,6 +397,7 @@ export const restoreElements = (
 ): ExcalidrawElement[] => {
  // used to detect duplicate top-level element ids
  const existingIds = new Set<string>();
+
  const localElementsMap = localElements ? arrayToMap(localElements) : null;
  const restoredElements = (elements || []).reduce((elements, element) => {
    // filtering out selection, which is legacy, no longer kept in elements,
@ -429,7 +416,6 @@ export const restoreElements = (
          migratedElement = { ...migratedElement, id: randomId() };
        }
        existingIds.add(migratedElement.id);
-
        elements.push(migratedElement);
      }
    }
--- a/src/data/transform.test.ts
+++ b/src/data/transform.test.ts
@ -1,706 +0,0 @@
-import { vi } from "vitest";
-import {
-  ExcalidrawElementSkeleton,
-  convertToExcalidrawElements,
-} from "./transform";
-import { ExcalidrawArrowElement } from "../element/types";
-
-describe("Test Transform", () => {
-  it("should transform regular shapes", () => {
-    const elements = [
-      {
-        type: "rectangle",
-        x: 100,
-        y: 100,
-      },
-      {
-        type: "ellipse",
-        x: 100,
-        y: 250,
-      },
-      {
-        type: "diamond",
-        x: 100,
-        y: 400,
-      },
-      {
-        type: "rectangle",
-        x: 300,
-        y: 100,
-        width: 200,
-        height: 100,
-        backgroundColor: "#c0eb75",
-        strokeWidth: 2,
-      },
-      {
-        type: "ellipse",
-        x: 300,
-        y: 250,
-        width: 200,
-        height: 100,
-        backgroundColor: "#ffc9c9",
-        strokeStyle: "dotted",
-        fillStyle: "solid",
-        strokeWidth: 2,
-      },
-      {
-        type: "diamond",
-        x: 300,
-        y: 400,
-        width: 200,
-        height: 100,
-        backgroundColor: "#a5d8ff",
-        strokeColor: "#1971c2",
-        strokeStyle: "dashed",
-        fillStyle: "cross-hatch",
-        strokeWidth: 2,
-      },
-    ];
-
-    convertToExcalidrawElements(
-      elements as ExcalidrawElementSkeleton[],
-    ).forEach((ele) => {
-      expect(ele).toMatchSnapshot({
-        seed: expect.any(Number),
-        versionNonce: expect.any(Number),
-        id: expect.any(String),
-      });
-    });
-  });
-
-  it("should transform text element", () => {
-    const elements = [
-      {
-        type: "text",
-        x: 100,
-        y: 100,
-        text: "HELLO WORLD!",
-      },
-      {
-        type: "text",
-        x: 100,
-        y: 150,
-        text: "STYLED HELLO WORLD!",
-        fontSize: 20,
-        strokeColor: "#5f3dc4",
-      },
-    ];
-    convertToExcalidrawElements(
-      elements as ExcalidrawElementSkeleton[],
-    ).forEach((ele) => {
-      expect(ele).toMatchSnapshot({
-        seed: expect.any(Number),
-        versionNonce: expect.any(Number),
-        id: expect.any(String),
-      });
-    });
-  });
-
-  it("should transform linear elements", () => {
-    const elements = [
-      {
-        type: "arrow",
-        x: 100,
-        y: 20,
-      },
-      {
-        type: "arrow",
-        x: 450,
-        y: 20,
-        startArrowhead: "dot",
-        endArrowhead: "triangle",
-        strokeColor: "#1971c2",
-        strokeWidth: 2,
-      },
-      {
-        type: "line",
-        x: 100,
-        y: 60,
-      },
-      {
-        type: "line",
-        x: 450,
-        y: 60,
-        strokeColor: "#2f9e44",
-        strokeWidth: 2,
-        strokeStyle: "dotted",
-      },
-    ];
-    const excaldrawElements = convertToExcalidrawElements(
-      elements as ExcalidrawElementSkeleton[],
-    );
-
-    expect(excaldrawElements.length).toBe(4);
-
-    excaldrawElements.forEach((ele) => {
-      expect(ele).toMatchSnapshot({
-        seed: expect.any(Number),
-        versionNonce: expect.any(Number),
-        id: expect.any(String),
-      });
-    });
-  });
-
-  it("should transform to text containers when label provided", () => {
-    const elements = [
-      {
-        type: "rectangle",
-        x: 100,
-        y: 100,
-        label: {
-          text: "RECTANGLE TEXT CONTAINER",
-        },
-      },
-      {
-        type: "ellipse",
-        x: 500,
-        y: 100,
-        width: 200,
-        label: {
-          text: "ELLIPSE TEXT CONTAINER",
-        },
-      },
-      {
-        type: "diamond",
-        x: 100,
-        y: 150,
-        width: 280,
-        label: {
-          text: "DIAMOND\nTEXT CONTAINER",
-        },
-      },
-      {
-        type: "diamond",
-        x: 100,
-        y: 400,
-        width: 300,
-        backgroundColor: "#fff3bf",
-        strokeWidth: 2,
-        label: {
-          text: "STYLED DIAMOND TEXT CONTAINER",
-          strokeColor: "#099268",
-          fontSize: 20,
-        },
-      },
-      {
-        type: "rectangle",
-        x: 500,
-        y: 300,
-        width: 200,
-        strokeColor: "#c2255c",
-        label: {
-          text: "TOP LEFT ALIGNED RECTANGLE TEXT CONTAINER",
-          textAlign: "left",
-          verticalAlign: "top",
-          fontSize: 20,
-        },
-      },
-      {
-        type: "ellipse",
-        x: 500,
-        y: 500,
-        strokeColor: "#f08c00",
-        backgroundColor: "#ffec99",
-        width: 200,
-        label: {
-          text: "STYLED ELLIPSE TEXT CONTAINER",
-          strokeColor: "#c2255c",
-        },
-      },
-    ];
-    const excaldrawElements = convertToExcalidrawElements(
-      elements as ExcalidrawElementSkeleton[],
-    );
-
-    expect(excaldrawElements.length).toBe(12);
-
-    excaldrawElements.forEach((ele) => {
-      expect(ele).toMatchSnapshot({
-        seed: expect.any(Number),
-        versionNonce: expect.any(Number),
-        id: expect.any(String),
-      });
-    });
-  });
-
-  it("should transform to labelled arrows when label provided for arrows", () => {
-    const elements = [
-      {
-        type: "arrow",
-        x: 100,
-        y: 100,
-        label: {
-          text: "LABELED ARROW",
-        },
-      },
-      {
-        type: "arrow",
-        x: 100,
-        y: 200,
-        label: {
-          text: "STYLED LABELED ARROW",
-          strokeColor: "#099268",
-          fontSize: 20,
-        },
-      },
-      {
-        type: "arrow",
-        x: 100,
-        y: 300,
-        strokeColor: "#1098ad",
-        strokeWidth: 2,
-        label: {
-          text: "ANOTHER STYLED LABELLED ARROW",
-        },
-      },
-      {
-        type: "arrow",
-        x: 100,
-        y: 400,
-        strokeColor: "#1098ad",
-        strokeWidth: 2,
-        label: {
-          text: "ANOTHER STYLED LABELLED ARROW",
-          strokeColor: "#099268",
-        },
-      },
-    ];
-    const excaldrawElements = convertToExcalidrawElements(
-      elements as ExcalidrawElementSkeleton[],
-    );
-
-    expect(excaldrawElements.length).toBe(8);
-
-    excaldrawElements.forEach((ele) => {
-      expect(ele).toMatchSnapshot({
-        seed: expect.any(Number),
-        versionNonce: expect.any(Number),
-        id: expect.any(String),
-      });
-    });
-  });
-
-  describe("Test arrow bindings", () => {
-    it("should bind arrows to shapes when start / end provided without ids", () => {
-      const elements = [
-        {
-          type: "arrow",
-          x: 255,
-          y: 239,
-          label: {
-            text: "HELLO WORLD!!",
-          },
-          start: {
-            type: "rectangle",
-          },
-          end: {
-            type: "ellipse",
-          },
-        },
-      ];
-      const excaldrawElements = convertToExcalidrawElements(
-        elements as ExcalidrawElementSkeleton[],
-      );
-
-      expect(excaldrawElements.length).toBe(4);
-      const [arrow, text, rectangle, ellipse] = excaldrawElements;
-      expect(arrow).toMatchObject({
-        type: "arrow",
-        x: 255,
-        y: 239,
-        boundElements: [{ id: text.id, type: "text" }],
-        startBinding: {
-          elementId: rectangle.id,
-          focus: 0,
-          gap: 1,
-        },
-        endBinding: {
-          elementId: ellipse.id,
-          focus: 0,
-        },
-      });
-
-      expect(text).toMatchObject({
-        x: 340,
-        y: 226.5,
-        type: "text",
-        text: "HELLO WORLD!!",
-        containerId: arrow.id,
-      });
-
-      expect(rectangle).toMatchObject({
-        x: 155,
-        y: 189,
-        type: "rectangle",
-        boundElements: [
-          {
-            id: arrow.id,
-            type: "arrow",
-          },
-        ],
-      });
-
-      expect(ellipse).toMatchObject({
-        x: 555,
-        y: 189,
-        type: "ellipse",
-        boundElements: [
-          {
-            id: arrow.id,
-            type: "arrow",
-          },
-        ],
-      });
-
-      excaldrawElements.forEach((ele) => {
-        expect(ele).toMatchSnapshot({
-          seed: expect.any(Number),
-          versionNonce: expect.any(Number),
-          id: expect.any(String),
-        });
-      });
-    });
-
-    it("should bind arrows to text when start / end provided without ids", () => {
-      const elements = [
-        {
-          type: "arrow",
-          x: 255,
-          y: 239,
-          label: {
-            text: "HELLO WORLD!!",
-          },
-          start: {
-            type: "text",
-            text: "HEYYYYY",
-          },
-          end: {
-            type: "text",
-            text: "WHATS UP ?",
-          },
-        },
-      ];
-
-      const excaldrawElements = convertToExcalidrawElements(
-        elements as ExcalidrawElementSkeleton[],
-      );
-
-      expect(excaldrawElements.length).toBe(4);
-
-      const [arrow, text1, text2, text3] = excaldrawElements;
-
-      expect(arrow).toMatchObject({
-        type: "arrow",
-        x: 255,
-        y: 239,
-        boundElements: [{ id: text1.id, type: "text" }],
-        startBinding: {
-          elementId: text2.id,
-          focus: 0,
-          gap: 1,
-        },
-        endBinding: {
-          elementId: text3.id,
-          focus: 0,
-        },
-      });
-
-      expect(text1).toMatchObject({
-        x: 340,
-        y: 226.5,
-        type: "text",
-        text: "HELLO WORLD!!",
-        containerId: arrow.id,
-      });
-
-      expect(text2).toMatchObject({
-        x: 185,
-        y: 226.5,
-        type: "text",
-        boundElements: [
-          {
-            id: arrow.id,
-            type: "arrow",
-          },
-        ],
-      });
-
-      expect(text3).toMatchObject({
-        x: 555,
-        y: 226.5,
-        type: "text",
-        boundElements: [
-          {
-            id: arrow.id,
-            type: "arrow",
-          },
-        ],
-      });
-
-      excaldrawElements.forEach((ele) => {
-        expect(ele).toMatchSnapshot({
-          seed: expect.any(Number),
-          versionNonce: expect.any(Number),
-          id: expect.any(String),
-        });
-      });
-    });
-
-    it("should bind arrows to existing shapes when start / end provided with ids", () => {
-      const elements = [
-        {
-          type: "ellipse",
-          id: "ellipse-1",
-          strokeColor: "#66a80f",
-          x: 630,
-          y: 316,
-          width: 300,
-          height: 300,
-          backgroundColor: "#d8f5a2",
-        },
-        {
-          type: "diamond",
-          id: "diamond-1",
-          strokeColor: "#9c36b5",
-          width: 140,
-          x: 96,
-          y: 400,
-        },
-        {
-          type: "arrow",
-          x: 247,
-          y: 420,
-          width: 395,
-          height: 35,
-          strokeColor: "#1864ab",
-          start: {
-            type: "rectangle",
-            width: 300,
-            height: 300,
-          },
-          end: {
-            id: "ellipse-1",
-          },
-        },
-        {
-          type: "arrow",
-          x: 227,
-          y: 450,
-          width: 400,
-          strokeColor: "#e67700",
-          start: {
-            id: "diamond-1",
-          },
-          end: {
-            id: "ellipse-1",
-          },
-        },
-      ];
-
-      const excaldrawElements = convertToExcalidrawElements(
-        elements as ExcalidrawElementSkeleton[],
-      );
-
-      expect(excaldrawElements.length).toBe(5);
-
-      excaldrawElements.forEach((ele) => {
-        expect(ele).toMatchSnapshot({
-          seed: expect.any(Number),
-          versionNonce: expect.any(Number),
-          id: expect.any(String),
-        });
-      });
-    });
-
-    it("should bind arrows to existing text elements when start / end provided with ids", () => {
-      const elements = [
-        {
-          x: 100,
-          y: 239,
-          type: "text",
-          text: "HEYYYYY",
-          id: "text-1",
-          strokeColor: "#c2255c",
-        },
-        {
-          type: "text",
-          id: "text-2",
-          x: 560,
-          y: 239,
-          text: "Whats up ?",
-        },
-        {
-          type: "arrow",
-          x: 255,
-          y: 239,
-          label: {
-            text: "HELLO WORLD!!",
-          },
-          start: {
-            id: "text-1",
-          },
-          end: {
-            id: "text-2",
-          },
-        },
-      ];
-
-      const excaldrawElements = convertToExcalidrawElements(
-        elements as ExcalidrawElementSkeleton[],
-      );
-
-      expect(excaldrawElements.length).toBe(4);
-
-      excaldrawElements.forEach((ele) => {
-        expect(ele).toMatchSnapshot({
-          seed: expect.any(Number),
-          versionNonce: expect.any(Number),
-          id: expect.any(String),
-        });
-      });
-    });
-
-    it("should bind arrows to existing elements if ids are correct", () => {
-      const consoleErrorSpy = vi
-        .spyOn(console, "error")
-        .mockImplementationOnce(() => void 0);
-      const elements = [
-        {
-          x: 100,
-          y: 239,
-          type: "text",
-          text: "HEYYYYY",
-          id: "text-1",
-          strokeColor: "#c2255c",
-        },
-        {
-          type: "rectangle",
-          x: 560,
-          y: 139,
-          id: "rect-1",
-          width: 100,
-          height: 200,
-          backgroundColor: "#bac8ff",
-        },
-        {
-          type: "arrow",
-          x: 255,
-          y: 239,
-          label: {
-            text: "HELLO WORLD!!",
-          },
-          start: {
-            id: "text-13",
-          },
-          end: {
-            id: "rect-11",
-          },
-        },
-      ];
-
-      const excaldrawElements = convertToExcalidrawElements(
-        elements as ExcalidrawElementSkeleton[],
-      );
-
-      expect(excaldrawElements.length).toBe(4);
-      const [, , arrow] = excaldrawElements;
-      expect(arrow).toMatchObject({
-        type: "arrow",
-        x: 255,
-        y: 239,
-        boundElements: [
-          {
-            id: "id46",
-            type: "text",
-          },
-        ],
-        startBinding: null,
-        endBinding: null,
-      });
-      expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
-      expect(consoleErrorSpy).toHaveBeenNthCalledWith(
-        1,
-        "No element for start binding with id text-13 found",
-      );
-      expect(consoleErrorSpy).toHaveBeenNthCalledWith(
-        2,
-        "No element for end binding with id rect-11 found",
-      );
-    });
-
-    it("should bind when ids referenced before the element data", () => {
-      const elements = [
-        {
-          type: "arrow",
-          x: 255,
-          y: 239,
-          end: {
-            id: "rect-1",
-          },
-        },
-        {
-          type: "rectangle",
-          x: 560,
-          y: 139,
-          id: "rect-1",
-          width: 100,
-          height: 200,
-          backgroundColor: "#bac8ff",
-        },
-      ];
-      const excaldrawElements = convertToExcalidrawElements(
-        elements as ExcalidrawElementSkeleton[],
-      );
-      expect(excaldrawElements.length).toBe(2);
-      const [arrow, rect] = excaldrawElements;
-      expect((arrow as ExcalidrawArrowElement).endBinding).toStrictEqual({
-        elementId: "rect-1",
-        focus: 0,
-        gap: 5,
-      });
-      expect(rect.boundElements).toStrictEqual([
-        {
-          id: "id47",
-          type: "arrow",
-        },
-      ]);
-    });
-  });
-
-  it("should not allow duplicate ids", () => {
-    const consoleErrorSpy = vi
-      .spyOn(console, "error")
-      .mockImplementationOnce(() => void 0);
-    const elements = [
-      {
-        type: "rectangle",
-        x: 300,
-        y: 100,
-        id: "rect-1",
-        width: 100,
-        height: 200,
-      },
-
-      {
-        type: "rectangle",
-        x: 100,
-        y: 200,
-        id: "rect-1",
-        width: 100,
-        height: 200,
-      },
-    ];
-    const excaldrawElements = convertToExcalidrawElements(
-      elements as ExcalidrawElementSkeleton[],
-    );
-
-    expect(excaldrawElements.length).toBe(1);
-    expect(excaldrawElements[0]).toMatchSnapshot({
-      seed: expect.any(Number),
-      versionNonce: expect.any(Number),
-    });
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      "Duplicate id found for rect-1",
-    );
-  });
-});
--- a/src/data/transform.ts
+++ b/src/data/transform.ts
@ -1,561 +0,0 @@
-import {
-  DEFAULT_FONT_FAMILY,
-  DEFAULT_FONT_SIZE,
-  TEXT_ALIGN,
-  VERTICAL_ALIGN,
-} from "../constants";
-import {
-  newElement,
-  newLinearElement,
-  redrawTextBoundingBox,
-} from "../element";
-import { bindLinearElement } from "../element/binding";
-import {
-  ElementConstructorOpts,
-  newImageElement,
-  newTextElement,
-} from "../element/newElement";
-import {
-  getDefaultLineHeight,
-  measureText,
-  normalizeText,
-} from "../element/textElement";
-import {
-  ExcalidrawArrowElement,
-  ExcalidrawBindableElement,
-  ExcalidrawElement,
-  ExcalidrawEmbeddableElement,
-  ExcalidrawFrameElement,
-  ExcalidrawFreeDrawElement,
-  ExcalidrawGenericElement,
-  ExcalidrawImageElement,
-  ExcalidrawLinearElement,
-  ExcalidrawSelectionElement,
-  ExcalidrawTextElement,
-  FileId,
-  FontFamilyValues,
-  TextAlign,
-  VerticalAlign,
-} from "../element/types";
-import { MarkOptional } from "../utility-types";
-import { assertNever, getFontString } from "../utils";
-
-export type ValidLinearElement = {
-  type: "arrow" | "line";
-  x: number;
-  y: number;
-  label?: {
-    text: string;
-    fontSize?: number;
-    fontFamily?: FontFamilyValues;
-    textAlign?: TextAlign;
-    verticalAlign?: VerticalAlign;
-  } & MarkOptional<ElementConstructorOpts, "x" | "y">;
-  end?:
-    | (
-        | (
-            | {
-                type: Exclude<
-                  ExcalidrawBindableElement["type"],
-                  "image" | "text" | "frame" | "embeddable"
-                >;
-                id?: ExcalidrawGenericElement["id"];
-              }
-            | {
-                id: ExcalidrawGenericElement["id"];
-                type?: Exclude<
-                  ExcalidrawBindableElement["type"],
-                  "image" | "text" | "frame" | "embeddable"
-                >;
-              }
-          )
-        | ((
-            | {
-                type: "text";
-                text: string;
-              }
-            | {
-                type?: "text";
-                id: ExcalidrawTextElement["id"];
-                text: string;
-              }
-          ) &
-            Partial<ExcalidrawTextElement>)
-      ) &
-        MarkOptional<ElementConstructorOpts, "x" | "y">;
-  start?:
-    | (
-        | (
-            | {
-                type: Exclude<
-                  ExcalidrawBindableElement["type"],
-                  "image" | "text" | "frame" | "embeddable"
-                >;
-                id?: ExcalidrawGenericElement["id"];
-              }
-            | {
-                id: ExcalidrawGenericElement["id"];
-                type?: Exclude<
-                  ExcalidrawBindableElement["type"],
-                  "image" | "text" | "frame" | "embeddable"
-                >;
-              }
-          )
-        | ((
-            | {
-                type: "text";
-                text: string;
-              }
-            | {
-                type?: "text";
-                id: ExcalidrawTextElement["id"];
-                text: string;
-              }
-          ) &
-            Partial<ExcalidrawTextElement>)
-      ) &
-        MarkOptional<ElementConstructorOpts, "x" | "y">;
-} & Partial<ExcalidrawLinearElement>;
-
-export type ValidContainer =
-  | {
-      type: Exclude<ExcalidrawGenericElement["type"], "selection">;
-      id?: ExcalidrawGenericElement["id"];
-      label?: {
-        text: string;
-        fontSize?: number;
-        fontFamily?: FontFamilyValues;
-        textAlign?: TextAlign;
-        verticalAlign?: VerticalAlign;
-      } & MarkOptional<ElementConstructorOpts, "x" | "y">;
-    } & ElementConstructorOpts;
-
-export type ExcalidrawElementSkeleton =
-  | Extract<
-      Exclude<ExcalidrawElement, ExcalidrawSelectionElement>,
-      | ExcalidrawEmbeddableElement
-      | ExcalidrawFreeDrawElement
-      | ExcalidrawFrameElement
-    >
-  | ({
-      type: Extract<ExcalidrawLinearElement["type"], "line">;
-      x: number;
-      y: number;
-    } & Partial<ExcalidrawLinearElement>)
-  | ValidContainer
-  | ValidLinearElement
-  | ({
-      type: "text";
-      text: string;
-      x: number;
-      y: number;
-      id?: ExcalidrawTextElement["id"];
-    } & Partial<ExcalidrawTextElement>)
-  | ({
-      type: Extract<ExcalidrawImageElement["type"], "image">;
-      x: number;
-      y: number;
-      fileId: FileId;
-    } & Partial<ExcalidrawImageElement>);
-
-const DEFAULT_LINEAR_ELEMENT_PROPS = {
-  width: 300,
-  height: 0,
-};
-
-const DEFAULT_DIMENSION = 100;
-
-const bindTextToContainer = (
-  container: ExcalidrawElement,
-  textProps: { text: string } & MarkOptional<ElementConstructorOpts, "x" | "y">,
-) => {
-  const textElement: ExcalidrawTextElement = newTextElement({
-    x: 0,
-    y: 0,
-    textAlign: TEXT_ALIGN.CENTER,
-    verticalAlign: VERTICAL_ALIGN.MIDDLE,
-    ...textProps,
-    containerId: container.id,
-    strokeColor: textProps.strokeColor || container.strokeColor,
-  });
-
-  Object.assign(container, {
-    boundElements: (container.boundElements || []).concat({
-      type: "text",
-      id: textElement.id,
-    }),
-  });
-
-  redrawTextBoundingBox(textElement, container);
-  return [container, textElement] as const;
-};
-
-const bindLinearElementToElement = (
-  linearElement: ExcalidrawArrowElement,
-  start: ValidLinearElement["start"],
-  end: ValidLinearElement["end"],
-  elementStore: ElementStore,
-): {
-  linearElement: ExcalidrawLinearElement;
-  startBoundElement?: ExcalidrawElement;
-  endBoundElement?: ExcalidrawElement;
-} => {
-  let startBoundElement;
-  let endBoundElement;
-
-  Object.assign(linearElement, {
-    startBinding: linearElement?.startBinding || null,
-    endBinding: linearElement.endBinding || null,
-  });
-
-  if (start) {
-    const width = start?.width ?? DEFAULT_DIMENSION;
-    const height = start?.height ?? DEFAULT_DIMENSION;
-
-    let existingElement;
-    if (start.id) {
-      existingElement = elementStore.getElement(start.id);
-      if (!existingElement) {
-        console.error(`No element for start binding with id ${start.id} found`);
-      }
-    }
-
-    const startX = start.x || linearElement.x - width;
-    const startY = start.y || linearElement.y - height / 2;
-    const startType = existingElement ? existingElement.type : start.type;
-
-    if (startType) {
-      if (startType === "text") {
-        let text = "";
-        if (existingElement && existingElement.type === "text") {
-          text = existingElement.text;
-        } else if (start.type === "text") {
-          text = start.text;
-        }
-        if (!text) {
-          console.error(
-            `No text found for start binding text element for ${linearElement.id}`,
-          );
-        }
-        startBoundElement = newTextElement({
-          x: startX,
-          y: startY,
-          type: "text",
-          ...existingElement,
-          ...start,
-          text,
-        });
-        // to position the text correctly when coordinates not provided
-        Object.assign(startBoundElement, {
-          x: start.x || linearElement.x - startBoundElement.width,
-          y: start.y || linearElement.y - startBoundElement.height / 2,
-        });
-      } else {
-        switch (startType) {
-          case "rectangle":
-          case "ellipse":
-          case "diamond": {
-            startBoundElement = newElement({
-              x: startX,
-              y: startY,
-              width,
-              height,
-              ...existingElement,
-              ...start,
-              type: startType,
-            });
-            break;
-          }
-          default: {
-            assertNever(
-              linearElement as never,
-              `Unhandled element start type "${start.type}"`,
-              true,
-            );
-          }
-        }
-      }
-
-      bindLinearElement(
-        linearElement,
-        startBoundElement as ExcalidrawBindableElement,
-        "start",
-      );
-    }
-  }
-  if (end) {
-    const height = end?.height ?? DEFAULT_DIMENSION;
-    const width = end?.width ?? DEFAULT_DIMENSION;
-
-    let existingElement;
-    if (end.id) {
-      existingElement = elementStore.getElement(end.id);
-      if (!existingElement) {
-        console.error(`No element for end binding with id ${end.id} found`);
-      }
-    }
-    const endX = end.x || linearElement.x + linearElement.width;
-    const endY = end.y || linearElement.y - height / 2;
-    const endType = existingElement ? existingElement.type : end.type;
-
-    if (endType) {
-      if (endType === "text") {
-        let text = "";
-        if (existingElement && existingElement.type === "text") {
-          text = existingElement.text;
-        } else if (end.type === "text") {
-          text = end.text;
-        }
-
-        if (!text) {
-          console.error(
-            `No text found for end binding text element for ${linearElement.id}`,
-          );
-        }
-        endBoundElement = newTextElement({
-          x: endX,
-          y: endY,
-          type: "text",
-          ...existingElement,
-          ...end,
-          text,
-        });
-        // to position the text correctly when coordinates not provided
-        Object.assign(endBoundElement, {
-          y: end.y || linearElement.y - endBoundElement.height / 2,
-        });
-      } else {
-        switch (endType) {
-          case "rectangle":
-          case "ellipse":
-          case "diamond": {
-            endBoundElement = newElement({
-              x: endX,
-              y: endY,
-              width,
-              height,
-              ...existingElement,
-              ...end,
-              type: endType,
-            });
-            break;
-          }
-          default: {
-            assertNever(
-              linearElement as never,
-              `Unhandled element end type "${endType}"`,
-              true,
-            );
-          }
-        }
-      }
-
-      bindLinearElement(
-        linearElement,
-        endBoundElement as ExcalidrawBindableElement,
-        "end",
-      );
-    }
-  }
-  return {
-    linearElement,
-    startBoundElement,
-    endBoundElement,
-  };
-};
-
-class ElementStore {
-  excalidrawElements = new Map<string, ExcalidrawElement>();
-
-  add = (ele?: ExcalidrawElement) => {
-    if (!ele) {
-      return;
-    }
-
-    this.excalidrawElements.set(ele.id, ele);
-  };
-  getElements = () => {
-    return Array.from(this.excalidrawElements.values());
-  };
-
-  getElement = (id: string) => {
-    return this.excalidrawElements.get(id);
-  };
-}
-
-export const convertToExcalidrawElements = (
-  elements: ExcalidrawElementSkeleton[] | null,
-) => {
-  if (!elements) {
-    return [];
-  }
-
-  const elementStore = new ElementStore();
-  const elementsWithIds = new Map<string, ExcalidrawElementSkeleton>();
-
-  // Create individual elements
-  for (const element of elements) {
-    let excalidrawElement: ExcalidrawElement;
-    switch (element.type) {
-      case "rectangle":
-      case "ellipse":
-      case "diamond": {
-        const width =
-          element?.label?.text && element.width === undefined
-            ? 0
-            : element?.width || DEFAULT_DIMENSION;
-        const height =
-          element?.label?.text && element.height === undefined
-            ? 0
-            : element?.height || DEFAULT_DIMENSION;
-        excalidrawElement = newElement({
-          ...element,
-          width,
-          height,
-        });
-
-        break;
-      }
-      case "line": {
-        const width = element.width || DEFAULT_LINEAR_ELEMENT_PROPS.width;
-        const height = element.height || DEFAULT_LINEAR_ELEMENT_PROPS.height;
-        excalidrawElement = newLinearElement({
-          width,
-          height,
-          points: [
-            [0, 0],
-            [width, height],
-          ],
-          ...element,
-        });
-
-        break;
-      }
-      case "arrow": {
-        const width = element.width || DEFAULT_LINEAR_ELEMENT_PROPS.width;
-        const height = element.height || DEFAULT_LINEAR_ELEMENT_PROPS.height;
-        excalidrawElement = newLinearElement({
-          width,
-          height,
-          endArrowhead: "arrow",
-          points: [
-            [0, 0],
-            [width, height],
-          ],
-          ...element,
-        });
-        break;
-      }
-      case "text": {
-        const fontFamily = element?.fontFamily || DEFAULT_FONT_FAMILY;
-        const fontSize = element?.fontSize || DEFAULT_FONT_SIZE;
-        const lineHeight =
-          element?.lineHeight || getDefaultLineHeight(fontFamily);
-        const text = element.text ?? "";
-        const normalizedText = normalizeText(text);
-        const metrics = measureText(
-          normalizedText,
-          getFontString({ fontFamily, fontSize }),
-          lineHeight,
-        );
-
-        excalidrawElement = newTextElement({
-          width: metrics.width,
-          height: metrics.height,
-          fontFamily,
-          fontSize,
-          ...element,
-        });
-        break;
-      }
-      case "image": {
-        excalidrawElement = newImageElement({
-          width: element?.width || DEFAULT_DIMENSION,
-          height: element?.height || DEFAULT_DIMENSION,
-          ...element,
-        });
-
-        break;
-      }
-      case "freedraw":
-      case "frame":
-      case "embeddable": {
-        excalidrawElement = element;
-        break;
-      }
-
-      default: {
-        excalidrawElement = element;
-        assertNever(
-          element,
-          `Unhandled element type "${(element as any).type}"`,
-          true,
-        );
-      }
-    }
-    const existingElement = elementStore.getElement(excalidrawElement.id);
-    if (existingElement) {
-      console.error(`Duplicate id found for ${excalidrawElement.id}`);
-    } else {
-      elementStore.add(excalidrawElement);
-      elementsWithIds.set(excalidrawElement.id, element);
-    }
-  }
-
-  // Add labels and arrow bindings
-  for (const [id, element] of elementsWithIds) {
-    const excalidrawElement = elementStore.getElement(id)!;
-
-    switch (element.type) {
-      case "rectangle":
-      case "ellipse":
-      case "diamond":
-      case "arrow": {
-        if (element.label?.text) {
-          let [container, text] = bindTextToContainer(
-            excalidrawElement,
-            element?.label,
-          );
-          elementStore.add(container);
-          elementStore.add(text);
-
-          if (container.type === "arrow") {
-            const originalStart =
-              element.type === "arrow" ? element?.start : undefined;
-            const originalEnd =
-              element.type === "arrow" ? element?.end : undefined;
-            const { linearElement, startBoundElement, endBoundElement } =
-              bindLinearElementToElement(
-                container as ExcalidrawArrowElement,
-                originalStart,
-                originalEnd,
-                elementStore,
-              );
-            container = linearElement;
-            elementStore.add(linearElement);
-            elementStore.add(startBoundElement);
-            elementStore.add(endBoundElement);
-          }
-        } else {
-          switch (element.type) {
-            case "arrow": {
-              const { linearElement, startBoundElement, endBoundElement } =
-                bindLinearElementToElement(
-                  excalidrawElement as ExcalidrawArrowElement,
-                  element.start,
-                  element.end,
-                  elementStore,
-                );
-              elementStore.add(linearElement);
-              elementStore.add(startBoundElement);
-              elementStore.add(endBoundElement);
-              break;
-            }
-          }
-        }
-        break;
-      }
-    }
-  }
-  return elementStore.getElements();
-};
--- a/src/data/url.ts
+++ b/src/data/url.ts
@ -1,35 +1,9 @@
 import { sanitizeUrl } from "@braintree/sanitize-url";

 export const normalizeLink = (link: string) => {
-  link = link.trim();
-  if (!link) {
-    return link;
-  }
  return sanitizeUrl(link);
 };

 export const isLocalLink = (link: string | null) => {
  return !!(link?.includes(location.origin) || link?.startsWith("/"));
 };
-
-/**
- * Returns URL sanitized and safe for usage in places such as
- * iframe's src attribute or <a> href attributes.
- */
-export const toValidURL = (link: string) => {
-  link = normalizeLink(link);
-
-  // make relative links into fully-qualified urls
-  if (link.startsWith("/")) {
-    return `${location.origin}${link}`;
-  }
-
-  try {
-    new URL(link);
-  } catch {
-    // if link does not parse as URL, assume invalid and return blank page
-    return "about:blank";
-  }
-
-  return link;
-};
--- a/src/element/Hyperlink.scss
+++ b/src/element/Hyperlink.scss
@ -55,6 +55,10 @@
    }
  }

+  .d-none {
+    display: none;
+  }
+
  &--remove .ToolIcon__icon svg {
    color: $oc-red-6;
  }
--- a/src/element/Hyperlink.tsx
+++ b/src/element/Hyperlink.tsx
@ -5,12 +5,8 @@ import {
  viewportCoordsToSceneCoords,
  wrapEvent,
 } from "../utils";
-import { getEmbedLink, embeddableURLValidator } from "./embeddable";
 import { mutateElement } from "./mutateElement";
-import {
-  ExcalidrawEmbeddableElement,
-  NonDeletedExcalidrawElement,
-} from "./types";
+import { NonDeletedExcalidrawElement } from "./types";

 import { register } from "../actions/register";
 import { ToolButton } from "../components/ToolButton";
@ -25,10 +21,7 @@ import {
 } from "react";
 import clsx from "clsx";
 import { KEYS } from "../keys";
-import {
-  DEFAULT_LINK_SIZE,
-  invalidateShapeForElement,
-} from "../renderer/renderElement";
+import { DEFAULT_LINK_SIZE } from "../renderer/renderElement";
 import { rotate } from "../math";
 import { EVENT, HYPERLINK_TOOLTIP_DELAY, MIME_TYPES } from "../constants";
 import { Bounds } from "./bounds";
@ -40,8 +33,7 @@ import { isLocalLink, normalizeLink } from "../data/url";

 import "./Hyperlink.scss";
 import { trackEvent } from "../analytics";
-import { useAppProps, useExcalidrawAppState } from "../components/App";
-import { isEmbeddableElement } from "./typeChecks";
+import { useExcalidrawAppState } from "../components/App";

 const CONTAINER_WIDTH = 320;
 const SPACE_BOTTOM = 85;
@ -56,112 +48,37 @@ EXTERNAL_LINK_IMG.src = `data:${MIME_TYPES.svg}, ${encodeURIComponent(

 let IS_HYPERLINK_TOOLTIP_VISIBLE = false;

-const embeddableLinkCache = new Map<
-  ExcalidrawEmbeddableElement["id"],
-  string
->();
-
 export const Hyperlink = ({
  element,
  setAppState,
  onLinkOpen,
-  setToast,
 }: {
  element: NonDeletedExcalidrawElement;
  setAppState: React.Component<any, AppState>["setState"];
  onLinkOpen: ExcalidrawProps["onLinkOpen"];
-  setToast: (
-    toast: { message: string; closable?: boolean; duration?: number } | null,
-  ) => void;
 }) => {
  const appState = useExcalidrawAppState();
-  const appProps = useAppProps();

  const linkVal = element.link || "";

  const [inputVal, setInputVal] = useState(linkVal);
  const inputRef = useRef<HTMLInputElement>(null);
-  const isEditing = appState.showHyperlinkPopup === "editor";
+  const isEditing = appState.showHyperlinkPopup === "editor" || !linkVal;

  const handleSubmit = useCallback(() => {
    if (!inputRef.current) {
      return;
    }

-    const link = normalizeLink(inputRef.current.value) || null;
+    const link = normalizeLink(inputRef.current.value);

    if (!element.link && link) {
      trackEvent("hyperlink", "create");
    }

-    if (isEmbeddableElement(element)) {
-      if (appState.activeEmbeddable?.element === element) {
-        setAppState({ activeEmbeddable: null });
-      }
-      if (!link) {
-        mutateElement(element, {
-          validated: false,
-          link: null,
-        });
-        return;
-      }
-
-      if (!embeddableURLValidator(link, appProps.validateEmbeddable)) {
-        if (link) {
-          setToast({ message: t("toast.unableToEmbed"), closable: true });
-        }
-        element.link && embeddableLinkCache.set(element.id, element.link);
-        mutateElement(element, {
-          validated: false,
-          link,
-        });
-        invalidateShapeForElement(element);
-      } else {
-        const { width, height } = element;
-        const embedLink = getEmbedLink(link);
-        if (embedLink?.warning) {
-          setToast({ message: embedLink.warning, closable: true });
-        }
-        const ar = embedLink
-          ? embedLink.aspectRatio.w / embedLink.aspectRatio.h
-          : 1;
-        const hasLinkChanged =
-          embeddableLinkCache.get(element.id) !== element.link;
-        mutateElement(element, {
-          ...(hasLinkChanged
-            ? {
-                width:
-                  embedLink?.type === "video"
-                    ? width > height
-                      ? width
-                      : height * ar
-                    : width,
-                height:
-                  embedLink?.type === "video"
-                    ? width > height
-                      ? width / ar
-                      : height
-                    : height,
-              }
-            : {}),
-          validated: true,
-          link,
-        });
-        invalidateShapeForElement(element);
-        if (embeddableLinkCache.has(element.id)) {
-          embeddableLinkCache.delete(element.id);
-        }
-      }
-    } else {
    mutateElement(element, { link });
-    }
-  }, [
-    element,
-    setToast,
-    appProps.validateEmbeddable,
-    appState.activeEmbeddable,
-    setAppState,
-  ]);
+    setAppState({ showHyperlinkPopup: "info" });
+  }, [element, setAppState]);

  useLayoutEffect(() => {
    return () => {
@ -215,12 +132,10 @@ export const Hyperlink = ({
    appState.draggingElement ||
    appState.resizingElement ||
    appState.isRotating ||
-    appState.openMenu ||
-    appState.viewModeEnabled
+    appState.openMenu
  ) {
    return null;
  }
-
  return (
    <div
      className="excalidraw-hyperlinkContainer"
@ -230,11 +145,6 @@ export const Hyperlink = ({
        width: CONTAINER_WIDTH,
        padding: CONTAINER_PADDING,
      }}
-      onClick={() => {
-        if (!element.link && !isEditing) {
-          setAppState({ showHyperlinkPopup: "editor" });
-        }
-      }}
    >
      {isEditing ? (
        <input
@ -252,14 +162,15 @@ export const Hyperlink = ({
            }
            if (event.key === KEYS.ENTER || event.key === KEYS.ESCAPE) {
              handleSubmit();
-              setAppState({ showHyperlinkPopup: "info" });
            }
          }}
        />
-      ) : element.link ? (
+      ) : (
        <a
          href={normalizeLink(element.link || "")}
-          className="excalidraw-hyperlinkContainer-link"
+          className={clsx("excalidraw-hyperlinkContainer-link", {
+            "d-none": isEditing,
+          })}
          target={isLocalLink(element.link) ? "_self" : "_blank"}
          onClick={(event) => {
            if (element.link && onLinkOpen) {
@ -283,10 +194,6 @@ export const Hyperlink = ({
        >
          {element.link}
        </a>
-      ) : (
-        <div className="excalidraw-hyperlinkContainer-link">
-          {t("labels.link.empty")}
-        </div>
      )}
      <div className="excalidraw-hyperlinkContainer__buttons">
        {!isEditing && (
@ -300,7 +207,8 @@ export const Hyperlink = ({
            icon={FreedrawIcon}
          />
        )}
-        {linkVal && !isEmbeddableElement(element) && (
+
+        {linkVal && (
          <ToolButton
            type="button"
            title={t("buttons.remove")}
@ -363,11 +271,7 @@ export const actionLink = register({
        type="button"
        icon={LinkIcon}
        aria-label={t(getContextMenuLabel(elements, appState))}
-        title={`${
-          isEmbeddableElement(elements[0])
-            ? t("labels.link.labelEmbed")
-            : t("labels.link.label")
-        } - ${getShortcutKey("CtrlOrCmd+K")}`}
+        title={`${t("labels.link.label")} - ${getShortcutKey("CtrlOrCmd+K")}`}
        onClick={() => updateData(null)}
        selected={selectedElements.length === 1 && !!selectedElements[0].link}
      />
@ -381,11 +285,7 @@ export const getContextMenuLabel = (
 ) => {
  const selectedElements = getSelectedElements(elements, appState);
  const label = selectedElements[0]!.link
-    ? isEmbeddableElement(selectedElements[0])
-      ? "labels.link.editEmbed"
-      : "labels.link.edit"
-    : isEmbeddableElement(selectedElements[0])
-    ? "labels.link.createEmbed"
+    ? "labels.link.edit"
    : "labels.link.create";
  return label;
 };
@ -427,26 +327,6 @@ export const isPointHittingLinkIcon = (
  element: NonDeletedExcalidrawElement,
  appState: AppState,
  [x, y]: Point,
-) => {
-  const threshold = 4 / appState.zoom.value;
-  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;
-};
-
-export const isPointHittingLink = (
-  element: NonDeletedExcalidrawElement,
-  appState: AppState,
-  [x, y]: Point,
  isMobile: boolean,
 ) => {
  if (!element.link || appState.selectedElementIds[element.id]) {
@ -460,7 +340,19 @@ export const isPointHittingLink = (
  ) {
    return true;
  }
-  return isPointHittingLinkIcon(element, appState, [x, y]);
+  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;
--- a/src/element/binding.ts
+++ b/src/element/binding.ts
@ -190,7 +190,7 @@ export const maybeBindLinearElement = (
  }
 };

-export const bindLinearElement = (
+const bindLinearElement = (
  linearElement: NonDeleted<ExcalidrawLinearElement>,
  hoveredElement: ExcalidrawBindableElement,
  startOrEnd: "start" | "end",
--- a/src/element/collision.ts
+++ b/src/element/collision.ts
@ -18,7 +18,6 @@ import {
  ExcalidrawBindableElement,
  ExcalidrawElement,
  ExcalidrawRectangleElement,
-  ExcalidrawEmbeddableElement,
  ExcalidrawDiamondElement,
  ExcalidrawTextElement,
  ExcalidrawEllipseElement,
@ -40,11 +39,7 @@ import { FrameNameBoundsCache, Point } from "../types";
 import { Drawable } from "roughjs/bin/core";
 import { AppState } from "../types";
 import { getShapeForElement } from "../renderer/renderElement";
-import {
-  hasBoundTextElement,
-  isEmbeddableElement,
-  isImageElement,
-} from "./typeChecks";
+import { hasBoundTextElement, isImageElement } from "./typeChecks";
 import { isTextElement } from ".";
 import { isTransparent } from "../utils";
 import { shouldShowBoundingBox } from "./transformHandles";
@ -62,9 +57,7 @@ const isElementDraggableFromInside = (
    return true;
  }
  const isDraggableFromInside =
-    !isTransparent(element.backgroundColor) ||
-    hasBoundTextElement(element) ||
-    isEmbeddableElement(element);
+    !isTransparent(element.backgroundColor) || hasBoundTextElement(element);
  if (element.type === "line") {
    return isDraggableFromInside && isPathALoop(element.points);
  }
@ -255,7 +248,6 @@ type HitTestArgs = {
 const hitTestPointAgainstElement = (args: HitTestArgs): boolean => {
  switch (args.element.type) {
    case "rectangle":
-    case "embeddable":
    case "image":
    case "text":
    case "diamond":
@ -314,7 +306,6 @@ export const distanceToBindableElement = (
    case "rectangle":
    case "image":
    case "text":
-    case "embeddable":
    case "frame":
      return distanceToRectangle(element, point);
    case "diamond":
@ -346,7 +337,6 @@ const distanceToRectangle = (
    | ExcalidrawTextElement
    | ExcalidrawFreeDrawElement
    | ExcalidrawImageElement
-    | ExcalidrawEmbeddableElement
    | ExcalidrawFrameElement,
  point: Point,
 ): number => {
@ -655,23 +645,17 @@ export const determineFocusDistance = (
  const c = line[1];
  const mabs = Math.abs(m);
  const nabs = Math.abs(n);
-  let ret;
  switch (element.type) {
    case "rectangle":
    case "image":
    case "text":
-    case "embeddable":
    case "frame":
-      ret = c / (hwidth * (nabs + q * mabs));
-      break;
+      return c / (hwidth * (nabs + q * mabs));
    case "diamond":
-      ret = mabs < nabs ? c / (nabs * hwidth) : c / (mabs * hheight);
-      break;
+      return mabs < nabs ? c / (nabs * hwidth) : c / (mabs * hheight);
    case "ellipse":
-      ret = c / (hwidth * Math.sqrt(n ** 2 + q ** 2 * m ** 2));
-      break;
+      return c / (hwidth * Math.sqrt(n ** 2 + q ** 2 * m ** 2));
  }
-  return ret || 0;
 };

 export const determineFocusPoint = (
@ -698,7 +682,6 @@ export const determineFocusPoint = (
    case "image":
    case "text":
    case "diamond":
-    case "embeddable":
    case "frame":
      point = findFocusPointForRectangulars(element, focus, adjecentPointRel);
      break;
@ -750,7 +733,6 @@ const getSortedElementLineIntersections = (
    case "image":
    case "text":
    case "diamond":
-    case "embeddable":
    case "frame":
      const corners = getCorners(element);
      intersections = corners
@ -786,7 +768,6 @@ const getCorners = (
    | ExcalidrawImageElement
    | ExcalidrawDiamondElement
    | ExcalidrawTextElement
-    | ExcalidrawEmbeddableElement
    | ExcalidrawFrameElement,
  scale: number = 1,
 ): GA.Point[] => {
@ -796,7 +777,6 @@ const getCorners = (
    case "rectangle":
    case "image":
    case "text":
-    case "embeddable":
    case "frame":
      return [
        GA.point(hx, hy),
@ -946,7 +926,6 @@ export const findFocusPointForRectangulars = (
    | ExcalidrawImageElement
    | ExcalidrawDiamondElement
    | ExcalidrawTextElement
-    | ExcalidrawEmbeddableElement
    | ExcalidrawFrameElement,
  // Between -1 and 1 for how far away should the focus point be relative
  // to the size of the element. Sign determines orientation.
--- a/src/element/embeddable.ts
+++ b/src/element/embeddable.ts
@ -1,350 +0,0 @@
-import { register } from "../actions/register";
-import { FONT_FAMILY, VERTICAL_ALIGN } from "../constants";
-import { t } from "../i18n";
-import { ExcalidrawProps } from "../types";
-import { getFontString, setCursorForShape, updateActiveTool } from "../utils";
-import { newTextElement } from "./newElement";
-import { getContainerElement, wrapText } from "./textElement";
-import { isEmbeddableElement } from "./typeChecks";
-import {
-  ExcalidrawElement,
-  ExcalidrawEmbeddableElement,
-  NonDeletedExcalidrawElement,
-  Theme,
-} from "./types";
-
-type EmbeddedLink =
-  | ({
-      aspectRatio: { w: number; h: number };
-      warning?: string;
-    } & (
-      | { type: "video" | "generic"; link: string }
-      | { type: "document"; srcdoc: (theme: Theme) => string }
-    ))
-  | null;
-
-const embeddedLinkCache = new Map<string, EmbeddedLink>();
-
-const RE_YOUTUBE =
-  /^(?:http(?:s)?:\/\/)?(?:www\.)?youtu(?:be\.com|\.be)\/(embed\/|watch\?v=|shorts\/|playlist\?list=|embed\/videoseries\?list=)?([a-zA-Z0-9_-]+)(?:\?t=|&t=|\?start=|&start=)?([a-zA-Z0-9_-]+)?[^\s]*$/;
-const RE_VIMEO =
-  /^(?:http(?:s)?:\/\/)?(?:(?:w){3}.)?(?:player\.)?vimeo\.com\/(?:video\/)?([^?\s]+)(?:\?.*)?$/;
-const RE_FIGMA = /^https:\/\/(?:www\.)?figma\.com/;
-
-const RE_GH_GIST = /^https:\/\/gist\.github\.com/;
-const RE_GH_GIST_EMBED =
-  /^<script[\s\S]*?\ssrc=["'](https:\/\/gist.github.com\/.*?)\.js["']/i;
-
-// not anchored to start to allow <blockquote> twitter embeds
-const RE_TWITTER = /(?:http(?:s)?:\/\/)?(?:(?:w){3}.)?twitter.com/;
-const RE_TWITTER_EMBED =
-  /^<blockquote[\s\S]*?\shref=["'](https:\/\/twitter.com\/[^"']*)/i;
-
-const RE_VALTOWN =
-  /^https:\/\/(?:www\.)?val.town\/(v|embed)\/[a-zA-Z_$][0-9a-zA-Z_$]+\.[a-zA-Z_$][0-9a-zA-Z_$]+/;
-
-const RE_GENERIC_EMBED =
-  /^<(?:iframe|blockquote)[\s\S]*?\s(?:src|href)=["']([^"']*)["'][\s\S]*?>$/i;
-
-const ALLOWED_DOMAINS = new Set([
-  "youtube.com",
-  "youtu.be",
-  "vimeo.com",
-  "player.vimeo.com",
-  "figma.com",
-  "link.excalidraw.com",
-  "gist.github.com",
-  "twitter.com",
-  "*.simplepdf.eu",
-  "stackblitz.com",
-  "val.town",
-]);
-
-const createSrcDoc = (body: string) => {
-  return `<html><body>${body}</body></html>`;
-};
-
-export const getEmbedLink = (link: string | null | undefined): EmbeddedLink => {
-  if (!link) {
-    return null;
-  }
-
-  if (embeddedLinkCache.has(link)) {
-    return embeddedLinkCache.get(link)!;
-  }
-
-  const originalLink = link;
-
-  let type: "video" | "generic" = "generic";
-  let aspectRatio = { w: 560, h: 840 };
-  const ytLink = link.match(RE_YOUTUBE);
-  if (ytLink?.[2]) {
-    const time = ytLink[3] ? `&start=${ytLink[3]}` : ``;
-    const isPortrait = link.includes("shorts");
-    type = "video";
-    switch (ytLink[1]) {
-      case "embed/":
-      case "watch?v=":
-      case "shorts/":
-        link = `https://www.youtube.com/embed/${ytLink[2]}?enablejsapi=1${time}`;
-        break;
-      case "playlist?list=":
-      case "embed/videoseries?list=":
-        link = `https://www.youtube.com/embed/videoseries?list=${ytLink[2]}&enablejsapi=1${time}`;
-        break;
-      default:
-        link = `https://www.youtube.com/embed/${ytLink[2]}?enablejsapi=1${time}`;
-        break;
-    }
-    aspectRatio = isPortrait ? { w: 315, h: 560 } : { w: 560, h: 315 };
-    embeddedLinkCache.set(originalLink, { link, aspectRatio, type });
-    return { link, aspectRatio, type };
-  }
-
-  const vimeoLink = link.match(RE_VIMEO);
-  if (vimeoLink?.[1]) {
-    const target = vimeoLink?.[1];
-    const warning = !/^\d+$/.test(target)
-      ? t("toast.unrecognizedLinkFormat")
-      : undefined;
-    type = "video";
-    link = `https://player.vimeo.com/video/${target}?api=1`;
-    aspectRatio = { w: 560, h: 315 };
-    //warning deliberately ommited so it is displayed only once per link
-    //same link next time will be served from cache
-    embeddedLinkCache.set(originalLink, { link, aspectRatio, type });
-    return { link, aspectRatio, type, warning };
-  }
-
-  const figmaLink = link.match(RE_FIGMA);
-  if (figmaLink) {
-    type = "generic";
-    link = `https://www.figma.com/embed?embed_host=share&url=${encodeURIComponent(
-      link,
-    )}`;
-    aspectRatio = { w: 550, h: 550 };
-    embeddedLinkCache.set(originalLink, { link, aspectRatio, type });
-    return { link, aspectRatio, type };
-  }
-
-  const valLink = link.match(RE_VALTOWN);
-  if (valLink) {
-    link =
-      valLink[1] === "embed" ? valLink[0] : valLink[0].replace("/v", "/embed");
-    embeddedLinkCache.set(originalLink, { link, aspectRatio, type });
-    return { link, aspectRatio, type };
-  }
-
-  if (RE_TWITTER.test(link)) {
-    let ret: EmbeddedLink;
-    // assume embed code
-    if (/<blockquote/.test(link)) {
-      const srcDoc = createSrcDoc(link);
-      ret = {
-        type: "document",
-        srcdoc: () => srcDoc,
-        aspectRatio: { w: 480, h: 480 },
-      };
-      // assume regular tweet url
-    } else {
-      ret = {
-        type: "document",
-        srcdoc: (theme: string) =>
-          createSrcDoc(
-            `<blockquote class="twitter-tweet" data-dnt="true" data-theme="${theme}"><a href="${link}"></a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>`,
-          ),
-        aspectRatio: { w: 480, h: 480 },
-      };
-    }
-    embeddedLinkCache.set(originalLink, ret);
-    return ret;
-  }
-
-  if (RE_GH_GIST.test(link)) {
-    let ret: EmbeddedLink;
-    // assume embed code
-    if (/<script>/.test(link)) {
-      const srcDoc = createSrcDoc(link);
-      ret = {
-        type: "document",
-        srcdoc: () => srcDoc,
-        aspectRatio: { w: 550, h: 720 },
-      };
-      // assume regular url
-    } else {
-      ret = {
-        type: "document",
-        srcdoc: () =>
-          createSrcDoc(`
-          <script src="${link}.js"></script>
-          <style type="text/css">
-            * { margin: 0px; }
-            table, .gist { height: 100%; }
-            .gist .gist-file { height: calc(100vh - 2px); padding: 0px; display: grid; grid-template-rows: 1fr auto; }
-          </style>
-        `),
-        aspectRatio: { w: 550, h: 720 },
-      };
-    }
-    embeddedLinkCache.set(link, ret);
-    return ret;
-  }
-
-  embeddedLinkCache.set(link, { link, aspectRatio, type });
-  return { link, aspectRatio, type };
-};
-
-export const isEmbeddableOrFrameLabel = (
-  element: NonDeletedExcalidrawElement,
-): Boolean => {
-  if (isEmbeddableElement(element)) {
-    return true;
-  }
-  if (element.type === "text") {
-    const container = getContainerElement(element);
-    if (container && isEmbeddableElement(container)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-export const createPlaceholderEmbeddableLabel = (
-  element: ExcalidrawEmbeddableElement,
-): ExcalidrawElement => {
-  const text =
-    !element.link || element?.link === "" ? "Empty Web-Embed" : element.link;
-  const fontSize = Math.max(
-    Math.min(element.width / 2, element.width / text.length),
-    element.width / 30,
-  );
-  const fontFamily = FONT_FAMILY.Helvetica;
-
-  const fontString = getFontString({
-    fontSize,
-    fontFamily,
-  });
-
-  return newTextElement({
-    x: element.x + element.width / 2,
-    y: element.y + element.height / 2,
-    strokeColor:
-      element.strokeColor !== "transparent" ? element.strokeColor : "black",
-    backgroundColor: "transparent",
-    fontFamily,
-    fontSize,
-    text: wrapText(text, fontString, element.width - 20),
-    textAlign: "center",
-    verticalAlign: VERTICAL_ALIGN.MIDDLE,
-    angle: element.angle ?? 0,
-  });
-};
-
-export const actionSetEmbeddableAsActiveTool = register({
-  name: "setEmbeddableAsActiveTool",
-  trackEvent: { category: "toolbar" },
-  perform: (elements, appState, _, app) => {
-    const nextActiveTool = updateActiveTool(appState, {
-      type: "embeddable",
-    });
-
-    setCursorForShape(app.canvas, {
-      ...appState,
-      activeTool: nextActiveTool,
-    });
-
-    return {
-      elements,
-      appState: {
-        ...appState,
-        activeTool: updateActiveTool(appState, {
-          type: "embeddable",
-        }),
-      },
-      commitToHistory: false,
-    };
-  },
-});
-
-const validateHostname = (
-  url: string,
-  /** using a Set assumes it already contains normalized bare domains */
-  allowedHostnames: Set<string> | string,
-): boolean => {
-  try {
-    const { hostname } = new URL(url);
-
-    const bareDomain = hostname.replace(/^www\./, "");
-    const bareDomainWithFirstSubdomainWildcarded = bareDomain.replace(
-      /^([^.]+)/,
-      "*",
-    );
-
-    if (allowedHostnames instanceof Set) {
-      return (
-        ALLOWED_DOMAINS.has(bareDomain) ||
-        ALLOWED_DOMAINS.has(bareDomainWithFirstSubdomainWildcarded)
-      );
-    }
-
-    if (bareDomain === allowedHostnames.replace(/^www\./, "")) {
-      return true;
-    }
-  } catch (error) {
-    // ignore
-  }
-  return false;
-};
-
-export const extractSrc = (htmlString: string): string => {
-  const twitterMatch = htmlString.match(RE_TWITTER_EMBED);
-  if (twitterMatch && twitterMatch.length === 2) {
-    return twitterMatch[1];
-  }
-
-  const gistMatch = htmlString.match(RE_GH_GIST_EMBED);
-  if (gistMatch && gistMatch.length === 2) {
-    return gistMatch[1];
-  }
-
-  const match = htmlString.match(RE_GENERIC_EMBED);
-  if (match && match.length === 2) {
-    return match[1];
-  }
-  return htmlString;
-};
-
-export const embeddableURLValidator = (
-  url: string | null | undefined,
-  validateEmbeddable: ExcalidrawProps["validateEmbeddable"],
-): boolean => {
-  if (!url) {
-    return false;
-  }
-  if (validateEmbeddable != null) {
-    if (typeof validateEmbeddable === "function") {
-      const ret = validateEmbeddable(url);
-      // if return value is undefined, leave validation to default
-      if (typeof ret === "boolean") {
-        return ret;
-      }
-    } else if (typeof validateEmbeddable === "boolean") {
-      return validateEmbeddable;
-    } else if (validateEmbeddable instanceof RegExp) {
-      return validateEmbeddable.test(url);
-    } else if (Array.isArray(validateEmbeddable)) {
-      for (const domain of validateEmbeddable) {
-        if (domain instanceof RegExp) {
-          if (url.match(domain)) {
-            return true;
-          }
-        } else if (validateHostname(url, domain)) {
-          return true;
-        }
-      }
-      return false;
-    }
-  }
-
-  return validateHostname(url, ALLOWED_DOMAINS);
-};
--- a/src/element/linearElementEditor.ts
+++ b/src/element/linearElementEditor.ts
@ -264,12 +264,12 @@ export class LinearElementEditor {
            };
          }),
        );
-      }

        const boundTextElement = getBoundTextElement(element);
        if (boundTextElement) {
          handleBindTextResize(element, false);
        }
+      }

      // suggest bindings for first and last point if selected
      if (isBindingElement(element, false)) {
--- a/src/element/newElement.ts
+++ b/src/element/newElement.ts
@ -13,7 +13,6 @@ import {
  FontFamilyValues,
  ExcalidrawTextContainer,
  ExcalidrawFrameElement,
-  ExcalidrawEmbeddableElement,
 } from "../element/types";
 import {
  arrayToMap,
@ -46,7 +45,7 @@ import {
 } from "../constants";
 import { MarkOptional, Merge, Mutable } from "../utility-types";

-export type ElementConstructorOpts = MarkOptional<
+type ElementConstructorOpts = MarkOptional<
  Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">,
  | "width"
  | "height"
@ -131,18 +130,6 @@ export const newElement = (
 ): NonDeleted<ExcalidrawGenericElement> =>
  _newElementBase<ExcalidrawGenericElement>(opts.type, opts);

-export const newEmbeddableElement = (
-  opts: {
-    type: "embeddable";
-    validated: ExcalidrawEmbeddableElement["validated"];
-  } & ElementConstructorOpts,
-): NonDeleted<ExcalidrawEmbeddableElement> => {
-  return {
-    ..._newElementBase<ExcalidrawEmbeddableElement>("embeddable", opts),
-    validated: opts.validated,
-  };
-};
-
 export const newFrameElement = (
  opts: ElementConstructorOpts,
 ): NonDeleted<ExcalidrawFrameElement> => {
@ -187,9 +174,10 @@ export const newTextElement = (
    fontFamily?: FontFamilyValues;
    textAlign?: TextAlign;
    verticalAlign?: VerticalAlign;
-    containerId?: ExcalidrawTextContainer["id"] | null;
+    containerId?: ExcalidrawTextContainer["id"];
    lineHeight?: ExcalidrawTextElement["lineHeight"];
    strokeWidth?: ExcalidrawTextElement["strokeWidth"];
+    isFrameName?: boolean;
  } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawTextElement> => {
  const fontFamily = opts.fontFamily || DEFAULT_FONT_FAMILY;
@ -224,6 +212,7 @@ export const newTextElement = (
      containerId: opts.containerId || null,
      originalText: text,
      lineHeight,
+      isFrameName: opts.isFrameName || false,
    },
    {},
  );
@ -361,8 +350,8 @@ export const newFreeDrawElement = (
 export const newLinearElement = (
  opts: {
    type: ExcalidrawLinearElement["type"];
-    startArrowhead?: Arrowhead | null;
-    endArrowhead?: Arrowhead | null;
+    startArrowhead: Arrowhead | null;
+    endArrowhead: Arrowhead | null;
    points?: ExcalidrawLinearElement["points"];
  } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawLinearElement> => {
@ -372,8 +361,8 @@ export const newLinearElement = (
    lastCommittedPoint: null,
    startBinding: null,
    endBinding: null,
-    startArrowhead: opts.startArrowhead || null,
-    endArrowhead: opts.endArrowhead || null,
+    startArrowhead: opts.startArrowhead,
+    endArrowhead: opts.endArrowhead,
  };
 };

@ -443,7 +432,7 @@ const _deepCopyElement = (val: any, depth: number = 0) => {
  // we're not cloning non-array & non-plain-object objects because we
  // don't support them on excalidraw elements yet. If we do, we need to make
  // sure we start cloning them, so let's warn about it.
-  if (import.meta.env.DEV) {
+  if (process.env.NODE_ENV === "development") {
    if (
      objectType !== "[object Object]" &&
      objectType !== "[object Array]" &&
@ -477,7 +466,7 @@ export const deepCopyElement = <T extends ExcalidrawElement>(
 * utility wrapper to generate new id. In test env it reuses the old + postfix
 * for test assertions.
 */
-export const regenerateId = (
+const regenerateId = (
  /** supply null if no previous id exists */
  previousId: string | null,
 ) => {
--- a/src/element/resizeElements.ts
+++ b/src/element/resizeElements.ts
@ -1,4 +1,4 @@
-import { MIN_FONT_SIZE, SHIFT_LOCKING_ANGLE } from "../constants";
+import { SHIFT_LOCKING_ANGLE } from "../constants";
 import { rescalePoints } from "../points";

 import {
@ -204,6 +204,8 @@ const rescalePointsInElement = (
      }
    : {};

+const MIN_FONT_SIZE = 1;
+
 const measureFontSizeFromWidth = (
  element: NonDeleted<ExcalidrawTextElement>,
  nextWidth: number,
@ -587,42 +589,24 @@ export const resizeSingleElement = (
    });
  }

-  if (
-    isArrowElement(element) &&
-    boundTextElement &&
-    shouldMaintainAspectRatio
-  ) {
-    const fontSize =
-      (resizedElement.width / element.width) * boundTextElement.fontSize;
-    if (fontSize < MIN_FONT_SIZE) {
-      return;
-    }
-    boundTextFont.fontSize = fontSize;
-  }
-
  if (
    resizedElement.width !== 0 &&
    resizedElement.height !== 0 &&
    Number.isFinite(resizedElement.x) &&
    Number.isFinite(resizedElement.y)
  ) {
-    mutateElement(element, resizedElement);
-
    updateBoundElements(element, {
      newSize: { width: resizedElement.width, height: resizedElement.height },
    });

+    mutateElement(element, resizedElement);
    if (boundTextElement && boundTextFont != null) {
      mutateElement(boundTextElement, {
        fontSize: boundTextFont.fontSize,
        baseline: boundTextFont.baseline,
      });
    }
-    handleBindTextResize(
-      element,
-      transformHandleDirection,
-      shouldMaintainAspectRatio,
-    );
+    handleBindTextResize(element, transformHandleDirection);
  }
 };

@ -738,8 +722,12 @@ export const resizeMultipleElements = (
      fontSize?: ExcalidrawTextElement["fontSize"];
      baseline?: ExcalidrawTextElement["baseline"];
      scale?: ExcalidrawImageElement["scale"];
-      boundTextFontSize?: ExcalidrawTextElement["fontSize"];
    };
+    boundText: {
+      element: ExcalidrawTextElementWithContainer;
+      fontSize: ExcalidrawTextElement["fontSize"];
+      baseline: ExcalidrawTextElement["baseline"];
+    } | null;
  }[] = [];

  for (const { orig, latest } of targetElements) {
@ -810,39 +798,50 @@ export const resizeMultipleElements = (
      }
    }

-    if (isTextElement(orig)) {
-      const metrics = measureFontSizeFromWidth(orig, width, height);
+    let boundText: typeof elementsAndUpdates[0]["boundText"] = null;
+
+    const boundTextElement = getBoundTextElement(latest);
+
+    if (boundTextElement || isTextElement(orig)) {
+      const updatedElement = {
+        ...latest,
+        width,
+        height,
+      };
+      const metrics = measureFontSizeFromWidth(
+        boundTextElement ?? (orig as ExcalidrawTextElement),
+        boundTextElement
+          ? getBoundTextMaxWidth(updatedElement)
+          : updatedElement.width,
+        boundTextElement
+          ? getBoundTextMaxHeight(updatedElement, boundTextElement)
+          : updatedElement.height,
+      );
+
      if (!metrics) {
        return;
      }
+
+      if (isTextElement(orig)) {
        update.fontSize = metrics.size;
        update.baseline = metrics.baseline;
      }

-    const boundTextElement = pointerDownState.originalElements.get(
-      getBoundTextElementId(orig) ?? "",
-    ) as ExcalidrawTextElementWithContainer | undefined;
-
      if (boundTextElement) {
-      const newFontSize = boundTextElement.fontSize * scale;
-      if (newFontSize < MIN_FONT_SIZE) {
-        return;
+        boundText = {
+          element: boundTextElement,
+          fontSize: metrics.size,
+          baseline: metrics.baseline,
+        };
      }
-      update.boundTextFontSize = newFontSize;
    }

-    elementsAndUpdates.push({
-      element: latest,
-      update,
-    });
+    elementsAndUpdates.push({ element: latest, update, boundText });
  }

  const elementsToUpdate = elementsAndUpdates.map(({ element }) => element);

-  for (const {
-    element,
-    update: { boundTextFontSize, ...update },
-  } of elementsAndUpdates) {
+  for (const { element, update, boundText } of elementsAndUpdates) {
    const { width, height, angle } = update;

    mutateElement(element, update, false);
@ -852,17 +851,17 @@ export const resizeMultipleElements = (
      newSize: { width, height },
    });

-    const boundTextElement = getBoundTextElement(element);
-    if (boundTextElement && boundTextFontSize) {
+    if (boundText) {
+      const { element: boundTextElement, ...boundTextUpdates } = boundText;
      mutateElement(
        boundTextElement,
        {
-          fontSize: boundTextFontSize,
+          ...boundTextUpdates,
          angle: isLinearElement(element) ? undefined : angle,
        },
        false,
      );
-      handleBindTextResize(element, transformHandleType, true);
+      handleBindTextResize(element, transformHandleType);
    }
  }

--- a/src/element/showSelectedShapeActions.ts
+++ b/src/element/showSelectedShapeActions.ts
@ -7,11 +7,11 @@ export const showSelectedShapeActions = (
  elements: readonly NonDeletedExcalidrawElement[],
 ) =>
  Boolean(
-    !appState.viewModeEnabled &&
-      ((appState.activeTool.type !== "custom" &&
+    (!appState.viewModeEnabled &&
+      appState.activeTool.type !== "custom" &&
      (appState.editingElement ||
        (appState.activeTool.type !== "selection" &&
          appState.activeTool.type !== "eraser" &&
          appState.activeTool.type !== "hand"))) ||
-        getSelectedElements(elements, appState).length),
+      getSelectedElements(elements, appState).length,
  );
--- a/src/element/sizeHelpers.test.ts
+++ b/src/element/sizeHelpers.test.ts
@ -1,32 +1,19 @@
-import { vi } from "vitest";
 import { getPerfectElementSize } from "./sizeHelpers";
 import * as constants from "../constants";

 const EPSILON_DIGITS = 3;
-// Needed so that we can mock the value of constants which is done in
-// below tests. In Jest this wasn't needed as global override was possible
-// but vite doesn't allow that hence we need to mock
-vi.mock(
-  "../constants.ts",
-  //@ts-ignore
-  async (importOriginal) => {
-    const module: any = await importOriginal();
-    return { ...module };
-  },
-);
+
 describe("getPerfectElementSize", () => {
  it("should return height:0 if `elementType` is line and locked angle is 0", () => {
    const { height, width } = getPerfectElementSize("line", 149, 10);
    expect(width).toBeCloseTo(149, EPSILON_DIGITS);
    expect(height).toBeCloseTo(0, EPSILON_DIGITS);
  });
-
  it("should return width:0 if `elementType` is line and locked angle is 90 deg (Math.PI/2)", () => {
    const { height, width } = getPerfectElementSize("line", 10, 140);
    expect(width).toBeCloseTo(0, EPSILON_DIGITS);
    expect(height).toBeCloseTo(140, EPSILON_DIGITS);
  });
-
  it("should return height:0 if `elementType` is arrow and locked angle is 0", () => {
    const { height, width } = getPerfectElementSize("arrow", 200, 20);
    expect(width).toBeCloseTo(200, EPSILON_DIGITS);
@ -37,19 +24,16 @@ describe("getPerfectElementSize", () => {
    expect(width).toBeCloseTo(0, EPSILON_DIGITS);
    expect(height).toBeCloseTo(100, EPSILON_DIGITS);
  });
-
  it("should return adjust height to be width * tan(locked angle)", () => {
    const { height, width } = getPerfectElementSize("arrow", 120, 185);
    expect(width).toBeCloseTo(120, EPSILON_DIGITS);
    expect(height).toBeCloseTo(207.846, EPSILON_DIGITS);
  });
-
  it("should return height equals to width if locked angle is 45 deg", () => {
    const { height, width } = getPerfectElementSize("arrow", 135, 145);
    expect(width).toBeCloseTo(135, EPSILON_DIGITS);
    expect(height).toBeCloseTo(135, EPSILON_DIGITS);
  });
-
  it("should return height:0 and width:0 when width and height are 0", () => {
    const { height, width } = getPerfectElementSize("arrow", 0, 0);
    expect(width).toBeCloseTo(0, EPSILON_DIGITS);
--- a/Show More
+++ b/Show More